โอเปอเรเตอร์การเปรียบเทียบ

โอเปอเรเตอร์การเปรียบเทียบจะเปรียบเทียบค่าของตัวถูกดำเนินการ 2 ตัวและประเมินว่าฟังก์ชัน ข้อความที่สร้างคือ true หรือ false ตัวอย่างต่อไปนี้ใช้ โอเปอเรเตอร์ Strict Equality (===) เพื่อเปรียบเทียบตัวถูกดำเนินการ 2 ตัว ซึ่งก็คือนิพจน์ 2 + 2 และค่า 4 เนื่องจากผลลัพธ์ของนิพจน์และตัวเลข ค่า 4 เหมือนกัน นิพจน์นี้จะประเมินเป็น true

2 + 2 === 4
> true

พิมพ์การบีบบังคับและความเท่าเทียม

โอเปอเรเตอร์การเปรียบเทียบที่ใช้บ่อยที่สุด 2 รายการคือ == สําหรับความเท่าเทียมแบบหลวม และ===เพื่อความเท่าเทียมที่เข้มงวด == จะทำการเปรียบเทียบแบบคร่าวๆ ระหว่าง โดยการปรับตัวถูกดำเนินการให้เป็นประเภทข้อมูลที่ตรงกัน ถ้าเป็นไปได้ สำหรับ ตัวอย่างเช่น 2 == "2" จะแสดงผล true แม้ว่าจะทำการเปรียบเทียบ ระหว่างค่าตัวเลขกับค่าสตริง

2 == 2
> true

2 == "2"
> true

เช่นเดียวกันกับ != ซึ่งจะแสดงผล true ก็ต่อเมื่อตัวถูกดำเนินการถูก เปรียบเทียบว่าไม่เท่ากันอย่างหลวมๆ เลย

2 != 3
> true

2 != "2"
> false

การเปรียบเทียบแบบเข้มงวดที่ใช้ === หรือ !== จะไม่บีบบังคับประเภท สำหรับ การเปรียบเทียบอย่างเคร่งครัดเพื่อประเมินกับ true ค่าที่จะเปรียบเทียบต้องมีแอตทริบิวต์ ข้อมูลประเภทเดียวกัน ด้วยเหตุนี้ 2 == "2" จึงแสดงผล true แต่เป็น 2 === "2" แสดงผล false:

2 === 3
> false

2 === "2"
> false

หากต้องการลบความกำกวมที่อาจเกิดขึ้นจากการบังคับใช้อัตโนมัติ ให้ใช้ === เมื่อใดก็ได้ เท่าที่จะเป็นไปได้

โอเปอเรเตอร์ คำอธิบาย การใช้งาน ผลลัพธ์
=== เท่ากันทุกประการ 2 === 2 จริง
!== ไม่เท่าเทียมกันอย่างเคร่งครัด 2 !== "2" จริง
== เท่ากับ (หรือ "เท่ากันแบบหลวมๆ") 2 == "2" จริง
!= ไม่เท่ากัน 2 != "3" จริง
> มากกว่า 3 2 ครั้ง จริง
>= มากกว่าหรือเท่ากับ 2 >= 2 จริง
< น้อยกว่า 2 < 3 ครั้ง จริง
<= น้อยกว่าหรือเท่ากับ 2 <= 3 จริง

จริงและเท็จ

ค่าทั้งหมดใน JavaScript เป็น true หรือ false โดยปริยาย และสามารถบังคับให้เป็น ค่าบูลีนที่เกี่ยวข้อง เช่น โดยใช้ฟังก์ชัน "loosely equal" ตัวเปรียบเทียบ ชุดค่าที่จำกัดบังคับให้เป็น false:

  • 0
  • null
  • undefined
  • NaN
  • สตริงว่าง ("")

ค่าอื่นๆ ทั้งหมดจะบังคับให้เป็น true รวมถึงสตริงที่มีอย่างน้อย 1 รายการ อักขระและตัวเลขทั้งหมดที่ไม่ใช่ 0 เหล่านี้เรียกกันโดยทั่วไปว่า "ทรูธี" และ "หลอก"

"My string" == true
> true

100 == true
> true

0 == true
> false

โอเปอเรเตอร์ทางตรรกะ

ใช้ตัวดำเนินการตรรกะ AND (&&), หรือ (||) และ NOT (!) เพื่อควบคุมการทำงานของสคริปต์ตามการประเมินคำสั่งแบบมีเงื่อนไขตั้งแต่ 2 คำสั่งขึ้นไป ดังนี้


2 === 3 || 5 === 5;
> true

2 === 2 && 2 === "2"
> false

2 === 2 && !"My string."
> false

นิพจน์เชิงตรรกะ NOT (!) จะลบค่าที่แท้จริงหรือค่าที่ไม่ถูกต้องของตัวถูกดำเนินการ การประเมินเป็น true หากตัวถูกดำเนินการประเมินเป็น false และประเมินเป็น false หากตัวถูกดำเนินการประเมินเป็น true


true
> true

!true
> false

!false
> true

การใช้โอเปอเรเตอร์ตรรกะ NOT (!) หน้าข้อมูลประเภทอื่น เช่น ตัวเลขหรือสตริง บังคับค่านั้นเป็นบูลีนและกลับค่าทรูธ (truthy) หรือ ของผลลัพธ์ที่ไม่ถูกต้อง

"string"
> "string"

!"string"
> false

0
> 0

!0
> true

แนวทางปฏิบัติทั่วไปคือการใช้โอเปอเรเตอร์ NOT 2 ตัวเพื่อบังคับให้ข้อมูลไปยัง ค่าบูลีนที่ตรงกัน:

!!"string"
> true

!!0
> false

ตัวดำเนินการตรรกะ AND และ OR จะไม่ทำการบังคับด้วยตัวเอง โฆษณาเหล่านี้ จะแสดงค่าของตัวถูกดำเนินการ 1 ใน 2 ตัวที่กำลังประเมิน ด้วยค่า ตัวถูกดำเนินการที่กำหนดโดยการประเมินนั้น

ตัวถูกดำเนินการตรรกะ AND (&&) จะแสดงผลตัวถูกดำเนินการแรกจาก 2 ตัวก็ต่อเมื่อตัวถูกดำเนินการนั้น ประเมินได้เป็น false และตัวถูกดำเนินการที่สองเป็นอย่างอื่น ในการเปรียบเทียบ ประเมินเป็นค่าบูลีน ระบบจะแสดงผล true ก็ต่อเมื่อตัวถูกดำเนินการทั้ง 2 ฝั่ง ของตรรกะ AND ประเมินผลกับ true หากทั้ง 2 ฝั่งประเมินเป็น false ระบบจะประเมิน แสดงผล false

true && false
> false

false && true
> false

false && false
> false

true && true
> true

เมื่อใช้ && กับตัวถูกดำเนินการที่ไม่ใช่บูลีน 2 ตัว ระบบจะแสดงผลตัวถูกดำเนินการแรก ไม่เปลี่ยนแปลงหากเปลี่ยนเป็น false ได้ หากสามารถเปลี่ยนตัวถูกดำเนินการแรกได้ เป็น true จะแสดงผลตัวถูกดำเนินการที่ 2 ไม่เปลี่ยนแปลง

false && "My string"
> false

null && "My string"
> null

"My string" && false
> false

"My string" && "My second string"
> "My second string"

2 === 2 && "My string"
> "My string"

ตัวถูกดำเนินการตรรกะ OR (||) จะแสดงผลตัวถูกดำเนินการแรกจาก 2 ตัวก็ต่อเมื่อตัวถูกดำเนินการนั้น ประเมินได้เป็น true และตัวถูกดำเนินการที่สองเป็นอย่างอื่น ในการเปรียบเทียบ ประเมินเป็นค่าบูลีน ซึ่งหมายความว่าจะแสดงผล true หากตัวถูกดำเนินการอย่างใดอย่างหนึ่ง ประเมินเป็น true และหากไม่มีทั้ง 2 ฝั่งประเมินเป็น true ก็จะแสดงผล false:

true || false
> true

false || true
> true

true || true
> true

false || false
> false

เมื่อใช้ || กับตัวถูกดำเนินการที่ไม่ใช่บูลีน 2 ตัว จะแสดงผลตัวถูกดำเนินการแรก ไม่เปลี่ยนแปลงหากสามารถเปลี่ยนเป็น true หากสามารถเปลี่ยนตัวถูกดำเนินการแรกได้ เป็น false จะแสดงผลตัวถูกดำเนินการที่ 2 ไม่เปลี่ยนแปลง

false || "My string"
> "My string"

null || "My string"
> "My string"

"My string" || false
> "My string"

"My string" || "My second string"
> "My string"

2 === 2 || "My string"
> true

โอเปอเรเตอร์การรวมที่ไม่มีข้อมูล

เปิดตัวใน ES2020 "โอเปอเรเตอร์การรวมที่ไม่มีข้อมูล" (??) จะแสดงผลตัวถูกดำเนินการแรกก็ต่อเมื่อ ตัวถูกดำเนินการมีค่าอื่นนอกเหนือจาก null หรือ undefined มิเช่นนั้น ระบบจะส่งคืน ตัวถูกดำเนินการที่สอง

null ?? "My string"
> "My string"

undefined ?? "My string"
> "My string"

true ?? "My string";
> true

?? คล้ายกับตรรกะ OR แต่เข้มงวดกว่าในค่าของตัวถูกดำเนินการแรก ประเมินผลแล้ว || จะแสดงผลตัวถูกดำเนินการที่สองสำหรับนิพจน์ใดๆ ที่สามารถ เปลี่ยนเป็น false รวมถึง undefined และ null ?? แสดงผลเป็นชิ้นที่ 2 เมื่อตัวถูกดำเนินการแรกเป็นอะไรก็ตาม ยกเว้น null หรือ undefined แม้ว่าตัวถูกดำเนินการ สามารถเปลี่ยนเป็น false:

0 ?? "My string";
> 0

false ?? "My string";
> false

undefined ?? "My string";
> "My string"

โอเปอเรเตอร์การกำหนดเชิงตรรกะ

ใช้โอเปอเรเตอร์การมอบหมายเพื่อกำหนดค่าของโอเปอเรเตอร์รายการที่ 2 ให้กับโอเปอเรเตอร์แรก ตัวอย่างที่พบบ่อยที่สุดคือเครื่องหมายเท่ากับเดี่ยว (=) ใช้เพื่อ กำหนดค่าให้กับตัวแปรที่ประกาศ

ใช้โอเปอเรเตอร์การกำหนดเชิงตรรกะเพื่อกำหนดค่าตัวแปรอย่างมีเงื่อนไข โดยอิงจากค่าที่แท้จริงหรือค่าที่เป็นเท็จของตัวแปรนั้น

โอเปอเรเตอร์เชิงตรรกะ AND การกำหนด (&&=) จะประเมินตัวถูกดำเนินการลำดับที่ 2 และ จะกำหนดให้กับตัวถูกดำเนินการแรกก็ต่อเมื่อตัวถูกดำเนินการแรกเท่านั้น true อย่างมีประสิทธิภาพ "หากตัวถูกดำเนินการแรกเป็นจริง ให้กำหนดค่า ตัวถูกดำเนินการที่สองแทน"

let myVariable = false;
myVariable
&&= 2 + 2;
> false

myVariable
= true;
myVariable
&&= 2 + 2;
> 4

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

let myVariable = 5;
myVariable
> 2 &&= "My string"
> SyntaxError: Invalid left-hand side in assignment

โอเปอเรเตอร์ตรรกะการกำหนด OR (||=) จะประเมินตัวถูกดำเนินการที่ 2 และ กำหนดให้ตัวถูกดำเนินการแรกหากตัวถูกดำเนินการแรกประเมินเป็น false "หากตัวถูกดำเนินการแรกเป็น "เท็จ" ให้กำหนดค่าของตัวดำเนินการที่สอง ตัวถูกดำเนินการแทน:"

let myVariable = false;
myVariable
||= 2 + 2;
> 4

myVariable
= true;
myVariable
||= 2 + 2;
> true

ตรวจสอบความเข้าใจ

โอเปอเรเตอร์ใดระบุว่า "เท่ากันทั้งหมด"

!=
=
==
===