ActionScript 3
typer

Skriv gjutning

Typgjutning görs med antingen as operatör:

var chair:Chair = furniture as Chair;

Eller genom att lägga in värdet i Type() :

var chair:Chair = Chair(furniture);

Om rollbesättningen misslyckas med as är resultatet av den rollen null . Om rollbesättningen misslyckas genom att lägga in Type() kastas en TypeError .

Funktionstypen

Funktioner är av typen Function :

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

De kan hänvisas till av andra variabler med typen Function :

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

Och de kan skickas in som argument för parametrar vars typ är Function :

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

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

Klasstypen

Hänvisningar till klassdeklarationer skrivs Class :

var spriteClass:Class = Sprite;

Du kan använda variabler typ Class att instansera instanser av klassen:

var sprite:Sprite = new spriteClass();

Detta kan vara användbart för att överföra ett argument av typen Class till en funktion som kan skapa och instans av den medföljande klassen:

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

Kommentera typer

Du kan berätta kompilatorn om värdetyp genom att kommentera det med :Type :

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

Funktionsparametrar och returtyper kan också kommenteras:

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

Att försöka tilldela ett värde med en felanpassningstyp resulterar i en TypeError :

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

Kontrollera typer

Du kan använda is operatör för att bekräfta huruvida ett värde av en viss typ:

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.

Det finns också en instanceof operatör (föråldrat), som fungerar nästan identiskt med is förutom att den returnerar false vid kontroll av genomförda gränssnitt och int / uint typer.

Den as operatören kan också genom användas precis som is operatör. Detta är särskilt användbart om du använder några smarta IDE-enheter som FlashDevelop som ger dig en lista över alla möjliga egenskaper av uttrycklig objekttyp. Exempel:

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

För att få samma effekt med is du skulle skriva (försiktigt mindre bekvämt):

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

Tänk bara på att när du kontrollerar kodningar med as operatör, kommer det givna värdet att konverteras till nästa till angiven typ och sedan kommer resultatet av den operationen att kontrolleras om inte falskt, så var försiktig när du använder det med möjliga falska / NaN-värden:

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

Nedanstående tabell visar några grundläggande värden och typer med resultat av typoperatörer. Gröna celler kommer att utvärdera till sant, rött till falskt och fett kommer att orsaka kompilering / runtime-fel.

Typade matriser

Tyvärr har ActionScript 3 inte ett begrepp generiska, så det följer att det inte finns något sätt att definiera en typad matris som Array<T> . Det finns dock en specialklassvektor Vector.<T> som fungerar på liknande sätt förutom att du måste ange en referens till en konkret klass när du instigerar vektorn. Detta betyder att det inte finns något sätt att bygga abstraktioner ovanpå Vector.<T> -typen (t.ex. utöka den och lägga till ny funktionalitet) vilket är en enorm nackdel.

Ett enklare sätt att titta på är som om varje klass du definierar automatiskt hade en ledsagarklass med namnet Vector.<NameOfYourClass> .

Med det sagt finns det fortfarande enorma fördelar med Vector.<T> typ över en konventionell matris:

• Det går att öka prestanda när du arbetar med Vector.<T> vs matriser ¹ .
• Du får kompileringstyp TypeError om du försöker infoga icke-T-värden i samlingen.
• IDE: er ger information om användbar typ av antydningar för objekten i en Vector.<T> -instans.

Exempel på att skapa en Vector.<T> :

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

¹ Vektorer ger faktiskt endast anmärkningsvärda prestandaförbättringar jämfört med matriser när du arbetar med primitiva typer ( String , int , uint , Number , etc).