ความแตกต่างระหว่างตัวดำเนินการความเท่าเทียมกันอย่างเข้มงวดกับตัวดำเนินการความเท่าเทียมกันใน JavaScript คืออะไร?

เรียนรู้เกี่ยวกับความแตกต่างระหว่างตัวดำเนินการความเท่าเทียมกันที่เข้มงวดกับตัวดำเนินการความเท่าเทียมกันที่หลวมใน JavaScript และเหตุใดจึงสำคัญ

ใน JavaScript คุณสามารถใช้โอเปอเรเตอร์ความเท่าเทียมกันสองตัวเพื่อเปรียบเทียบค่า ตัวดำเนินการความเท่าเทียมกันหลวม == (สองเท่า) และตัวดำเนินการความเท่าเทียมกันที่เข้มงวด === (สามเท่ากับ). ปรากฏบนพื้นผิวเหมือนกัน แต่ไม่เหมือนกัน และสิ่งสำคัญคือต้องเข้าใจความแตกต่าง เพราะหากไม่เป็นเช่นนั้น คุณอาจพบข้อบกพร่อง

ลองรันโค้ดต่อไปนี้ในคอนโซลของคุณ:

let a = 4 // number
let b = "4" // string

console.log(a == b) // output: true

เหตุใด JavaScript จึงบอกว่าข้อความข้างต้น จริง เมื่อไม่ได้? เรามีค่าประเภท number เปรียบเทียบกับค่าประเภท string — แล้วจะมีค่าเท่ากันได้อย่างไร?

นั่นเป็นเพราะเมื่อคุณใช้ตัวดำเนินการความเท่าเทียมกันหลวม == มันแปลงตัวถูกดำเนินการเป็น เหมือนกัน พิมพ์ (ถ้ายังไม่ได้) แล้วเปรียบเทียบค่าของพวกเขา

กระบวนการนี้เรียกว่า การบีบบังคับ (เมื่อเปรียบเทียบสองค่า หลัง พยายามแปลงเป็นประเภททั่วไป)

ในตัวอย่างข้างต้น ผลลัพธ์ของ true ถูกต้อง เพราะก่อนที่จะเปรียบเทียบค่า ประเภทของค่าจะถูกแปลงให้เหมือนกัน

ว้าว โง่จัง!

ฉันเห็นด้วย แต่นั่นเป็นวิธีการ สิ่งสำคัญคือคุณต้องตระหนักถึง "ความแปลกประหลาด" ของ JavaScript ที่ไม่สะดวก

และนั่นคือจุดที่ตัวดำเนินการความเท่าเทียมที่เข้มงวด === เข้ามาประหยัดวันเพราะไม่แปลงประเภทค่า อย่างเคร่งครัด เปรียบเทียบประเภทค่าแล้วตรวจสอบความเท่าเทียมกัน:

let a = 4
let b = "4"

console.log(a === b)
// output: false

ตอนนี้เราได้รับ false เนื่องจากแม้ว่าตัวแปรทั้งสอง (a &b) จะมีค่าเป็น “4” แต่ตัวถูกดำเนินการเป็นประเภทค่าที่แตกต่างกัน (a คือค่าตัวเลข b คือค่าสตริง)

ต่างจาก == . ที่ไม่เข้มงวด โอเปอเรเตอร์ === . ที่เข้มงวด โอเปอเรเตอร์ให้ผลลัพธ์ที่คาดเดาได้ ซึ่งเป็นสาเหตุที่นักพัฒนาส่วนใหญ่ไม่แนะนำให้ใช้ == .

เคยมีเหตุผลที่ดีหรือไม่ เพื่อใช้ตัวดำเนินการเปรียบเทียบแบบไม่เข้มงวดใน JavaScript?

ไม่ค่อยมี แต่ฉันแน่ใจว่าคุณสามารถหาตัวอย่างได้ ตามกฎทั่วไป ค่าเริ่มต้นคือการใช้ === . ที่เข้มงวด ตัวดำเนินการความเท่าเทียมกัน เว้นแต่จะมีชัดเจน เหตุผลที่ใช้ == . ที่ไม่เคร่งครัด ตัวดำเนินการความเท่าเทียมกัน วิธีนี้จะช่วยให้คุณขจัดข้อบกพร่องในโค้ดที่เกิดจากการใช้ตัวดำเนินการความเท่าเทียมกันที่ไม่ถูกต้อง ซึ่งถือเป็นโบนัสเสมอ