Pourquoi == est vrai mais {} === {} est faux.

L'opérateur d'égalité stricte de JavaScript (===) semble simple à première vue, mais certaines situations peuvent vous dérouter. Explorons pourquoi 1 === 1 revient true, tandis que {} === {} renvoie false.

Mécanisme de mémoire : valeurs et objets primitifs

Pour comprendre ce comportement, vous devez comprendre comment JavaScript gère les valeurs brutes et les objets en mémoire.

Valeur originale

Les valeurs primitives incluent les nombres, les chaînes, les booléens, undefined, null et les symboles. Lors de la comparaison de deux valeurs primitives à l'aide de ===, JavaScript vérifie si leurs valeurs sont les mêmes. Puisque les deux 1 === 1 dans 1 font référence à la même valeur, la comparaison donne true.

Objet

Les objets sont plus complexes. Ils sont stockés dans une zone de mémoire spéciale appelée Heap. Chaque fois qu'un objet est créé, il obtient un nouvel emplacement mémoire dans le tas. Lorsque vous utilisez === pour comparer des objets, JavaScript vérifie si les deux objets font référence au même emplacement mémoire. Puisque {} et {} sont deux objets différents créés en mémoire et qu'ils ne partagent pas le même emplacement mémoire, le résultat de {} === {} est false.

Plongée approfondie : mémoire et tas

Ce qui suit est un schéma simplifié :

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

Cette différence est due au fait que les objets sont des types de référence, ce qui signifie que la comparaison vérifie si les références sont identiques, pas le contenu.

Utilisez typeof pour vérifier le type de valeur

L'opérateur typeof en JavaScript vous aide à comprendre le type d'une valeur. Voici comment l'utiliser :

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

Inattendu : null et les tableaux sont des objets

Vous remarquerez peut-être quelque chose d'étrange : typeof null Renvoie "objet". Il s'agit d'un bug historique de JavaScript qui ne peut être corrigé sans casser le Web. Cependant, les tableaux et les fonctions sont bel et bien des objets cachés.

Les fonctions sont des objets spéciaux

Les fonctions sont bien des objets, mais elles ont une propriété unique : [[Call]]. Cette propriété interne les rend appelables, c'est pourquoi vous pouvez les appeler ainsi :

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

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

Importance

Comprendre la différence entre les valeurs primitives et les objets est essentiel pour écrire du code JavaScript robuste. Lorsque vous comparez des objets, utilisez des vérifications d'égalité approfondies si vous souhaitez comparer leur contenu. Par exemple :

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

Conclusion

La clé est que 1 === 1 renvoie true car les primitives se comparent par valeur, et {} === {} renvoie false car les objets se comparent par référence. Une fois que vous maîtriserez cela, vous serez en mesure de mieux comprendre les fonctionnalités et les subtilités de JavaScript !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!