JavaScript Opérations de comparaison d'égalité


Exemple

JavaScript a quatre opérations de comparaison d'égalité différentes.

SameValue

Il renvoie true si les deux opérandes appartiennent au même type et ont la même valeur.

Note: la valeur d'un objet est une référence.

Vous pouvez utiliser cet algorithme de comparaison via Object.is (ECMAScript 6).

Exemples:

Object.is(1, 1);            // true
Object.is(+0, -0);          // false
Object.is(NaN, NaN);        // true
Object.is(true, "true");    // false
Object.is(false, 0);        // false
Object.is(null, undefined); // false
Object.is(1, "1");          // false
Object.is([], []);          // false

Cet algorithme a les propriétés d'une relation d'équivalence :

  • Réflexivité : Object.is(x, x) est true , pour toute valeur x
  • Symétrie : Object.is(x, y) est true si et seulement si Object.is(y, x) est true pour toutes les valeurs x et y .
  • Transitivité : si Object.is(x, y) et Object.is(y, z) sont true , Object.is(x, z) est également true pour toutes les valeurs x , y et z .

SameValueZero

Il se comporte comme SameValue, mais considère que +0 et -0 sont égaux.

Vous pouvez utiliser cet algorithme de comparaison via Array.prototype.includes (ECMAScript 7).

Exemples:

[1].includes(1);            // true
[+0].includes(-0);          // true
[NaN].includes(NaN);        // true
[true].includes("true");    // false
[false].includes(0);        // false
[1].includes("1");          // false
[null].includes(undefined); // false
[[]].includes([]);          // false

Cet algorithme a toujours les propriétés d'une relation d'équivalence :

  • Réflexivité : [x].includes(x) est true , pour toute valeur x
  • Symétrie : [x].includes(y) est true si et seulement si [y].includes(x) est true pour toutes les valeurs x et y .
  • Transitivité : Si [x].includes(y) et [y].includes(z) sont true , alors [x].includes(z) est également true pour toutes les valeurs x , y et z .

Comparaison stricte de l'égalité

Il se comporte comme SameValue, mais

  • Considère que +0 et -0 sont égaux.
  • Considère NaN différent de toute valeur, y compris lui-même

Vous pouvez utiliser cet algorithme de comparaison via l'opérateur === (ECMAScript 3).

Il y a aussi l'opérateur !== (ECMAScript 3), qui annule le résultat de === .

Exemples:

1 === 1;            // true
+0 === -0;          // true
NaN === NaN;        // false
true === "true";    // false
false === 0;        // false
1 === "1";          // false
null === undefined; // false
[] === [];          // false

Cet algorithme a les propriétés suivantes:

  • Symétrie : x === y est true si, et seulement si, y === x is vrai , for any values x and y`.
  • Transitivité : Si x === y et y === z sont true , alors x === z est également true pour toutes les valeurs x , y et z .

Mais n'est pas une relation d'équivalence car

Comparaison d'égalité abstraite

Si les deux opérandes appartiennent au même type, il se comporte comme la comparaison stricte d'égalité.

Sinon, il les contraint comme suit:

  • undefined et null sont considérés comme égaux
  • Lorsque vous comparez un nombre avec une chaîne, la chaîne est forcée à un nombre
  • En comparant un booléen avec autre chose, le booléen est forcé à un nombre
  • Lors de la comparaison d'un objet avec un nombre, une chaîne ou un symbole, l'objet est contraint à une primitive

S'il y avait coercition, les valeurs coercitives sont comparées récursivement. Sinon, l'algorithme retourne false .

Vous pouvez utiliser cet algorithme de comparaison via l'opérateur == (ECMAScript 1).

Il y a aussi l'opérateur != (ECMAScript 1), qui annule le résultat de == .

Exemples:

1 == 1;            // true
+0 == -0;          // true
NaN == NaN;        // false
true == "true";    // false
false == 0;        // true
1 == "1";          // true
null == undefined; // true
[] == [];          // false

Cet algorithme a la propriété suivante:

  • Symétrie : x == y est true si et seulement si y == x est true pour toutes les valeurs x et y .

Mais n'est pas une relation d'équivalence car