Pourquoi ne pouvons-nous pas comparer les tableaux et les objets avec ===

Cet article explore une question JavaScript commune: pourquoi l'opérateur d'égalité strict (===) ne fonctionne pas comme prévu lors de la comparaison des tableaux et des objets. Nous nous plongerons dans les travaux internes de JavaScript pour comprendre ce comportement.

JavaScript distingue les types de données primitifs et non primitifs. Les types primitifs (booléen, nul, non défini, chaîne, nombre) sont passés par valeur, tandis que les types non primitifs (tableaux, fonctions et objets - tous les objets techniquement) sont passés par référence.

Comportement de type primitif (passer par valeur)

Lorsque vous déclarez une variable primitive, la valeur est stockée directement:

<code class="language-javascript">const name = 'John';
const age = 25;</code>

Variable	Value
name	'John'
age	25

Comportement de type non primitif (passer par référence)

Les variables non primitives stockent une référence à l'emplacement de la mémoire de l'objet, pas l'objet lui-même:

<code class="language-javascript">const name = 'John';
const age = 25;</code>

Initialement, fruits détient une référence (par exemple, l'adresse de mémoire H001) pointant vers un tableau vide. Après push(), le tableau à H001 est modifié.

Copie de référence

Lorsque vous copiez une variable de référence à l'aide de =, vous copiez la référence, pas les données de l'objet:

<code class="language-javascript">const fruits = [];
fruits.push('Banana');</code>

à la fois fruits et yellowFruits pointent désormais le même emplacement de mémoire. La modification de l'une modifie l'autre.

ajoutant «ananas» à yellowFruits change également fruits parce qu'ils partagent la même référence.

Réaffectation des variables de référence

La réaffectation d'une variable de référence crée une nouvelle référence:

<code class="language-javascript">const fruits = ['Banana'];
const yellowFruits = fruits;</code>

L'objet d'origine { name: 'John' } reste en mémoire, mais person pointe désormais vers un nouvel objet { name: 'Mary' }.

Pourquoi === échoue avec les tableaux et les objets

L'opérateur === compare les références pour les types non primitifs. Par conséquent:

<code class="language-javascript">let person = { name: 'John' };
person = { name: 'Mary' };</code>

Même si arr1 et arr3 ont un contenu identique, ils ont différentes adresses de mémoire, ce qui entraîne false.

Paramètres de fonction et pureté

Passer des valeurs primitives aux fonctions copie la valeur. Cependant, le passage des objets passe la référence. Cette distinction est cruciale pour comprendre les fonctions pures et impures.

• Fonctions pures: Ne modifiez pas l'état externe. Ils fonctionnent uniquement sur leurs entrées et produisent des sorties prévisibles.
• Fonctions impures: Peut modifier les objets passés comme arguments, affectant l'objet d'origine en dehors de la portée de la fonction.

Pour créer une fonction pure qui modifie un objet, créez une copie avant la modification:

<code class="language-javascript">const arr1 = ['1'];
const arr2 = arr1;  // Same reference

console.log(arr1 === arr2); // true

const arr3 = ['1']; // Different reference
console.log(arr1 === arr3); // false</code>

en résumé

1. Les types primitifs sont passés par valeur; Les types non primitifs sont passés par référence.
2. === compare les références pour les types non primitifs.
3. Comprendre la copie de référence est vitale pour l'écriture de code prévisible et maintenable.
4. Les fonctions pures évitent les effets secondaires en ne modifiant pas l'état externe.

Pour une plongée plus profonde dans la gestion de la mémoire JavaScript, explorez la pile d'appels et le tas de mémoire.

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!