Pertanyaan Operator yang sama (== vs ===) harus digunakan dalam perbandingan JavaScript?


saya menggunakan JSLint melalui JavaScript, dan mengembalikan banyak saran untuk diganti == (dua tanda sama dengan) === (tiga tanda sama dengan) ketika melakukan hal-hal seperti membandingkan idSele_UNVEHtype.value.length == 0 di dalam sebuah if pernyataan.

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

Setiap peningkatan kinerja akan disambut baik oleh banyak operator perbandingan.

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


5674
2017-12-11 14:19


asal


Jawaban:


Identitas (===) operator berperilaku identik dengan kesetaraan (==) operator kecuali tanpa konversi tipe dilakukan, dan jenis harus sama untuk dianggap sama.

Referensi: Javascript Tutorial: Operator Perbandingan

Itu == operator akan membandingkan untuk kesetaraan setelah melakukan konversi jenis yang diperlukan. Itu === operator akan tidak lakukan konversi, jadi jika dua nilai bukan tipe yang sama === hanya akan kembali false. Keduanya sama-sama cepat.

Mengutip pendapat Douglas Crockford JavaScript: Bagian-bagian yang Baik,

JavaScript memiliki dua set operator kesetaraan: === dan !==, dan kembar jahat mereka == dan !=. Yang baik bekerja dengan cara 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 operandnya bertipe sama, tetapi jika mereka memiliki tipe yang berbeda, mereka berusaha untuk menekan nilai-nilai. aturan yang mereka lakukan itu rumit dan tidak menyenangkan. Ini adalah beberapa kasus yang 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 ditampilkan menghasilkan false dengan === operator.


Memperbarui:

Poin yang bagus dibesarkan oleh @Casebash di komentar dan di @Phillipe Laybaert  menjawab tentang jenis referensi. Untuk tipe referensi == dan === bertindak secara konsisten dengan 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 literal dengan objek yang mengevaluasi ke literal yang sama, karena sifatnya toString atau valueOf metode. Sebagai contoh, pertimbangkan perbandingan string literal dengan objek string yang dibuat oleh String konstruktor.

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

Di sini == operator memeriksa nilai dari dua objek dan kembali true, tetapi === adalah 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 mengabaikan pertanyaan sepenuhnya dan hanya tidak menggunakan String konstruktor untuk membuat objek string.

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


5716
2017-12-11 14:25



Menggunakan ==operator (Persamaan)

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 (Identitas)

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

Ini karena operator kesetaraan == tidak melakukan pemaksaan, artinya interpreter secara implisit mencoba mengonversi nilai sebelum membandingkan.

Di sisi lain, itu operator identitas === tidak melakukan pemaksaan jenis, dan dengan demikian tidak mengubah nilai saat membandingkan.


988
2018-06-05 19:11



Dalam jawaban di sini, saya tidak membaca apa pun tentang apa sama cara. Beberapa orang akan mengatakan itu === cara sama dan dari tipe yang sama, tapi itu tidak benar. Itu sebenarnya berarti itu kedua operand mereferensikan objek yang sama, atau dalam kasus jenis 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 setara dan memiliki tipe yang sama.

Aturannya adalah:

Untuk jenis nilai (angka):
a === b mengembalikan nilai true jika a dan b memiliki nilai yang sama dan memiliki tipe yang sama

Untuk tipe referensi:
a === b mengembalikan nilai true jika a dan b referensi objek yang sama persis

Untuk string:
a === b mengembalikan nilai true jika a dan b keduanya string dan berisi karakter yang sama persis


String: kasus khusus ...

String bukanlah jenis nilai, tetapi dalam Javascript mereka berperilaku seperti jenis nilai, sehingga mereka akan "sama" ketika karakter dalam string 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

Tetapi 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 Anda tanyakan ... Dalam hal ini a dan b bukan tipe yang sama. a adalah tipe Object, sementara b adalah tipe string. Ingatlah bahwa membuat objek string menggunakan String konstruktor menciptakan sesuatu yang bertipe Object yang berfungsi sebagai string sebagian besar waktu.


545
2018-05-05 05:21



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

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


var1 === var2

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

Equality evaluation of === in JS


var1 == var2

Ketika menggunakan == untuk pengujian kesamaan JavaScript, beberapa   konversi yang funky terjadi.

Equality evaluation of == in JS

Pesan moral dalam cerita: 

Menggunakan === kecuali Anda benar-benar memahami   konversi yang terjadi dengan ==.


519
2017-11-28 18:18



Izinkan saya menambahkan nasihat ini:

Jika ragu, bacalah spesifikasi! 

ECMA-262 adalah spesifikasi untuk bahasa scripting di mana JavaScript adalah dialek. Tentu saja dalam praktik itu lebih penting bagaimana browser yang paling penting berperilaku daripada definisi esoterik tentang bagaimana sesuatu seharusnya ditangani. Tetapi sangat membantu untuk memahami mengapa String baru ("a")! == "a".

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

Mencari file PDF untuk === membawa saya ke halaman 56 dari spesifikasi: 11.9.4. Operator Setara yang Setara (===), dan setelah mengarungi hal-hal spesifik yang saya temukan:

11.9.6 Algoritme Perbandingan Persamaan yang Ketat
  Perbandingan x === y, di mana x dan y adalah nilai, menghasilkan benar atau Salah. Perbandingan seperti itu dilakukan sebagai berikut:
  1. Jika Jenis (x) berbeda dari Jenis (y), kembalikan Salah.
  2. Jika Jenis (x) Tidak Terdefinisi, kembali benar.
  3. Jika Jenis (x) Null, kembali benar.
  4. Jika Jenis (x) bukan Angka, lanjutkan ke langkah 11.
  5. Jika x NaN, kembali Salah.
  6. Jika Anda NaN, kembali Salah.
  7. Jika x adalah nilai angka yang sama dengan y, kembali benar.
  8. Jika x +0 dan y adalah −0, kembali benar.
  9. Jika x adalah −0 dan y +0, kembali benar.
  10. Kembali Salah.
  11. Jika Type (x) adalah String, maka kembalikan benar jika x dan y adalah urutan karakter yang persis sama (panjang yang sama dan karakter yang sama dalam posisi yang sesuai); jika tidak, kembalikan Salah.
  12. Jika Jenis (x) adalah Boolean, kembali benar jika x dan y keduanya benar atau keduanya Salah; jika tidak, kembalikan Salah.
  13. Kembali benar jika x dan y merujuk ke objek yang sama atau jika mereka merujuk pada objek yang tergabung satu sama lain (lihat 13.1.2). Jika tidak, kembalikan Salah.

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

Tidak terlalu cepat!

Mari kita periksa jenis operan. Cobalah sendiri dengan membungkusnya jenis(). aku menemukan bahwa String baru ("a") adalah objek, dan langkah 1 digunakan: kembali Salah jika jenisnya 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 spesifikasi

11.2.2 Operator baru:

Jika Jenis (konstruktor) bukan Objek, buang pengecualian TypeError.

Dengan kata lain, jika String tidak bertipe Objek, itu tidak bisa digunakan dengan operator baru.

baru selalu mengembalikan Object, bahkan untuk Tali konstruktor juga. Dan sayangnya! Nilai semantik untuk string (lihat langkah 11) hilang.

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


250
2018-05-12 12:58



Di PHP dan JavaScript, itu adalah operator kesetaraan yang ketat. Yang berarti, ia akan membandingkan kedua jenis dan nilainya.


93
2017-12-25 11:17



Saya menguji ini di Firefox dengan Pembakar 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 (diuji lima kali masing-masing dan dirata-ratakan):

==: 115.2
===: 114.4

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


88
2018-05-12 12:58



Dalam JavaScript artinya nilai dan jenis yang sama.

Sebagai contoh,

4 == "4" // will return true

tapi

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

84
2017-12-11 14:58