La verifica del tipo in fase di compilazione è spesso preferita nei progetti di grandi dimensioni perché, con il crescere delle dimensioni del progetto, la flessibilità dei tipi di dati perde generalmente importanza a favore della possibilità di rilevare tutti gli errori di tipo con la massima tempestività. È per questo motivo che, per impostazione predefinita, il compilatore ActionScript in Flash Professional e in Flash Builder è configurato per essere eseguito in modalità rigorosa.

Per eseguire la verifica del tipo in fase di compilazione, il compilatore deve conoscere il tipo di dati delle variabili o delle espressioni contenute nel codice. Per dichiarare esplicitamente il tipo di dati di una variabile, aggiungete al nome della variabile l'operatore due punti (:) seguito dal tipo di dati come suffisso. Per associare un tipo di dati a un parametro, utilizzate l'operatore due punti seguito dal tipo di dati. Ad esempio, il codice seguente aggiunge il tipo di dati al parametro xParam e dichiara una variabile myParam con un tipo di dati esplicito:

function runtimeTest(xParam:String) 
{ 
    trace(xParam); 
} 
var myParam:String = "hello"; 
runtimeTest(myParam);

In modalità rigorosa, il compilatore ActionScript segnala i casi di mancata corrispondenza del tipo come errori di compilazione. Ad esempio, il codice seguente dichiara un parametro di funzione xParam, del tipo Object, ma successivamente tenta di assegnare valori del tipo String e Number allo stesso parametro. In modalità rigorosa, questo codice genera un errore del compilatore.

function dynamicTest(xParam:Object) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; // compiler error in strict mode 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; // compiler error in strict mode 
        trace("Number: " + myNum); 
    } 
}

Anche in modalità rigorosa, tuttavia, è possibile scegliere di non eseguire la verifica del tipo in fase di compilazione non specificando il tipo sul lato destro di un'istruzione di assegnazione. Per contrassegnare una variabile o un'espressione come priva di tipo, è possibile omettere l'annotazione di tipo o utilizzare l'annotazione speciale dell'asterisco (*). Ad esempio, se il parametro xParam contenuto nel codice precedente viene modificato omettendo l'annotazione di tipo, il codice viene compilato anche in modalità rigorosa:

function dynamicTest(xParam) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; 
        trace("Number: " + myNum); 
    } 
} 
dynamicTest(100) 
dynamicTest("one hundred");

Il controllo del tipo in fase di runtime viene eseguito in ActionScript 3.0 sia nella modalità di compilazione rigorosa che in modalità standard. Considerate una situazione in cui il valore 3 viene passato come argomento a una funzione per la quale è previsto array. In modalità rigorosa, il compilatore genera un errore perché il valore 3 non è compatibile con il tipo di dati Array. Se disattivate la modalità rigorosa e attivate la modalità standard, il compilatore non rileva la mancata corrispondenza del tipo, ma la verifica in fase di runtime genera un errore runtime.

L'esempio seguente mostra una funzione denominata typeTest() per la quale è previsto un argomento Array ma alla quale viene invece passato il valore 3. Questa situazione genera un errore runtime in modalità standard perché il valore 3 non è un membro del tipo di dati dichiarato del parametro (Array).

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum:Number = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0 standard mode

In determinati casi può essere generato un errore runtime di tipo anche in modalità rigorosa. Questa situazione può verificarsi quando, pur essendo attiva la modalità rigorosa, si sceglie di non eseguire la verifica del tipo in fase di compilazione specificando una variabile senza tipo. L'uso di una variabile senza tipo non elimina la verifica del tipo, bensì la rimanda alla fase di runtime. Ad esempio, se la variabile myNum dell'esempio precedente non ha un tipo di dati dichiarato, il compilatore non è in grado di rilevare la mancata corrispondenza del tipo ma il codice genera un errore runtime perché esegue un confronto tra il valore runtime di myNum, che è impostato su 3 dall'istruzione di assegnazione, e il tipo di dati di xParam, che è Array.

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0

La verifica in fase di runtime consente anche un uso più flessibile dell'ereditarietà rispetto a quella in fase di compilazione. Rimandando la verifica del tipo alla fase di runtime, la modalità standard permette di fare riferimento alle proprietà di una sottoclasse anche se eseguite un upcast, ovvero utilizzate una classe di base per dichiarare il tipo di un'istanza di classe ma una sottoclasse per creare l'istanza vera e propria. Ad esempio, potete creare una classe denominata ClassBase che può essere estesa (non è possibile estendere le classi con attributo final):

class ClassBase 
{ 
}

Successivamente potete creare una sottoclasse di ClassBase denominata ClassExtender, dotata di una proprietà di nome someString, come nel codice seguente:

class ClassExtender extends ClassBase 
{ 
    var someString:String; 
}

Utilizzando entrambe le classi, è possibile definire un'istanza di classe dichiarata mediante il tipo di dati ClassBase ma creata utilizzando la funzione di costruzione ClassExtender. Un'operazione di upcast è considerata sicura perché la classe di base non contiene proprietà o metodi che non sono disponibili nella sottoclasse.

var myClass:ClassBase = new ClassExtender();

Una sottoclasse, al contrario, può contenere proprietà o metodi che non sono presenti nella rispettiva classe di base. Ad esempio, la classe ClassExtender contiene la proprietà someString, che non esiste nella classe ClassBase. Nella modalità standard di ActionScript 3.0, è possibile fare riferimento a questa proprietà usando l'istanza myClass senza generare un errore in fase di compilazione, come mostra l'esempio seguente:

var myClass:ClassBase = new ClassExtender(); 
myClass.someString = "hello"; 
// no error in ActionScript 3.0 standard mode

L'operatore is consente di verificare se una variabile o un'espressione è un membro di un determinato tipo di dati. Nelle versioni precedenti di ActionScript, la stessa funzionalità era fornita dall'operatore instanceof, che tuttavia in ActionScript 3.0 non va utilizzato per verificare l'appartenenza a un tipo di dati. È necessario utilizzare l'operatore is anziché instanceof per eseguire la verifica manuale del tipo, perché l'espressione x instanceof y si limita a controllare se nella catena di prototipi di x è presente y (in ActionScript 3.0, la catena di prototipi non fornisce un quadro completo della gerarchia di ereditarietà).

L'operatore is invece esamina la gerarchia di ereditarietà effettiva e consente di verificare non solo se un oggetto è un'istanza di una particolare classe, ma anche se è un'istanza di una classe che implementa una particolare interfaccia. L'esempio seguente crea un'istanza della classe Sprite denominata mySprite e utilizza l'operatore is per verificare se mySprite è un'istanza delle classi Sprite e DisplayObject e se implementa l'interfaccia IEventDispatcher:

var mySprite:Sprite = new Sprite(); 
trace(mySprite is Sprite); // true 
trace(mySprite is DisplayObject);// true 
trace(mySprite is IEventDispatcher); // true

L'operatore is controlla la gerarchia di ereditarietà e segnala correttamente che mySprite è compatibile con le classi Sprite e DisplayObject (Sprite è una sottoclasse della classe DisplayObject). Inoltre, verifica se mySprite eredita da qualunque classe che implementa l'interfaccia IEventDispatcher. Poiché la classe Sprite eredita dalla classe EventDispatcher, che implementa l'interfaccia IEventDispatcher, l'operatore is segnala correttamente che mySprite implementa la stessa interfaccia.

Il codice dell'esempio seguente esegue gli stessi controlli di quello precedente, ma con l'operatore instanceof al posto di is. L'operatore instanceof identifica correttamente mySprite come istanza di Sprite o DisplayObject, ma restituisce false quando viene utilizzato per verificare se mySprite implementa l'interfaccia IEventDispatcher.

trace(mySprite instanceof Sprite); // true 
trace(mySprite instanceof DisplayObject);// true 
trace(mySprite instanceof IEventDispatcher); // false

Anche l'operatore as consente di verificare se un'espressione è un membro di un determinato tipo di dati. A differenza di is, tuttavia, as non restituisce un valore booleano, bensì il valore dell'espressione (invece di true) oppure null (invece di false). L'esempio seguente mostra il risultato che si ottiene utilizzando l'operatore as anziché is per controllare semplicemente se un'istanza Sprite è membro dei tipi di dati DisplayObject, IEventDispatcher e Number.

var mySprite:Sprite = new Sprite(); 
trace(mySprite as Sprite);                 // [object Sprite] 
trace(mySprite as DisplayObject);                 // [object Sprite] 
trace(mySprite as IEventDispatcher);                 // [object Sprite] 
trace(mySprite as Number);                                       // null

Quando si usa l'operatore as, l'operando sulla destra deve essere un tipo di dati. Un eventuale tentativo di utilizzare un'espressione diversa da un tipo di dati come operando sulla destra produrrebbe un errore.

Il tipo di dati Boolean include due valori: true e false. Nessun altro valore è consentito per le variabili di questo tipo. Il valore predefinito di una variabile Boolean dichiarata ma non inizializzata è false.

Il tipo di dati int è memorizzato internamente come numero intero a 32 bit e include la serie di numeri interi da

-2.147.483.648 (-2³¹) a 2.147.483.647 (2³¹ - 1). Le versioni precedenti di ActionScript offrivano solo il tipo di dati Number, utilizzato sia per i numeri interi che per quelli a virgola mobile. In ActionScript 3.0 è ora possibile accedere ai tipi macchina di basso livello per i numeri interi a 32 bit con e senza segno. Se la variabile non deve usare numeri a virgola mobile, l'impiego del tipo di dati int al posto di Number garantisce maggiore velocità ed efficienza.

Per i numeri interi al di fuori dell'intervallo dei valori minimo e massimo, utilizzate il tipo di dati Number, che è in grado di gestire i valori compresi tra -9.007.199.254.740.992 e 9.007.199.254.740.992 (valori interi a 53 bit). Il valore predefinito per le variabili del tipo di dati int è 0.

Il tipo di dati Null contiene un solo valore, null. Questo è il valore predefinito per il tipo di dati String e per tutte le classi che definiscono tipi di dati complessi, compresa la classe Object. Nessuno degli altri tipi di dati di base, come Boolean, Number, int e uint, contiene il valore null. In fase di runtime, il valore null viene convertito nel valore predefinito appropriato se tentate di assegnare null a variabili di tipo Boolean, Number, int o uint. Non è possibile utilizzare questo tipo di dati come annotazione di tipo.

In ActionScript 3.0, il tipo di dati Number può rappresentare numeri interi, numeri interi senza segno e numeri a virgola mobile. Tuttavia, per ottimizzare le prestazioni, è meglio utilizzare il tipo di dati Number solo per i numeri interi maggiori dei numeri a 32 bit memorizzabili dai tipi int e uint, oppure per i numeri a virgola mobile. Per memorizzare un numero a virgola mobile, includete il punto dei decimali nel numero. Se omettete il punto dei decimali, il valore viene memorizzato come numero intero.

Il tipo di dati Number utilizza il formato a doppia precisione a 64 bit specificato dallo standard IEEE 754 per i calcoli aritmetici binari a virgola mobile, che prescrive come devono essere memorizzati i numeri a virgola mobile utilizzando i 64 bit disponibili. Un bit serve per designare il numero come positivo o negativo, undici bit sono utilizzati per l'esponente (memorizzato come base 2) e i rimanenti 52 bit servono per memorizzare il significante (chiamato anche mantissa), ovvero il numero che viene elevato alla potenza indicata dall'esponente.

Utilizzando alcuni dei bit per memorizzare un esponente, il tipo di dati Number può memorizzare numeri a virgola mobile notevolmente più grandi che non se utilizzasse tutti i bit per il significante. Ad esempio, se il tipo di dati Number utilizzasse tutti i 64 bit per memorizzare il significante, il numero più grande che potrebbe memorizzare sarebbe 2⁶⁵ - 1. Utilizzando 11 bit per memorizzare un esponente, il tipo di dati Number può elevare il significante fino a una potenza di ¹⁰²³.

I valori massimo e minimo che il tipo Number può rappresentare sono memorizzati in proprietà statiche della classe Number denominate Number.MAX_VALUE e Number.MIN_VALUE.

Number.MAX_VALUE == 1.79769313486231e+308 
Number.MIN_VALUE == 4.940656458412467e-324

Un intervallo di numeri così ampio va a scapito della precisione. Il tipo di dati Number utilizza 52 bit per memorizzare il significante, con il risultato che i numeri che richiedono più di 52 bit per essere rappresentati con precisione, ad esempio la frazione 1/3, sono solo approssimazioni. Se l'applicazione richiede una precisione assoluta per i numeri decimali, è necessario utilizzare un software in grado di implementare i calcoli aritmetici a virgola mobile decimali anziché quelli binari.

Quando memorizzate valori interi con il tipo di dati Number, vengono utilizzati solo i 52 bit del significante. Il tipo di dati Number usa questi 52 bit e un bit speciale nascosto per rappresentare i numeri interi da -9.007.199.254.740.992 (-2⁵³) a 9.007.199.254.740.992 (2⁵³).

Il valore NaN non solo è il valore predefinito per le variabili di tipo Number, ma è anche il risultato di qualunque operazione che deve restituire un numero e invece restituisce un valore diverso. Ad esempio, se tentate di calcolare la radice quadrata di un numero negativo, il risultato è NaN. Altri valori Number speciali sono infinito positivo e infinito negativo.

Il tipo di dati String rappresenta una sequenza di caratteri a 16 bit. Le stringhe vengono memorizzate internamente come caratteri Unicode, utilizzando il formato UTF-16. Come nel linguaggio di programmazione Java, le stringhe sono valori immutabili. Un'operazione su un valore String restituisce una nuova istanza della stringa. Il valore predefinito di una variabile dichiarata con il tipo di dati String è null. Il valore null non è equivalente a una stringa vuota (""). Il valore null indica che la variabile non contiene alcun valore, mentre la stringa vuota indica che il valore della variabile è un tipo String che non contiene nessun carattere.

Il tipo di dati uint è memorizzato internamente come numero intero a 32 bit senza segno e include la serie di numeri interi da 0 a 4.294.967.295 (2³² - 1). Utilizzate il tipo di dati uint in circostanze speciali che richiedono numeri interi non negativi. Ad esempio, va necessariamente utilizzato per rappresentare i valori di colore dei pixel, perché il tipo di dati int ha un bit di segno interno che non è appropriato per la gestione dei valori di colore. Per i numeri interi maggiori del valore uint massimo, utilizzate il tipo di dati Number, che è in grado di gestire i valori interi a 53 bit. Il valore predefinito per le variabili del tipo di dati uint è 0.

Il tipo di dati void contiene un solo valore, undefined. Nelle versioni precedenti di ActionScript, undefined era il valore predefinito per le istanze della classe Object. In ActionScript 3.0, il valore predefinito delle istanze Object è null. Se tentate di assegnare il valore undefined a un'istanza della classe Object, il valore viene convertito in null. È possibile assegnare il valore undefined solo alle variabili senza tipo, ovvero quelle che sono prive di un'annotazione di tipo oppure utilizzano l'asterisco (*) come annotazione. Potete utilizzare void solo come annotazione del tipo restituito.

Il tipo di dati Object è definito dalla classe Object che viene utilizzata come classe di base per tutte le definizioni di classe in ActionScript. La versione ActionScript 3.0 del tipo di dati Object differisce dalle versioni precedenti per tre aspetti. Innanzi tutto, il tipo di dati Object non è più il tipo predefinito assegnato alle variabili prive di annotazione di tipo. In secondo luogo, il tipo Object non include più il valore undefined, che era il valore predefinito di tutte le istanze Object. Infine, in ActionScript 3.0 il valore predefinito delle istanze della classe Object è null.

Nelle versioni precedenti di ActionScript, a una variabile priva di annotazione di tipo veniva assegnato automaticamente il tipo di dati Object. ActionScript 3.0, al contrario, prevede la possibilità di variabili effettivamente prive di tipo. Pertanto, le variabili per le quali non viene fornita un'annotazione di tipo vengono ora considerate senza tipo. Se preferite rendere esplicito a chi leggerà il codice che la vostra intenzione è effettivamente quella di lasciare una variabile priva di tipo, potete utilizzare il simbolo di asterisco (*) come annotazione di tipo, che equivale a omettere l'annotazione. L'esempio seguente mostra due istruzioni equivalenti, che dichiarano entrambe una variabile senza tipo x:

var x 
var x:*

Solo le variabili senza tipo possono contenere il valore undefined. Se tentate di assegnare il valore undefined a una variabile che appartiene a un tipo di dati, il runtime converte il valore undefined nel valore predefinito del tipo di dati in questione. Per le istanze del tipo di dati Object, il valore predefinito è null. Pertanto, se tentate di assegnare undefined a un'istanza Object il valore viene convertito in null.