Documentazione di Flash CS3

Programmazione in ActionScript 3.0 > Linguaggio e sintassi ActionScript > Tipi di dati > Conversione del tipo di dati

Conversione del tipo di dati

Una conversione del tipo di dati ha luogo quando un valore viene trasformato in un valore appartenente a un tipo di dati diverso. Le conversioni di tipo possono essere implicite o esplicite. Una conversione implicita, chiamata anche assegnazione forzata (in inglese, coercion), viene talvolta eseguita da Flash Player in fase di runtime. Ad esempio, se il valore 2 è assegnato a una variabile del tipo di dati Boolean, Flash Player converte il valore 2 nel valore booleano true prima di assegnare il valore alla variabile. La conversione esplicita, chiamata anche inserimento (in inglese, casting), ha luogo quando il codice passa al compilatore l'istruzione di elaborare una variabile di un tipo di dati particolare come se appartenesse a un tipo di dati diverso. Quando l'operazione riguarda valori di base, l'inserimento ha effettivamente il risultato di convertire i valori da un tipo di dati a un altro. Per inserire un oggetto in un tipo diverso, occorre racchiudere il nome dell'oggetto tra parentesi e farlo precedere dal nome del nuovo tipo. Il codice seguente, ad esempio, accetta un valore booleano e lo inserisce in un numero intero:

var myBoolean:Boolean = true;
var myINT:int = int(myBoolean);
trace(myINT); // 1

Sezioni

Conversione implicita

La conversione implicita viene eseguita in fase di runtime in una serie di casi:

• Nelle istruzioni di assegnazione
• Quando i valori vengono passati come argomenti di funzioni
• Quando i valori vengono restituiti da funzioni
• Nelle espressioni che utilizzano determinati operatori, ad esempio l'operatore di addizione (+)

Per i tipi definiti dall'utente, la conversione implicita ha luogo quando il valore da convertire è un'istanza della classe di destinazione o di una classe derivata da essa. Se una conversione implicita ha esito negativo, viene generato un errore. Ad esempio, il codice seguente contiene una conversione implicita corretta e una con esito negativo:

class A {}
class B extends A {}

var objA:A = new A();
var objB:B = new B();
var arr:Array = new Array();

objA = objB; // La conversione viene eseguita.
objB = arr; // La conversione non viene eseguita.

Per i tipi di base, le conversioni implicite vengono gestite chiamando gli stessi algoritmi di conversione interni che vengono chiamati dalle funzioni di conversione esplicita. Le conversioni dei tipi di base sono descritte in dettaglio nelle sezioni che seguono.

Conversione esplicita

È utile ricorrere alla conversione esplicita (detta anche inserimento o casting) quando si compila il codice in modalità rigorosa, in particolare quando si vuole evitare che una mancata corrispondenza di tipo generi un errore in fase di compilazione. Questa situazione può verificarsi quando si ha la certezza che i valori saranno convertiti correttamente in fase di runtime mediante l'assegnazione forzata. Ad esempio, quando si utilizzano i dati ricevuti da un form, si può scegliere di ricorrere all'assegnazione forzata per convertire determinati valori di stringa in valori numerici. Il codice seguente genera un errore di compilazione anche se, in modalità standard, verrebbe eseguito senza problemi.

var quantityField:String = "3";
var quantity:int = quantityField; // Errore di compilazione in modalità rigorosa

Se si desidera continuare a utilizzare la modalità rigorosa ma si vuole convertire la stringa in numero intero, è possibile utilizzare la conversione esplicita, come nell'esempio seguente:

var quantityField:String = "3";
var quantity:int = int(quantityField); // La conversione esplicita viene eseguita.

Inserimento nei tipi int, uint e Number

È possibile inserire qualunque tipo di dati nei tre seguenti tipi numerici: int, uint e Number. Se Flash Player non è in grado di convertire il numero per qualunque motivo, viene assegnato il valore predefinito 0 per i tipi di dati int e uint e il valore predefinito NaN per il tipo di dati Number. Se si converte un valore booleano in numero, true diventa 1 e false diventa 0.

var myBoolean:Boolean = true;
var myUINT:uint = uint(myBoolean);
var myINT:int = int(myBoolean);
var myNum:Number = Number(myBoolean);
trace(myUINT, myINT, myNum); // 1 1 1
myBoolean = false;
myUINT = uint(myBoolean);
myINT = int(myBoolean);
myNum = Number(myBoolean);
trace(myUINT, myINT, myNum); // 0 0 0

I valori stringa che contengono solo cifre possono essere convertiti correttamente in uno dei tre tipi numerici, i quali consentono inoltre di convertire stringhe che assomigliano a numeri negativi o che rappresentano un valore esadecimale (ad esempio, 0x1A). Il processo di conversione ignora gli eventuali caratteri di spazio vuoto presenti all'inizio e alla fine del valore stringa. È anche possibile convertire le stringhe che hanno l'aspetto di numeri a virgola mobile utilizzando Number(). Se viene incluso il punto dei decimali, uint() e int() restituiscono un numero intero in cui i caratteri che seguono il punto sono troncati. Ad esempio, i valori stringa seguenti possono essere inseriti in valori numerici:

trace(uint("5"));     // 5
trace(uint("-5"));    // 4294967291. Riprende da MAX_VALUE
trace(uint(" 27 "));  // 27
trace(uint("3.7"));   // 3
trace(int("3.7"));    // 3
trace(int("0x1A"));   // 26
trace(Number("3.7")); // 3.7

I valori stringa che contengono caratteri non numerici restituiscono 0 se vengono convertiti con int() o uint() oppure NaN se convertiti con Number(). Il processo di conversione ignora lo spazio vuoto all'inizio e alla fine, ma restituisce 0 o NaN se una stringa contiene uno spazio vuoto tra due numeri.

trace(uint("5a"));    // 0
trace(uint("ten"));   // 0
trace(uint("17 63")); // 0

In ActionScript 3.0, la funzione Number() non supporta più gli ottali, ovvero i numeri a base 8. Se si passa una stringa con uno zero iniziale alla funzione Number() di ActionScript 2.0, il numero viene interpretato come ottale e convertito nell'equivalente decimale. Lo stesso non vale per la funzione Number() di ActionScript 3.0, che invece ignora lo zero iniziale. Ad esempio, il codice seguente genera un output diverso se viene compilato con versioni differenti di ActionScript:

trace(Number("044")); 
// ActionScript 3.0 44
// ActionScript 2.0 36

L'inserimento non è necessario quando un valore di un tipo numerico viene assegnato a una variabile di un altro tipo numerico. Anche in modalità rigorosa, i tipi numerici vengono convertiti implicitamente in altri tipi numerici. Ciò significa che in alcuni casi si possono ottenere valori imprevisti quando viene superato l'intervallo di un tipo numerico. Gli esempi seguenti vengono compilati correttamente in modalità rigorosa, ma alcuni di essi generano valori imprevisti:

var myUInt:uint = -3; // Assegna un valore di tipo int/Number alla variabile uint
trace(myUInt); // 4294967293

var myNum:Number = sampleUINT; // Assegna un valore di tipo int/uint alla variabile Number
trace(myNum) // 4294967293

var myInt:int = uint.MAX_VALUE + 1; // Assegna un valore di tipo Number alla variabile uint
trace(myInt); // 0

myInt = int.MAX_VALUE + 1; // Assegna un valore di tipo uint/Number alla variabile int
trace(myInt); // -2147483648

La tabella che segue riepiloga i risultati dell'inserimento nei tipi Number, int o uint da altri tipi di dati.

Inserimento nel tipo Boolean

L'inserimento di un tipo di dati numerico (uint, int o Number) nel tipo Boolean restituisce false se il valore numerico è 0 e true in tutti gli altri casi. Per il tipo di dati Number, anche il valore NaN restituisce false. L'esempio seguente illustra i risultati di un inserimento dei numeri -1, 0 e 1:

var myNum:Number;
for (myNum = -1; myNum<2; myNum++)
{
    trace("Boolean(" + myNum +") is " + Boolean(myNum));
}

L'output dell'esempio mostra che dei tre numeri solo 0 restituisce il valore false:

Boolean(-1) is true
Boolean(0) is false
Boolean(1) is true

L'inserimento di un valore String nel tipo Boolean restituisce false se la stringa è null o vuota ("") e true in tutti gli altri casi.

var str1:String;       // La stringa non inizializzata è null.
trace(Boolean(str1));  // false

var str2:String = "";  // Stringa vuota
trace(Boolean(str2));  // false

var str3:String = " "; // Solo spazio vuoto
trace(Boolean(str3));  // true

L'inserimento di un'istanza della classe Object nel tipo Boolean restituisce false se l'istanza è null e true in tutti gli altri casi:

var myObj:Object;      // L'oggetto non inizializzato è null.
trace(Boolean(myObj)); // false

myObj = new Object();  // Crea un'istanza 
trace(Boolean(myObj)); // true

Le variabili Boolean vengono elaborate in un modo speciale in modalità rigorosa, ovvero è possibile assegnare valori di qualunque tipo di dati a una variabile Boolean senza eseguire l'inserimento. L'assegnazione forzata implicita da tutti i tipi di dati al tipo Boolean viene eseguita anche in modalità rigorosa. In altri termini, contrariamente a quasi tutti gli altri tipi di dati, l'inserimento nel tipo Boolean non è necessario per evitare gli errori della modalità rigorosa. Gli esempi seguenti vengono compilati correttamente in modalità rigorosa e danno i risultati previsti anche in fase di runtime:

var myObj:Object = new Object();  // Crea un'istanza 
var bool:Boolean = myObj;
trace(bool); // true
bool = "random string";
trace(bool); // true
bool = new Array();
trace(bool); // true
bool = NaN;
trace(bool); // false

La tabella che segue riepiloga i risultati dell'inserimento nel tipo Boolean da altri tipi di dati.

Inserimento nel tipo String

L'inserimento di un tipo di dati numerico nel tipo di dati String restituisce una rappresentazione del numero sotto forma di stringa. Se invece si inserisce un valore booleano nel tipo di dati String, viene restituita la stringa "true" se il valore è true e la stringa "false" se il valore è false.

Se si inserisce un'istanza della classe Object nel tipo di dati String, viene restituita la stringa "null" se l'istanza è null. In tutti gli altri casi, l'inserimento della classe Object nel tipo di dati String restituisce la stringa "[object Object]".

Quando si inserire un'istanza della classe Array nel tipo String, viene restituita una stringa composta da un elenco delimitato da virgole di tutti gli elementi dell'array. Ad esempio, il seguente inserimento nel tipo di dati String restituisce una sola stringa contenente tutti e tre gli elementi dell'array:

var myArray:Array = ["primary", "secondary", "tertiary"];
trace(String(myArray)); // primary,secondary,tertiary

Se si inserisce un'istanza della classe Date nel tipo di dati String, viene restituita una rappresentazione della data contenuta nell'istanza sotto forma di stringa. Ad esempio, il codice seguente restituisce una rappresentazione sotto forma di stringa dell'istanza della classe Date. L'output mostra i risultati per l'ora legale del Pacifico:

var myDate:Date = new Date(2005,6,1);
trace(String(myDate)); // Venerdì 1 luglio 00.00.00 GMT-0700 2005

La tabella che segue riepiloga i risultati dell'inserimento nel tipo String da altri tipi di dati.

Flash CS3

Inviami un messaggio e-mail quando vengono aggiunti dei commenti a questa | Rapporto sui commenti

Pagina corrente: http://livedocs.adobe.com/flash/9.0_it/main/00000048.html

Aggiungi commento