Que se passe-t-il en JavaScript lors d'une comparaison non stricte (==) ?

Lors de la comparaison non stricte (==) en JavaScript, une conversion de types (coercition) des opérandes est effectuée avant la comparaison. Si les types des opérandes diffèrent, JavaScript tente de convertir l’un ou les deux opérandes en un même type, en se basant sur une série de règles.

Principales règles de conversion avec == :

1. Nombre et chaîne : La chaîne est convertie en nombre. Si la conversion échoue (NaN), le résultat est toujours false.

   // "10" devient 10. Résultat : true
   console.log(10 == "10");
   // "abc" devient NaN. Résultat : false
   console.log(10 == "abc");
   

2. Boolean et non-Boolean : Le Boolean est converti en nombre (true en 1, false en 0). Ensuite, le nombre et l’autre opérande (qui peut être converti) sont comparés.

   // true devient 1. Résultat : true
   console.log(true == 1);
   // false devient 0. Résultat : true
   console.log(false == 0);
   // false devient 0, "0" devient 0. Résultat : true
   console.log(false == "0");
   

3. Null et Undefined : null est égal à undefined comme true, et à rien d’autre (sauf lui-même) comme true.

   // Résultat : true
   console.log(null == undefined);
   // Résultat : false
   console.log(null == 0);
   // Résultat : false
   console.log(undefined == 0);
   

4. Objet et primitif : L’objet est converti en primitif (via valueOf ou toString), puis les primitivess sont comparés.

   // L’objet devient la chaîne "10" (via toString()), puis comparé au nombre 10
   // "10" devient 10. Résultat : true
   console.log({ toString: () => "10" } == 10);
   

5. Symbole et autre : Le symbole ne peut être comparé qu’à un autre symbole ou à une valeur primitive à laquelle le symbole peut être converti (ce qui est impossible dans la plupart des cas).

   // Résultat : false
   console.log(Symbol('a') == 'a');
   

La comparaison non stricte peut conduire à des résultats inattendus en raison de la conversion automatique des types. Pour un comportement plus prévisible, il est recommandé d’utiliser la comparaison stricte (===), qui ne réalise pas de conversion de types et compare directement les opérandes.