Perbedaan antara operator == dan === Pada JavaScript

Perbedaan antara operator == dan === Pada JavaScript

iis

September 3, 2019

Operator identitas (===) identik dengan operator kesetaraan (==) kecuali tidak ada konversi jenis yang dilakukan, dan jenisnya harus sama agar dianggap sama.

javascript-illustration

Operator == akan membandingkan kesetaraan setelah melakukan konversi jenis apa pun yang diperlukan. Operator === tidak akan melakukan konversi, jadi jika dua nilai bukan tipe yang sama === hanya akan mengembalikan false. Keduanya sama-sama cepat.

JavaScript memiliki dua set operator persamaan: === dan! ==, dan si kembar jahat mereka == dan! =. Yang bagus bekerja seperti yang Anda harapkan. Jika dua operan memiliki tipe yang sama dan memiliki nilai yang sama, maka === menghasilkan true dan! == menghasilkan 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 melaluinya mereka rumit dan tidak bisa dilanggar. Ini adalah beberapa kasus menarik:

    '' == '0' // false
0 == '' // benar
0 == '0' // benar
false == 'false' // false
false == '0' // benar
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. Sebagai gantinya, selalu gunakan === dan! ==. Semua perbandingan yang baru saja ditampilkan menghasilkan false dengan operator ===.

Untuk tipe referensi == 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 // benar
e === f // benar

Kasus khusus adalah ketika Anda membandingkan literal dengan objek yang mengevaluasi ke literal yang sama, karena toString atau metode valueOf. Sebagai contoh, pertimbangkan perbandingan string literal dengan objek string yang dibuat oleh konstruktor String.

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

Di sini operator == sedang memeriksa nilai-nilai dari dua objek dan mengembalikan true, tetapi === melihat bahwa mereka bukan tipe yang sama dan mengembalikan 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 konstruktor string untuk membuat objek string.