Die Typüberprüfung während der Kompilierung wird insbesondere bei größeren Projekten bevorzugt, da die Datentypflexibilität mit wachsender Projektgröße weniger wichtig als das rechtzeitige Erfassung von Typfehlern wird. Aus diesem Grund ist der ActionScript-Compiler in Flash Professional und Flash Builder standardmäßig auf den strikten Modus eingestellt.

Der Compiler muss die Datentypinformationen der Variablen oder Ausdrücke in Ihrem Code kennen, um eine Typüberprüfung während der Kompilierung durchführen zu können. Um einen Datentyp für eine Variable explizit zu deklarieren, fügen Sie den Doppelpunktoperator (:) gefolgt vom Datentyp als Suffix zum Variablennamen hinzu. Um einem Parameter einen Datentyp zuzuordnen, verwenden Sie den Doppelpunktoperator gefolgt vom Datentyp. Im folgenden Code werden dem Parameter xParam Datentypinformationen hinzugefügt. Zudem wird eine Variable myParam mit einem expliziten Datentyp deklariert:

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

Im strikten Modus meldet der ActionScript-Compiler Typdiskrepanzen als Compiler-Fehler. Im folgenden Code wird ein Funktionsparameter xParam des Typs „Object“ deklariert, im weiteren Verlauf wird jedoch versucht, diesem Parameter Werte des Typs „String“ und „Number“ zuzuweisen. Im strikten Modus führt dies zu einem Compiler-Fehler.

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

Auch im strikten Modus können Sie die Typüberprüfung während der Kompilierung selektiv deaktivieren, indem Sie die rechte Seite einer Zuweisungsanweisung nicht typisieren. Um eine Variable oder einen Ausdruck als nicht typisiert zu kennzeichnen, lassen Sie entweder die Typanmerkung weg oder verwenden die Sondertypanmerkung * (Sternchen). Wenn beispielsweise der xParam-Parameter aus dem vorherigen Beispiel so geändert wird, dass er keine Typanmerkung mehr aufweist, wird der Code im strikten Modus kompiliert:

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

Die Typüberprüfung zur Laufzeit findet in ActionScript 3.0 unabhängig davon statt, ob Sie im strikten Modus oder im Standardmodus kompilieren. Stellen Sie sich eine Situation vor, bei der der Wert 3 als Argument an eine Funktion übergeben wird, die ein Array erwartet. Im strikten Modus erzeugt der Compiler einen Fehler, weil der Wert 3 nicht mit dem Datentyp „Array“ kompatibel ist. Wenn Sie den strikten Modus deaktivieren und den Standardmodus ausführen, meldet der Compiler keine Typdiskrepanzen, aber eine Typüberprüfung zur Laufzeit führt zu einem Laufzeitfehler.

Im folgenden Beispiel ist eine Funktion namens typeTest() dargestellt, die ein Array-Argument erwartet, stattdessen jedoch den Wert 3 empfängt. Dies führt im Standardmodus zu einem Laufzeitfehler, da der Wert 3 kein Mitglied des deklarierten Datentyps des Parameters (Array) ist.

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

Es gibt auch Situationen, in denen ein Laufzeitfehler erzeugt wird, obwohl Sie im strikten Modus arbeiten. In einem solchen Fall haben Sie den strikten Modus verwendet, die Typüberprüfung während der Kompilierung jedoch durch das Verwenden einer nicht typisierten Variablen ausgeschaltet. Durch Verwenden einer nicht typisierten Variablen wird die Typüberprüfung nicht deaktiviert, sondern bis zur Laufzeit zurückgestellt. Angenommen, die myNum-Variable aus dem vorhergehenden Beispiel weist keinen deklarierten Datentyp auf. In diesem Fall kann der Compiler keine Typdiskrepanz erkennen, es wird jedoch ein Laufzeitfehler erzeugt, da der Laufzeitwert von myNum (der als Ergebnis der Zuweisungsanweisung auf 3 festgelegt ist) mit dem Datentyp von xParam verglichen wird, der auf „Array“ gesetzt ist.

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

Die Typüberprüfung zur Laufzeit ermöglicht auch eine flexiblere Verwendung der Vererbung als die Typüberprüfung während der Kompilierung. Durch das Zurückstellen der Typüberprüfung bis zur Laufzeit können Sie im Standardmodus auch dann auf die Eigenschaften einer Unterklasse verweisen, wenn Sie verallgemeinern (upcast). Eine Verallgemeinerung findet statt, wenn Sie eine Basisklasse zum Deklarieren des Typs einer Klasseninstanz verwenden, jedoch eine Unterklasse zum Instanziieren angeben. Beispielsweise können Sie eine Klasse mit dem Namen „ClassBase“ erstellen, die erweitert werden kann (Klassen mit dem Attribut final können nicht erweitert werden):

class ClassBase 
{ 
}

Anschließend können Sie eine Unterklasse von „ClassBase“ namens „ClassExtender“ erstellen, die eine Eigenschaft mit der Bezeichnung someString aufweist. Dies wird im folgenden Code gezeigt:

class ClassExtender extends ClassBase 
{ 
    var someString:String; 
}

Mit beiden Klassen können Sie eine Klasseninstanz erstellen, die mit dem Datentyp „ClassBase“ deklariert ist, jedoch mit dem ClassExtender-Konstruktor instanziiert wird. Eine Verallgemeinerung wird als sichere Operation angesehen, da die Basisklasse keine Eigenschaften oder Methoden enthält, die nicht in der Unterklasse vorhanden sind.

var myClass:ClassBase = new ClassExtender();

Eine Unterklasse kann jedoch Eigenschaften oder Methoden enthalten, die in der Basisklasse nicht enthalten sind. Beispielsweise enthält die ClassExtender-Klasse die Eigenschaft someString, die in der ClassBase-Klasse nicht vorhanden ist. Im Standardmodus von ActionScript 3.0 können Sie mit der myClass-Instanz auf diese Eigenschaft verweisen, ohne einen Fehler während der Kompilierung zu erzeugen. Dies wird im folgenden Beispiel gezeigt:

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

Mit dem is-Operator können Sie testen, ob eine Variable oder ein Ausdruck Mitglied eines bestimmten Datentyps ist. In früheren Versionen von ActionScript wurde diese Funktion vom instanceof-Operator bereitgestellt, in ActionScript 3.0 sollte der instanceof-Operator jedoch nicht mehr zum Testen der Datentypmitgliedschaft verwendet werden. Stattdessen sollten Sie zur manuellen Typüberprüfung den is-Operator anstelle des instanceof-Operators verwenden, da der Ausdruck x instanceof y lediglich die Prototypkette von x auf das Vorhandensein von y überprüft (und die Prototypkette in ActionScript 3.0 kein vollständiges Bild der Vererbungshierarchie bietet).

Der is-Operator überprüft die genaue Vererbungshierarchie. Er kann also nicht nur überprüfen, ob ein Objekt eine Instanz einer bestimmten Klasse ist, sondern auch, ob ein Objekt eine Instanz einer Klasse ist, die eine bestimmte Schnittstelle implementiert. Im folgenden Beispiel wird eine Instanz der Sprite-Klasse namens mySprite erstellt und mit dem is-Operator überprüft, ob mySprite eine Instanz der Sprite- und DisplayObject-Klassen ist und ob es die IEventDispatcher-Schnittstelle implementiert:

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

Der is-Operator überprüft die Vererbungshierarchie und meldet unverzüglich, ob mySprite mit den Sprite- und DisplayObject-Klassen kompatibel ist (die Sprite-Klasse ist eine Unterklasse der DisplayObject-Klasse). Außerdem überprüft der is-Operator, ob mySprite von einer der Klassen erbt, welche die IEventDispatcher-Schnittstelle implementieren. Da die Sprite-Klasse von der EventDispatcher-Klasse erbt, die wiederum die IEventDispatcher-Schnittstelle implementiert, meldet der is-Operator folgerichtig, dass mySprite die gleiche Schnittstelle implementiert.

Das folgende Beispiel zeigt die gleichen Tests wie das vorangegangene Beispiel, diesmal jedoch mit dem instanceof-Operator anstelle des is-Operators. Der instanceof-Operator erkennt richtig, dass mySprite eine Instanz von Sprite oder DisplayObject ist, gibt jedoch den Wert false zurück, wenn getestet wird, ob mySprite die IEventDispatcher-Schnittstelle implementiert.

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

Mit dem as-Operator können Sie auch testen, ob ein Ausdruck Mitglied eines bestimmten Datentyps ist. Im Gegensatz zum is-Operator liefert der as-Operator keinen booleschen Wert. Der as-Operator gibt den Wert des Ausdrucks anstelle von true und null anstelle von false zurück. Das folgende Beispiel zeigt, was geschieht, wenn in einem einfachen Fall mit dem as-Operator anstelle des is-Operators überprüft werden soll, ob eine Sprite-Instanz ein Mitglied der Datentypen „DisplayObject“, „IEventDispatcher“ und „Number“ ist.

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

Wenn Sie den as-Operator verwenden, muss der Operand auf der rechten Seite ein Datentyp sein. Der Versuch, einen anderen Ausdruck als einen Datentyp als Operanden auf der rechten Seite zu verwenden, führt zu einem Fehler.

Der Boolean-Datentyp beinhaltet zwei Werte: true und false. Für Variable des Typ „Boolean“ sind keine anderen Werte zulässig. Der Standardwert einer Boolean-Variablen, die zwar deklariert, jedoch nicht initialisiert wurde, lautet false.

Der Datentyp „int“ wird intern als Ganzzahl mit 32 Bit gespeichert und umfasst Ganzzahlen im Bereich von

-2.147.483.648 (-2³¹) bis einschließlich 2.147.483.647 (2³¹ - 1). Frühere Versionen von ActionScript boten lediglich den Datentyp „Number“, der sowohl für Ganzzahlen als auch für Gleitkommazahlen verwendet wurde. In ActionScript 3.0 können Sie jetzt auch auf untergeordnete Maschinentypen für 32-Bit-Ganzzahlen mit und ohne Vorzeichen zugreifen. Wenn für eine Variable keine Gleitkommazahlen erforderlich sind, bietet der Datentyp „int“ eine höhere Geschwindigkeit und Effizienz als der Datentyp „Number“.

Für ganzzahlige Werte außerhalb des Bereichs für int-Werte verwenden Sie den Datentyp „Number“, der Werte zwischen plus/minus 9.007.199.254.740.992 (ganzzahlige Werte mit 53 Bit) verarbeiten kann. Der Standardwert für Variable des Datentyps „int“ lautet 0.

Der Null-Datentyp umfasst nur den Wert null. Dies ist der Standardwert für den Datentyp „String“ und alle Klassen, die komplexe Datentypen definieren. Hierzu gehört auch die Object-Klasse. Keiner der anderen Grunddatentypen, wie „Boolean“, „Number“, „int“ und „uint“, enthält den Wert null. Wenn Sie versuchen, Variablen des Typs „Boolean“, „Number“, „int“ oder „uint“ den Wert null zuzuweisen, wird null zur Laufzeit in den entsprechenden Standardwert umgewandelt. Sie können diesen Datentyp nicht als Typanmerkung verwenden.

In ActionScript 3.0 kann der Datentyp „Number“ Ganzzahlen, vorzeichenlose Ganzzahlen und Gleitkommazahlen darstellen. Um die Leistung zu maximieren, sollten Sie den Datentyp „Number“ jedoch nur für ganzzahlige Werte größer als die Speichergrenze für int- und uint-Typen mit 32 Bit oder für Gleitkommazahlen verwenden. Zum Speichern als Gleitkommazahl müssen Sie mit der Zahl ein Dezimalzeichen angeben. Ohne das Dezimalzeichen wird die Zahl als Ganzzahl gespeichert.

Der Datentyp „Number“ verwendet eine Gleitkommazahl nach dem IEEE Standard for Binary Floating-Point Arithmetic (IEEE-754) mit doppelter Genauigkeit (64 Bit). Dieser Standard legt fest, wie Gleitkommazahlen mit 64 verfügbaren Bits gespeichert werden. Ein Bit legt fest, ob die Zahl positiv oder negativ ist. 11 Bit werden für den Exponenten verwendet, der als Basis 2 gespeichert wird. Die verbleibenden 52 Bit werden zum Speichern des Signifikand (auch als Mantisse bezeichnet) verwendet. Dies ist die Zahl, die durch den Exponenten potenziert wird.

Indem einige Bits zum Speichern eines Exponenten verwendet werden, kann der Datentyp „Number“ wesentlich größere Gleitkommazahlen speichern, als wenn alle Bits für die Mantisse verwendet werden. Würde der Datentyp „Number“ alle 64 Bit zum Speichern der Mantisse verwenden, könnte lediglich eine Zahl in der Größe von 2⁶⁵ -1 gespeichert werden. Indem 11 Bit zum Speichern eines Exponenten verwendet werden, kann der Datentyp „Number“ die Mantisse bis zu einer Potenz von 2¹⁰²³ anheben.

Die Höchst- und Mindestwerte, die der Datentyp „Number“ darstellen kann, sind in den statischen Eigenschaften der Number-Klasse namens Number.MAX_VALUE und Number.MIN_VALUE gespeichert.

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

Dieser enorm große Zahlenbereich geht jedoch zu Lasten der Genauigkeit. Der Datentyp „Number“ verwendet 52 Bit zum Speichern der Mantisse. Dadurch sind Zahlen, die mehr als 52 Bit zur exakten Darstellung benötigen, wie z. B. der Bruch 1/3, nur Annäherungen. Wenn die Anwendung Dezimalzahlen mit absoluter Präzision erfordert, benötigen Sie Software, die anstelle von Binär-Gleitkommaarithmetik die Dezimal-Gleitkommaarithmetik verwendet.

Wenn Sie ganzzahlige Werte mit dem Datentyp „Number“ speichern, werden nur die 52 Bit der Mantisse verwendet. Der Datentyp „Number“ verwendet diese 52 Bit sowie ein spezielles verborgenes Bit, um Ganzzahlen im Bereich von -9.007.199.254.740.992 (-2⁵³) bis 9.007.199.254.740.992 (2⁵³) darzustellen.

Der Wert NaN wird nicht nur als Standardwert für Variablen mit dem Number-Typ verwendet, sondern auch als Ergebnis für jeden Vorgang, der eine Zahl zurückgeben sollte, aber einen anderen Wert liefert. Wenn Sie beispielsweise versuchen, die Quadratwurzel einer negativen Zahl zu berechnen, lautet das Ergebnis NaN. Weitere spezielle Number-Werte sind positive infinity (positive Unendlichkeit) und negative infinity (negative Unendlichkeit).

Der Datentyp „String“ stellt eine Zeichenfolge von 16 Bit dar. Strings werden intern als Unicode-Zeichen im Format UTF-16 gespeichert. Strings sind, ebenso wie in der Programmiersprache Java, unveränderliche Werte. Eine Operation mit einem Stringwert liefert eine neue Instanz des Strings. Der Standardwert für eine Variable, die mit dem Datentyp „String“ deklariert ist, lautet null. Der Wert null ist nicht mit einem leeren String ("") identisch. Beim Wert null ist in der Variablen kein Wert gespeichert; bei einem leeren String enthält die Variable einen Wert, der ein String ohne Zeichen ist.

Der Datentyp „uint“ wird intern als vorzeichenlose Ganzzahl mit 32 Bit gespeichert und enthält Ganzzahlen im Bereich von 0 bis einschließlich 4.294.967.295 (2³² - 1). Sie verwenden den Datentyp „uint“ für Sonderfälle, die nicht-negative Ganzzahlen verlangen. Beispielsweise müssen Sie den Datentyp „uint“ zur Darstellung von Farbwerten für Pixel verwenden, da der Datentyp „int“ ein internes Vorzeichen-Bit umfasst, das für die Verarbeitung von Farbwerten nicht geeignet ist. Für ganzzahlige Werte größer als der uint-Höchstwert verwenden Sie den Datentyp „Number“, der ganzzahlige Werte mit 53 Bit verarbeiten kann. Der Standardwert für Variablen des Datentyps „uint“ lautet 0.

Der Datentyp „void“ umfasst nur den Wert undefined. In früheren Versionen von ActionScript war undefined der Standardwert für Instanzen der Object-Klasse. In ActionScript 3.0 lautet der Standardwert für Object-Instanzen null. Wenn Sie versuchen, einer Instanz der Object-Klasse den Wert undefined zuzuweisen, wird der Wert in null umgewandelt. Der Wert undefined kann nur nicht typisierten Variablen zugewiesen werden. Nicht typisierte Variablen sind Variablen, denen entweder eine Typanmerkung fehlt oder die das Sternchen-Symbol (*) als Typanmerkung verwenden. Sie können void nur als Rückgabe-Typanmerkung verwenden.

Der Object-Datentyp wird von der Object-Klasse definiert. Die Object-Klasse dient als Basisklasse für alle Klassendefinitionen in ActionScript. Der Datentyp „Object“ in ActionScript 3.0 unterscheidet sich vom Datentyp „Object“ in früheren Versionen in dreifacher Hinsicht. Zunächst einmal ist der Datentyp „Object“ nicht mehr der Standarddatentyp, der Variablen ohne Typanmerkung zugewiesen wird. Zweitens enthält der Datentyp „Object“ nicht mehr den Wert undefined, der als Standardwert für Object-Instanzen verwendet wurde. Drittens lautet der Standardwert für Instanzen der Object-Klasse in ActionScript 3.0 jetzt null.

In früheren Versionen von ActionScript wurde einer Variablen ohne Typanmerkung automatisch der Datentyp „Object“ zugewiesen. Dies findet in ActionScript 3.0 nicht mehr statt, da ActionScript 3.0 jetzt das Konzept einer wahrhaft nicht typisierten Variablen enthält. Variablen ohne Typanmerkung werden jetzt als nicht typisiert betrachtet. Wenn Sie anderen Programmierern, die Ihren Code lesen, deutlich machen möchten, dass Sie eine Variable absichtlich nicht typisiert haben, können Sie das Sternchen-Symbol (*) als Typanmerkung verwenden. Dies entspricht dem Weglassen einer Typanmerkung. Im folgenden Beispiel sind zwei gleichwertige Anweisungen dargestellt. Beide deklarieren eine nicht typisierte Variable x:

var x 
var x:*

Nur nicht typisierte Variable können den Wert undefined annehmen. Wenn Sie versuchen, einer Variablen mit einem Datentyp den Wert undefined zuzuweisen, wandelt die Laufzeit den Wert undefined in den Standardwert dieses Datentyps um. Bei Instanzen des Object-Datentyps lautet der Standardwert null. Wenn Sie also versuchen, einer Object-Instanz den Wert undefined zuzuweisen, wird der Wert in null umgewandelt.