ActionScript 3
Rodzaje

Typ Casting

Rzutowanie typu odbywa się za pomocą operatora as :

var chair:Chair = furniture as Chair;

Lub przez zawinięcie wartości w Type() :

var chair:Chair = Chair(furniture);

Jeśli rzutowanie zakończy się niepowodzeniem as , wynik tego rzutu jest null . Jeśli rzutowanie nie powiedzie się przez zawijanie w Type() , TypeError jest błąd TypeError .

Typ funkcji

Funkcje są typu Function :

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

Mogą się do nich odwoływać inne zmienne o typie Function :

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

I mogą być przekazywane jako argumenty dla parametrów, których typ to Function :

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

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

Typ klasy

Odniesienia do deklaracji klas są wpisywane Class :

var spriteClass:Class = Sprite;

Możesz użyć zmiennych typu Class aby utworzyć instancję tej klasy:

var sprite:Sprite = new spriteClass();

Może to być przydatne do przekazania argumentu typu Class do funkcji, która może utworzyć i instancję podanej klasy:

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

Typy adnotacji

Możesz podać kompilatorowi typ wartości, dodając do niego adnotację :Type :

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

Parametry funkcji i typy zwracane mogą być również opatrzone adnotacjami:

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

Próba przypisania wartości z niedopasowania typu będzie skutkować TypeError :

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

Sprawdzanie typów

Za pomocą operatora is można sprawdzić, czy wartość określonego typu:

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.

Istnieje także instanceof operator (przestarzałe), który działa niemal identyczna is poza tym, że zwraca false podczas sprawdzania wdrożonych interfejsów i typów int / uint.

as operator może również stosować tak jak is operator. Jest to szczególnie przydatne, jeśli używasz inteligentnego IDE, takiego jak FlashDevelop, który da ci listę wszystkich możliwych właściwości jawnego typu obiektu. Przykład:

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

Aby uzyskać ten sam efekt, is napisać (nieco mniej wygodne):

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

Pamiętaj tylko, że podczas sprawdzania kodowań as operator, podana wartość zostanie najpierw skonwertowana na określony typ, a następnie wynik tej operacji zostanie sprawdzony, jeśli nie jest fałszywy, więc zachowaj ostrożność, używając jej z możliwymi wartościami false / NaN:

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

Poniższa tabela pokazuje podstawowe wartości i typy z wynikami operatorów typów. Zielone komórki będą oceniać na prawdę, czerwone na fałsz, a szarość spowoduje błędy kompilacji / działania.

Wpisane tablice

Niestety w języku ActionScript 3 nie ma pojęcia rodzajowego, dlatego nie można zdefiniować tablicy typowanej jako Array<T> . Istnieje jednak specjalna klasa Vector.<T> która działa w podobny sposób, z tym wyjątkiem, że podczas tworzenia wektora należy podać odwołanie do konkretnej klasy . Oznacza to, że nie ma możliwości budowania abstrakcji na typie Vector.<T> (np. Rozszerzenie i dodanie nowej funkcjonalności), co jest ogromną wadą.

Prostszym sposobem patrzenia jest to, jakby każda zdefiniowana przez ciebie klasa automatycznie miała klasę towarzyszącą o nazwie Vector.<NameOfYourClass> .

To powiedziawszy, nadal istnieją ogromne zalety typu Vector.<T> porównaniu z konwencjonalną tablicą:

• Podczas pracy z urządzeniem Vector.<T> występuje wzrost wydajności Vector.<T> vs tablice ¹ .
• Otrzymujesz kompilacji typ TypeError ów jeśli próba wstawienia wartości non-T do odbioru.
• IDE dostarczają użytecznych informacji wskazujących na typ obiektów wewnątrz instancji Vector.<T> .

Przykłady tworzenia Vector.<T> :

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

¹ Wektory zapewniają zauważalną poprawę wydajności w porównaniu do tablic podczas pracy z typami pierwotnymi ( String , int , uint , Number itp.).