ความแตกต่างระหว่าง (NaN! = NaN) และ (NaN! == NaN) คืออะไร

ก่อนอื่นฉันต้องการพูดถึงว่าฉันรู้วิธีisNaN()และการNumber.isNaN()ทำงาน ฉันกำลังอ่านคู่มือที่ชัดเจนโดย David Flanagan และเขายกตัวอย่างวิธีการตรวจสอบว่ามีค่าNaN:

x !== x

ซึ่งจะส่งผลtrueถ้าหากมีxNaN

แต่ตอนนี้ฉันมีคำถาม: ทำไมเขาใช้การเปรียบเทียบที่เข้มงวด เพราะดูเหมือนว่า

x != x

ทำงานในลักษณะเดียวกัน มันมีความปลอดภัยที่จะใช้ทั้งสองรุ่นหรือฉันหายไปค่าบางอย่าง (s) ใน JavaScript ที่จะกลับมาtrueสำหรับx !== xและfalseสำหรับx != x?

ก่อนอื่นให้ฉันชี้ให้เห็นว่าNaNเป็นค่าพิเศษมาก: ตามคำนิยามมันไม่เท่ากับตัวเอง มาจากมาตรฐาน IEEE-754 ที่ใช้จาวาสคริปต์ ค่า "ไม่ใช่ตัวเลข" จะไม่เท่ากับตัวเองแม้ว่าบิตจะเป็นการจับคู่ที่ตรงกัน (ซึ่งไม่จำเป็นต้องอยู่ใน IEEE-754 แต่จะอนุญาตให้ใช้ค่า "ไม่ใช่ตัวเลข" ได้หลายค่า) ซึ่งเป็นสาเหตุที่ทำให้เกิดสิ่งนี้ขึ้นมา ค่าอื่น ๆ ทั้งหมดในจาวาสคริปต์นั้นมีค่าเท่ากับตัวเองNaNเป็นพิเศษ

... ฉันไม่มีค่าบางอย่างใน JavaScript ที่จะคืนค่าจริงสำหรับ x! == x และ false สำหรับ x! = x?

ไม่คุณไม่ได้ ความแตกต่างเพียงอย่างเดียวระหว่าง!==และ!=คือว่าหลังจะบีบบังคับประเภทถ้าจำเป็นที่จะได้รับประเภทของตัวถูกดำเนินการจะเหมือนกัน ในประเภทของตัวถูกดำเนินการที่มีความเหมือนกันและดังนั้นจึงเป็นเหมือนกับx != xx !== x

สิ่งนี้ชัดเจนตั้งแต่จุดเริ่มต้นของคำนิยามของการดำเนินงานความเสมอภาคทางนามธรรม :

1. ReturnIfAbrupt (x)
2. ReturnIfAbrupt (y)

3. หาก Type (x) เหมือนกับ Type (y) ดังนั้น

   ส่งคืนผลลัพธ์ของการทำการเปรียบเทียบความเข้มงวดที่เข้มงวด x === y

4. ...

สองขั้นตอนแรกคือการประปาขั้นพื้นฐาน ดังนั้นในขั้นตอนแรกของ==การดูว่าประเภทเดียวกันหรือไม่และหากเป็นเช่นนั้นให้ทำ===แทน !=และ!==เป็นรุ่นเมื่อตะกี้ของที่

ดังนั้นหากฟลานาแกนถูกต้องที่เพียงNaNให้ความจริงx !== xเราก็มั่นใจได้ว่ามันจะเป็นจริงที่NaNจะให้ความจริงx != xเท่านั้น

โปรแกรมเมอร์จาวาสคริปต์หลายคนเริ่มต้นที่จะใช้===และ!==หลีกเลี่ยงข้อผิดพลาดบางอย่างเกี่ยวกับการบีบบังคับแบบหลวม ๆ ที่ผู้ประกอบการทำ

สำหรับวัตถุประสงค์ของ NaN !=และ!==ทำสิ่งเดียวกัน

อย่างไรก็ตามโปรแกรมเมอร์จำนวนมากหลีกเลี่ยง==หรือ!=ใช้ JavaScript ตัวอย่างเช่น Douglas Crockford ถือว่าพวกเขาอยู่ใน " ส่วนที่ไม่ดี " ของภาษา JavaScript เพราะพวกเขาทำงานในลักษณะที่ไม่คาดคิดและสับสน:

JavaScript มีสองชุดของผู้ประกอบการเท่าเทียมกัน: ===และ!==และฝาแฝดที่ชั่วร้ายของพวกเขาและ== !=คนดีทำงานในแบบที่คุณคาดหวัง

... คำแนะนำของฉันคืออย่าใช้ฝาแฝดที่ชั่วร้าย แต่มักจะใช้และ===!==

เพื่อความสนุกผมขอแสดงตัวอย่างที่xไม่ได้อยู่ตรงหน้าNaNแต่ตัวดำเนินการทำงานแตกต่างออกไป ก่อนกำหนด:

Object.defineProperty(
  self,
  'x',
  { get: function() { return self.y = self.y ? 0 : '0'; } }
);

ถ้าอย่างนั้นเราก็มี

x != x // false

แต่

x !== x // true

ฉันแค่ต้องการชี้ให้เห็นNaNไม่ใช่สิ่งเดียวที่ผลิตx !== xโดยไม่ใช้วัตถุระดับโลก มีวิธีที่ชาญฉลาดมากมายในการกระตุ้นให้เกิดพฤติกรรมนี้ นี่คือสิ่งที่ใช้ getters:

var i = 0, obj = { get x() { return i++; }};
with(obj) // force dynamic context, this is evil. 
console.log(x === x); // false

ดังที่คำตอบอื่น ๆ ชี้ให้เห็น==ดำเนินการพิมพ์ดีด แต่ในภาษาอื่น ๆ และมาตรฐาน - NaN บ่งบอกถึงความล้มเหลวในการคำนวณและด้วยเหตุผลที่ดีไม่เท่ากับตัวเอง

ด้วยเหตุผลบางอย่างนอกเหนือจากฉันคนที่เห็นปัญหานี้กับ JS แต่ภาษาส่วนใหญ่ที่มีสองเท่า (เช่น C, Java, C ++, C #, Python และอื่น ๆ ) แสดงพฤติกรรมที่แน่นอนนี้และผู้คนก็ไม่เป็นไร

บางครั้งรูปภาพก็ดีกว่าคำตรวจสอบตารางนี้(ซึ่งเป็นเหตุผลสำหรับฉันที่จะทำให้คำตอบนี้แทนความคิดเห็นเพราะมันทำให้ทัศนวิสัยดีขึ้น)

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

var f = "-1" === -1; //false

ในขณะที่การเปรียบเทียบความเท่าเทียมกันทางนามธรรม (==) ตรวจสอบเฉพาะเนื้อหา * โดยการแปลงประเภทแล้วทำการเปรียบเทียบอย่างเคร่งครัด:

var t = "-1" == -1; //true

แม้ว่ามันจะไม่ชัดเจนหากไม่ได้ปรึกษาECMAแต่ JavaScript จะพิจารณาสิ่งใดเมื่อเปรียบเทียบในลักษณะที่การร้องของรหัสประเมินเป็นจริง

 var howAmISupposedToKnowThat = [] == false; //true