โอเปอเรเตอร์การเปรียบเทียบจะเปรียบเทียบค่าของตัวถูกดำเนินการ 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
ตรวจสอบความเข้าใจ
โอเปอเรเตอร์ใดระบุว่า "เท่ากันทั้งหมด"
!=
=
===
==