Comprendere la Coercizione e la Conversione dei Tipi in JavaScript

JavaScript è un linguaggio debolmente tipizzato, il che significa che permette la conversione implicita dei valori da un tipo di dato a un altro. Questo processo automatico è noto come coercizione dei tipi. Comprendere come JavaScript gestisce la conversione dei tipi può aiutare a evitare comportamenti imprevisti nel codice. Esploriamo i diversi aspetti della coercizione e della conversione dei tipi in JavaScript.

Coercizione Primaria

La coercizione primaria si verifica quando ci si aspetta un valore primitivo (stringa, numero o BigInt), ma il tipo non è rigidamente imposto. Diversi operatori e metodi di JavaScript attivano questa conversione:

• Il costruttore Date() interpreta le stringhe come stringhe di data e i numeri come timestamp.
• L’operatore + esegue la concatenazione di stringhe se uno degli operandi è una stringa; altrimenti, esegue l’addizione numerica.
• L’operatore == converte gli oggetti in valori primitivi prima di effettuare il confronto.

Quando JavaScript converte un oggetto in un valore primitivo, segue questa sequenza:

1. Chiama [Symbol.toPrimitive](hint), se disponibile.
2. Chiama valueOf(), e se restituisce un valore primitivo, lo utilizza.
3. Chiama toString() se valueOf() non restituisce un valore primitivo.
4. Se nessuno dei due restituisce un valore primitivo, viene generato un TypeError.

Esempio

console.log([] + {}); // Output: "[object Object]"
console.log({} + []); // Output: "[object Object]"

coercizione Numerica

JavaScript ha due tipi numerici: Number e BigInt. La coercizione numerica si verifica quando un’operazione richiede un numero. La maggior parte degli operatori aritmetici attiva questa coercizione:

• Number([]) // 0
• Number(null) // 0
• Number("Test") // NaN

Esempio

console.log(12 + ""); // Output: "12"
console.log("15" - 2); // Output: 13
console.log("15" * "3"); // Output: 45
console.log("15" + "3"); // Output: "153" (concatenation)

Conversione Implicita vs. Esplicita

La conversione implicita avviene automaticamente in JavaScript, mentre la conversione esplicita richiede l’uso di funzioni integrate come Number(), String() e Boolean().

Esempi Conversione Implicita

console.log(true + true); // Output: 2
console.log("10" - 5); // Output: 5
console.log(undefined + 6); // Output: NaN
console.log("Hello" + null); // Output: "Hellonull"

Esempi Conversione Esplicita

console.log(Number("25")); // Output: 25
console.log(String(25)); // Output: "25"
console.log(Boolean(0)); // Output: false
console.log(Boolean([])); // Output: true

Uguaglianza Stretta vs. Uguaglianza Lasca

JavaScript fornisce tre operatori di uguaglianza:

• Uguaglianza stretta (===): Non avviene alcuna conversione di tipo. Valori di tipi diversi non sono mai considerati uguali.
• Uguaglianza lasca (==): Se i tipi sono diversi, JavaScript tenta di convertirli prima del confronto.
• Object.is(): Simile a ===, ma tratta NaN come uguale a sé stesso e distingue tra +0 e -0.

Esempio

console.log(0 == false); // Output: true (coercion happens)
console.log(0 === false); // Output: false (strict comparison)
console.log(null == undefined); // Output: true
console.log(null === undefined); // Output: false

Valori Veri e Falsi

In JavaScript, i valori sono veri o falsi quando valutati in un contesto booleano. Valori falsi comprendono:

• false
• 0, -0, 0n
• "" (stringa vuota)
• null, undefined
• NaN

Tutto il resto è vero, inclusi:

• {} (oggetto vuoto)
• [] (array vuoto)
• "0", "false" (stringa non-vuota)
• 42, -42
• Infinity, -Infinity

Esempio

if ([]) {
  console.log("Truthy"); // Output: "Truthy"
}

console.log("0" == true); // Output: false ("0" coerces to 0, which is falsy)

Coercizione con Operatori Logici

Gli operatori logici && e || usano la coercizione:

console.log(true && "dog"); // Output: "dog"
console.log(false || "cat"); // Output: "cat"