49 Soru: JavaScript karşılaştırmalarında hangi eşittir operatörü (== vs ===) kullanılmalıdır?

tarafından oluşturulan soru Wed, Mar 22, 2017 12:00 AM

JavaScript’i gözden geçirmek için JSLint kullanıyorum ve bu, ==’un yerini almak için birçok öneri getiriyor (iki eşittir işareti) === ifadesinde idSele_UNVEHtype.value.length == 0 ile karşılaştırmak gibi şeyler yaparken if ile (üç eşittir işareti).

=='u === ile değiştirmenin bir performans avantajı var mı?

Çok sayıda karşılaştırma operatörü bulunduğundan herhangi bir performans artışı memnuniyetle karşılanacaktır.

Tip dönüşümü gerçekleşmezse, ==’un üzerinde bir performans kazancı olur mu?

    
5669
  1. === vs == ile aynı konuya ilgi duyanlara, ancak PHP'de burada okuyabilir: stackoverflow.com/questions/2401478/why-is-faster-than-in-php/…
    2010-12-31 12: 33: 37Z
  2. Sadece 2012'de merak eden varsa: ===, yoludur , =='dan daha hızlıdır. jsperf.com/comparison-of-comparisons
    2012-07-03 23: 02: 38Z
  3. @ minitech, dönüştürme türünü yapmadığı gibi olmalıdır
    2012-07-14 19: 10: 25Z
  4. @ minitech, === üzerinden == kullanarak herkesin uygulamalarını gözle görülür şekilde daha hızlı hale getireceğinden şüpheliyim. Aslında, kıyaslama hem modern tarayıcılar arasında büyük bir fark göstermiyor. Şahsen, gerçekten sıkı bir eşitliğe ihtiyacım olmadığı sürece, her yerde == kullanıyorum.
    2012-12-25 09: 09: 27Z
  5. İşte, Crockford'un JS The Good Parts konuşmasının === ve == operatörlerini tartıştığı bir bölüm: youtube.com/… Çalmıyorsa, 15 : 20
    2013-04-22 16: 17: 00Z
30 Yanıtlar                              30                         

Kimlik (===) operatörü, tür dönüştürmesi yapılmadığı sürece eşitlik (==) operatörüne aynı şekilde davranır ve türleri eşit olarak kabul edilmesi gereken aynı olmalıdır.

Referans: Javascript Eğitimi: Karşılaştırma Operatörleri

== işleci, gerekli tür dönüştürmeleri yaptıktan sonra eşitliği ile karşılaştırır. . === operatörü dönüşümü yapmaz , bu nedenle iki değer aynı değilse ===, yalnızca false değerini döndürür. Her ikisi de eşit derecede hızlıdır.

Douglas Crockford'un mükemmel JavaScript: İyi Parçalar ,

'den alıntı yapmak için >
  

JavaScript'te iki eşitlik operatörü vardır: === ve !== ve şeytani ikizleri == ve !=. İyi olanlar beklediğiniz gibi çalışır. İki işlenen aynı türden ve aynı değere sahipse, === true ve !== false üretir. Kötü ikizler, operandlar aynı tip olduğunda doğru olanı yaparlar, ancak farklı tiplerdeyse değerleri zorlamaya çalışırlar. Yaptıkları kurallar karmaşık ve unutulmaz. Bunlar ilginç durumlardan bazıları:

 
'' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true
     

Geçilebilirlik eksikliği endişe vericidir. Tavsiyem asla kötü ikizleri kullanmamak. Bunun yerine, her zaman === ve !== kullanın. Az önce gösterilen karşılaştırmaların tümü, false operatörüyle === üretir.


Güncelleme:

Comme'de @Casebash tarafından iyi bir nokta ortaya atıldınts ve @Phillipe Laybaert's cevap . == ve === referans tipleri için birbirleriyle tutarlı hareket ederler (özel durumlar hariç).

 
var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Özel durum, bir değişmezi toString veya valueOf yöntemi nedeniyle aynı değişmeze değerlendiren bir nesneyle karşılaştırdığınızda ortaya çıkar. Örneğin, String yapıcısı tarafından oluşturulan bir dize hazır bilgisinin bir dize nesnesiyle karşılaştırılmasını düşünün.

 
"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Burada == operatörü iki nesnenin değerlerini kontrol ediyor ve true'u döndürüyor, ancak === aynı tip olmadığını görüyor ve false'u döndürüyor. Hangisi doğru? Bu gerçekten karşılaştırmaya çalıştığınız şeye bağlıdır. Tavsiyem soruyu tamamen atlamak ve String yapıcısını string nesneler oluşturmak için kullanmamanız.

Referans

http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

    
6193
2017-05-23 12: 10: 45Z
  1. ===, türler aynıysa daha hızlı değildir. Türler aynı değilse, === daha hızlı olacaktır, çünkü dönüşümü yapmaya çalışmaz.
    2008-12-31 03: 02: 11Z
  2. === == öğesinden daha yavaş olmayacaktır. Her ikisi de yazım denetimi yapar, bu nedenle ===, == ile karşılaştırıldığında fazladan hiçbir şey yapmaz, ancak tür denetimi, türlerin aynı olmadığı durumlarda daha erken çıkmasına izin verebilir.
    2009-02-02 04: 17: 55Z
  3. Tümünü değiştir == /! = ile === /! ==, js dosyasının boyutunu artırır, sonra yüklenmesi daha uzun sürer. :)
    2010-03-31 09: 22: 07Z
  4. "... yaptıkları kurallar karmaşık ve unutulmaz ..." Şimdi böyle ifadeler programlama yaparken kendinizi güvende hissettiriyor ...
    2011-12-09 16: 24: 46Z
  5. Bazen JavaScript’in yazı sistemi çığlıktan kaçmak istememe neden oluyor.
    2012-11-08 04: 06: 58Z

== işlecini kullanma ( Eşitlik )

 
true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

=== işlecini kullanma ( Kimlik )

 
true === 1; //false
"2" === 2;  //false

Bunun nedeni, == eşitlik işlecinin zorlama yazmasıdır , yani tercümanın karşılaştırmadan önce değerleri dönüştürmeye çalıştığı anlamına gelir.

Diğer taraftan, kimlik operatörü === zorlama türü yazmaz ve bu nedenle karşılaştırırken değerleri dönüştürmez ve bu nedenle daha hızlıdır ( Bu JS kriter testi) bir adımı atladığı için.

    
1074
2019-04-29 01: 53: 48Z
  1. @ Yazılım Maymun: değer türleri için değil (sayı, boole, ...)
    2009-06-05 20: 00: 24Z
  2. type coercion vs type casting vs type convertion: stackoverflow.com/questions/8857763/…
    2014-07-23 12: 02: 16Z
  3. Javascript Eşitlik Tablosundan kimse bahsetmediğinden, burada: dorey.github.io/JavaScript-Equality-Table
    2015-01-06 03: 17: 19Z
  4. İlk ifadede, 'true' öğesinin 1 değerine, 1 değerinin true değerine dönüştürülmediğinden emin misiniz?
    2016-11-22 10: 05: 58Z
  5. "Eşitlik" ve "kimlik" terimleri nereden geliyor? Standart bu şartları kullanmaz. == "soyut eşitlik" ve === "katı eşitlik" olarak adlandırır. =='a her türlü "eşitlik" demesi kabul edildiğinde, IMHO korkunçtur, çünkü geçişli değildir, ama neden kelime oyunu? Yine de "kimlik" ile daha fazla sorun yaşıyorum; Bence bu terim "işe yarıyor" olsa da oldukça yanıltıcıdır. Fakat cidden, "kimlik" terimini kim oluşturdu? Standardı araştırıyorum ve bulamadım.
    2018-02-07 08: 03: 44Z

== ve === arasındaki eşitlik karşılaştırmasının ilginç bir resimsel gösterimi.

Kaynak: http://dorey.github.io/JavaScript-Equality- Tablo /


var1 === var2

  

JavaScript eşitlik testi için === kullanırken, her şey olduğu gibi. Hiçbir şey değerlendirilmeden önce dönüştürülmez.

=== JS’de eşitlik değerlendirmesi


var1 == var2

  

JavaScript eşitlik testi için == kullanırken, bazı   korkak dönüşümler gerçekleşiyor.

== JS’de eşitlik değerlendirmesi

  

Hikayenin ahlaki:

     

Tam olarak anlamadığınız sürece === kullanın.   == ile gerçekleşen dönüşümler.

    
639
2018-07-13 17: 14: 41Z
  1. Ahlaki ile daha da ileri gideceğim: her zaman kullan === /! === kullanın ancak diğer kişilerin koduyla başa çıkabilmek için dönüşümü anlayın
    2015-05-08 11: 11: 03Z
  2. @ mfeineis === yerine veya == veya! = yerine! Yeni kodlayıcıları karıştırmak istemiyorum;)
    2016-06-23 14: 04: 34Z
  3. , üç eşit kullanım deneyimimden, sorunlara neden olabilir ve tam olarak anlaşılmadığı sürece kaçınılması gerekir. iki eşittir çok daha iyi sonuçlar üretir çünkü zamanın% 99'u gerçekten istemiyorum türlerin eşit olmasını istiyor.
    2017-02-12 08: 47: 06Z
  4. @ vsync: gerçekten türlerin eşit olmasını istemiyorsanız , kullanmalısınız kullanmalısınız üç eşittir !
    2017-04-24 05: 19: 24Z
  5. Bir istisna: x == null'un x veya null olup olmadığını kontrol etmek için güvenle undefined kullanabilirsiniz.
    2018-09-12 15: 40: 08Z

Buradaki cevaplarda, eşit 'in ne anlama geldiği hakkında hiçbir şey okumadım. Bazıları ===’un eşit ve aynı türden anlamına geldiğini söylüyor, ancak bu doğru değil. Aslında, her iki işlenen de aynı nesneye başvuruyor veya değer türleri olması durumunda aynı değere sahip anlamına gelir.

Öyleyse, aşağıdaki kodu alalım:

 
var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Burada da aynı:

 
var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Veya hatta:

 
var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Bu davranış her zaman açık değildir. Hikayede, eşit olmak ve aynı türde olmaktan daha fazlası var.

Kural şudur:

Değer türleri (sayılar) için: a === b ve a aynı değere sahipse ve aynı türdeyse,
b doğru döndürür

Referans türleri için:
a === b, eğer a ve b tam sam’a başvuruda bulunursa true değerini döndürür.e nesne

Dizeler için: a === b ve a’un her ikisi de dizgaysa ve aynı karakterleri içeriyorsa,
b true değerini döndürür


Dizeler: özel durum ...

Dizeler değer türleri değildir, ancak Javascript'te değer türleri gibi davranırlar, bu nedenle dizedeki karakterler aynı olduğunda ve aynı uzunlukta olduklarında (üçüncü kuralda açıklandığı gibi) "eşit" olurlar

Şimdi ilginçleşiyor:

 
var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

Ama buna ne dersiniz ?:

 
var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

Dizelerin değer türleri gibi davrandığını düşündüm? Kime sorduğuna bağlı ... Bu durumda a ve b aynı tip değil. a, Object, b ise string türündedir. Unutmayın, String yapıcısını kullanarak bir dize nesnesi oluşturmanın, çoğu zaman bir dize görevi gören Object türünde bir şey oluşturduğunu unutmayın.     

596
2012-01-10 09: 08: 34Z
  1. activa: Dizelerin yalnızca değişmez olduklarında eşit olduklarını açıklığa kavuştururum. new String ("abc") === "abc" yanlıştır (araştırmama göre).
    2009-06-05 19: 54: 58Z
  2. new Number() == "0". Ayrıca Firefox'ta: (function(){}) == "function () {\n}"
    2011-03-30 05: 21: 36Z
  3. Neden new String("123") !== "123"'u açıkladığınız için teşekkür ederiz. Onlar farklı tipler. Basit ama kafa karıştırıcı.
    2012-08-26 05: 51: 54Z
  4. String nesne, başka bir nesne gibi dizeleri gibi davranır . new String asla kullanılmamalıdır, çünkü gerçek dizgiler yaratmaz. Gerçek bir dizedir ve dize değişmezleri ile yapılabilir ya da String'u olmadan new işlevi olarak çağırabilir, örneğin: String(0); //"0", Real string, not an object
    2012-12-04 23: 51: 33Z
  5. Ancak, ayrıntılandırdığınız durumlarda, "==" operatörü aynı şekilde davranır.
    2015-02-06 10: 48: 04Z

Bu danışmanı ekleyeyim:

Şüpheniz varsa, belirtimini !

ECMA-262, JavaScript'in lehçe olduğu bir betik dili belirtimidir. Elbette pratikte, en önemli tarayıcıların, bir şeyin nasıl kullanılması gerektiği ile ilgili ezoterik bir tanımdan daha çok nasıl davrandığı daha önemlidir. Ancak, neden yeni Dize ("a")! == "a" .

olduğunu anlamak yararlı olacaktır.

Lütfen bu soruyu netleştirmek için özellikleri nasıl okuyacağımı açıklayayım. Bu çok eski konuda kimsenin çok garip etki için bir cevabı olmadığını görüyorum. Bu nedenle, bir şartnameyi okuyabiliyorsanız, bu size mesleğinizde çok yardımcı olacaktır. Bu edinilmiş bir beceridir. Öyleyse devam edelim.

PDF dosyasının aranması === beni şartnamenin 56. sayfasına getiriyor: 11.9.4. Sıkı Eşit Operatör (===) ve bulduğum spesiyalistin içinden geçtikten sonra:

  

11.9.6 Katı Eşitlik Karşılaştırma Algoritması
  X ve y değerlerinin olduğu x === y karşılaştırması, doğru veya yanlış üretir. Böyle bir karşılaştırma aşağıdaki gibi yapılır:
  1. Tür (x), Tür (y) den farklıysa, false değerini döndürün.
  2. Tür (x) Tanımsız ise, true değerini döndürün.
  3. Tür (x) Boş ise, true değerini döndürün.
  4. Tip (x) Sayı değilse, 11. adıma gidin.
  5. x, NaN ise, false değerini döndürün.
  6. y NaN ise, false değerini döndürün.
  7. x, y ile aynı sayı değerindeyse, true değerini döndürün.
  8. x +0 ve y −0 ise, true değerini döndürün.
  9. x, −0 ve y +0 ise, true değerini döndürün.
  10. false değerini döndürün.
  11. Eğer Tür (x), String ise, eğer x ve y tamamen aynı karakter dizilimi ise (truekarşılık gelen pozisyonlarda ength ve aynı karakterler); aksi takdirde, false değerini döndürün.
  12. Eğer Tür (x) Boolean ise, x ve y her ikisi de doğru ya da her ikisinde de yanlış ise doğru ; aksi takdirde, false değerini döndürün.
  13. Eğer x ve y aynı nesneyi ya da birbirlerine katılan nesneleri ifade ediyorlarsa, true değerini döndürün (bkz. 13.1.2). Aksi takdirde, false değerini döndürün.

İlgi çekici adım 11'dir. Evet, dizeler değer türleri olarak değerlendirilir. Ancak bu, neden yeni Dize ("a")! == "a" olduğunu açıklamıyor. ECMA-262 ile uyumlu olmayan bir tarayıcımız var mı?

Çok hızlı değil!

İşlenenlerin türlerini kontrol edelim. Bunları typeof () 'a sararak kendiniz deneyin. yeni Dize ("a") 'nın bir nesne olduğunu ve adım 1’in kullanıldığını biliyorum: türler farklıysa false değerini döndürün.

Neden yeni Dize ("a") 'in bir dize döndürmediğini merak ediyorsanız, bir spesifikasyonu okumaya ne dersiniz? İyi eğlenceler!


Aidiakapi bunu aşağıdaki yorumda yazdı:

  

Spesifikasyondan

     

11.2.2 Yeni Operatör :

     

Tür (yapıcı) Nesne değilse, bir TypeError istisnası atın.

     

Başka bir deyişle, String, Object türünde değilse, yeni operatörle kullanılamaz.

yeni , String yapıcılar için bile her zaman bir Nesne döndürür. Ve ne yazık ki! Dizgelerin semantikleri (bkz. Adım 11) kaybolur.

Sonunda bu şu anlama gelir: yeni Dize ("a")! == "a" .

    
261
2015-10-26 10: 45: 32Z
  1. Tür (x) sonucunun typeof?
    ile aynı olduğu ima edildi.
    2012-11-15 18: 35: 49Z
  2. @ nalply new String('x')'daki davranış hakkındaki endişeyi tam olarak anlamadım, çünkü vahşi ilkel sarmalayıcı nesnelerini kullanan herhangi bir kod görmedim ve Bu günlerde değil, özellikle de bunun için iyi bir sebep olduğunu düşünmeyin. Hiç kod çözdünüz mü?
    2018-09-10 18: 28: 06Z
  3. @ Andy sorun kötü niyetli ya da sadece özensiz üçüncü taraf kodu, o zaman kimsenin new String() kullanmadığını varsayamazsınız.
    2018-09-11 09: 46: 36Z
  4. Özensizse, === nasıl bulacağınızla ilgilidir. Kötü niyetli ise, new String()'un muhtemelen endişelerinizin en küçüğü olduğunu düşünüyorum. Teoride duyduğum endişeyi anlıyorum ama yine de gerçek dünyadan örneklerin var mı? Bana göre bu birisinin undefined'u başka bir değere ayarlayabileceği endişesi gibi.
    2018-09-12 15: 34: 23Z
  5. Bunu nereden aldığınızı bilmiyorum, ancak karşılaştırma algoritmanız 2. adımda yanlış oluyor. Aynısı, eğer evet ise sayıdır. Aksi halde "7.2.12 SameValueNonNumber (x, y)" bölümü kullanılır.
    2019-06-17 19: 40: 22Z

PHP ve JavaScript'te katı bir eşitlik operatörüdür. Bu, hem türü hem de değerleri karşılaştıracağı anlamına gelir.

    
98
2010-05-12 12: 58: 39Z
  1. @ David: doğru. Bu yüzden bu cevap yanlış (veya hatta yanlış)
    2010-05-31 12: 25: 27Z
  2. @ David var a = {}, b = {}; a == b, false döndürür.
    2011-02-26 18: 37: 49Z
  3. Evet: Aynı tür ve değer co olan iki farklı nesnempare false, yani, bu cevap yanlıştır. Neden 50 oy var?
    2013-10-18 10: 45: 37Z
  4. Bunun eski olduğunu biliyorum, ancak bu cevabın neden hala "doğru" olduğunu açıklığa kavuşturmak için var a = {}, b = {}; örneğinde, çünkü hem a hem de b aslında hem bir nesne, hem de teknik olarak konuşursak aynı değer değildir. Bunlar farklı durumlardır. Karşılaştırma örneklerinin, ilkel değerleri karşılaştırmaktan farklı davrandığını unutmayın. Muhtemelen bu karışıklığa ekler. İlkel veri türlerinin örnek sürümünü kullanıyorsanız, benzer bir karşılaştırma davranışı göreceksiniz. E., new String('asdf') veya new Number(5). Örn: new Number(5) == new Number(5) aynı değerde olsalar bile yanlıştır.
    2017-05-18 18: 02: 00Z
  5. Hepimiz bir nesneye referansın bir bellek yuvasına işaretçi olarak aslında bir Değer Türü olduğunu unuturuz. Nesne karşılaştırması, "nesnenin değerini" karşılaştırmak değil, aynı zamanda her iki işaretçinin de aynı olup olmadığını aynı bellek yuvasına başvurdukları anlamına gelir. Bu, "===" işlecinin "bellekteki nesneye tür, değer ve başvuru aynıysa" demesi gerektiği için, Türleri karşılaştırırken çok ince bir fark var.
    2018-09-03 20: 05: 25Z

Bunu Firefox'ta şöyle test ettim: Firebug bu kodu kullanarak p>  

console.time("testEquality");
var n = 0;
while(true) {
    n++;
    if(n==100000) 
        break;
}
console.timeEnd("testEquality");

ve

 
console.time("testTypeEquality");
var n = 0;
while(true) {
    n++;
    if(n===100000) 
        break;
}
console.timeEnd("testTypeEquality");

Sonuçlarım (her biri beş kez test edildi ve ortalaması alındı):

 
==: 115.2
===: 114.4

Öyleyse, minik farkın (bu 100000'in üzerinde yinelemedir, hatırlayın) ihmal edilebilir olduğunu söyleyebilirim. Performans değil, ===. Güvenliği yazın (peki, JavaScript’te alacağınız kadar güvenli) ve kod kalitesi.

    
94
2014-10-26 11: 07: 41Z
  1. Tip güvenliğinden daha fazlası mantıklı bir doğruluk istiyor - bazen == aynı fikirde olmadığında işlerin haksız olmasını istiyorsun.
    2011-09-13 21: 14: 15Z
  2. Şimdi, bunlar == operatörü için gerçek bir tür zorlama olduğunda bunlar nasıl karşılaştırılır? Unutma, performans artışı olduğunda o zaman.
    2013-07-13 21: 13: 44Z
  3. Bahsedilen daha hızlı nedenlerle yalnızca tip eşitsizliğini kontrol etmek için yukarıda belirtilen nedenlerle doğru şekilde test edildiğinde BÜYÜK farklılık. jsfiddle.net/4jhuxkb2
    2015-07-06 17: 04: 57Z

JavaScript’te aynı değer ve tür anlamına gelir.

Örneğin,

 
4 == "4" // will return true

 
4 === "4" // will return false 
    
91
2014-10-26 11: 11: 58Z

=== operatörüne katı bir karşılaştırma operatörü denir, ise == operatöründen farklıdır

2 a ve b çeşidi alalım.

Doğru olarak değerlendirmek için "a == b" için a ve b’nin aynı değer olması gerekir.

"a === b" durumunda, a ve b, aynı değer ve ayrıca bunun için aynı tür olmalıdır doğru olarak değerlendirmek.

Aşağıdaki örneği alın

 
var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

Özet olarak ; == operatörünü kullanmak, istemediğiniz durumlarda gerçeği değerlendirebilir, bu nedenle === operatörünü kullanmak daha güvenli olur.

% 90 kullanım senaryosunda, hangisini kullandığınız önemli değildir, ancak beklenmedik bir şekilde fark ettiğinizde farkı bilmek faydalı olurbir gün davranış.

    
80
2013-08-21 08: 39: 53Z

Aynı tarafların türde ile değerde eşit olup olmadığını kontrol eder.

Örnek:

 
'1' === 1 // will return "false" because `string` is not a `number`

Yaygın örnek:

 
0 == ''  // will be "true", but it's very common to want this check to be "false"

Başka bir yaygın örnek:

 
null == undefined // returns "true", but in most cases a distinction is necessary
    
74
2018-07-19 07: 04: 17Z
  1. ayrıca, 'string' !== 'number'
    2012-01-06 19: 34: 54Z

Neden == bu kadar tahmin edilemez?

Boş bir "" sayısını sıfır 0 ile karşılaştırdığınızda ne elde edersiniz?

true

Evet, ==’a göre boş bir dize doğru ve sıfır sayısı aynı anda.

Ve orada bitmiyor, işte bir tane daha:

 
'0' == false // true

Dizilerde işler gerçekten garipleşiyor.

 
[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

Sonra dizeleriyle garip

 
[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

Daha kötüsü:

Ne zaman eşit değildir?

 
let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

Bunu tekrar söyleyeyim:

 
(A == B) && (B == C) // true
(A == C) // **FALSE**

Ve bu sadece ilkellerle aldığın çılgın şeyler.

=='u nesnelerle kullandığınızda yepyeni bir delilik düzeyi.

Bu noktada muhtemelen merak ediyorsun ...

Bu neden oluyor?

Çünkü, iki değerin aynı olup olmadığını kontrol eden "üçlü eşittir" den (===) farklı olarak.

==, bir sürü başka şey yapar .

İşlevler için özel işlem, boşlar için özel işlem, tanımsız, dizeler, siz onu isimlendirin.

Çok çılgına dönüyor.

Aslında, =='un yaptığı şeyi yapan bir işlev yazmaya çalıştıysanız, bunun gibi bir şey olurdu:

 
function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if(typeof x === "string") {
            return x === y.toString();
        } else if(typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);
    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

Peki bu ne anlama geliyor?

==’un karmaşık olduğu anlamına gelir.

Çünkü karmaşık bir şey kullandığınızda ne olacağını bilmek zor.

Bu, böcekle sonuçlanabileceği anlamına gelir.

Öyleyse hikayenin ahlakı ...

Hayatınızı daha az karmaşık hale getirin.

=== yerine == kullanın.

Son.

    
72
2018-04-21 15: 39: 44Z
  1. looseEqual'unuz yanlış. Function == Function.toString() doğru, ancak looseEqual(Function, Function.toString()) yanlış. İşlevleri neden başlangıçta filtrelediğinizden emin değilsiniz.
    2016-09-07 22: 16: 44Z
  2. @ Oriol haklıydınız, hesaba katma kodunu güncelledim, FYI testlerime dayanarak "fonksiyonlar" için filtreyi kaldırmak yeterli değildi "işlevler" tamamen farklı şekilde ele alınmalıydı.
    2016-09-08 22: 43: 51Z
  3. Farkında olun teknik özellik farklı işlevler yerine getirmiyor, sadece nesneler. Sorun, bunun bir nesne olup olmadığını kontrol etmek için typeof x === "object"'a güveniyor görünüyorsunuz, ancak `typeof yalnızca boş olmayan ilkeller için işe yarıyor. bir değerin bir nesne olup olmadığını kontrol etmenin doğru yollarının listesiyle ilgilenebilirsiniz
    2016-09-08 23: 25: 01Z
  4. İşlevlere ve nesnelere aynı şekilde davranmayı denedim, ancak sonuçlarının yanlış olduğunu öğrendim. Örneğin, işlevler nesnelere benzer şekilde muamele edilirse, bir işlevi bir işlevi valueOf () veya toString () işlevini uygulayan bir nesneyle karşılaştırmak, işlevle eşleşen işlevi geçer, ancak gerçekte gerçekleşmez. Örnek: (function blah() { console.log("test"); }) != {valueOf:function(){return "function blah() { console.log(\"test\"); }";}} - tüm testleri çalıştıran bu JS Fiddle’ı inceleyin: jsfiddle.net/luisperezphd/7k6gcn6g (1.225 test izni var)
    2016-09-10 16: 22: 22Z
  5. Haklısınız, büyük gözlemler, bu, =='un sonuçları daha kolay tahmin etmeyi zorlaştırırken, ==='un birçok şeyi yapması gerektiğini vurgulamaktadır. ==='un ana nedenlerinden biri olan tahmin edilebilir bir seçimdir. (Amacınızı belirten cevaba not ekleyeceğim)
    2016-09-11 13: 20: 38Z

Katı eşitlik için Javascript çalıştırma akış şeması /Karşılaştırma '==='

Javascript katı eşitlik

Katı olmayan eşitlik /karşılaştırma için Javascript çalıştırma akış şeması '=='

Javascript eşitlik dışı

    
67
2015-09-05 13: 53: 16Z
  1. string okunun neden büyük gri kutuya işaret ettiğini anlamıyorum, kesicinin diziyi bir sayıya çevirdiği anlamına mı geliyor?
    2017-02-11 13: 26: 09Z
  2. @ vsync Gri kutudaki string seçeneğine işaret eder i.e string - > # || NaN. Javascript bir tip-script dili değildir, yani herhangi bir değişkene sahip olabilir. Bu yüzden, o gri kutuya işaret edildi.
    2017-02-12 06: 56: 21Z
  3. Sadece string'un number tipiyle karşılaştırılması gerektiği için döküm amaçlı olup olmadığını sordum, böylelikle kesici, dizgenin neyle karşılaştırılması gerektiğine bakar ve dize uygun şekilde kullanın?
    2017-02-12 08: 44: 48Z
  4. Büyük gri kutu, farklı türler verildiğinde ToNumber'un döndüreceği şeydir, bu nedenle bir dize verilirse yalnızca son seçeneği seçer (ve onu bir sayıya dönüştürür) ). ==, ToNumber'u yalnızca yukarıdaki string == number veya boolean == anything durumlarda (ve yalnızca string /boolean'da) kullanır. Bu, =='un gri kutuda olsa bile asla undefined veya null'u dönüştürmeyeceği anlamına gelir. (undefined veya null veya her ikisinin bir kombinasyonu için, == her zaman true değerini döndürür. Ayrıca, bir değerin sol veya sağ tarafta olması önemli değil, == (ve ===) aynı sonucu verir.)
    2018-03-07 05: 54: 22Z

JavaScript === vs ==.

 
0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type
    
53
2015-11-12 03: 18: 12Z

Bu, zorlama olmadan eşitlik anlamına gelir zorlama türü, JavaScript'in diğer veri türlerini otomatik olarak dize veri türlerine dönüştürmediği anlamına gelir

 
0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 

2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 

2===2   //true because both have same value and same types 
    
52
2017-07-30 21: 40: 44Z

Tipik bir komut dosyasında performans farkı olmaz. Daha önemlisi, bin "===" 'in binden daha ağır olan 1 KB olması "==" :) JavaScript profiler durumunuzda performans farkı olup olmadığını söyleyebilir.

Ama şahsen JSLint'in önerdiği şeyi yapardım. Bu öneri, performans sorunları nedeniyle değil aynı zamanda tiper coercio için de geçerlidir.n, ('\t\r\n' == 0)’un doğru olduğu anlamına gelir.

    
47
2017-05-23 12: 02: 56Z
  1. Her zaman doğru değil. Gzip sıkıştırmasıyla fark hemen hemen yok sayılabilir.
    2009-06-22 23: 43: 15Z
  2. Kabul ediyorum, ancak bin "===" aynı zamanda 10 bin kod satırı daha anlamına gelir, yani 1kb az ya da çok ...;)
    2016-09-28 18: 32: 51Z
  3. boyutunuzla ilgili endişeleriniz varsa, sonra == ile === 'nizi değiştirin, sonra geri almak için av eval içine sarılmış bir regexp kullanın
    2017-04-23 03: 30: 55Z

Eşit karşılaştırma operatörü == kafa karıştırıcıdır ve kaçınılması gerekir.

Onunla birlikte yaşıyorsanız, yaşıyorsanız , aşağıdaki 3 şeyi unutmayın:

  1. Geçişli değil: (a == b) ve (b == c) (a == c )
  2. Bu, olumsuzlamasına karşılıklı olarak özgüdür: (a == b) ve (a! = b) , tüm a ve b.
  3. Şüphe durumunda, aşağıdaki doğruluk tablosunu yürekten öğrenin:

JAVASCRIPT'TA EŞİT OPERATÖR GERÇEĞİ TABLOSU

  • Tablodaki her satır, karşılıklı olarak 3 eşit "değer" kümesinden oluşur; bu, aralarındaki 2 değerin eşit == işareti *
  • kullanılarak eşit olduğu anlamına gelir.

** STRANGE: ilk sütundaki iki değerin bu anlamda eşit olmadığını unutmayın. **

 
''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
'\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.
    
43
2014-02-19 15: 01: 17Z

Kullanımınızdaki iki işlem arasında herhangi bir performans farkının olması olası değildir. Her iki parametre de aynı tip olduğundan, yapılması gereken bir tür dönüşümü yoktur. Her iki işlemin de bir tür karşılaştırması ve ardından bir değer karşılaştırması olacaktır.

    
36
2008-12-11 14: 44: 55Z

Evet! Önemli.

javascript'teki === operatörü değeri olduğu gibi türünü de kontrol eder , burada == operatörü yalnızca değeri kontrol eder (gerekirse dönüşüm türünü yazar) .

resim tanımını buraya girin

Kolayca test edebilirsiniz. Bir HTML dosyasına aşağıdaki kodu yapıştırın ve tarayıcıda açın

 
<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

' yanlış ' u alarma geçirirsiniz. Şimdi onPageLoad() yöntemini alert(x == 5); olarak değiştirerek doğru elde edersiniz.

    
36
2015-01-10 14: 34: 14Z

=== operatörü, değerlerin yanı sıra eşitlik için değişken türlerini de kontrol eder.

== operatörü, eşitlik için değişkenlerin değerini yalnızca kontrol eder.

    
33
2017-11-20 12: 05: 13Z

Sıkı bir kontrol testi.

Özellikle 0 ile yanlış ve boş arasında kontrol ediyorsanız, iyi bir şeydir.

Örneğin, varsa:

 
$a = 0;

Ardından:

 
$a==0; 
$a==NULL;
$a==false;

Her şey doğru olur ve bunu istemeyebilirsiniz. Diyelim ki bir dizinin 0ncı indeksini döndürebilecek bir fonksiyonunuz var ya da hata durumunda yanlış. "==" false ile işaretlerseniz, kafa karıştırıcı bir sonuç alabilirsiniz.

Yani yukarıdakiyle aynı şeyle, ancak sıkı bir testle:

 
$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false
    
31
2015-04-27 08: 26: 10Z
  1. JavaScript'te bu tamamen yanlıştır ve eksiktir. 0 != null. -1
    2013-05-06 03: 07: 17Z

JSLint bazen işleri değiştirmek için gerçekçi olmayan sebepler verir. Türler zaten aynıysa, ===, tam olarak == ile aynı performansa sahiptir.

Yalnızca türler aynı olmadığında daha hızlıdır, bu durumda türleri dönüştürmeye çalışmaz ancak doğrudan bir false döndürür.

Öyleyse, IMHO, JSLint belki yeni kod yazmak için kullanılır, ancak faydasız aşırı optimizasyondan kaçınılmalıdır.

Yani, =='dan ==='a, if (a == 'test') gibi bir çekle, sadece bir Dize olabileceği gerçeğini bildiğiniz zaman değiştirmek için hiçbir neden yoktur.

Geliştiricilerin ve hakemlerin zamanını boşa harcayan ve hiçbir şey elde etmeyen bir çok kodu değiştirmek.

    
30
2017-11-20 12: 11: 45Z

Basitçe

==, type conversion ile ile işlenenler arasında karşılaştırma anlamına gelir

&Sons

===, type conversion olmadan işlenenler arasında karşılaştırma anlamına gelir

javaScript'deki tür dönüştürme, javaScript'in diğer tüm veri türlerini otomatik olarak dize veri türlerine dönüştürmesini sağlar.

Örneğin:

 
123=='123'   //will return true, because JS convert integer 123 to string '123'
             //as we used '==' operator 

123==='123' //will return false, because JS do not convert integer 123 to string 
            //'123' as we used '===' operator 
    
29
2017-11-20 12: 49: 58Z

Basit bir örnek:

 
2 == '2'  -> true, values are SAME because of type conversion.

2 === '2'  -> false, values are NOT SAME because of no type conversion.
    
25
2015-07-04 03: 56: 47Z

Genel bir kural olarak, genellikle === yerine == (ve !== yerine !=) kullanırdım.

Nedenler yukarıdaki cevaplarda açıklanmıştır ve ayrıca Douglas Crockford bu konuda oldukça açıktır ( JavaScript: İyi Parçalar ).

Ancak, bir tek istisna vardır:  == null 'boş veya tanımsız' olup olmadığını kontrol etmenin etkili bir yoludur:

 
if( value == null ){
    // value is either null or undefined
}

Örneğin, jQuery 1.9.1 bu kalıbı 43 kez kullanıyor ve JSHint sözdizimi denetleyicisi Hatta eqnull'a bu nedenle rahatlatıcı bir seçenek sunuyor.

jQuery stil kılavuzundan :

  

Sıkı eşitlik kontrolleri (===) == lehine kullanılmalıdır. Tek   Bunun istisnası, tanımsız ve null değerinin null olarak kontrol edilmesidir.

 
// Check for both undefined and null values, for some important reason. 
undefOrNull == null;
    
24
2013-04-27 14: 15: 38Z

Belirtilen ilk 2 cevap == = eşitlik anlamına gelir ve === kimlik anlamına gelir. Ne yazık ki, bu ifade yanlıştır.

== her iki işleci de nesne ise, aynı nesne olup olmadıklarını görmek için karşılaştırılır. Her iki işlenen de aynı nesneyi gösterirse, eşit işleç true değerini döndürür. Aksi takdirde, ikisi eşit değil.

 
var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false  

Yukarıdaki kodda, hem == hem === yanlış olsun çünkü a ve b aynı nesneler değildir.

Bunun anlamı şudur: == her iki işleci de nesne ise, == === ile aynı şekilde davranır, bu da kimlik anlamına gelir. Bu iki operatörün temel farkı tür dönüşümüyle ilgilidir. == eşitliği kontrol etmeden önce dönüşümü var, ancak === yapmıyor.

    
24
2013-09-09 08: 31: 45Z

Sorun, JavaScript’in çok fazla gizli dönüşüm anlamına gelmesinden dolayı kolayca sorun yaşamanız olabilir ...

 
var x = 0;
var isTrue = x == null;
var isFalse = x === null;

Çok yakında hangisi sorun olur. Örtük dönüşümün neden "kötü" olduğuna dair en iyi örnek bu koddan MFC /C ++ bu aslında CString'den HANDLE'ye bir tip dönüşümü türü olan gizli bir dönüşümden dolayı derlenecek ...

 
CString x;
delete x;

Çalışma zamanı sırasında açıkça hangisi çok tanımsız şeyler yapar ...

Google, C ++ ve STL 'daki örtük dönüşümler için aleyhine bazı argümanları almak için .. .

    
22
2014-10-26 11: 08: 37Z
  1. 0 == null yanlıştır.
    2014-01-13 00: 25: 19Z

çekirdek javascript referansından

  

=== İşlenenler tamamen eşitse, true değerini döndürür (yukarıya bakın)   tür dönüşümü olmadan.

    
22
2015-11-12 03: 17: 34Z

Eşitlik karşılaştırması:

Operatör ==

Her iki işlenen de eşit olduğunda true değerini döndürür. İşlenenler karşılaştırılmadan önce aynı türe dönüştürülür.

 
>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true

Eşitlik ve tür karşılaştırması:

Operatör ===

Her iki işlenen de eşit ve aynı türde olduğunda doğru döndürür. Genellikle Bu yolu karşılaştırırsanız daha iyi ve daha güvenli, çünkü sahne arkası tipi dönüşümleri yoktur.

 
>>> 1 === '1'
false
>>> 1 === 1
true
    
21
2013-10-02 21: 54: 43Z

* Operatörler === vs == *

 
1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true
    
19
2014-03-19 12: 08: 11Z

İşte gerçekleşen dönüşümleri ve == ile === arasındaki farkları gösteren kullanışlı bir karşılaştırma tablosu.

Sonuçta belirtildiği gibi:

  

"Alınan dönüşümleri tam olarak anlamadığınız sürece üç eşit kullanın   iki eşittir için yer. "

http://dorey.github.io/JavaScript-Equality-Table/

    
19
2014-03-27 11: 41: 35Z
kaynak yerleştirildi İşte