Mi történik JavaScriptben a nem szigorú összehasonlításnál (==)?

A JavaScript-ben az == nem szigorú összehasonlítás esetén típuskonverziót (coercion) hajt végre az operandusokon a összehasonlítás előtt. Ha az operandusok típusai eltérnek, JavaScript megpróbálja az egyik vagy mindkét operandust ugyanarra a típusra konvertálni, egy sor szabály szerint.

Az == fő típuskonverziós szabályai:

1. Szám és szöveg: A szöveg számra konvertálódik. Ha a konverzió nem sikerül (NaN), az eredmény mindig false.

   // "10" konvertálódik 10-re. Eredmény: true
   console.log(10 == "10");
   // "abc" konvertálódik NaN-re. Eredmény: false
   console.log(10 == "abc");
   

2. Boolean és nem-Boolean: A Boolean számra konvertálódik (true 1-re, false 0-ra). Ezután összehasonlítják a számot és a másik operandust.

   // true 1-re konvertálódik. Eredmény: true
   console.log(true == 1);
   // false 0-ra konvertálódik. Eredmény: true
   console.log(false == 0);
   // false 0-ra konvertálódik, "0" 0-ra. Eredmény: true
   console.log(false == "0");
   

3. Null és Undefined: null egyenlő undefined-del true-ként, és semmivel másval, kivéve saját magát, szintén true-ként.

   // Eredmény: true
   console.log(null == undefined);
   // Eredmény: false
   console.log(null == 0);
   // Eredmény: false
   console.log(undefined == 0);
   

4. Objektum és primitív: Az objektum primitívvé konvertálódik (valueOf vagy toString segítségével), majd összehasonlítják a primitív értékeket.

   // Az objektum "10" stringgé konvertálódik (toString() által), majd összehasonlítják a számmal 10
   // "10" konvertálódik 10-re. Eredmény: true
   console.log({ toString: () => "10" } == 10);
   

5. Szimbólum és más: A szimbólumokat csak másik szimbólummal vagy olyan primitívvel lehet összehasonlítani, amelyhez a szimbólum konvertálható (ami a legtöbb esetben lehetetlen).

   // Eredmény: false
   console.log(Symbol('a') == 'a');
   

A nem szigorú összehasonlítás automatikus típuskonverzió miatt váratlan eredményekhez vezethet. Egy előre láthatóbb viselkedés érdekében ajánlott a szigorú összehasonlítás (===) használata, amely nem hajt végre típuskonverziót, és közvetlenül összehasonlítja az operandusokat.