Mengapa == s benar tetapi {} === {} adalah palsu.

Pengendali kesamaan ketat JavaScript (===) nampak mudah pada pandangan pertama, tetapi sesetengah situasi mungkin mengelirukan anda. Mari terokai sebab 1 === 1 mengembalikan true, manakala {} === {} mengembalikan false.

Mekanisme ingatan: nilai primitif dan objek

Untuk memahami tingkah laku ini, anda perlu memahami cara JavaScript mengendalikan nilai mentah dan objek dalam ingatan.

Nilai asal

Nilai primitif termasuk nombor, rentetan, boolean, undefined, null dan simbol. Apabila membandingkan dua nilai primitif menggunakan ===, JavaScript menyemak sama ada nilai mereka adalah sama. Memandangkan dua 1 === 1 dalam 1 merujuk kepada nilai yang sama, perbandingan menghasilkan true.

Objek

Objek lebih kompleks. Ia disimpan dalam kawasan memori khas yang dipanggil Timbunan. Setiap kali objek dicipta, ia mendapat lokasi memori baharu dalam timbunan. Apabila anda menggunakan === untuk membandingkan objek, JavaScript menyemak sama ada kedua-dua objek merujuk lokasi memori yang sama. Memandangkan {} dan {} ialah dua objek berbeza yang dicipta dalam ingatan dan mereka tidak berkongsi lokasi memori yang sama, hasil daripada {} === {} ialah false.

Selam dalam: ingatan dan timbunan

Berikut ialah rajah yang dipermudahkan:

<code class="language-javascript">const obj1 = {}; // 在内存位置 A 创建
const obj2 = {}; // 在内存位置 B 创建

console.log(obj1 === obj2); // false，因为 A !== B

const obj3 = obj1; // obj3 指向与 obj1 相同的位置
console.log(obj1 === obj3); // true，因为两者都指向 A</code>

Perbezaan ini kerana objek adalah jenis rujukan, yang bermaksud perbandingan menyemak sama ada rujukan adalah sama, bukan kandungannya.

Gunakan typeof untuk menyemak jenis nilai

Pengendali typeof dalam JavaScript membantu anda memahami jenis nilai. Begini cara menggunakannya:

<code class="language-javascript">console.log(typeof "hello"); // "string"
console.log(typeof 42);       // "number"
console.log(typeof true);     // "boolean"
console.log(typeof undefined);// "undefined"
console.log(typeof null);     // "object" (已知的 bug!)
console.log(typeof {});       // "object"
console.log(typeof []);       // "object"
console.log(typeof function () {}); // "function"</code>

Tidak dijangka: null dan tatasusunan ialah objek

Anda mungkin perasan sesuatu yang pelik: typeof null Mengembalikan "objek". Ini ialah pepijat sejarah dalam JavaScript yang tidak boleh diperbaiki tanpa memecahkan web. Walau bagaimanapun, tatasusunan dan fungsi sememangnya objek di bawah hud.

Fungsi ialah objek istimewa

Fungsi sememangnya objek, tetapi ia mempunyai satu sifat unik: [[Call]]. Sifat dalaman ini menjadikannya boleh dipanggil, itulah sebabnya anda boleh memanggilnya seperti ini:

<code class="language-javascript">function greet() {
  console.log("Hello!");
}

greet(); // "Hello!"</code>

Kepentingan

Memahami perbezaan antara nilai primitif dan objek adalah penting untuk menulis kod JavaScript yang mantap. Apabila membandingkan objek, gunakan semakan kesamaan mendalam jika anda ingin membandingkan kandungannya. Contohnya:

<code class="language-javascript">const objA = { name: "Alice" };
const objB = { name: "Alice" };

// 浅比较
console.log(objA === objB); // false

// 深度比较
const isEqual = JSON.stringify(objA) === JSON.stringify(objB);
console.log(isEqual); // true</code>

Kesimpulan

Kuncinya ialah 1 === 1 mengembalikan true kerana primitif membandingkan mengikut nilai dan {} === {} mengembalikan false kerana objek membandingkan dengan rujukan. Sebaik sahaja anda menguasai ini, anda akan dapat memahami dengan lebih baik ciri dan selok-belok JavaScript!

Atas ialah kandungan terperinci Mengapa == s benar tetapi {} === {} adalah palsu.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!