ActionScript 3
Types

Type Casting

Type casting wordt gedaan met de operator as :

var chair:Chair = furniture as Chair;

Of door de waarde in Type() verpakken:

var chair:Chair = Chair(furniture);

Als de cast met as mislukt, is het resultaat van die cast null . Als de cast mislukt door Type() in te TypeError , wordt een TypeError gegenereerd.

Het type functie

Functies zijn van het type Function :

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

Er kan naar andere variabelen worden verwezen met het type Function :

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

En ze kunnen worden doorgegeven als argumenten voor parameters waarvan het type Function :

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

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

Het klasse type

Verwijzingen naar klasseverklaringen worden getypt Class :

var spriteClass:Class = Sprite;

U kunt variabelen met de Class om instanties van die klasse te instantiëren:

var sprite:Sprite = new spriteClass();

Dit kan handig zijn om een argument van het type Class aan een functie die een instantie van de opgegeven klasse kan maken:

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

Annoterende typen

U kunt de compiler het type van een waarde vertellen door deze te annoteren met :Type :

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

Functieparameters en retourtypen kunnen ook worden geannoteerd:

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

Als u probeert een waarde met een niet-overeenkomend type toe te wijzen, resulteert dit in een TypeError :

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

Typen controleren

U kunt de operator is gebruiken om te valideren of een waarde van een bepaald type is:

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.

Er is ook een instanceof operator (verouderd) die vrijwel identiek is behalve dat deze false retourneert bij het controleren op geïmplementeerde interfaces en int / uint-typen.

De as operator kan ook worden gebruikt, net als is operator. Dit is vooral handig als u een slimme IDE zoals FlashDevelop gebruikt, die u een lijst met alle mogelijke eigenschappen van een expliciet objecttype geeft. Voorbeeld:

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

Om hetzelfde effect te krijgen bij is je zou schrijven (sligthly minder geschikt zou zijn):

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

Houd er rekening mee dat bij het controleren van codities met as operator, de opgegeven waarde met de vuist wordt geconverteerd naar het opgegeven type en het resultaat van die bewerking wordt gecontroleerd als deze niet vals is, dus wees voorzichtig bij het gebruik met mogelijke false / NaN-waarden:

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

Onderstaande tabel toont enkele basiswaarden en types met resultaat van type-operatoren. Groene cellen evalueren naar waar, rood naar onwaar en vet zullen compileer / runtime-fouten veroorzaken.

Getypte reeksen

Helaas heeft ActionScript 3 geen concept van generieke termen, dus hieruit volgt dat er geen manier is om een getypte array als Array<T> te definiëren. Er is echter een speciale klasse Vector.<T> die op een vergelijkbare manier werkt, behalve dat u een verwijzing naar een concrete klasse moet opgeven wanneer u de vector instantieert. Dit betekent dat er geen manier is om abstracties bovenop het Vector.<T> -type te bouwen (bijv. Uitbreiden en nieuwe functionaliteit toevoegen), wat een enorm nadeel is.

Een eenvoudigere manier om naar te kijken is alsof elke klasse die u definieert automatisch een begeleidende klasse heeft met de naam Vector.<NameOfYourClass> .

Dat gezegd hebbende, zijn er nog steeds enorme voordelen aan het Vector.<T> -type ten opzichte van een conventionele array:

• Er is een prestatieverbetering bij het werken met Vector.<T> versus arrays ¹ .
• U ontvangt compile-type TypeError s als u probeert niet-T-waarden in de verzameling in te voegen.
• IDE's bieden nuttige type-hintinformatie voor de objecten in een Vector.<T> -instantie.

Voorbeelden van het maken van een Vector.<T> :

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

¹ Vectoren bieden eigenlijk alleen opmerkelijke prestatieverbeteringen ten opzichte van arrays bij het werken met primitieve typen ( String , int , uint , Number , enz.).