ActionScript 3
tipi

Digitare Casting

Il casting del tipo viene eseguito con l'operatore as :

var chair:Chair = furniture as Chair;

O avvolgendo il valore in Type() :

var chair:Chair = Chair(furniture);

Se il cast fallisce con as , il risultato di tale cast è null . Se il cast fallisce avvolgendo in Type() , viene lanciato un errore TypeError .

Il tipo di funzione

Le funzioni sono del tipo Function :

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

Possono essere referenziati da altre variabili con il tipo Function :

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

E possono essere passati come argomenti per parametri il cui tipo è Function :

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

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

Il tipo di classe

I riferimenti alle dichiarazioni di classe sono tipizzati Class :

var spriteClass:Class = Sprite;

È possibile utilizzare variabili digitate Class per creare istanze di tale classe:

var sprite:Sprite = new spriteClass();

Questo può essere utile per passare un argomento di tipo Class a una funzione che potrebbe creare e istanza della classe fornita:

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

Tipi di annotazione

Puoi dire al compilatore il tipo di un valore annotandolo con :Type :

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

I parametri delle funzioni e i tipi di ritorno possono anche essere annotati:

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

Se si tenta di assegnare un valore con un tipo non corrispondente, verrà TypeError un TypeError :

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

Controllo dei tipi

È possibile utilizzare l'operatore is per verificare se un valore è di un determinato tipo:

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.

C'è anche un instanceof operatore (sconsigliato), che funziona quasi identica a is la differenza che restituisce false quando si controlla per le interfacce implementate e tipi int / uint.

Il as operatore può anche utilizzato proprio come is operatore. Ciò è particolarmente utile se si utilizzano IDE intelligenti come FlashDevelop che forniranno un elenco di tutte le proprietà possibili del tipo di oggetto esplicito. Esempio:

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

Per ottenere lo stesso effetto con is scrivere (leggermente meno conveniente):

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

Tieni presente che quando si controllano le codifiche con as operatore as , il valore dato verrà convertito in un tipo specificato e il risultato di tale operazione verrà controllato se non falso, quindi fai attenzione quando lo utilizzi con possibili valori falsi / NaN:

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

La tabella seguente mostra alcuni valori e tipi di base con il risultato di operatori di tipi. Le celle verdi valuteranno il true, il rosso al false e il greay causeranno errori di compilazione / runtime.

Matrici tipizzate

Sfortunatamente ActionScript 3 non ha un concetto di generici, quindi ne consegue che non esiste un modo per definire un array tipizzato come Array<T> . Esiste comunque una classe speciale Vector.<T> che funziona in modo simile, tranne che è necessario fornire un riferimento a una classe concreta durante l'istanziazione del vettore. Ciò significa che non è possibile creare astrazioni sopra il tipo Vector.<T> (ad esempio estenderlo e aggiungere nuove funzionalità), il che è un enorme inconveniente.

Un modo più semplice di guardare è come se ogni classe definita avesse automaticamente una classe companion chiamata Vector.<NameOfYourClass> .

Detto questo, ci sono ancora enormi vantaggi per il tipo Vector.<T> su un array convenzionale:

• C'è un aumento delle prestazioni quando si lavora con Vector.<T> vs array ¹ .
• Riceverai TypeError tipo compile se tenti di inserire valori non T nella collezione.
• Gli IDE forniscono utili informazioni sull'hint di tipo per gli oggetti all'interno di un'istanza Vector.<T> .

Esempi di creazione di un Vector.<T> :

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

^{1 I} vettori in realtà forniscono miglioramenti delle prestazioni notevoli rispetto agli array quando si utilizzano tipi primitivi ( String , int , uint , Number , ecc.).