ActionScript 3
typer
Sök…
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 1 . - 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>[];
1 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).