Ce se întâmplă în JavaScript la o comparație nestrictă (==)?

În comparația nestrictă (==) în JavaScript, are loc o conversie de tipuri (coercion) a operandilor înainte de comparație. Dacă tipurile operandilor diferă, JavaScript încearcă să convertească unul sau ambii operanzi la același tip, bazându-se pe o serie de reguli.

Reguli principale de conversie cu ==:

1. Număr și șir de caractere: Șirul de caractere este convertit în număr. Dacă conversia nu reușește (NaN), rezultatul este întotdeauna false.

   // "10" devine 10. Rezultat: true
   console.log(10 == "10");
   // "abc" devine NaN. Rezultat: false
   console.log(10 == "abc");
   

2. Boolean și non-Boolean: Booleanul este convertit în număr (true în 1, false în 0). Apoi, se compară numărul și celălalt operand (care poate fi convertit).

   // true devine 1. Rezultat: true
   console.log(true == 1);
   // false devine 0. Rezultat: true
   console.log(false == 0);
   // false devine 0, "0" devine 0. Rezultat: true
   console.log(false == "0");
   

3. Null și Undefined: null este egal cu undefined ca true, și cu nimic altceva (cu excepția lui însuși) ca true.

   // Rezultat: true
   console.log(null == undefined);
   // Rezultat: false
   console.log(null == 0);
   // Rezultat: false
   console.log(undefined == 0);
   

4. Obiect și primitiv: Obiectul este convertit în primitiv (folosind valueOf sau toString), apoi se compară primitivele.

   // Obiectul se convertește în șirul "10" (prin toString()), apoi se compară cu numărul 10
   // "10" devine 10. Rezultat: true
   console.log({ toString: () => "10" } == 10);
   

5. Simbol și altceva: Simbolurile pot fi comparate doar cu alt simbol sau cu o valoare primitivă la care simbolul poate fi convertit (ceea ce în cazuri standard este imposibil).

   // Rezultat: false
   console.log(Symbol('a') == 'a');
   

Compararea nestrictă poate duce la rezultate neașteptate din cauza conversiei automate a tipurilor. Pentru un comportament mai previzibil, se recomandă utilizarea comparației stricte (===), care nu efectuează conversie de tipuri și compară operandii direct.