JavaScript Égalité abstraite (==)


Exemple

Les opérandes de l'opérateur d'égalité abstraite sont comparés après avoir été convertis en un type commun. Comment cette conversion se produit est basée sur les spécifications de l'opérateur:

Spécification pour l'opérateur == :

7.2.13 Comparaison d'égalité abstraite

La comparaison x == y , où x et y sont des valeurs, produit true ou false . Une telle comparaison est effectuée comme suit:

  1. Si Type(x) est identique à Type(y) , alors:
  • une. Renvoie le résultat de l'exécution de Strict Equality Comparison x === y .
  1. Si x est null et que y est undefined , retournez true .
  2. Si x n'est undefined et que y est null , retournez true .
  3. Si Type(x) est Number et Type(y) est String , retournez le résultat de la comparaison x == ToNumber(y) .
  4. Si Type(x) est String et Type(y) est Number , retournez le résultat de la comparaison ToNumber(x) == y .
  5. Si Type(x) est Boolean , retournez le résultat de la comparaison ToNumber(x) == y .
  6. Si Type(y) est Boolean , retournez le résultat de la comparison x == ToNumber(y) .
  7. Si Type(x) est soit String , Number , ou Symbol et Type(y) est Object , renvoyez le résultat de la comparaison x == ToPrimitive(y) .
  8. Si Type(x) est Object et Type(y) est String , Number ou Symbol , renvoyez le résultat de la comparaison ToPrimitive(x) == y .
  9. Retourne false .

Exemples:

1 == 1;                     // true
1 == true;                  // true  (operand converted to number: true => 1)
1 == '1';                   // true  (operand converted to number: '1' => 1 )
1 == '1.00';                // true
1 == '1.00000000001';       // false
1 == '1.00000000000000001'; // true  (true due to precision loss)
null == undefined;          // true  (spec #2)
1 == 2;                     // false
0 == false;                 // true
0 == undefined;             // false
0 == "";                    // true