Apa perbedaan antara (NaN! = NaN) dan (NaN! == NaN)?

Pertama-tama saya ingin menyebutkan bahwa saya tahu caranya isNaN()dan Number.isNaN()bekerja. Saya membaca The Definite Guide oleh David Flanagan dan dia memberikan contoh bagaimana memeriksa apakah nilainya NaN:

x !== x

Hal ini akan mengakibatkan truejika dan hanya jika xisNaN .

Tapi sekarang saya punya pertanyaan: mengapa dia menggunakan perbandingan yang ketat? Karena sepertinya begitu

x != x

berperilaku dengan cara yang sama. Apakah aman menggunakan kedua versi, atau saya kehilangan beberapa nilai dalam JavaScript yang akan kembali trueuntuk x !== xdan falseuntuk x != x?

Pertama, izinkan saya menunjukkan bahwa itu NaNadalah nilai yang sangat istimewa: Menurut definisi, itu tidak sama dengan dirinya sendiri. Itu berasal dari standar IEEE-754 yang digunakan angka JavaScript. Nilai "bukan angka" tidak pernah sama dengan nilai itu sendiri, bahkan ketika bitnya sama persis. (Yang tidak harus dalam IEEE-754, ini memungkinkan untuk beberapa nilai "bukan angka" yang berbeda.) Itulah mengapa ini bahkan muncul; semua nilai lain dalam JavaScript sama dengan dirinya sendiri, NaNhanya istimewa.

... apakah saya kehilangan beberapa nilai dalam JavaScript yang akan mengembalikan true untuk x! == x dan false untuk x! = x?

Tidak, bukan kau. Satu-satunya perbedaan antara !==dan !=adalah bahwa yang terakhir akan melakukan tipe paksaan jika perlu untuk mendapatkan jenis operan yang sama. Pada x != x, jenis operan adalah sama, dan itu persis sama dengan x !== x.

Ini jelas dari awal definisi Operasi Kesetaraan Abstrak :

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

3. Jika Tipe (x) sama dengan Tipe (y), maka

   Kembalikan hasil melakukan Perbandingan Kesetaraan Ketat x === y.

4. ...

Dua langkah pertama adalah pipa ledeng dasar. Jadi sebenarnya, langkah pertama ==adalah untuk melihat apakah tipenya sama dan, jika demikian, lakukan ===saja. !=dan !==hanya versi negated dari itu.

Jadi jika Flanagan benar bahwa hanya NaNakan memberikan yang benar untuk x !== x, kita dapat yakin bahwa itu juga benar bahwa hanya NaNakan memberikan yang benar untuk x != x.

Banyak programmer JavaScript yang secara default menggunakan ===dan !==menghindari beberapa jebakan di sekitar tipe paksaan yang dilakukan operator longgar, tetapi tidak ada yang bisa dibaca dalam penggunaan Flanagan terhadap operator ketat dan longgar dalam hal ini.

Untuk keperluan NaN, !=dan !==lakukan hal yang sama.

Namun, banyak programmer menghindari ==atau !=menggunakan JavaScript. Misalnya, Douglas Crockford menganggap mereka sebagai " bagian buruk " dari bahasa JavaScript karena mereka berperilaku dengan cara yang tidak terduga dan membingungkan:

JavaScript memiliki dua set operator kesetaraan: ===dan !==, dan si kembar jahat ==dan !=. Yang bagus bekerja seperti yang Anda harapkan.

... Saran saya adalah jangan pernah menggunakan si kembar jahat. Sebaliknya, selalu gunakan=== dan !==.

Hanya untuk bersenang-senang, izinkan saya menunjukkan kepada Anda contoh buatan di mana xtidak ada NaNtetapi operator berperilaku berbeda pula. Definisi pertama:

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

Lalu kita punya

x != x // false

tapi

x !== x // true

Saya hanya ingin menunjukkan NaNbukan satu-satunya hal yang menghasilkan x !== xtanpa menggunakan objek global. Ada banyak cara pintar untuk memicu perilaku ini. Berikut ini salah satu yang menggunakan getter:

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

Sebagai jawaban lain menunjukkan, ==melakukan jenis koersi, tetapi dalam bahasa lain dan par standar - NaN menunjukkan kegagalan perhitungan, dan untuk alasan yang baik tidak sama dengan itu sendiri.

Untuk beberapa alasan di luar saya orang menganggap ini masalah dengan JS tetapi kebanyakan bahasa yang memiliki dua kali lipat (yaitu, C, Java, C ++, C #, Python dan lain-lain) menunjukkan perilaku yang tepat ini dan orang-orang baik-baik saja dengan itu.

Seperti terkadang, gambar lebih baik daripada kata-kata, periksa tabel ini (yang merupakan alasan bagi saya untuk membuat ini sebagai jawaban, bukan komentar karena mendapat visibilitas yang lebih baik).

Di sana Anda dapat melihat bahwa perbandingan kesetaraan yang ketat (===) hanya mengembalikan true jika jenis dan konten cocok, maka

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

Sementara perbandingan kesetaraan abstrak (==) hanya memeriksa konten * dengan mengonversi jenis dan kemudian membandingkannya dengan ketat:

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

Meskipun tidak jelas, tanpa berkonsultasi dengan ECMA , apa yang dipertimbangkan JavaScript saat membandingkan, dengan cara yang dievaluasi oleh kode di bawah sebagai true.

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