Égalité stricte en JavaScript : ce que === compare vraiment

C'est l'opérateur de comparaison qu'on recommande partout, et à raison. Il n'empêche pas pour autant deux surprises : un nombre qui n'est pas égal à lui-même, et deux objets identiques que le langage déclare différents.

Définition

L'égalité stricte, écrite avec trois signes égal, compare deux valeurs sans effectuer la moindre conversion. Si les types diffèrent, la réponse est immédiatement false, sans même regarder le contenu.

console.log("2" === 2);   // false : chaîne contre nombre
console.log(2 === 2);      // true
console.log(null === undefined); // false

// L'opposé s'écrit avec !==
console.log("2" !== 2);   // true

C'est exactement ce qui la sépare de l'Égalité faible (==), qui convertit avant de comparer et produit des résultats difficiles à prévoir. La règle admise dans la profession tient en une phrase : utilisez toujours trois signes égal, sauf dans le cas précis décrit sur la page de l'égalité faible.

Les deux valeurs qui échappent à la règle

Deux cas ne suivent pas l'intuition, et ils viennent tous les deux de la norme des nombres à virgule flottante.

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

// La bonne façon de tester chacun des deux
console.log(Number.isNaN(NaN));  // true
console.log(Object.is(0, -0));   // false

NaN représente un calcul numérique qui a échoué, et deux échecs n'ont aucune raison d'être le même échec : il n'est donc égal à rien, pas même à lui-même. À l'inverse, le zéro négatif est bien distinct du zéro positif en mémoire, mais l'égalité stricte les confond.

Les objets se comparent par leur adresse

Voilà le point qui coûte le plus de temps aux débutants. Sur un objet, un tableau ou une fonction, l'opérateur ne regarde pas le contenu : il demande s'il s'agit du même exemplaire en mémoire.

const a = [1, 2];
const b = [1, 2];
const c = a;

console.log(a === b); // false : deux tableaux distincts
console.log(a === c); // true  : le même tableau

// Comparer le contenu demande une autre méthode
console.log(JSON.stringify(a) === JSON.stringify(b)); // true

La dernière ligne dépanne sur des données simples, mais elle dépend de l'ordre des clés et ne gère ni les dates ni les fonctions. Pour une comparaison sérieuse, écrivez une fonction dédiée ou passez par une bibliothèque.

Questions fréquentes

Oui, à une exception près. L'écriture valeur == null teste d'un coup null et undefined, ce qui rend service. Partout ailleurs, trois signes égal évitent des conversions invisibles qui produisent des bugs très difficiles à retrouver.

En comparant leurs propriétés une à une, ce qu'aucun opérateur du langage ne fait pour vous. Sur des structures plates, une boucle sur les clés suffit. Sur des structures imbriquées, la comparaison devient récursive et mérite une fonction bien testée plutôt qu'un enchaînement écrit à la hâte.

Parce que l'addition ne donne pas exactement 0,3 mais une valeur très légèrement supérieure, conséquence du codage binaire des nombres à virgule. L'opérateur, lui, fait son travail correctement. Pour comparer des décimaux, testez que l'écart absolu reste inférieur à une petite tolérance.