JavaScript karşılaştırmalarında hangi eşitlik operatörü (== mı yoksa === mi) kullanılmalıdır?

JavaScript'i incelemek için JSLint kullanıyorum ve if ifadesi içinde idSele_UNVEHtype.value.length == 0 gibi şeyleri karşılaştırırken == (iki eşittir işareti) yerine === (üç eşittir işareti) kullanmamla ilgili pek çok öneri dönüyor.

== ile ==='yi değiştirmek performans açısından bir fayda sağlar mı?

Birçok karşılaştırma operatörü mevcut olduğundan, herhangi bir performans iyileştirmesi memnuniyetle karşılanacaktır.

Eğer hiçbir tür dönüşümü gerçekleşmezse, =='ye kıyasla bir performans kazancı olur mu?

Cevap #1

Sıkı eşitlik operatörü (===), tür dönüşümü yapılmaması ve eşit sayılabilmesi için türlerin aynı olması dışında soyut eşitlik operatörü (==) ile aynı şekilde davranır.

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

== operatörü, gerekli tür dönüşümlerini yaptıktan sonra eşitliği karşılaştıracaktır. === operatörü dönüşümü yapmayacaktır, bu yüzden iki değer aynı türde değilse === basitçe false döndürecektir. Her ikisi de eşit derecede hızlıdır.

Douglas Crockford'ın mükemmel JavaScript: İyi Parçalar kitabından alıntı yapmak gerekirse,

JavaScript'in iki set eşitlik operatörü vardır: === ve !==, ve onların kötü ikizleri == ve !=. İyi olanlar beklediğiniz şekilde çalışır. Eğer iki operand aynı türde ve aynı değere sahipse, === true döner ve !== false döner. Kötü ikizler, operandlar aynı türde olduğunda doğru sonucu verir, ancak farklı türlerde olduklarında değerleri zorla dönüştürmeye çalışır. Bunu yapma kuralları karmaşık ve akılda kalıcı değildir. İşte ilginç bazı durumlar:

'' == '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çiş eksikliği endişe verici. Benim tavsiyem kötü ikizleri asla kullanmamanızdır. Bunun yerine, her zaman === ve !== kullanın. Az önce gösterilen tüm karşılaştırmalar === operatörü ile false üretir.

Güncelle

@Casebash, yorumlarda ve @Phillipe Laybaert'in cevabında nesnelerle ilgili olarak iyi bir nokta ortaya koydu. Nesneler için, == ve === birbirleriyle tutarlı şekilde davranır (özel bir durum dışında).

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 ilkel değeri, toString veya valueOf yöntemi sayesinde aynı ilkel değere dönüştürülen bir nesne ile karşılaştırdığınız durumdur. Örneğin, bir string ilkel değerini String yapıcısı kullanılarak oluşturulmuş bir string nesnesi ile karşılaştırmayı düşünün.

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

Burada == operatörü iki nesnenin değerlerini kontrol ediyor ve true döndürüyor, ancak === operatörü onların aynı türde olmadığını görüyor ve false döndürüyor. Hangi doğru? Bu tamamen neyi karşılaştırmaya çalıştığınıza bağlı. Benim tavsiyem, bu soruyu tamamen atlamak ve string literallerden string nesneleri oluşturmak için String yapıcısını kullanmamaktır.

Referans
https://262.ecma-international.org/5.1/#sec-11.9.3

Cevap #2

== operatörünü (Eşitlik) kullanma

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

=== operatörünü (Özdeşlik) kullanmak

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

Bunun nedeni, eşitlik operatörü == tür zorlaması yapar, yani yorumlayıcı karşılaştırmadan önce değerleri zımnen dönüştürmeye çalışır.

Öte yandan, kimlik operatörü === tip zorlaması yapmaz ve bu nedenle karşılaştırma yaparken değerleri dönüştürmez.

Cevap #3

İşte == ve === arasındaki eşitlik karşılaştırmasının ilginç bir görselleştirmesi.

Kaynak: https://github.com/dorey/JavaScript-Equality-Table (demo, birleşik demo)

var1 === var2

JavaScript eşitlik testi için === kullanıldığında, her şey olduğu gibidir.
Değerlendirilmeden önce hiçbir şey dönüştürülmez.

var1 == var2

JavaScript eşitlik testi için == kullanıldığında, bazı tuhaf dönüşümler gerçekleşir.

Javascript'te eşitliğin özeti

Sonuç:

Her zaman === kullanın, == ile gerçekleşen tuhaf dönüşümleri tamamen anlamadığınız sürece.

Cevap #4

Buradaki cevaplarda, eşitin ne anlama geldiği hakkında hiçbir şey okumadım. Bazıları === operatörünün eşit ve aynı türden anlamına geldiğini söyleyecek, ama bu gerçekten doğru değil. Aslında bu, her iki operandın aynı nesneyi referans ettiği anlamına gelir veya değer tipleri için, aynı değere sahip oldukları anlamına gelir.

O halde, aşağıdaki kodu ele 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

Aynısı burada da:

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 belli değildir. Hikayede eşit olmak ve aynı türden olmak dışında daha fazlası vardır.

Kural şudur:

Değer tipleri (sayılar) için:
a === b, a ve b aynı değere sahipse ve aynı türdeyse true döner

Referans türleri için:
a === b, a ve b tam olarak aynı nesneyi referans ediyorsa true döner

Stringler için:
a === b, a ve b her ikisi de string ise ve tam olarak aynı karakterleri içeriyorsa true döner

Dizeler: özel durum...

Dizeler değer türleri değildir, ancak Javascript'te değer türleri gibi davranırlar, bu yüzden dizideki karakterler aynı olduğunda ve aynı uzunluktaysa (üçüncü kuralda açıklandığı gibi) "eşit" olacaklardır

Şimdi ilginç hale geliyor:

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

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

Ama bunun hakkında ne dersin?:

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

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

Stringlerin değer tipleri gibi davrandığını sanıyordum? Eh, kime sorduğunuza bağlı... Bu durumda a ve b aynı türde değiller. a tür olarak Object, b ise tür olarak string. Sadece, String yapıcısını kullanarak bir string nesnesi oluşturmanın, çoğu zaman bir string gibi davranan tür olarak Object türünde bir şey oluşturduğunu unutmayın.

Cevap #5

İzin verin bu öğüdü ekleyeyim:

Şüphe duyarsanız, özellikleri okuyun! :

ECMA-262, JavaScript'in bir lehçesi olan bir betik dili için spesifikasyondur. Elbette pratikte, bir şeyin nasıl ele alınması gerektiğine dair ezoterik bir tanımdan ziyade, en önemli tarayıcıların nasıl davrandığı daha önemlidir. Ama new String("a") !== "a" olduğunu anlamak faydalıdır.

Lütfen bu soruyu açıklığa kavuşturmak için nasıl bir spesifikasyonu okuyacağımı açıklamama izin verin. Bu çok eski konuyu incelediğimde, kimsenin çok garip etki için bir cevabı olmadığını görüyorum. Yani, eğer bir spesifikasyonu okuyabiliyorsanız, bu mesleğinizde size muazzam derecede yardımcı olacaktır. Bu kazanılmış bir beceridir. Öyleyse, devam edelim.

PDF dosyasında === aramak beni spesifikasyonun 56. sayfasına götürüyor: 11.9.4. Katı Eşitlik Operatörü ( === ), ve spesifikasyon dilinde gezinip bulduğum şey:

11.9.6 Katı Eşitlik Karşılaştırma Algoritması
x ve y değerleri için yapılan x === y karşılaştırması true veya false sonucunu üretir. Böyle bir karşılaştırma aşağıdaki şekilde gerçekleştirilir:
1. Eğer Type(x) Type(y) ile farklıysa, false döndür.
2. Eğer Type(x) Undefined ise, true döndür.
3. Eğer Type(x) Null ise, true döndür.
4. Eğer Type(x) Number değilse, 11. adıma git.
5. Eğer x NaN ise, false döndür.
6. Eğer y NaN ise, false döndür.
7. Eğer x, y ile aynı sayısal değere sahipse, true döndür.
8. Eğer x +0 ve y −0 ise, true döndür.
9. Eğer x −0 ve y +0 ise, true döndürün.
10. false döndürün.
11. Eğer Type(x) String ise, x ve y tam olarak aynı karakter dizisine sahiplerse (aynı uzunlukta ve karşılık gelen pozisyonlarda aynı karakterler), true döndürün; aksi takdirde false döndürün.
12. Eğer Type(x) Boolean ise, x ve y her ikisi de true veya her ikisi de false ise true döndürün; aksi takdirde false döndürün.
13. Eğer x ve y aynı nesneye referans veriyorsa veya birbirine bağlı nesnelere referans veriyorlarsa true döndürün (bkz. 13.1.2). Aksi takdirde false döndürün.

İlginç olan adım 11. Evet, dizeler değer tipi olarak ele alınır. Ama bu, neden new String("a") !== "a" olduğunu açıklamıyor. ECMA-262’ye uymayan bir tarayıcımız mı var?

O kadar da hızlı değil!

Operandlerin türlerini kontrol edelim. Kendiniz typeof() ile sararak deneyin. Ben new String("a")'nın bir nesne olduğunu görüyorum ve adım 1 kullanılıyor: Türler farklıysa false döndür.

Eğer neden new String("a") bir string döndürmediğini merak ediyorsanız, bir spesifikasyon okumayı egzersiz olarak yapmaya ne dersiniz? İyi eğlenceler!

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

Spesifikasyondan

11.2.2 Yeni Operatör:

Eğer Type(constructor) Object değilse, bir TypeError istisnası fırlat.

Başka bir deyişle, eğer String türü Object olmasaydı, new operatörü ile kullanılamazdı.

new her zaman bir Nesne döndürür, String yapıcıları için bile. Ve ne yazık ki! Stringlerin değer semantiği (bkz. adım 11) kaybolur.

Ve bu nihayetinde şunu ifade eder: new String("a") !== "a".

Cevap #6

Bunu Firefox'ta Firebug kullanarak şöyle bir kodla test ettim:

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

Yani, minik farkın (hatırlayın, bu 100.000'den fazla yineleme üzerinde) ihmal edilebilir olduğunu söyleyebilirim. Performans === yapmanın bir nedeni değil. Tür güvenliği (JavaScript'te elde edebileceğiniz kadar güvenli) ve kod kalitesi ise bir neden.

Cevap #7

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

Cevap #8

JavaScript'te bu, aynı değere ve tipe sahip olmak anlamına gelir.

Örneğin,

4 == "4" // will return true

ama

4 === "4" // will return false 

Cevap #9

== neden bu kadar öngörülemez?

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

true

Evet, == operatörüne göre boş bir dize ve sıfır sayısı aynı şeydir.

Ve bununla bitmiyor, işte bir tane daha:

'0' == false // true

Dizilerle işler gerçekten garipleşiyor.

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

Sonra dizelerle daha garip

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

Daha da kötüleşiyor:

Eşit olduğunda 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 bir kez daha söylememe izin verin:

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

Ve bu sadece ilkel tiplerle elde ettiğiniz çılgın şeyler.

Objelerle == kullandığınızda bu tamamen yeni bir çılgınlık seviyesidir.

Bu noktada muhtemelen merak ediyorsunuz...

Bu neden olur?

Aslında bunun nedeni, sadece iki değerin aynı olup olmadığını kontrol eden "üç eşittir" (===) operatöründen farklı olmasıdır.

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

Fonksiyonlar için özel işlem, null, undefined, stringler için özel işlem, aklınıza ne gelirse var.

Oldukça tuhaflaşıyor.

Aslında, eğer == operatörünün yaptığı şeyi yapan bir fonksiyon yazmayı deneseydiniz, şöyle 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?

Bu, =='nin karmaşık olduğu anlamına geliyor.

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

Bu, sonunda hatalarla karşılaşabileceğiniz anlamına geliyor.

Öykünün ahlaki...

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

== yerine === kullanın.

Son.

Cevap #10

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

İki değişken alalım: a ve b.

"a == b" ifadesinin doğru olarak değerlendirilmesi için a ve b aynı değerde olmalıdır.

"a === b" durumunda, a ve b aynı değer olmalı ve ayrıca aynı tipe sahip olmalıdır ki doğru olarak değerlendirsin.

Aşağıdaki örneği ele 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");
}

Özetle; == operatörünü kullanmak istemediğiniz durumlarda doğru olarak değerlendirilebilir, bu yüzden === operatörünü kullanmak daha güvenli olacaktır.

Yüzde 90 kullanım senaryosunda hangisini kullandığınız fark etmez, ancak bir gün beklenmedik bir davranışla karşılaştığınızda farkı bilmek kullanışlı olur.

Cevap #11

=== aynı tarafların değer olarak olduğu kadar tip olarak da 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 yaygın bir örnek:

null == undefined // returns "true", but in most cases a distinction is necessary

Uzun yıllara dayanan deneyimime göre, bir tip belirtilmemiş kontrol tercih edilir çünkü değerin undefined, null, 0 veya "" olup olmadığıyla ilgilenmezsiniz.

Başka bir karşılaştırma yöntemi Object.is kullanmaktır ve işte bunun hakkında harika bilgilendirici bir cevap.

Cevap #12

Sıkı eşitlik/Karşılaştırma '===' için Javascript yürütme akış diyagramı

Javascript yürütme akış diyagramı, katı olmayan eşitlik/karşılaştırma '==' için

Cevap #13

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

Cevap #14

Bu, tip zorlaması olmadan eşitlik anlamına gelir. Tip zorlaması, JavaScript'in diğer veri türlerini otomatik olarak string veri türüne dönüştürmemesi 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 

Cevap #15

Tipik bir betikte performans farkı olmayacaktır. Daha önemli olan, binlerce "===" 'in binlerce "==" 'den 1 KB daha ağır olması olabilir :) JavaScript profil araçları, sizin durumunuzda performans farkı olup olmadığını söyleyebilir.

Ama şahsen JSLint'in önerdiğini yapardım. Bu öneri performans sorunları nedeniyle değil, tip zorlama nedeniyle ('\t\r\n' == 0) ifadesinin doğru olması sebebiyle vardır.

Cevap #16

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

Eğer bununla YAŞAMAK ZORUNDAYSANIZ, o zaman aşağıdaki 3 şeyi unutmayın:

1. Geçişli değildir: (a == b) ve (b == c), (a == c)'ye yol açmaz
2. Olumsuzuyla karşılıklıdır: (a == b) ve (a != b) her zaman tüm a ve b için zıt Boolean değerler alır.
3. Şüphe durumunda, aşağıdaki doğruluk tablosunu ezberleyin:

JAVASCRIPT'TE EŞİTLİK OPERATÖRÜ DOĞRULUK TABLOSU

• Tablodaki her satır, 3 karşılıklı "eşit" değerden oluşan bir kümedir; bu, aralarındaki herhangi 2 değerin eşittir == işareti kullanılarak eşit olduğu anlamına gelir*

** GARİP: ilk sütundaki herhangi 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.

Cevap #17

Evet! Bu önemlidir.

=== operatörü javascript'te hem değeri hem de türü kontrol eder, oysa == operatörü sadece değeri kontrol eder (gerekirse tür dönüşümü yapar).

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

<head>

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

Uyarıda 'false' alacaksınız. Şimdi onPageLoad() metodunu alert(x == 5); olarak değiştirin, true alacaksınız.

Cevap #18

Kullanımınızda iki işlem arasında muhtemelen herhangi bir performans farkı olmayacaktır. Her iki parametre zaten aynı türde olduğu için herhangi bir tür dönüşümü yapılmasına gerek yoktur. Her iki işlem de bir tür karşılaştırmasının ardından bir değer karşılaştırması yapacaktır.

Cevap #19

Basitçe

==, tip zorlaması ile işlemler arasında karşılaştırma anlamına gelir

ve

===, operandler arasında tür dönüştürme olmadan karşılaştırma anlamına gelir.

JavaScript'te tür zorlama, veri türlerini otomatik olarak diğer veri türlerine dönüştürmek anlamına gelir.

Örneğin:

123 == "123"  // Returns true, because JS coerces string "123" to number 123
              // and then goes on to compare `123 == 123`.

123 === "123" // Returns false, because JS does not coerce values of different types here.

Cevap #20

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

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

Ancak tek bir istisna vardır: == null, 'null veya undefined mi' kontrol etmek için etkili bir yoldur:

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

Örneğin jQuery 1.9.1 bu deseni 43 kez kullanır ve JSHint sözdizimi denetleyicisi bu nedenle eqnull rahatlatma seçeneğini bile sağlar.

jQuery stil rehberinden:

Katı eşitlik kontrolleri (===) == yerine kullanılmalıdır. Tek istisna, undefined ve null'ü null aracılığıyla kontrol etmektir.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

DÜZENLEME 2021-03:

Günümüzde çoğu tarayıcı, bir değişken null veya undefined ise varsayılan bir değer atamak için daha kısa bir yol sunan Nullish birleştirme operatörü (??) ve Mantıksal nullish atama (??=) operatörünü desteklemektedir, örneğin:

if (a.speed == null) {
  // Set default if null or undefined
  a.speed = 42;
}

bunlardan herhangi bir formda yazılabilir

a.speed ??= 42;
a.speed ?? a.speed = 42;
a.speed = a.speed ?? 42;

Cevap #21

=== operatörü, değişkenlerin değerlerini ve türlerini eşitlik açısından kontrol eder.

== operatörü sadece değişkenlerin değerlerinin eşitliğini kontrol eder.

Cevap #22

Bu sıkı bir kontrol testidir.

Bu özellikle 0 ile false ve null arasında kontrol ediyorsanız iyi bir şey.

Örneğin, eğer şunlara sahipseniz:

$a = 0;

Sonra :

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

Tümü doğru döner ve bunu istemeyebilirsiniz. Bir dizinin 0. indeksini döndürebilen veya başarısız olduğunda false döndürebilen bir fonksiyonunuz olduğunu varsayalım. '==' ile false'u kontrol ederseniz, kafa karıştırıcı bir sonuç alabilirsiniz.

Yukarıdakiyle aynı şekilde, ama sıkı bir test:

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

Cevap #23

JSLint bazen bir şeyi değiştirmek için gerçekçi olmayan nedenler verir. Eğer tipler zaten aynıysa, === ile == tam olarak aynı performansa sahiptir.

Sadece türler aynı olmadığında daha hızlıdır; bu durumda türleri dönüştürmeye çalışmaz, doğrudan false döner.

Yani, IMHO, JSLint yeni kod yazmak için kullanılabilir, ama gereksiz aşırı optimizasyon her ne pahasına olursa olsun kaçınılmalıdır.

Yani, if (a == 'test') gibi bir kontrolde == yerine === kullanmak için bir sebep yoktur, eğer a'nın sadece bir String olabileceğini kesin olarak biliyorsanız.

Kodun çok miktarda bu şekilde değiştirilmesi, geliştiricilerin ve inceleyicilerin zamanını boşa harcar ve hiçbir şey kazandırmaz.

Cevap #24

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.

Cevap #25

En iyi 2 cevapta her ikisi de == eşitlik anlamına gelir ve === kimlik anlamına gelir deniyor. Ne yazık ki, bu ifade yanlıştır.

Eğer == operatörünün her iki işlemi de nesne ise, o zaman aynı nesne olup olmadıklarını görmek için karşılaştırılırlar. Eğer her iki işlem de aynı nesneye işaret ediyorsa, eşit operatör true döner. Aksi takdirde, ikisi eşit değildir.

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 de === yanlış döner çünkü a ve b aynı nesneler değildir.

Yani şunu söylemek gerekir: Eğer == operatörünün her iki operandı da nesne ise, == tıpkı === gibi davranır, bu da aynı zamanda özdeşlik anlamına gelir. Bu iki operatörün temel farkı tip dönüşümü ile ilgilidir. == eşitliği kontrol etmeden önce dönüşüm yapar, ama === yapmaz.

Cevap #26

Sorun şu ki, JavaScript'in çok fazla örtük dönüşümü olduğu anlamına geldiği için kolayca başınızı belaya sokabilirsiniz...

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

Bu da oldukça kısa sürede bir problem haline gelir. Implicit dönüşümün neden “kötü” olduğuna dair en iyi örnek, aslında CString’den HANDLE’a (bir pointer typedef türüdür) yapılan implicit dönüşüm sayesinde derlenecek olan MFC/C++ kodundan alınabilir...

CString x;
delete x;

Bu açık ki çalışma zamanında çok tanımsız şeyler yapıyor...

C++ ve STL'deki örtük dönüşümlerle ilgili bazı itirazları öğrenmek için Google'da arama yapın...

Cevap #27

Temel JavaScript referansından

=== Operantlar tür dönüşümü olmadan sıkı bir şekilde eşitse true döner (yukarıya bakın).

Cevap #28

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

Operatör ==

Her iki işlemci eşit olduğunda true döner. İşlemciler karşılaştırılmadan önce aynı tipe 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 operand da eşit ve aynı türdeyse true döner. Bu şekilde karşılaştırma yapmak genellikle daha iyi ve güvenlidir, çünkü arkada tür dönüşümleri yapılmaz.

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

Cevap #29

İşte == ve === arasındaki dönüşümlerin ve farkların gösterildiği kullanışlı bir karşılaştırma tablosu.

Sonuç bölümünde şöyle denilmektedir:

"İki eşittir için gerçekleşen dönüşümleri tam olarak anlamadığınız sürece üç eşittir kullanın."

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

Cevap #30

null ve undefined hiçbirliktir, yani

var a;
var b = null;

Burada a ve b değerlere sahip değildir. Oysa, 0, false ve '' değerlerdir. Bunların hepsinin ortak bir özelliği, hepsinin yanlış (falsy) değerler olmasıdır, bu da tümünün yanlış (falsy) koşulları karşıladığı anlamına gelir.

Yani, 0, false ve '' birlikte bir alt grup oluşturur. Öte yandan, null ve undefined ikinci alt grubu oluşturur. Aşağıdaki resimdeki karşılaştırmaları kontrol edin. null ve undefined eşit olur. Diğer üçü birbirine eşit olur. Ama hepsi JavaScript'te yanlış (falsy) koşullar olarak kabul edilir.

Bu, herhangi bir nesne (ör. {}, diziler, vb.), boş olmayan string ve Boolean true gibi tümüyle doğru (truthy) durumlardır. Ama hepsi eşit değildir.