JavaScript Egalité abstraite / inégalité et conversion de type


Exemple

Le problème

Les opérateurs d'égalité abstraite et d'inégalité ( == et != ) Convertissent leurs opérandes si les types d'opérandes ne correspondent pas. Ce type de coercition est une source commune de confusion sur les résultats de ces opérateurs, en particulier, ces opérateurs ne sont pas toujours transitifs comme on pourrait s’y attendre.

"" ==  0;     // true A
 0 == "0";    // true A
"" == "0";    // false B
false == 0;   // true
false == "0"; // true

"" !=  0;     // false A
 0 != "0";    // false A
"" != "0";    // true B
false != 0;   // false
false != "0"; // false

Les résultats commencent à avoir un sens si vous considérez comment JavaScript convertit les chaînes vides en nombres.

Number("");    // 0
Number("0");   // 0
Number(false); // 0

La solution

Dans la déclaration false B , les deux opérandes sont des chaînes ( "" et "0" ), il n'y aura donc pas de conversion de type et puisque "" et "0" n'ont pas la même valeur, "" == "0" est false comme prévu.

Une façon d'éliminer les comportements inattendus est de toujours comparer les opérandes du même type. Par exemple, si vous souhaitez que les résultats de la comparaison numérique utilisent une conversion explicite:

var test = (a,b) => Number(a) == Number(b); 
test("", 0);        // true;
test("0", 0);       // true
test("", "0");      // true;
test("abc", "abc"); // false as operands are not numbers 

Ou, si vous voulez une comparaison de chaînes:

var test = (a,b) => String(a) == String(b);
test("", 0);   // false;
test("0", 0);  // true
test("", "0"); // false;

Note : Le Number("0") et le new Number("0") ne sont pas la même chose! Alors que le premier effectue une conversion de type, le second crée un nouvel objet. Les objets sont comparés par référence et non par valeur, ce qui explique les résultats ci-dessous.

Number("0") == Number("0");         // true;
new Number("0") == new Number("0"); // false 

Enfin, vous avez la possibilité d'utiliser des opérateurs d'égalité et d'inégalité stricts qui n'effectueront aucune conversion de type implicite.

"" ===  0;  // false
 0 === "0"; // false
"" === "0"; // false

Vous trouverez d'autres références à ce sujet ici:

Quel est l'opérateur égal (== vs ===) à utiliser dans les comparaisons JavaScript? .

Égalité abstraite (==)