Cosa succede in JavaScript durante un confronto non rigoroso (==)?

Nel confronto non rigoroso (==) in JavaScript, viene eseguita una conversione di tipo (coercizione) degli operandi prima del confronto. Se i tipi degli operandi sono diversi, JavaScript tenta di convertire uno o entrambi gli operandi nello stesso tipo, basandosi su una serie di regole.

Regole principali di conversione con ==:

1. Numero e stringa: La stringa viene convertita in numero. Se la conversione fallisce (NaN), il risultato è sempre false.

   // "10" si converte in 10. Risultato: true
   console.log(10 == "10");
   // "abc" si converte in NaN. Risultato: false
   console.log(10 == "abc");
   

2. Booleano e non-Booleano: Il Booleano viene convertito in numero (true in 1, false in 0). Poi si confrontano il numero e l’altro operando (che può essere convertito).

   // true si converte in 1. Risultato: true
   console.log(true == 1);
   // false si converte in 0. Risultato: true
   console.log(false == 0);
   // false si converte in 0, "0" si converte in 0. Risultato: true
   console.log(false == "0");
   

3. Null e Undefined: null è uguale a undefined come true, e con nient’altro (eccetto se stesso) come true.

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

4. Oggetto e primitivo: L’oggetto viene convertito in primitivo (usando valueOf o toString), poi vengono confrontati i primitivi.

   // L’oggetto si converte in la stringa "10" (tramite toString()), poi si confronta con il numero 10
   // "10" si converte in 10. Risultato: true
   console.log({ toString: () => "10" } == 10);
   

5. Simbolo e altro: I simboli possono essere confrontati solo con un altro simbolo o con un valore primitivo a cui il simbolo può essere convertito (cosa che di default è impossibile).

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

Il confronto non rigoroso può portare a risultati inaspettati a causa della conversione automatica dei tipi. Per un comportamento più prevedibile, si consiglia di usare il confronto rigoroso (===), che non esegue conversione di tipi e confronta direttamente gli operandi.