Conversione di tipi
La conversione del tipo è il processo del passaggio di un valore da un tipo a un altro. La stringa "1234", ad esempio, può essere convertita in un numero. Inoltre, qualsiasi tipo di dati può essere convertito nel tipo String. Alcune conversioni di tipi non potranno mai avere esito positivo. Un oggetto Date, ad esempio, non può essere convertito in un oggetto ActiveXObject.
Le conversioni di tipo possono essere verso un tipo di dati più grande o verso un tipo di dati più piccolo: le prime non generano mai overflow e hanno sempre esito positivo, mentre le conversioni verso un tipo di dati più piccolo comportano una perdita di informazioni e possono avere esito negativo.
Entrambi i tipi di conversione possono essere realizzati in modo esplicito, mediante l'identificatore del tipo di dati, o in modo implicito senza l'identificatore del tipo di dati. Le conversioni esplicite valide vengono sempre eseguite correttamente e non determinano mai perdite di informazioni. Le conversioni implicite, invece, funzionano solo quando non vi è perdita di informazioni, altrimenti generano un errore di compilazione o di runtime.
Si verificano conversioni lacunose quando per i dati originali non esiste un diretto equivalente nel tipo di dati in cui vengono convertiti. La stringa "Fred", ad esempio, non può essere convertita in un numero. In questi casi, la funzione di conversione dei tipi restituisce un valore predefinito. Per il tipo Number il valore predefinito è NaN. Per il tipo int il valore predefinito è il numero zero.
Alcuni tipi di conversioni, quali quelle da stringa a numero, richiedono parecchio tempo. Minore sarà il ricorso del programma alle conversioni, maggiore sarà la sua efficienza.
Conversioni implicite
La maggior parte delle conversioni di tipo, quali l'assegnazione di un valore a una variabile, hanno luogo automaticamente. Il tipo di dati della variabile determina il tipo di dati di destinazione della conversione dell'espressione.
In questo esempio viene mostrato come sia possibile convertire in modo implicito dati tra un valore int, un valore String e un valore double:
var i : int;
var d : double;
var s : String;
i = 5;
s = i; // Widening: the int value 5 coverted to the String "5".
d = i; // Widening: the int value 5 coverted to the double 5.
s = d; // Widening: the double value 5 coverted to the String "5".
i = d; // Narrowing: the double value 5 coverted to the int 5.
i = s; // Narrowing: the String value "5" coverted to the int 5.
d = s; // Narrowing: the String value "5" coverted to the double 5.
Durante la compilazione del codice, potranno essere visualizzati avvisi in fase di compilazione in cui si avverte che le conversioni verso un tipo di dati più piccolo possono avere esito negativo o sono lente.
Le conversioni verso un tipo di dati più piccolo implicite non funzioneranno se la conversione richiede una perdita di informazioni. Le seguenti righe, ad esempio, non produrranno alcun effetto:
var i : int;
var f : float;
var s : String;
f = 3.14;
i = f; // Run-time error. The number 3.14 cannot be represented with an int.
s = "apple";
i = s; // Run-time error. The string "apple" cannot be converted to an int.
Conversioni esplicite
Per convertire in modo esplicito un'espressione in un particolare tipo di dati, utilizzare l'identificatore del tipo di dati seguito dall'espressione da convertire racchiusa tra parentesi. Le conversioni esplicite richiedono l'immissione di un numero maggiore di dati rispetto alle conversioni implicite, ma comportano risultati più certi. Inoltre, le conversioni esplicite possono gestire conversioni lacunose.
In questo esempio viene mostrato come è possibile convertire in modo esplicito dati tra un valore int, un valore String e un valore double:
var i : int;
var d : double;
var s : String;
i = 5;
s = String(i); // Widening: the int value 5 coverted to the String "5".
d = double(i); // Widening: the int value 5 coverted to the double 5.
s = String(d); // Widening: the double value 5 coverted to the String "5".
i = int(d); // Narrowing: the double value 5 coverted to the int 5.
i = int(s); // Narrowing: the String value "5" coverted to the int 5.
d = double(s); // Narrowing: the String value "5" coverted to the double 5.
Di norma, le conversioni verso un tipo di dati più piccolo esplicite funzioneranno anche se la conversione richiede una perdita di informazioni. Non è possibile utilizzare conversioni esplicite tra tipi di dati incompatibili. Non è possibile, ad esempio, convertire dati Date verso o da dati RegExp. Inoltre, alcuni valori non possono essere convertiti quando non vi sono valori di destinazione appropriati. Se si tenta, ad esempio, di convertire in modo esplicito un valore double NaN in un valore decimal, verrà generato un errore. Infatti, non vi sono valori decimal che potrebbero essere identificati con NaN.
In questo esempio, un numero con una parte decimale e una stringa vengono entrambi convertiti in un integer:
var i : int;
var d : double;
var s : String;
d = 3.14;
i = int(d);
print(i);
s = "apple";
i = int(s);
print(i);
L'output è
3
0
Il comportamento della conversione esplicita dipende sia dal tipo di dati originale che dal tipo di dati di destinazione.