Typkontroll vid kompilering föredras ofta i större projekt. Detta beror på, att när man arbetar med stora projekt blir det viktigare att hitta typfel så tidigt som möjligt än att man använder en flexibel datatyp. Det är därför som ActionScript-kompilatorn i Flash Professional och Flash Builder som standard är inställd på att köras i strikt läge.

För att kompilatorn ska kunna utföra typkontroll vid kompilering måste koden innehålla datatypsinformation om variabler och uttryck. Om du vill deklarera en datatyp för en variabel lägger du till kolonoperatorn (:) följt av datatypen som suffix i variabelnamnet. Om du vill associera en datatyp med en parameter använder du kolonoperatorn följt av datatypen. I följande kod läggs datatypsinformation till i parametern xParam och deklareras variabeln myParam med en explicit datatyp:

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

I strikt läge rapporterar ActionScript-kompilatorn felaktig matchning av typer som kompileringsfel. I följande kod deklareras funktionsparametern xParam, för typen Object, men försök görs senare att tilldela värden av typen String och Number till den parametern. Detta skapar ett kompileringsfel i strikt läge.

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); 
    } 
}

Du kan emellertid även i strikt läge selektivt välja bort typkontroll vid kompilering genom att låta höger sida av en tilldelningsprogramsats vara typlös. Du kan markera en variabel eller ett uttryck som typlöst genom att antingen utesluta en typanteckning eller använda den speciella asterisktypanteckningen (*). Om parametern xParam i föregående exempel ändras så att den inte längre har en typanteckning kompileras koden i strikt läge:

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");

Typkontroll vid körning utförs i ActionScript 3.0 vare sig du kompilerar i strikt läge eller i standardläge. Anta att värdet 3 skickas som ett argument till en funktion som förväntar sig en array. I strikt läge genereras ett fel eftersom värdet 3 inte är kompatibelt med datatypen Array. Om du inaktiverar strikt läge och kör i standardläge reagerar kompilatorn inte över typmatchningsfelet, men typkontrollen vid körning resulterar i ett körningsfel.

I följande exempel visas funktionen typeTest() som förväntar sig ett Array-argument men som tar emot värdet 3. Detta förorsakar ett körningsfel i standardläge eftersom värdet 3 inte ingår i parameterns deklarerade datatyp (Array).

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

Du kan också i vissa situationer få ett körningsfel även när du arbetar i strikt läge. Detta kan hända om du använder strikt läge men väljer bort typkontroll vid kompilering genom att använda en typlös variabel. När du använder en typlös variabel väljer du inte bort typkontrollen, utan fördröjer den till körningen. Om till exempel variabeln myNum i föregående exempel inte har en deklarerad datatyp kan kompilatorn inte identifiera typmatchningsfelet. Koden genererar då ett körningsfel, eftersom körningsvärdet för myNum, som har värdet 3 som ett resultat av tilldelningsprogramsatsen, jämförs med typen för xParam, som är inställd på datatypen Array.

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

Typkontroll vid körning tillåter flexiblare användning av arv än typkontroll vid kompilering. Genom att fördröja typkontrollen till körningen kan du i standardläge referera egenskaper av en underklass även om du använder upcast. En upcast inträffar när du använder en basklass för att deklarera typ av klassinstans men en underklass för att instansiera den. Du kan alltså skapa en klass med namnet ClassBase som kan utökas (klasser med attributet final kan inte utökas):

class ClassBase 
{ 
}

Du kan därefter skapa en underklass för ClassBase som heter ClassExtender som har en egenskap som heter someString enligt följande:

class ClassExtender extends ClassBase 
{ 
    var someString:String; 
}

Om du använder båda klasserna kan du skapa en klassinstans som deklareras med datatypen ClassBase men som instansieras med konstruktorn ClassExtender. En upcast är en säker åtgärd eftersom basklassen bara innehåller egenskaper och metoder som finns i underklassen.

var myClass:ClassBase = new ClassExtender();

En underklass innehåller däremot egenskaper och metoder som basklassen inte innehåller. Klassen ClassExtender innehåller till exempel egenskapen someString som inte finns i klassen ClassBase. I standardläge i ActionScript 3.0 kan du referera den här egenskapen med instansen myClass utan att generera ett kompileringsfel, vilket visas i följande exempel:

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

Med operatorn is kan du testa om en variabel eller ett uttryck är medlem i en viss datatyp. I tidigare versioner av ActionScript hade operatorn instanceof den här funktionaliteten, men i ActionScript 3.0 ska operatorn instanceof inte användas för att testa datatypsmedlemskap. Använd operatorn is i stället för operatorn instanceof för manuell typkontroll eftersom uttrycket x instanceof y snarare kontrollerar om prototypkedjan för x innehåller y (och i ActionScript 3.0 ger prototypkedjan inte en fullständig bild av arvshierarkin).

Operatorn is kontrollerar arvshierarkin och kan användas för att kontrollera inte bara om ett objekt är en instans av en viss klass, utan även om objektet är en instans av en klass som implementerar ett visst gränssnitt. I följande exempel skapas en instans av klassen Sprite som heter mySprite och använder operatorn is för att testa om mySprite är en instans av klasserna Sprite och DisplayObject, och huruvida den implementerar gränssnittet IEventDispatcher:

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

Operatorn is kontrollerar arvshierarkin och rapporterar att mySprite är kompatibel med klasserna Sprite och DisplayObject (klassen Sprite är en underklass till klassen DisplayObject). Operatorn is kontrollerar också om mySprite ärver från några klasser som implementerar gränssnittet IEventDispatcher. Eftersom klassen Sprite ärver från klassen EventDispatcher, som implementerar gränssnittet IEventDispatcher, rapporterar operatorn is att mySprite implementerar samma gränssnitt.

I följande exempel visas samma tester från föregående exempel, men med instanceof i stället för operatorn is. Operatorn instanceof identifierar att mySprite är en instans av Sprite eller DisplayObject, men den returnerar false när den används för att testa om mySprite implementerar gränssnittet IEventDispatcher.

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

Med operatorn as kan du testa om ett uttryck är medlem i en viss datatyp. l motsats till operatorn is returnerar operatorn as inte ett booleskt värde. I stället returnerar operatorn as värdet för uttrycket i stället för true, och null i stället för false. I följande exempel visas resultatet av att använda operatorn as i stället för operatorn is vid en enkel kontroll av om instansen Sprite är medlem i datatypen DisplayObject, IEventDispatcher och 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

När du använder operatorn as måste operanden till höger vara en datatyp. Om du försöker använda ett uttryck som inte är en datatyp som operand till höger genereras ett fel.

Datatypen Boolean kan ha två värden: true och false. Inga andra värden är giltiga för den här datatypen. Standard för en boolesk variabel som är deklarerad, men inte initierad, är false.

Datatypen int lagras internt som 32-bitars heltal och har en uppsättning heltal från

-2 147 483 648 (-2³¹) till och med 2 147 483 647 (2³¹ - 1). Tidigare versioner av ActionScript hade bara datatypen Number som användes för både heltal och flyttal. I ActionScript 3.0 kan du använda lågnivåmaskintyper för 32-bitars heltal med och utan tecken. Om din variabel inte använder flyttal går det snabbare och är effektivare om du använder datatypen int i stället för datatypen Number.

För heltalsvärden som ligger utanför minimi- och maximivärdena för int använder du datatypen Number, som kan hantera värden mellan positiva och negativa 9 007 199 254 740 992 (53-bitars heltalsvärden). Standardvärdet för variabler som är av datatypen int är 0.

Datatypen Null innehåller bara ett värde, null. Detta är standardvärdet för datatypen String och alla klasser som definierar komplexa datatyper, däribland klassen Object. Ingen av de primitiva datatyperna, till exempel Boolean, Number, int eller uint, innehåller värdet null. Vid körning konverteras värdet null till lämpligt standardvärde om du försöker tilldela null till variabler av typen Boolean, Number, int eller uint. Du kan inte använda den här datatypen som en typanteckning.

I ActionScript 3.0 kan den här datatypen representera heltal, heltal utan tecken och flyttal. Om du vill maximera prestanda bör du använda datatypen Number bara för heltal som är större än vad 32-bitarstyperna int och uint kan lagra eller för flyttal. Om du vill lagra flyttal måste du infoga ett decimalkomma i talet. Om du utesluter decimalkommat sparas talet som ett heltal.

Datatypen Number använder 64-bitars dubbelprecisionsformat som anges av IEEE:s standard för binär flyttalsaritmetik (IEEE-754). Denna standard anger hur flyttal lagras med 64 tillgängliga bitar. En bit används för att ange om talet är positivt eller negativt. Elva bitar används för exponenten som lagras som bas 2. De återstående 52 bitarna används för att lagra signifikanden (kallas också mantissa), som är det tal som upphöjs till det som anges av exponenten.

Genom att använda vissa bitar för att lagra en exponent kan datatypen Number lagra flyttal som är mycket större än om den använde alla bitarna för signifikanden. Om datatypen Number till exempel använder alla 64 bitar för att lagra signifikanden, bör den lagra ett tal som är så stort som 2⁶⁵ - 1. Genom att använda elva bitar för att lagra en exponent kan datatypen Number upphöja signifikanden till 2¹⁰²³.

Maximi- och minimivärdena som typen Number kan representera lagras i statiska egenskaper för klassen Number som kallas Number.MAX_VALUE respektive Number.MIN_VALUE.

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

Även om det här talintervallet är enormt är priset för intervallet precision. Datatypen Number använder 52 bitar för att lagra signifikanden, vilket resulterar i att tal som kräver mer än 52 bitar för att representeras exakt, till exempel bråket 1/3, bara blir approximationer. Om ditt program kräver absolut precision med decimaltal måste du använda program som implementerar decimalflyttalsaritmetik i motsats till binär flyttalsaritmetik.

När du lagrar heltalsvärden med datatypen Number används bara de 52 bitarna av signifikanden. Datatypen Number använder dessa 52 bitar och en speciell dold bit för att representera heltal från -9 007 199 254 740 992 (-2⁵³) till 9 007 199 254 740 992 (2⁵³).

Värdet NaN används inte bara som standardvärde för variabler av typen Number, utan också som resultatet av en beräkning som ska returnera ett tal men som inte gör det. Om du till exempel försöker beräkna kvadratroten av ett negativt tal blir resultatet NaN. Andra speciella Number-värden är positiv oändlighet och negativ oändlighet.

Datatypen String representerar en sekvens av 16-bitarstecken. Strängar sparas internt som Unicode-tecken med UTF-16-formatet. Strängar är oföränderliga värden, på samma sätt som i programmeringsspråket Java. En operation på ett String-värde resulterar i en ny instans av strängen. Standardvärdet för en variabel som har deklarerats med datatypen String är null. Värdet null är inte samma sak som den tomma strängen (""). Värdet null betyder att variabeln saknar ett sparat värde, medans en tom sträng betyder att variabeln har ett värde som är en sträng utan några tecken.

Datatypen uint lagras internt som ett 32-bitars heltal utan tecken och innehåller en serie heltal från 0 till och med 4 294 967 295 (2³² - 1). Använd datatypen uint vid speciella tillfällen som anropar icke-negativa heltal. Du måste till exempel använda datatypen uint för att representera pixelvärden i färg eftersom datatypen int har en intern bit med tecken som inte är lämplig för hantering av färgvärden. Om det gäller heltal som är större än maximivärdet för uint använder du datatypen Number som kan hantera 53-bitars heltal. Standardvärdet för variabler som är av datatypen uint är 0.

Datatypen void innehåller bara ett värde, undefined. I tidigare versioner av ActionScript var undefined standardvärde för instanser av klassen Object. I ActionScript 3.0 är standardvärdet för Object-instanser null. Om du försöker tilldela en instans av klassen Object värdet undefined konverteras värdet till null. Du kan bara tilldela variabler som är typlösa värdet undefined. Typlösa variabler är variabler som antingen saknar typanteckning eller som använder symbolen asterisk (*) för typanteckning. Du kan använda void bara som returtypsanteckning.

Datatypen Object definieras av klassen Object. Klassen Object fungerar som basklass för alla klassdefinitioner i ActionScript. ActionScript 3.0-versionen av datatypen Object skiljer sig på tre sätt från datatypen i tidigare versioner. För det första är datatypen Object inte längre standarddatatyp som tilldelas variabler utan typanteckning. För det andra innehåller datatypen Object inte längre värdet undefined, som används som standardvärde för Object-instanser. För det tredje är standardvärdet för klassen Object null i ActionScript 3.0.

I tidigare versioner av ActionScript har en variabel utan typanteckning automatiskt tilldelats datatypen Object. Detta gäller inte längre i ActionScript 3.0 som nu innehåller en helt typlös variabel. Variabler utan typanteckning betraktas nu som typlösa. Om du vill visa läsarna av din kod att du avsiktligen har lämnat en variabel typlös kan du använda en asterisk (*) för typanteckningen, vilket motsvarar att utesluta en typanteckning. I följande exempel visas två likvärdiga programsatser som båda deklarerar den typlösa variabeln x:

var x 
var x:*

Endast typlösa variabler kan innehålla värdet undefined. Om du försöker tilldela en variabel som har en datatyp värdet undefined konverteras värdet undefined till standardvärdet för den datatypen vid körning. För instanser av datatypen Object är standardvärdet null, vilket betyder att om du försöker tilldela värdet undefined till en Object-instans konverteras värdet till null.