ตัวดำเนินการเชิงตรรกะ

มีตัวดำเนินการเชิงตรรกะสี่ตัวใน JavaScript: || (หรือ) && (และ) ! (ไม่), ?? (การรวมตัวเป็นโมฆะ) ที่นี่เราครอบคลุมสามข้อแรก ?? โอเปอเรเตอร์อยู่ในบทความถัดไป

แม้ว่าจะถูกเรียกว่า "ตรรกะ" แต่ก็สามารถนำไปใช้กับค่าประเภทใดก็ได้ ไม่ใช่แค่บูลีนเท่านั้น ผลลัพธ์ของพวกเขาอาจเป็นประเภทใดก็ได้

เรามาดูรายละเอียดกันดีกว่า

- (หรือ)

ตัวดำเนินการ “OR” จะแสดงด้วยสัญลักษณ์เส้นแนวตั้ง 2 อัน:

 ผลลัพธ์ = ก || ข;

ในการเขียนโปรแกรมคลาสสิก ตรรกะ OR มีไว้เพื่อจัดการค่าบูลีนเท่านั้น หากอาร์กิวเมนต์ใดๆ เป็น true ก็จะส่งกลับค่า true มิฉะนั้นจะส่งกลับค่า false

ใน JavaScript โอเปอเรเตอร์จะซับซ้อนกว่าเล็กน้อยและมีประสิทธิภาพมากกว่า แต่ก่อนอื่น เรามาดูกันว่าเกิดอะไรขึ้นกับค่าบูลีน

มีการรวมตรรกะที่เป็นไปได้สี่แบบ:

 การแจ้งเตือน ( จริง || จริง );   // จริง
การแจ้งเตือน (เท็จ || จริง);  // จริง
การแจ้งเตือน ( จริง || เท็จ );  // จริง
การแจ้งเตือน (เท็จ || เท็จ); // เท็จ

ดังที่เราเห็น ผลลัพธ์จะเป็น true เสมอ ยกเว้นในกรณีที่ตัวถูกดำเนินการทั้งสองเป็น false

หากตัวถูกดำเนินการไม่ใช่บูลีน ก็จะถูกแปลงเป็นบูลีนสำหรับการประเมิน

ตัวอย่างเช่น หมายเลข 1 ถือเป็น true และหมายเลข 0 เป็น false :

 if (1 || 0) { // ทำงานเหมือนกับ if( true || false )
  alert( 'ความจริง!' );
-

เกือบตลอดเวลา หรือ || ใช้ในคำสั่ง if เพื่อทดสอบว่าเงื่อนไข ใดๆ ที่กำหนดเป็น true หรือไม่

ตัวอย่างเช่น:

 ให้ชั่วโมง = 9;

ถ้า (ชั่วโมง < 10 || ชั่วโมง > 18) {
  alert( 'สำนักงานปิดทำการ' );
-

เราสามารถผ่านเงื่อนไขเพิ่มเติมได้:

 ให้ชั่วโมง = 12;
ให้ isWeekend = จริง;

ถ้า (ชั่วโมง < 10 || ชั่วโมง > 18 || คือวันหยุดสุดสัปดาห์) {
  alert( 'สำนักงานปิดทำการ' ); // มันเป็นวันหยุดสุดสัปดาห์
-

หรือ "||" ค้นหาค่าความจริงแรก

ตรรกะที่อธิบายไว้ข้างต้นค่อนข้างคลาสสิก ตอนนี้เรามาดูคุณสมบัติ "พิเศษ" ของ JavaScript กันดีกว่า

อัลกอริธึมแบบขยายทำงานดังนี้

รับค่า OR'ed หลายค่า:

 ผลลัพธ์ = ค่า 1 || ค่า2 || ค่า3;

หรือ || โอเปอเรเตอร์ดำเนินการดังต่อไปนี้:

• ประเมินตัวถูกดำเนินการจากซ้ายไปขวา

• สำหรับตัวถูกดำเนินการแต่ละตัว ให้แปลงเป็นบูลีน หากผลลัพธ์เป็น true ให้หยุดและส่งกลับค่าเดิมของตัวถูกดำเนินการนั้น

• หากตัวถูกดำเนินการทั้งหมดได้รับการประเมิน (เช่น ทั้งหมดเป็น false ) จะส่งกลับตัวถูกดำเนินการสุดท้าย

ค่าจะถูกส่งกลับในรูปแบบดั้งเดิม โดยไม่มีการแปลง

กล่าวอีกนัยหนึ่งคือสายโซ่ของ OR || ส่งคืนค่าความจริงค่าแรกหรือค่าสุดท้ายหากไม่พบค่าความจริง

ตัวอย่างเช่น:

 การแจ้งเตือน (1 || 0 ); // 1 (1 เป็นความจริง)

การแจ้งเตือน ( null || 1 ); // 1 (1 คือค่าความจริงแรก)
การแจ้งเตือน ( null || 0 || 1 ); // 1 (ค่าความจริงแรก)

การแจ้งเตือน ( ไม่ได้กำหนด || null || 0 ); // 0 (เป็นเท็จทั้งหมด ส่งกลับค่าสุดท้าย)

สิ่งนี้นำไปสู่การใช้งานที่น่าสนใจเมื่อเปรียบเทียบกับ “pure, classic, boolean-only OR”

1. รับค่าความจริงแรกจากรายการตัวแปรหรือนิพจน์

   ตัวอย่างเช่น เรามีตัวแปร firstName , lastName และ nickName ซึ่งเป็นทางเลือกทั้งหมด (เช่น สามารถกำหนดไม่ได้หรือมีค่าเป็นเท็จก็ได้)

   ลองใช้ OR || กันดีกว่า เพื่อเลือกอันที่มีข้อมูลและแสดง (หรือ "Anonymous" หากไม่มีการตั้งค่า):

    ให้ firstName = "";
   ให้นามสกุล = "";
   ให้ชื่อเล่น = "SuperCoder";
   
   alert( ชื่อ || นามสกุล || ชื่อเล่น || "ไม่ระบุชื่อ"); // ซุปเปอร์โค้ดเดอร์

   หากตัวแปรทั้งหมดเป็นเท็จ "Anonymous" จะปรากฏขึ้น

2. การประเมินการลัดวงจร

   คุณสมบัติอื่นของ OR || ตัวดำเนินการคือการประเมินที่เรียกว่า "ลัดวงจร"

   แปลว่า || ประมวลผลอาร์กิวเมนต์ของมันจนกว่าจะถึงค่าความจริงค่าแรก จากนั้นค่าจะถูกส่งกลับทันที โดยไม่ต้องแตะต้องอาร์กิวเมนต์อื่นด้วยซ้ำ

   ความสำคัญของคุณลักษณะนี้จะเห็นได้ชัดหากตัวถูกดำเนินการไม่ได้เป็นเพียงค่า แต่เป็นนิพจน์ที่มีผลข้างเคียง เช่น การกำหนดตัวแปร หรือการเรียกใช้ฟังก์ชัน

   ในตัวอย่างด้านล่าง เฉพาะข้อความที่สองเท่านั้นที่ถูกพิมพ์:

    จริง || alert("ไม่ได้พิมพ์");
   เท็จ || alert("พิมพ์แล้ว");

   ในบรรทัดแรก OR || โอเปอเรเตอร์หยุดการประเมินทันทีเมื่อเห็น true ดังนั้น alert จะไม่ทำงาน

   บางครั้งผู้คนใช้คุณสมบัตินี้เพื่อดำเนินการคำสั่งเฉพาะในกรณีที่เงื่อนไขทางด้านซ้ายเป็นเท็จ

&& (และ)

ตัวดำเนินการ AND จะแสดงด้วยเครื่องหมายและสองตัว && :

 ผลลัพธ์ = ก && b;

ในการเขียนโปรแกรมแบบคลาสสิก AND จะคืนค่า true หากตัวถูกดำเนินการทั้งสองเป็นความจริงและ false มิฉะนั้น:

 การแจ้งเตือน ( จริง && จริง );   // จริง
การแจ้งเตือน (เท็จ && จริง);  // เท็จ
การแจ้งเตือน ( จริง && เท็จ );  // เท็จ
การแจ้งเตือน (เท็จ && เท็จ); // เท็จ

ตัวอย่างด้วย if :

 ให้ชั่วโมง = 12;
ให้นาที = 30;

ถ้า (ชั่วโมง == 12 && นาที == 30) {
  alert( 'ขณะนี้เวลา 12:30' );
-

เช่นเดียวกับ OR ค่าใดๆ จะได้รับอนุญาตให้เป็นตัวถูกดำเนินการของ AND:

 ถ้า (1 && 0) { // ประเมินว่าเป็นจริง && เท็จ
  alert( "ใช้งานไม่ได้เพราะผลออกมาไม่จริง" );
-

และ “&&” ค้นหาค่าเท็จแรก

รับค่า AND'ed หลายค่า:

 ผลลัพธ์ = value1 && value2 && value3;

ตัวดำเนินการ AND && ดำเนินการดังต่อไปนี้:

• ประเมินตัวถูกดำเนินการจากซ้ายไปขวา

• สำหรับตัวถูกดำเนินการแต่ละตัว ให้แปลงเป็นบูลีน หากผลลัพธ์เป็น false ให้หยุดและส่งคืนค่าเดิมของตัวถูกดำเนินการนั้น

• หากตัวถูกดำเนินการทั้งหมดได้รับการประเมิน (กล่าวคือ ทั้งหมดเป็นความจริง) จะส่งกลับตัวถูกดำเนินการสุดท้าย

กล่าวอีกนัยหนึ่ง AND ส่งคืนค่าเท็จแรกหรือค่าสุดท้ายหากไม่พบ

กฎข้างต้นคล้ายกับหรือ ข้อแตกต่างคือ AND ส่งคืนค่า เท็จค่า แรก ในขณะที่ OR ส่งคืน ค่าจริง ค่าแรก

ตัวอย่าง:

 // ถ้าตัวถูกดำเนินการตัวแรกเป็นจริง
// และส่งคืนตัวถูกดำเนินการที่สอง:
การแจ้งเตือน ( 1 && 0 ); // 0
การแจ้งเตือน( 1 && 5 ); // 5

// ถ้าตัวถูกดำเนินการตัวแรกเป็นเท็จ
// และส่งคืน ตัวถูกดำเนินการที่สองจะถูกละเว้น
การแจ้งเตือน ( null && 5 ); // โมฆะ
alert( 0 && "ไม่ว่าอะไรจะเกิดขึ้น" ); // 0

นอกจากนี้เรายังสามารถส่งค่าหลายค่าติดต่อกันได้ ดูว่าอันที่ผิดอันแรกถูกส่งกลับอย่างไร:

 การแจ้งเตือน ( 1 && 2 && null && 3 ); // โมฆะ

เมื่อค่าทั้งหมดเป็นความจริง ค่าสุดท้ายจะถูกส่งกลับ:

 การแจ้งเตือน ( 1 && 2 && 3 ); //3อันสุดท้าย

ลำดับความสำคัญของ AND && สูงกว่า OR ||

ลำดับความสำคัญของตัวดำเนินการ AND && สูงกว่า OR || -

ดังนั้นรหัส a && b || c && d โดยพื้นฐานแล้วเหมือนกับว่านิพจน์ && อยู่ในวงเล็บ: (a && b) || (c && d) .

อย่าแทนที่ if ด้วย || หรือ &&

บางครั้งผู้คนใช้ตัวดำเนินการ AND && เป็น “วิธีที่สั้นกว่าในการเขียน if ”

ตัวอย่างเช่น:

 ให้ x = 1;

(x > 0) && alert( 'มากกว่าศูนย์!' );

การดำเนินการในส่วนที่ถูกต้องของ && จะดำเนินการเฉพาะเมื่อการประเมินไปถึงเท่านั้น กล่าวคือ เมื่อ (x > 0) เป็นจริงเท่านั้น

ดังนั้นเราจึงมีอะนาล็อกสำหรับ:

 ให้ x = 1;

if (x > 0) alert( 'มากกว่าศูนย์!' );

แม้ว่ารูปแบบที่มี && จะดูสั้นกว่า if ชัดเจนกว่าและมีแนวโน้มที่จะอ่านง่ายกว่าเล็กน้อย ดังนั้นเราขอแนะนำให้ใช้ทุกโครงสร้างตามวัตถุประสงค์: ใช้ if เราต้องการ if และใช้ && หากเราต้องการ AND

- (ไม่)

ตัวดำเนินการ NOT แบบบูลีนจะแสดงด้วยเครื่องหมายอัศเจรีย์ ! -

ไวยากรณ์ค่อนข้างง่าย:

 ผลลัพธ์ = !ค่า;

ตัวดำเนินการยอมรับอาร์กิวเมนต์เดียวและดำเนินการดังต่อไปนี้:

1. แปลงตัวถูกดำเนินการให้เป็นประเภทบูลีน: true/false

2. ส่งกลับค่าผกผัน

ตัวอย่างเช่น:

 แจ้งเตือน( !true ); // เท็จ
แจ้งเตือน( !0 ); // จริง

ไม่สองเท่า !! บางครั้งใช้สำหรับการแปลงค่าเป็นประเภทบูลีน:

 alert( !!"สตริงไม่ว่าง" ); // จริง
แจ้งเตือน( !!null ); // เท็จ

นั่นคือ ค่าแรกไม่แปลงค่าเป็นบูลีนและส่งกลับค่าผกผัน และค่าที่สองไม่กลับค่าอีกครั้ง ในท้ายที่สุด เราก็มีการแปลงค่าเป็นบูลีนธรรมดา

มีวิธีที่ละเอียดกว่านี้เล็กน้อยในการทำสิ่งเดียวกัน – ฟังก์ชัน Boolean ในตัว:

 alert( บูลีน("สตริงที่ไม่ว่างเปล่า") ); // จริง
การแจ้งเตือน ( บูลีน (null) ); // เท็จ

ลำดับความสำคัญของ NOT ! เป็นตัวดำเนินการเชิงตรรกะที่สูงที่สุด ดังนั้นจึงจะดำเนินการก่อนเสมอ ก่อน && หรือ || -

งาน

ผลลัพธ์ของ OR คืออะไร?

ความสำคัญ: 5

รหัสด้านล่างจะส่งออกอะไร?

 การแจ้งเตือน ( null || 2 || ไม่ได้กำหนด );

สารละลาย

คำตอบคือ 2 นั่นคือค่าความจริงค่าแรก

 การแจ้งเตือน ( null || 2 || ไม่ได้กำหนด );

การแจ้งเตือน OR'ed มีผลอย่างไร?

ความสำคัญ: 3

รหัสด้านล่างจะแสดงผลอะไร?

 การแจ้งเตือน( การแจ้งเตือน(1) || 2 || การแจ้งเตือน(3) );

สารละลาย

คำตอบ: อันดับแรก 1 จากนั้น 2

 การแจ้งเตือน( การแจ้งเตือน(1) || 2 || การแจ้งเตือน(3) );

การเรียกแจ้ง alert ไม่ส่งกลับค่า หรืออีกนัยหนึ่ง จะส่งกลับ undefined

1. อันแรกหรือ || ประเมิน alert(1) นั่นแสดงข้อความแรกด้วย 1

2. alert จะส่งกลับค่า undefined ดังนั้น OR จะไปต่อที่ตัวถูกดำเนินการตัวที่สองเพื่อค้นหาค่าที่เป็นความจริง

3. ตัวถูกดำเนินการตัวที่สอง 2 เป็นค่าจริง ดังนั้นการดำเนินการจึงหยุดลง และ 2 จะถูกส่งกลับ จากนั้นจึงแสดงโดยการแจ้งเตือนภายนอก

จะไม่มี 3 เนื่องจากการประเมินไม่ถึง alert(3)

ผลลัพธ์ของ AND คืออะไร?

ความสำคัญ: 5

รหัสนี้จะแสดงอะไร?

 การแจ้งเตือน ( 1 && null && 2 );

สารละลาย

คำตอบ: null เนื่องจากเป็นค่าเท็จค่าแรกจากรายการ

 การแจ้งเตือน (1 && null && 2);

ผลลัพธ์ของการแจ้งเตือน AND'ed คืออะไร?

ความสำคัญ: 3

รหัสนี้จะแสดงอะไร?

 การแจ้งเตือน( การแจ้งเตือน(1) && การแจ้งเตือน(2) );

สารละลาย

คำตอบ: 1 แล้ว undefined

 การแจ้งเตือน( การแจ้งเตือน(1) && การแจ้งเตือน(2) );

การเรียกแจ้ง alert ส่งคืน undefined (เพียงแสดงข้อความ ดังนั้นจึงไม่มีการส่งคืนที่มีความหมาย)

ด้วยเหตุนี้ && จึงประเมินค่าตัวถูกดำเนินการทางด้านซ้าย (เอาต์พุต 1 ) และหยุดทันที เนื่องจาก undefined เป็นค่าเท็จ และ && ค้นหาค่าเท็จแล้วส่งคืน ก็เป็นอันเสร็จสิ้น

ผลลัพธ์ของ OR และ OR

ความสำคัญ: 5

ผลลัพธ์จะเป็นอย่างไร?

 การแจ้งเตือน ( null || 2 && 3 || 4 );

สารละลาย

คำตอบ: 3 .

 การแจ้งเตือน ( null || 2 && 3 || 4 );

ลำดับความสำคัญของ AND && สูงกว่า || ดังนั้นมันจึงดำเนินการก่อน

ผลลัพธ์ของ 2 && 3 = 3 ดังนั้นนิพจน์จึงกลายเป็น:

 โมฆะ || 3 || 4

ตอนนี้ผลลัพธ์คือค่าความจริงแรก: 3

ตรวจสอบช่วงระหว่าง

ความสำคัญ: 3

เขียนเงื่อนไข if เพื่อตรวจสอบว่า age อยู่ระหว่าง 14 ถึง 90 โดยรวม

“รวม” หมายความว่า age สามารถถึงขอบ 14 หรือ 90 ได้

สารละลาย

 ถ้า (อายุ >= 14 && อายุ <= 90)

ตรวจสอบระยะภายนอก

ความสำคัญ: 3

เขียนเงื่อนไข if เพื่อตรวจสอบว่า age ไม่ได้อยู่ระหว่าง 14 ถึง 90

สร้างสองรูปแบบ: แบบแรกโดยใช้ NOT ! อันที่สอง – ไม่มีมัน

สารละลาย

ตัวแปรแรก:

 ถ้า (!(อายุ >= 14 && อายุ <= 90))

ตัวแปรที่สอง:

 ถ้า (อายุ < 14 || อายุ > 90)

คำถามเกี่ยวกับ "ถ้า"

ความสำคัญ: 5

การ alert ใดต่อไปนี้ที่จะดำเนินการ?

ผลลัพธ์ของนิพจน์จะอยู่ภายใน if(...) อย่างไร?

 ถ้า (-1 || 0) แจ้งเตือน ( 'ครั้งแรก' );
ถ้า (-1 && 0) แจ้งเตือน ( 'วินาที' );
ถ้า (null || -1 && 1) การแจ้งเตือน ( 'ที่สาม' );

สารละลาย

คำตอบ: ตัวแรกและตัวที่สามจะดำเนินการ

รายละเอียด:

 //วิ่ง..
// ผลลัพธ์ของ -1 || 0 = -1 จริง
ถ้า (-1 || 0) แจ้งเตือน ( 'ครั้งแรก' );

//ไม่วิ่ง.
// -1 && 0 = 0, เท็จ
ถ้า (-1 && 0) แจ้งเตือน ( 'วินาที' );

//ดำเนินการ
// ตัวดำเนินการ && มีลำดับความสำคัญสูงกว่า ||
// ดังนั้น -1 && 1 จะดำเนินการก่อน โดยให้ห่วงโซ่แก่เรา:
// โมฆะ || -1 && 1 -> โมฆะ || 1 -> 1
ถ้า (null || -1 && 1) การแจ้งเตือน ( 'สาม' );

ตรวจสอบการเข้าสู่ระบบ

ความสำคัญ: 3

เขียนโค้ดที่ขอล็อกอินด้วย prompt

หากผู้เยี่ยมชมป้อน "Admin" ให้ prompt รหัสผ่าน หากอินพุตเป็นบรรทัดว่างหรือ Esc – แสดง “ยกเลิก” หากเป็นสตริงอื่น ให้แสดง “ฉันไม่รู้จักคุณ”

รหัสผ่านจะถูกตรวจสอบดังนี้:

• หากเท่ากับ “TheMaster” ให้แสดง “ยินดีต้อนรับ!”

• สตริงอื่น - แสดง "รหัสผ่านผิด"

• สำหรับสตริงว่างหรืออินพุตที่ยกเลิก ให้แสดง "ยกเลิก"

สคีมา:

กรุณาใช้ซ้อน if บล็อก คำนึงถึงความสามารถในการอ่านโดยรวมของโค้ด

คำแนะนำ: การส่งอินพุตว่างไปยังพรอมต์จะส่งคืนสตริงว่าง '' การกด ESC ในระหว่างที่พร้อมต์จะคืนค่า null

เรียกใช้การสาธิต

สารละลาย

 ให้ชื่อผู้ใช้ = prompt("มีใครอยู่บ้าง?", '');

ถ้า (ชื่อผู้ใช้ === 'ผู้ดูแลระบบ') {

  ให้ผ่าน = prompt('รหัสผ่าน?', '');

  ถ้า (ผ่าน === 'TheMaster') {
    alert( 'ยินดีต้อนรับ!' );
  } อื่นถ้า (ผ่าน === '' || ผ่าน === null) {
    alert( 'ยกเลิกแล้ว' );
  } อื่น {
    alert( 'รหัสผ่านผิด' );
  -

} อื่น ๆ ถ้า (ชื่อผู้ใช้ === '' || ชื่อผู้ใช้ === null) {
  alert( 'ยกเลิกแล้ว' );
} อื่น {
  alert( "ฉันไม่รู้จักคุณ" );
-

สังเกตการเยื้องแนวตั้งภายในบล็อก if ไม่จำเป็นในทางเทคนิค แต่ทำให้โค้ดอ่านง่ายขึ้น