(NaN! = NaN) ve (NaN! == NaN) arasındaki fark nedir?

Her şeyden önce nasıl isNaN()ve Number.isNaN()çalıştığını bildiğimi belirtmek istiyorum . David Flanagan tarafından Kesin Rehber okuyorum ve o değerin olup olmadığını kontrol etmek için bir örnek verir NaN:

x !== x

Bu neden olacaktır trueancak ve ancak xolduğunu NaN.

Ama şimdi bir sorum var: neden sıkı karşılaştırma kullanıyor? Çünkü öyle görünüyor ki

x != x

aynı şekilde davranır. Her iki sürümleri kullanmaya, yoksa dönecektir JavaScript bazı değer (ler) Eksik güvenli mi trueiçin x !== xve falseiçin x != x?

İlk olarak, NaNbunun çok özel bir değer olduğunu belirtmeme izin verin : Tanım olarak, kendisine eşit değildir. Bu, JavaScript numaralarının çizdiği IEEE-754 standardından gelir. "Bir sayı değil" değeri, bitler tam eşleşme olsa bile asla kendisiyle aynı değildir. (Bunlar mutlaka IEEE-754'te değil, birden fazla farklı "sayı değil" değerine izin verir.) Bu yüzden bu bile ortaya çıkıyor; JavaScript'teki diğer tüm değerler kendilerine eşittir NaN, sadece özeldir.

... JavaScript'te x! == x için true ve x! = x için false döndürecek bir değer eksik mi?

Hayır değilsin. Arasındaki tek fark !==ve !=aynı olacak şekilde operand tiplerini almak için gerekirse ikinci tip zorlama yapacak olmasıdır. İçinde x != x, işlenenlerin türleri aynıdır ve bu yüzden tam olarak aynıdır x !== x.

Bu Soyut Eşitlik Operasyonunun tanımının başlangıcından itibaren açıktır :

1. ReturnIfAbrupt (x) tanımlanmaktadır.
2. ReturnIfAbrupt (y).

3. Tür (x), Tür (y) ile aynıysa,

   Sıkı Eşitlik Karşılaştırması yapmanın sonucunu döndürün x === y.

4. ...

İlk iki adım temel tesisattır. Yani aslında, ilk adımı ==türlerin aynı olup olmadığını görmek ve eğer öyleyse ===bunun yerine yapmaktır . !=ve !==sadece olumsuzlanmış versiyonlarıdır.

Yani eğer Flanagan sadece bu doğru NaNiçin de geçerli verecektir x !== x, eminiz yalnızca o da doğru olabilir ki NaNiçin de geçerli verecektir x != x.

Birçok JavaScript programcısı , gevşek operatörlerin yaptığı tür zorlamasıyla ilgili bazı tuzakları kullanmaktan ===ve !==bunlardan kaçınmak için varsayılandır , ancak Flanagan'ın bu durumda katı ve gevşek operatörü kullanması hakkında okunacak hiçbir şey yoktur.

NaN amaçları için, !=ve !==aynı şeyi yapın.

Ancak, birçok programcı JavaScript'ten kaçınır ==veya !=JavaScript kullanır. Örneğin, Douglas Crockford onları beklenmedik ve kafa karıştırıcı şekillerde davrandıkları için JavaScript dilinin " kötü bölümleri " arasında kabul eder :

: JavaScript iki eşitlik operatörleri setleri vardır ===ve !==ve onların kötü ikizler ==ve !=. İyi olanlar beklediğiniz gibi çalışır.

... Benim tavsiyem asla kötü ikizleri kullanmamak. Bunun yerine, her zaman ===ve kullanın !==.

Sadece eğlence için, nerede Sana yapay örnek yapalım xdeğil NaNama operatörler yine farklı davranır. İlk önce şunu tanımlayın:

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

Sonra elimizde

x != x // false

fakat

x !== x // true

Sadece küresel nesneyi kullanmadan üretilen NaNtek şey olmadığını belirtmek istiyorum x !== x. Bu davranışı tetiklemenin birçok akıllı yolu vardır. İşte getters kullanan biri:

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

Diğer cevapların işaret ==ettiği gibi, tip tutarlılığını gerçekleştirir, ancak diğer dillerde olduğu gibi ve standardı eşitler - NaN bir hesaplama hatasını gösterir ve iyi nedenlerle kendine eşit değildir.

Bazı nedenlerden ötürü insanlar JS ile ilgili bir sorun olduğunu düşünüyorlar, ancak iki katına sahip çoğu dil (C, Java, C ++, C #, Python ve diğerleri) bu tam davranışı sergiliyor ve insanlar bununla iyi durumda.

Bazen, görüntüler kelimelerden daha iyidir, bu tabloyu kontrol edin (bu bir yorum yapmamın sebebi, bunun yerine bir yorum yapmamın nedeni, daha iyi görünürlük elde etmesidir).

Burada katı eşitlik karşılaştırmasının (===) yalnızca tür ve içerik eşleştiğinde doğru döndüğünü görebilirsiniz.

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

Soyut eşitlik karşılaştırması (==), türleri dönüştürerek ve sonra bunları kesinlikle karşılaştırarak yalnızca içeriği * kontrol eder:

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

Her ne kadar net olmasa da, ECMA'ya danışmadan , JavaScript'in karşılaştırırken ne düşündüğü, aşağıdaki kod doğru olarak değerlendirilir.

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