ActionScript 3
Typen

Geben Sie Casting ein

Das Typ-Casting erfolgt entweder mit dem Operator as :

var chair:Chair = furniture as Chair;

Oder indem Sie den Wert in Type() umschließen:

var chair:Chair = Chair(furniture);

Wenn die Besetzung mit as fehlschlägt, ist das Ergebnis dieser Besetzung null . Wenn der Cast durch das Wrapping in Type() fehlschlägt, wird ein TypeError ausgelöst.

Der Funktionstyp

Funktionen sind vom Typ Function :

function example():void { }
trace(example is Function); // true

Sie können von anderen Variablen mit dem Typ Function referenziert werden:

var ref:Function = example;
ref(); // ref.call(), ref.apply(), etc.

Sie können als Argumente für Parameter mit dem Typ Function :

function test(callback:Function):void {
    callback();
}

test(function() {
    trace('It works!');
}); // Output: It works!

Der Klassentyp

Verweise auf Klassendeklarationen sind typisiert Class :

var spriteClass:Class = Sprite;

Sie können mit Variablen typisierte Class , um Instanzen dieser Class zu instanziieren:

var sprite:Sprite = new spriteClass();

Dies kann nützlich sein, um ein Argument des Typs Class an eine Funktion zu übergeben, die möglicherweise eine Instanz der bereitgestellten Klasse erstellt:

function create(type:Class, x:int, y:int):* {
    var thing:* = new type();
    
    thing.x = x;
    thing.y = y;
    
    return thing;
}

var sprite:Sprite = create(Sprite, 100, 100);

Typen kommentieren

Sie können dem Compiler den Typ eines Werts mitteilen, indem Sie ihn mit :Type Anmerkungen versehen :Type :

var value:int = 10; // A property "value" of type "int".

Funktionsparameter und Rückgabetypen können auch kommentiert werden:

// This function accepts two ints and returns an int.
function sum(a:int, b:int):int {
    return a + b;
}

Der Versuch, einen Wert mit einem nicht übereinstimmenden Typ zuzuweisen, führt zu einem TypeError :

var sprite:Sprite = 10; // 10 is not a Sprite.

Typen prüfen

Mit dem Operator is können Sie überprüfen, ob ein Wert einen bestimmten Typ hat:

var sprite:Sprite = new Sprite();

trace(sprite is Sprite); // true
trace(sprite is DisplayObject); // true, Sprite inherits DisplayObject
trace(sprite is IBitmapDrawable); // true, DisplayObject implements IBitmapDrawable
trace(sprite is Number); // false
trace(sprite is Bitmap); // false, Bitmap inherits DisplayObject
                         // but is not inherited by Sprite.

Es gibt auch eine instanceof Operators (veraltet), der nahezu identisch is mit dem Unterschied, dass er bei der Prüfung auf implementierte Schnittstellen und Int / Uint-Typen false zurückgibt.

Der as Operator kann auch verwendet von gerade wie is Betreiber. Dies ist besonders nützlich, wenn Sie eine intelligente IDE wie FlashDevelop verwenden, die Ihnen eine Liste aller möglichen Eigenschaften eines expliziten Objekttyps gibt. Beispiel:

for (var i:int = 0; i < a.length; i++){
    var d:DisplayObject = a[i] as DisplayObject;
    if (!d) continue;
    d.//get hints here
    stage.addChild(d);
}

Um den gleichen Effekt mit is würden Sie schreiben (sligthly weniger bequem):

for (var i:int = 0; i < a.length; i++){
    if (a[i] is DisplayObject != true) continue;
    var d:DisplayObject = a[i] as DisplayObject;
    stage.addChild(d);
}

Denken Sie jedoch daran, dass bei der Überprüfung von Kodierungen mit as Operator der angegebene Wert zuerst in den angegebenen Typ konvertiert wird und das Ergebnis dieser Operation überprüft wird, wenn nicht false.

if(false as Boolean) trace("This will not be executed");
if(false as Boolean != null) trace("But this will be");

Die folgende Tabelle zeigt einige grundlegende Werte und Typen mit den Ergebnissen der Typenoperatoren. Grüne Zellen werden als "true" ausgewertet, Rot für "false" und "greay" führt zu Kompilierungs- / Laufzeitfehlern.

Typisierte Arrays

Leider gibt es in ActionScript 3 kein Konzept von Generics. Daher gibt es keine Möglichkeit, ein typisiertes Array als Array<T> zu definieren. Es gibt jedoch eine spezielle Klasse Vector.<T> die auf ähnliche Weise funktioniert, mit der Ausnahme, dass Sie beim Instantiieren des Vektors einen Verweis auf eine konkrete Klasse angeben müssen. Das bedeutet, dass es keine Möglichkeit gibt, Abstraktionen über dem Vector.<T> Typ zu erstellen ( Vector.<T> (z. B. erweitern und neue Funktionen hinzufügen), was einen großen Nachteil darstellt.

Eine einfachere Sichtweise besteht darin, dass jede von Ihnen definierte Klasse automatisch eine Begleiterklasse mit dem Namen Vector.<NameOfYourClass> .

Trotzdem hat der Vector.<T> großen Vorteil gegenüber einem herkömmlichen Array:

• Bei der Arbeit mit Vector.<T> gibt es eine Leistungssteigerung Vector.<T> vs. Arrays ¹ .
• Sie erhalten TypeError -Typen TypeError Typ TypeError wenn Sie versuchen, Nicht-T-Werte in die Auflistung einzufügen.
• IDEs liefern nützliche Typhinweisinformationen für die Objekte in einer Vector.<T> -Instanz.

Beispiele zum Erstellen eines Vector.<T> :

var strings:Vector.<String> = new Vector.<String>(); // or
var numbers:Vector.<Number> = new <Number>[];

¹ Vektoren bieten tatsächlich nur dann eine bemerkenswerte Leistungsverbesserung gegenüber Arrays, wenn mit primitiven Typen ( String , int , uint , Number usw.) gearbeitet wird.