Object.is vs ===

Saya menemukan contoh kode yang menggunakan perbandingan ini:

var someVar = 0;
Object.is(false, someVar); //Returns false 

Aku tahu false == 0akan truebahwa ini mengapa kita memiliki ===.

Bagaimana Object.isbedanya ===?

===disebut operator perbandingan ketat dalam JavaScript. Object.isdan operator perbandingan ketat berperilaku sama persis kecuali untuk NaNdan +0/-0.

Dari MDN:

Object.is()Metode tidak sama dengan menjadi sama menurut ===operator. The ===operator (dan ==Operator juga) memperlakukan nilai-nilai jumlah -0 dan 0 sebagai sama dan memperlakukan Number.NaNtidak sama untuk NaN.

Kode di bawah ini menyoroti perbedaan antara ===dan Object.is().

console.log(+0 === -0); //true
console.log(Object.is(+0, -0)); //false

console.log(NaN === NaN); // false
console.log(Object.is(NaN, NaN)); //true

console.log(Number.NaN === Number.NaN); // false
console.log(Object.is(Number.NaN, Number.NaN)); // true

console.log(NaN === Number.NaN); // false
console.log(Object.is(NaN, Number.NaN)); // true

Anda dapat menemukan lebih banyak contoh di sini .

Catatan : Object.isadalah bagian dari proposal ECMAScript 6 dan belum didukung secara luas (mis. Belum didukung oleh versi Internet Explorer atau banyak versi browser lainnya). Namun Anda dapat menggunakan polyfill untuk browser non-ES6 yang dapat ditemukan di tautan yang diberikan di atas.

Object.ismenggunakan algoritme SameValue spesifikasi , sedangkan ===menggunakan Algoritma Ketat Persamaan . Catatan tentang Algoritma Kesetaraan Ketat menyebutkan perbedaannya:

Algoritma ini berbeda dari SameValue Algorithm ... dalam perlakuannya terhadap nol dan NaN yang ditandatangani.

Perhatikan bahwa:

• NaN === NaNitu salah, tetapi Object.is(NaN, NaN)itu benar
• +0 === -0itu benar, tetapi Object.is(+0, -0)salah
• -0 === +0 itu benar, tapi Object.is(-0, +0)salah

JavaScript memiliki setidaknya empat jenis "kesetaraan":

• "Loose" ( ==), di mana operan akan dipaksa untuk membuatnya cocok. Aturannya jelas ditentukan , tetapi tidak jelas. ( "" == 0adalahtrue ; "true" == trueadalah false, ...).
• "Ketat" (=== ), di mana operan dari jenis yang berbeda tidak akan dipaksa (dan tidak akan sama), tetapi lihat catatan di atas tentang NaNdan nol positif dan negatif.
• SameValue - sebagaimana tercantum di atas (digunakan oleh Object.is ).
• SameValueZero - seperti SameValuekecuali +0dan -0sama, bukan berbeda (digunakan oleh Mapuntuk kunci, dan olehArray.prototype.includes ).

Ada juga ekuivalensi objek , yang tidak disediakan oleh bahasa atau runtime itu sendiri, tetapi biasanya dinyatakan sebagai: Objek memiliki prototipe yang sama, properti yang sama, dan nilai propertinya sama (oleh beberapa definisi masuk akal "sama" ).

Algoritma SameValue :

• Jika Tipe (x) berbeda dari Tipe (y), kembalikan salah.
• Jika Tipe (x) adalah Angka, maka
  • Jika x adalah NaN dan y adalah NaN, kembalikan benar.
  • Jika x adalah +0 dan y adalah -0, kembalikan salah.
  • Jika x adalah -0 dan y adalah +0, kembalikan salah.
  • Jika x adalah nilai Angka yang sama dengan y, kembalikan benar.
  • Kembali salah
• Kembalikan SameValueNonNumber (x, y).

... di mana SameValueNonNumber adalah:

• Menegaskan: Jenis (x) bukan Nomor.
• Menegaskan: Tipe (x) sama dengan Tipe (y).
• Jika Tipe (x) Tidak Terdefinisi, kembalikan benar.
• Jika Tipe (x) adalah Null, kembalikan benar.
• Jika Tipe (x) adalah String, maka
  • Jika x dan y adalah urutan yang persis sama dari unit kode (panjang yang sama dan unit kode yang sama pada indeks yang sesuai), kembalikan true; jika tidak, kembalikan salah.
• Jika Tipe (x) adalah Boolean, maka
  • Jika x dan y keduanya benar atau keduanya salah, kembalikan benar; jika tidak, kembalikan salah.
• Jika Tipe (x) adalah Simbol, maka
  • Jika x dan y keduanya nilai simbol yang sama, kembalikan benar; jika tidak, kembalikan salah.
• Mengembalikan nilai true jika x dan y adalah nilai Objek yang sama. Jika tidak, kembalikan salah.

Algoritma Persamaan Ketat :

1. Jika Tipe (x) berbeda dari Tipe (y), kembalikan salah.
2. Jika Tipe (x) adalah Angka, maka
   • Jika x adalah NaN, kembalikan salah.
   • Jika y adalah NaN, kembalikan salah.
   • Jika x adalah nilai Angka yang sama dengan y, kembalikan benar.
   • Jika x adalah +0 dan y adalah -0, kembalikan true.
   • Jika x adalah -0 dan y adalah +0, kembalikan true.
   • Kembali salah
3. Kembalikan SameValueNonNumber (x, y).

Object.is = function(v1, v2){
  //test for `-0`
  if(v1 === 0 && v2 === 0) {
    return 1 / v1 === 1 / v2;
  }
  
  //test for `NaN`
  if(v1 !== v1) {
    return v2 !== v2;
  }
  
  //everything else
  return v1 === v2;
}

Di atas adalah fungsi polyfill untuk menunjukkan cara Object.iskerjanya, bagi siapa saja yang tertarik untuk mengetahuinya. Referensi ke You-Don't-Know-JS

Ringkasan:

Itu Object.is() Fungsi mengambil 2 nilai sebagai argumen dan mengembalikan nilai true jika 2 nilai yang diberikan adalah persis sama, selain itu akan kembali palsu.

kenapa kita butuh ini?

Anda mungkin berpikir, kita sudah memiliki kesetaraan yang ketat (memeriksa tipe + nilai) memeriksa javascript dengan ===operator, mengapa kita membutuhkan fungsi ini? Kesetaraan yang ketat tidak cukup dalam beberapa kasus dan mereka adalah sebagai berikut:

console.log(NaN === NaN);   // false
console.log(-0 === +0);     // true

Object.is() membantu kami dengan dapat membandingkan nilai-nilai ini untuk melihat apakah mereka serupa, sesuatu yang tidak dapat dilakukan oleh operator kesetaraan yang ketat.

console.log(Object.is(NaN, NaN));  // true
console.log(Object.is(-0, 0));     // false
console.log(Object.is(+0, +0));    // true
console.log(Object.is(+0, -0));    // false

Singkatnya, mereka serupa, tetapi Object.islebih pintar dan lebih akurat ...

Mari kita lihat ini ...

+0 === -0 //true

Tapi ini tidak sepenuhnya benar karena mengabaikan -dan +sebelum ...

Sekarang kami menggunakan:

Object.is(+0, -0) //false

Seperti yang Anda lihat, ini lebih akurat untuk dibandingkan.

Juga dalam hal NaNitu berfungsi lebih seperti benar, karena menganggapnya NaNsama.