Conversione di tipi

Nella maggior parte dei casi, operatori e funzioni convertono automaticamente il valore nel tipo corretto.

Ad esempio, alert converte automaticamente un valore qualsiasi in una stringa, per poterla mostrare. Le operazioni matematiche convertono i valori in numeri.

Ci sono invece casi in cui è necessario convertire esplicitamente i valori per poter evitare errori.

Conversione di stringhe

La conversione a String è utile quando abbiamo bisogno del formato stringa di un valore.

Ad esempio, alert(value) effettua questa conversione per mostrare il valore.

Possiamo anche utilizzare la funzione String(value), per ottenere lo stesso risultato:

let value = true;
alert(typeof value); // boolean

value = String(value); // ora value è una stringa contenente "true"
alert(typeof value); // string

La conversione in stringa è quella più semplice. Il valore false diventa la stringa "false", mentre null diventa "null" etc.

Conversione numerica

La conversione a Number viene applicata automaticamente nelle funzioni ed espressioni matematiche.

Ad esempio, quando la divisione / viene applicata ad un tipo non numerico:

alert( "6" / "2" ); // 3, le stringhe sono state converite a numeri

Possiamo utilizzare la funzione Number(value) per convertire esplicitamente un valore value:

let str = "123";
alert(typeof str); // string

let num = Number(str); // diventa il numero 123

alert(typeof num); // number

Una conversione esplicita è solitamente richiesta quando leggiamo un valore da una risorsa di tipo stringa, come un form testuale, ma ci aspettiamo l’inserimento di un numero.

Se la stringa non risulta essere un numero valido, il risultato della conversione sarà NaN, ad esempio:

let age = Number("an arbitrary string instead of a number");

alert(age); // NaN, conversione fallita

Le regole di conversione numerica:

Esempi:

alert( Number("   123   ") ); // 123
alert( Number("123z") );      // NaN (errore nella lettura del numero "z")
alert( Number(true) );        // 1
alert( Number(false) );       // 0

Nota che null e undefined si comportano diversamente: null diventa zero, mentre undefined diventa NaN.

alert( 1 + '2' ); // '12' (stringa a destra)
alert( '1' + 2 ); // '12' (stringa a sinistra)

Boolean Conversion

La conversione a Boolean è quella più semplice.

Questa si verifica con le operazioni logiche (più avanti incontreremo i test di condizione ed altri tipi di operazione logiche), ma può anche essere richiamato manualmente con la funzione Boolean(value).

Le regole di conversione:

• I valori che sono intuitivamente “vuoti”, come lo 0, una stringa vuota, null, undefined e NaN diventano false.
• Gli altri valori diventano true.

Ad esempio:

alert( Boolean(1) ); // true
alert( Boolean(0) ); // false

alert( Boolean("hello") ); // true
alert( Boolean("") ); // false

alert( Boolean("0") ); // true
alert( Boolean(" ") ); // spazi vuoti, valgono true (qualsiasi stringa non vuota viene interpretata come true)

Riepilogo

I tre tipi di conversioni più utilizzati sono: a string, a number e a boolean.

Conversione a striga – Avviene quando stampiamo qualcosa a schermo, può essere richiamato con String(value). La conversione a stringa è solitamente ovvia per i valore primitivi.

Conversione numerica – Utilizzata nelle operazioni matematiche, può essere richiamata esplicitamente con Number(value).

La conversione segue le seguenti regole:

Conversione booleana – Avviene nelle operazioni logiche, può anche essere richiamato esplicitamente con Boolean(value).

Segue le regole:

La maggior parte di queste regole sono facili da capire e memorizzare. Gli errori più comuni che commettono le persone sono:

• undefined convertito a Number vale NaN, non 0.
• "0" e le stringhe che contengono solamente spazi " " vengono interpretate come true.

Qui non abbiamo coperto gli oggetti, ci ritorneremo più avanti nel capitolo Conversione da oggetto a primitivi che è dedicato esclusivamente agli oggetti, dopo che avremmo imparato più cose basilari su JavaScript.