Warum == wahr ist, aber {} === {} falsch ist.

Der strikte Gleichheitsoperator (===) von JavaScript scheint auf den ersten Blick einfach zu sein, aber einige Situationen können Sie verwirren. Lassen Sie uns untersuchen, warum 1 === 1 true zurückgibt, während {} === {} false zurückgibt.

Speichermechanismus: primitive Werte und Objekte

Um dieses Verhalten zu verstehen, müssen Sie verstehen, wie JavaScript mit Rohwerten und Objekten im Speicher umgeht.

Ursprünglicher Wert

Primitive Werte umfassen Zahlen, Zeichenfolgen, boolesche Werte, undefined, null und Symbole. Beim Vergleich zweier Grundwerte mit === prüft JavaScript, ob ihre Werte gleich sind. Da sich die beiden 1 === 1 in 1 auf denselben Wert beziehen, ergibt der Vergleich true.

Objekt

Objekte sind komplexer. Sie werden in einem speziellen Speicherbereich namens Heap gespeichert. Jedes Mal, wenn ein Objekt erstellt wird, erhält es einen neuen Speicherort im Heap. Wenn Sie === zum Vergleichen von Objekten verwenden, prüft JavaScript, ob die beiden Objekte auf den gleichen Speicherort verweisen. Da {} und {} zwei verschiedene im Speicher erstellte Objekte sind und nicht denselben Speicherort teilen, ist das Ergebnis von {} === {} false.

Deep Dive: Speicher und Heap

Das Folgende ist ein vereinfachtes Diagramm:

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

Dieser Unterschied liegt daran, dass es sich bei den Objekten um Referenztypen handelt, was bedeutet, dass beim Vergleich geprüft wird, ob die Referenzen identisch sind, nicht der Inhalt.

Verwenden Sie typeof, um den Werttyp zu überprüfen

Der typeof-Operator in JavaScript hilft Ihnen, den Typ eines Werts zu verstehen. So verwenden Sie es:

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

Unerwartet: null und Arrays sind Objekte

Vielleicht bemerken Sie etwas Seltsames: typeof null Gibt „Objekt“ zurück. Dies ist ein historischer Fehler in JavaScript, der nicht behoben werden kann, ohne das Web zu beschädigen. Allerdings sind Arrays und Funktionen tatsächlich Objekte unter der Haube.

Funktionen sind spezielle Objekte

Funktionen sind zwar Objekte, aber sie haben eine einzigartige Eigenschaft: [[Call]]. Diese interne Eigenschaft macht sie aufrufbar, weshalb Sie sie so nennen können:

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

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

Wichtigkeit

Das Verständnis des Unterschieds zwischen primitiven Werten und Objekten ist entscheidend für das Schreiben von robustem JavaScript-Code. Verwenden Sie beim Vergleichen von Objekten umfassende Gleichheitsprüfungen, wenn Sie deren Inhalte vergleichen möchten. Zum Beispiel:

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

Fazit

Der Schlüssel ist, dass 1 === 1 true zurückgibt, weil Grundelemente nach Wert verglichen werden, und {} === {} false zurückgibt, weil Objekte nach Referenz verglichen werden. Sobald Sie dies beherrschen, werden Sie die Funktionen und Feinheiten von JavaScript besser verstehen!

Das obige ist der detaillierte Inhalt vonWarum == wahr ist, aber {} === {} falsch ist.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!