Jaka jest różnica między (NaN! = NaN) a (NaN! == NaN)?

Przede wszystkim chcę wspomnieć, że umiem isNaN()i Number.isNaN()pracuję. Czytam The Definite Guide Davida Flanagana i podaje on przykład, jak sprawdzić, czy wartość wynosi NaN:

x !== x

Spowoduje to truewtedy i tylko wtedy, gdy xjest NaN.

Ale teraz mam pytanie: dlaczego używa ścisłego porównania? Ponieważ na to wygląda

x != x

zachowuje się w ten sam sposób. Czy używanie obu wersji jest bezpieczne, czy też brakuje mi pewnych wartości w JavaScript, które zostaną zwrócone truedla x !== xi falsedla x != x?

Po pierwsze, chciałbym zaznaczyć, że NaNjest to bardzo szczególna wartość: z definicji nie jest sobie równa. Wynika to ze standardu IEEE-754, z którego korzystają numery JavaScript. Wartość „nie jest liczbą” nigdy nie jest równa sobie, nawet jeśli bity są dokładnie zgodne. (Które niekoniecznie w IEEE-754, zezwala na wiele różnych wartości „nie jest liczbą”). Dlatego właśnie to się pojawia; wszystkie inne wartości w JavaScript są sobie równe, NaNsą po prostu wyjątkowe.

... czy brakuje mi jakiejś wartości w JavaScript, która zwróci prawdę dla x! == x i fałsz dla x! = x?

Nie, nie jesteś. Jedyna różnica między !==i !=polega na tym, że ten ostatni wykona wymuszenie typu, jeśli to konieczne, aby uzyskać takie same typy operandów. W x != xprogramie typy operandów są takie same, więc jest dokładnie takie samo, jak x !== x.

Jest to jasne od początku definicji Operacji Abstrakcyjnej Równości :

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

3. Jeśli Type (x) jest taki sam jak Type (y), to

   Zwróć wynik wykonywania Ścisłego porównania równości x === y.

4. ...

Pierwsze dwa kroki to podstawowa instalacja hydrauliczna. W efekcie pierwszym krokiem ==jest sprawdzenie, czy typy są takie same, a jeśli tak, to ===zamiast tego zrobić . !=i !==są po prostu zanegowanymi wersjami tego.

Więc jeśli Flanagan ma rację, że tylko NaNda prawdę x !== x, możemy być pewni, że prawdą jest również to, że tylko NaNda prawdę x != x.

Wielu programistów JavaScript domyślnie używa ===i !==unika pewnych pułapek związanych z wymuszaniem typów, jakie stosują operatory loose, ale nie ma nic do czytania w używaniu przez Flanagana operatora ścisłego i luźnego w tym przypadku.

Dla celów NaN !=i !==zrób to samo.

Jednak wielu programistów unika ==lub !=używa JavaScript. Na przykład Douglas Crockford uważa je za „ złe strony ” języka JavaScript, ponieważ zachowują się w nieoczekiwany i mylący sposób:

JavaScript ma dwa zestawy operatorów równości: ===and !==, oraz ich złe bliźniaki ==i !=. Te dobre działają zgodnie z oczekiwaniami.

... Moja rada brzmi: nigdy nie używaj złych bliźniaków. Zamiast tego zawsze używaj ===i !==.

Dla zabawy pozwólcie, że pokażę wam sztuczny przykład, gdzie go xnie ma, NaNale operatorzy i tak zachowują się inaczej. Najpierw zdefiniuj:

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

Następnie mamy

x != x // false

ale

x !== x // true

Chcę tylko podkreślić, że NaNnie jest jedyną rzeczą, która produkuje x !== xbez użycia obiektu globalnego. Istnieje wiele sprytnych sposobów wywołania tego zachowania. Oto jeden z pobierających:

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

Jak wskazują inne odpowiedzi, ==wykonuje koersję typów, ale tak jak w innych językach i par standard - NaN wskazuje na błąd obliczeniowy iz dobrych powodów nie jest sobie równy.

Z jakiegoś niezrozumiałego powodu ludzie uważają, że jest to problem z JS, ale większość języków, które mają dublety (a mianowicie C, Java, C ++, C #, Python i inne) wykazuje dokładnie to zachowanie i ludziom po prostu nie przeszkadza.

Ponieważ czasami obrazy są lepsze niż słowa, sprawdź tę tabelę (dlatego uważam, że jest to odpowiedź, zamiast komentarza, ponieważ staje się ona lepiej widoczna).

Możesz tam zobaczyć, że ścisłe porównanie równości (===) zwraca prawdę tylko wtedy, gdy typ i zawartość są zgodne, więc

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

Podczas gdy abstrakcyjne porównanie równości (==) sprawdza tylko zawartość *, konwertując typy, a następnie ściśle je porównując:

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

Chociaż nie jest jasne, bez konsultacji z ECMA , co JavaScript bierze pod uwagę podczas porównywania, w taki sposób, że poniższy kod ocenia jako prawdziwy.

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