Saya menggunakan JSLint untuk melihat JavaScript, dan mengembalikan banyak saran untuk menggantikan ==(dua tanda sama dengan) dengan ===(tiga tanda sama dengan) ketika melakukan hal-hal seperti membandingkan idSele_UNVEHtype.value.length == 0di dalam sebuah ifpernyataan.

Apakah ada manfaat kinerja untuk mengganti ==dengan ===?

Setiap peningkatan kinerja akan disambut karena ada banyak operator pembanding.

Jika tidak ada konversi jenis yang terjadi, apakah akan ada peningkatan kinerja ==?

Operator kesetaraan yang ketat ( ===) berperilaku identik dengan operator kesetaraan abstrak ( ==) kecuali tidak ada konversi tipe yang dilakukan, dan jenisnya harus sama agar dianggap sama.

Referensi: Tutorial Javascript: Operator Perbandingan

The ==Operator akan membandingkan kesetaraan setelah melakukan setiap konversi tipe yang diperlukan . The ===Operator akan tidak melakukan konversi, jadi jika dua nilai yang bukan tipe yang sama ===hanya akan kembali false. Keduanya sama-sama cepat.

Mengutip JavaScript luar biasa Douglas Crockford : The Good Parts ,

JavaScript memiliki dua set operator kesetaraan: ===dan !==, dan si kembar jahat ==dan !=. Yang bagus bekerja seperti yang Anda harapkan. Jika kedua operan memiliki tipe yang sama dan memiliki nilai yang sama, maka ===hasilkan truedan !==hasilkan false. Si kembar jahat melakukan hal yang benar ketika operan dari jenis yang sama, tetapi jika mereka dari jenis yang berbeda, mereka berusaha untuk memaksa nilai-nilai itu. aturan-aturan yang dengannya mereka melakukan hal itu rumit dan tidak dapat dilupakan. Ini adalah beberapa kasus menarik:

'' == '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

Kurangnya transitivitas mengkhawatirkan. Saran saya adalah jangan pernah menggunakan si kembar jahat. Sebaliknya, selalu gunakan ===dan !==. Semua perbandingan hanya menunjukkan produk falsedengan ===operator.

Memperbarui:

Poin yang bagus disampaikan oleh @Casebash dalam komentar dan dalam jawaban @Phillipe Laybaert mengenai objek. Untuk benda, dan bertindak secara konsisten satu sama lain (kecuali dalam kasus khusus).=====

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

Kasus khusus adalah ketika Anda membandingkan primitif dengan objek yang mengevaluasi ke primitif yang sama, karena yang toStringatau valueOfmetode. Sebagai contoh, perhatikan perbandingan string primitif dengan objek string yang dibuat menggunakan Stringkonstruktor.

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

Di sini ==operator memeriksa nilai dari dua objek dan kembali true, tetapi ===melihat bahwa mereka bukan tipe yang sama dan kembali false. Yang mana yang benar? Itu benar-benar tergantung pada apa yang Anda coba bandingkan. Saran saya adalah untuk memotong pertanyaan sepenuhnya dan hanya tidak menggunakan Stringkonstruktor untuk membuat objek string dari string literal.

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

Menggunakan ==operator ( Kesetaraan )

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

Menggunakan ===operator ( Identity )

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

Ini karena operator kesetaraan ==memang tipe paksaan , artinya penerjemah secara implisit mencoba untuk mengkonversi nilai-nilai sebelum membandingkan.

Di sisi lain, operator identitas ===tidak melakukan tipe paksaan , dan karenanya tidak mengkonversi nilai saat membandingkan, dan karenanya lebih cepat (sesuai dengan tes benchmark JS ini ) karena melompati satu langkah.

Representasi gambar yang menarik dari perbandingan kesetaraan antara ==dan ===.

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

var1 === var2

Saat menggunakan ===untuk pengujian kesetaraan JavaScript, semuanya seperti apa adanya. Tidak ada yang dikonversi sebelum dievaluasi.

var1 == var2

Saat menggunakan ==untuk pengujian kesetaraan JavaScript, beberapa konversi funky terjadi.

Pesan moral dalam cerita:

Gunakan ===kecuali jika Anda sepenuhnya memahami konversi yang terjadi ==.

Dalam jawaban di sini, saya tidak membaca apa pun tentang apa artinya sama . Beberapa orang akan mengatakan itu ===berarti sama dan berjenis sama , tetapi itu tidak sepenuhnya benar. Ini sebenarnya berarti bahwa kedua operan referensi objek yang sama , atau dalam kasus tipe nilai, memiliki nilai yang sama .

Jadi, mari kita ambil kode berikut:

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

Hal yang sama di sini:

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

Atau bahkan:

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

Perilaku ini tidak selalu jelas. Ada lebih banyak cerita daripada menjadi sama dan menjadi tipe yang sama.

Aturannya adalah:

Untuk tipe nilai (angka):
a === b mengembalikan true jikaadanbmemiliki nilai yang sama dan dari tipe yang sama

Untuk tipe referensi:
a === b mengembalikan true jikaadanbreferensi objek yang sama persis

Untuk string:
a === b mengembalikan true jikaadanbkeduanya string dan berisi karakter yang sama persis

Strings: kasus khusus ...

String bukan tipe nilai, tetapi dalam Javascript mereka berperilaku seperti tipe nilai, jadi mereka akan "sama" ketika karakter dalam string adalah sama dan ketika mereka memiliki panjang yang sama (seperti yang dijelaskan dalam aturan ketiga)

Sekarang menjadi menarik:

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

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

Tapi bagaimana dengan ini ?:

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

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

Saya pikir string berperilaku seperti tipe nilai? Yah, itu tergantung siapa yang kamu tanyakan ... Dalam hal ini a dan b bukan tipe yang sama. aadalah tipe Object, sedangkan btipe string. Hanya ingat bahwa membuat objek string menggunakan Stringkonstruktor menciptakan sesuatu tipe Objectyang berperilaku sebagai string sebagian besar waktu .

Izinkan saya menambahkan nasihat ini:

Jika ragu, baca spesifikasinya !

ECMA-262 adalah spesifikasi untuk bahasa scripting yang JavaScript adalah dialeknya. Tentu saja dalam praktiknya itu lebih penting bagaimana peramban yang paling penting berperilaku daripada definisi esoteris tentang bagaimana sesuatu seharusnya ditangani. Tetapi akan sangat membantu untuk memahami mengapa String baru ("a")! == "a" .

Tolong izinkan saya menjelaskan cara membaca spesifikasi untuk memperjelas pertanyaan ini. Saya melihat bahwa dalam topik yang sangat lama ini tidak ada yang punya jawaban untuk efek yang sangat aneh. Jadi, jika Anda dapat membaca spesifikasi, ini akan sangat membantu Anda dalam profesi Anda. Ini adalah keterampilan yang didapat. Jadi, mari kita lanjutkan.

Mencari file PDF untuk === membawa saya ke halaman 56 dari spesifikasi: 11.9.4. Operator Sama Ketat (===) , dan setelah mengarungi spesifik saya menemukan:

11.9.6 Algoritma Perbandingan Kesetaraan Ketat Perbandingan
x === y, di mana x dan y adalah nilai, menghasilkan benar atau salah . Perbandingan semacam itu dilakukan sebagai berikut:
  1. Jika Tipe (x) berbeda dari Tipe (y), return false .
  2. Jika Tipe (x) Tidak Terdefinisi, kembalikan true .
  3. Jika Tipe (x) kosong, kembalikan benar .
  4. Jika Tipe (x) bukan Angka, lanjutkan ke langkah 11.
  5. Jika x adalah NaN , kembalikan salah .
  6. Jika y adalah NaN , kembalikan salah .
  7. Jika x adalah nilai angka yang sama dengan y, kembalikan benar .
  8. Jika x adalah +0 dan y adalah −0, kembalikan true .
  9. Jika x adalah −0 dan y adalah +0, kembalikan true .
  10. Kembali salah .
  11. Jika Tipe (x) adalah String, maka mengembalikan true jika x dan y adalah urutan karakter yang sama (panjang yang sama dan karakter yang sama di posisi yang sesuai); jika tidak, kembalikan salah .
  12. Jika Tipe (x) adalah Boolean, kembalikan benar jika x dan y keduanya benar atau keduanya salah ; jika tidak, kembalikan salah .
  13. Kembalikan benarjika x dan y merujuk ke objek yang sama atau jika mereka merujuk ke objek yang bergabung satu sama lain (lihat 13.1.2). Jika tidak, kembalikan salah .

Menarik adalah langkah 11. Ya, string diperlakukan sebagai tipe nilai. Tapi ini tidak menjelaskan mengapa String baru ("a")! == "a" . Apakah kita memiliki browser yang tidak sesuai dengan ECMA-262?

Tidak secepat itu!

Mari kita periksa jenis operan. Cobalah sendiri dengan membungkusnya dalam typeof () . Saya menemukan bahwa String baru ("a") adalah objek, dan langkah 1 digunakan: return false jika tipenya berbeda.

Jika Anda bertanya-tanya mengapa String baru ("a") tidak mengembalikan string, bagaimana dengan latihan membaca spesifikasi? Selamat bersenang-senang!

Aidiakapi menulis ini dalam komentar di bawah ini:

Dari spesifikasinya

11.2.2 Operator baru :

Jika Tipe (konstruktor) bukan Objek, lempar pengecualian TypeError.

Dengan kata lain, jika String tidak akan menjadi tipe Object, itu tidak dapat digunakan dengan operator baru.

baru selalu mengembalikan Obyek, bahkan untuk konstruktor String juga. Dan sayangnya! Semantik nilai untuk string (lihat langkah 11) hilang.

Dan ini akhirnya berarti: String baru ("a")! == "a" .

Dalam PHP dan JavaScript, ini adalah operator kesetaraan yang ketat. Yang berarti, itu akan membandingkan jenis dan nilai.

Saya menguji ini di Firefox dengan Firebug menggunakan kode seperti ini:

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

dan

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

Hasil saya (masing-masing diuji lima kali dan rata-rata):

==: 115.2
===: 114.4

Jadi saya akan mengatakan bahwa perbedaan sangat kecil (ini lebih dari 100.000 iterasi, ingat) diabaikan. Kinerja bukan alasan untuk melakukannya ===. Ketik keamanan (well, seaman Anda akan mendapatkan JavaScript), dan kualitas kode.

Dalam JavaScript artinya nilai dan jenis yang sama.

Sebagai contoh,

4 == "4" // will return true

tapi

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

The === operator disebut operator perbandingan yang ketat, itu tidak berbeda dari == operator.

Mari kita ambil 2 vars a dan b.

Untuk "a == b" untuk mengevaluasi ke true a dan b perlu nilai yang sama .

Dalam kasus "a === b" a dan b harus memiliki nilai yang sama dan juga jenis yang sama untuk dievaluasi menjadi true.

Ambil contoh berikut

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");
}

Singkatnya ; menggunakan operator == dapat mengevaluasi true dalam situasi di mana Anda tidak menginginkannya jadi menggunakan operator === akan lebih aman.

Dalam skenario penggunaan 90% itu tidak masalah yang mana yang Anda gunakan, tetapi berguna untuk mengetahui perbedaannya ketika Anda mendapatkan perilaku yang tidak terduga suatu hari.

Mengapa ==begitu tak terduga?

Apa yang Anda dapatkan ketika Anda membandingkan string kosong ""dengan angka nol 0?

true

Yap, itu benar menurut ==string kosong dan angka nol adalah waktu yang sama.

Dan itu tidak berakhir di sini, ini satu lagi:

'0' == false // true

Banyak hal menjadi aneh dengan array.

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

Kemudian aneh dengan string

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

Itu semakin buruk:

Kapan sama tidak sama?

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!

Izinkan saya mengatakan itu lagi:

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

Dan ini hanya hal-hal gila yang Anda dapatkan dengan primitif.

Ini benar-benar tingkat gila saat Anda gunakan ==dengan benda.

Pada titik ini Anda mungkin bertanya-tanya ...

Mengapa ini terjadi?

Yah itu karena tidak seperti "triple sama dengan" ( ===) yang hanya memeriksa apakah dua nilai sama.

==melakukan banyak hal lainnya .

Ini memiliki penanganan khusus untuk fungsi, penanganan khusus untuk nulls, tidak terdefinisi, string, apa saja.

Agak aneh.

Bahkan, jika Anda mencoba untuk menulis fungsi yang melakukan apa ==yang akan terlihat seperti ini:

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();
}

Jadi apa artinya ini?

Artinya ==rumit.

Karena rumit, sulit untuk mengetahui apa yang akan terjadi ketika Anda menggunakannya.

Yang berarti Anda bisa berakhir dengan bug.

Jadi moral dari cerita ini adalah ...

Buat hidup Anda lebih mudah.

Gunakan ===sebagai ganti ==.

Tamat.

===memeriksa sisi yang sama dalam jenis dan nilai yang sama .

Contoh:

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

Contoh umum:

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

Contoh umum lainnya:

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

Banyak kali sebuah untyped cek akan berguna karena Anda tidak peduli jika nilai baik undefined, null, 0 atau""

Diagram alir eksekusi Javascript untuk kesetaraan / perbandingan '==='

Diagram alir eksekusi Javascript untuk persamaan / perbandingan tidak ketat '=='

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

Ini berarti kesetaraan tanpa paksaan tipe paksaan berarti JavaScript tidak secara otomatis mengkonversi tipe data lain ke tipe data string

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 

Dalam skrip tipikal tidak akan ada perbedaan kinerja. Yang lebih penting mungkin fakta bahwa ribuan "===" adalah 1 KB lebih berat dari seribu "==" :) JavaScript profiler dapat memberi tahu Anda jika ada perbedaan kinerja dalam kasus Anda.

Tetapi secara pribadi saya akan melakukan apa yang disarankan JSLint. Rekomendasi ini ada bukan karena masalah kinerja, tetapi karena tipe paksaan berarti ('\t\r\n' == 0)benar.

Operator perbandingan yang sama == membingungkan dan harus dihindari.

Jika Anda HARUS hidup dengannya, maka ingatlah 3 hal berikut:

1. Ini bukan transitif: (a == b) dan (b == c) tidak mengarah ke (a == c)
2. Ini saling eksklusif untuk negasinya: (a == b) dan (a! = B) selalu memiliki nilai Boolean yang berlawanan, dengan semua a dan b.
3. Jika ragu, pelajari dengan hati tabel kebenaran berikut:

MEJA KEBENARAN OPERATOR YANG SAMA DI JAVASCRIPT

• Setiap baris dalam tabel adalah satu set 3 nilai yang sama "sama", yang berarti bahwa setiap 2 nilai di antara mereka sama dengan menggunakan tanda == sama *

** STRANGE: perhatikan bahwa dua nilai pada kolom pertama tidak sama dalam arti itu. **

''       == 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.

Tidak mungkin ada perbedaan kinerja antara kedua operasi dalam penggunaan Anda. Tidak ada jenis konversi yang harus dilakukan karena kedua parameter sudah tipe yang sama. Kedua operasi akan memiliki perbandingan tipe diikuti oleh perbandingan nilai.

Iya! Bermasalah.

===operator di javascript memeriksa nilai dan juga mengetik di mana sebagai ==operator hanya memeriksa nilai (melakukan konversi jenis jika diperlukan) .

Anda dapat dengan mudah mengujinya. Rekatkan kode berikut dalam file HTML dan buka di browser

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

Anda akan mendapatkan ' false ' dalam peringatan. Sekarang ubah onPageLoad()metode agar alert(x == 5);Anda menjadi kenyataan .

=== Operator memeriksa nilai-nilai serta jenis variabel untuk kesetaraan.

== Operator hanya memeriksa nilai variabel untuk kesetaraan.

Ini tes pemeriksaan yang ketat.

Ini adalah hal yang baik terutama jika Anda memeriksa antara 0 dan false dan null.

Misalnya, jika Anda memiliki:

$a = 0;

Kemudian:

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

Semua mengembalikan true dan Anda mungkin tidak menginginkan ini. Misalkan Anda memiliki fungsi yang dapat mengembalikan indeks ke-0 array atau false pada kegagalan. Jika Anda mengecek "==" salah, Anda bisa mendapatkan hasil yang membingungkan.

Jadi dengan hal yang sama seperti di atas, tetapi tes yang ketat:

$a = 0;

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

JSLint terkadang memberi Anda alasan tidak realistis untuk memodifikasi barang. ===memiliki kinerja yang persis sama dengan== olah jenisnya sudah sama.

Itu lebih cepat hanya ketika jenis tidak sama, dalam hal ini tidak mencoba untuk mengkonversi jenis tetapi langsung mengembalikan yang salah.

Jadi, IMHO, JSLint mungkin digunakan untuk menulis kode baru, tetapi optimisasi berlebihan yang tidak berguna harus dihindari di semua biaya.

Artinya, tidak ada alasan untuk berubah ==ke ===dalam cek seperti if (a == 'test')ketika Anda mengetahuinya karena fakta bahwa hanya bisa menjadi String.

Memodifikasi banyak kode dengan cara itu menghabiskan waktu pengembang dan pengulas dan tidak menghasilkan apa-apa.

Secara sederhana

==berarti perbandingan antara operan dengan type conversion

&

===berarti perbandingan antara operan tanpa type conversion

Konversi tipe dalam javaScript berarti javaScript secara otomatis mengkonversi tipe data lain menjadi tipe data string.

Sebagai contoh:

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 

Contoh sederhana adalah

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

2 === '2'  -> false, values are NOT SAME because of no type conversion.

2 jawaban teratas yang disebutkan == berarti persamaan dan === berarti identitas. Sayangnya, pernyataan ini salah.

Jika kedua operan == adalah objek, maka mereka dibandingkan untuk melihat apakah keduanya adalah objek yang sama. Jika kedua operan menunjuk ke objek yang sama, maka operator yang sama mengembalikan true. Kalau tidak, keduanya tidak sama.

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

Dalam kode di atas, == dan === salah, karena a dan b bukan objek yang sama.

Itu mengatakan: jika kedua operan == adalah objek, == berperilaku sama dengan ===, yang juga berarti identitas. Perbedaan mendasar dari kedua operator ini adalah tentang konversi tipe. == memiliki konversi sebelum memeriksa kesetaraan, tetapi === tidak.

Sebagai aturan praktis, saya biasanya akan menggunakan ===bukannya ==(dan !==bukannya!= ).

Alasan dijelaskan dalam jawaban di atas dan juga Douglas Crockford cukup jelas tentang hal itu ( JavaScript: The Good Parts ).

Namun ada satu pengecualian tunggal : == nulladalah cara yang efisien untuk memeriksa 'apakah nol atau tidak terdefinisi':

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

Misalnya jQuery 1.9.1 menggunakan pola ini 43 kali, dan pemeriksa sintaks JSHint bahkan menyediakaneqnull opsi untuk alasan ini.

Dari panduan gaya jQuery :

Pemeriksaan kesetaraan yang ketat (===) harus digunakan untuk ==. Satu-satunya pengecualian adalah ketika memeriksa tidak terdefinisi dan null dengan nol.

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

Masalahnya adalah Anda mungkin dengan mudah mendapat masalah karena JavaScript memiliki banyak konversi tersirat yang berarti ...

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

Yang segera menjadi masalah. Sampel terbaik mengapa konversi implisit adalah "jahat" dapat diambil dari kode ini di MFC / C ++ yang sebenarnya akan dikompilasi karena konversi implisit dari CString ke HANDLE yang merupakan tipe pointer typedef ...

CString x;
delete x;

Yang jelas selama runtime melakukan hal-hal yang sangat tidak jelas ...

Google untuk konversi tersirat dalam C ++ dan STL untuk mendapatkan beberapa argumen yang menentangnya ...

Dari referensi javascript inti

===Mengembalikan truejika operan benar-benar sama (lihat di atas) tanpa konversi tipe.

Perbandingan kesetaraan:

Operator ==

Mengembalikan nilai true, ketika kedua operan sama. Operan dikonversi ke jenis yang sama sebelum dibandingkan.

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

Perbandingan kesetaraan dan jenis:

Operator ===

Mengembalikan nilai true jika kedua operan sama dan dari jenis yang sama. Biasanya lebih baik dan lebih aman jika Anda membandingkan cara ini, karena tidak ada konversi tipe di belakang layar.

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

Berikut ini adalah tabel perbandingan yang berguna yang menunjukkan konversi yang terjadi dan perbedaan antara ==dan ===.

Sebagai kesimpulan menyatakan:

"Gunakan tiga sama dengan kecuali Anda sepenuhnya memahami konversi yang terjadi untuk dua-sama."

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

null dan undefined adalah ketiadaan, yaitu,

var a;
var b = null;

Di sini adan btidak memiliki nilai. Sedangkan, 0, false dan '' adalah semua nilai. Satu hal yang umum di antara semua ini adalah bahwa semua itu adalah nilai-nilai palsu, yang berarti semuanya memuaskan kondisi palsu.

Jadi, 0, false, dan '' bersama-sama membentuk sub-grup. Dan di sisi lain, null & undefined membentuk sub-grup kedua. Periksa perbandingan pada gambar di bawah ini. null dan undefined akan sama. Tiga lainnya akan sama satu sama lain. Tapi, mereka semua diperlakukan sebagai kondisi palsu dalam JavaScript.

Ini sama dengan objek apa pun (seperti {}, array, dll.), String tidak kosong & Boolean true adalah semua kondisi yang benar. Tapi, mereka semua tidak setara.