ActionScript 3
Les types

Casting de type

Le casting de type se fait soit avec l'opérateur as :

var chair:Chair = furniture as Chair;

Ou en encapsulant la valeur dans Type() :

var chair:Chair = Chair(furniture);

Si la distribution échoue avec as , le résultat de cette distribution est null . Si la TypeError échoue en encapsulant dans Type() , une TypeError est TypeError .

Le type de fonction

Les fonctions sont du type Function :

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

Ils peuvent être référencés par d'autres variables avec le type Function :

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

Et ils peuvent être passés en arguments pour les paramètres dont le type est Function :

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

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

Le type de classe

Les références aux déclarations de classe sont typées Class :

var spriteClass:Class = Sprite;

Vous pouvez utiliser des variables typées Class pour instancier des instances de cette classe:

var sprite:Sprite = new spriteClass();

Cela peut être utile pour transmettre un argument de type Class à une fonction susceptible de créer une instance de la classe fournie:

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

Types d'annotation

Vous pouvez indiquer au compilateur le type d'une valeur en l'annotant avec :Type :

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

Les paramètres de fonction et les types de retour peuvent également être annotés:

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

TypeError d'attribuer une valeur avec un type incompatible, vous obtiendrez une TypeError :

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

Vérification des types

Vous pouvez utiliser l'opérateur is pour valider si une valeur est d'un certain type:

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.

Il existe également une instanceof opérateur (obsolète) qui fonctionne presque identique à is sauf qu’elle renvoie false lors de la vérification des interfaces implémentées et des types int / uint.

Le as opérateur peut aussi utilisé tout comme is l' opérateur. Cela est particulièrement utile si vous utilisez un IDE intelligent comme FlashDevelop qui vous donnera une liste de toutes les propriétés possibles du type d'objet explicite. Exemple:

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

Pour obtenir le même effet is que vous écririez (sligthly moins pratique):

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

Gardez simplement à l'esprit que lors de la vérification des coditions avec l'opérateur as , la valeur donnée sera convertie en un type spécifié et le résultat de cette opération sera vérifié si elle n'est pas fausse.

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

Le tableau ci-dessous montre quelques valeurs et types de base avec le résultat des opérateurs de type. Les cellules vertes seront évaluées à true, rouge à false et greay provoquera des erreurs de compilation / runtime.

Tableaux typés

Malheureusement, ActionScript 3 n’a pas de concept de générique, il s’ensuit qu’il n’ya aucun moyen de définir un tableau typé comme Array<T> . Il existe toutefois une classe spéciale Vector.<T> qui fonctionne de manière similaire, sauf que vous devez fournir une référence à une classe concrète lors de l’instanciation du vecteur. Cela signifie qu'il n'y a aucun moyen de créer des abstractions sur le type Vector.<T> (par exemple, étendre et ajouter de nouvelles fonctionnalités), ce qui est un inconvénient majeur.

Une manière plus simple de regarder est comme si chaque classe que vous définissiez avait automatiquement une classe compagnon nommée Vector.<NameOfYourClass> .

Cela dit, il y a encore des avantages énormes à Vector.<T> tapez sur un tableau conventionnel:

• Il y a une augmentation de performance lorsque vous travaillez avec Vector.<T> vs tableaux ¹ .
• Vous recevez le type de compilation TypeError s si vous essayez d'insérer des valeurs non-T dans la collection.
• Les IDE fournissent des informations utiles sur les indications de type pour les objets à l'intérieur d'une instance de Vector.<T> .

Exemples de création d'un Vector.<T> :

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

¹ Les vecteurs n'apportent en réalité que des améliorations notables des performances par rapport aux tableaux lors de l'utilisation de types primitifs ( String , int , uint , Number , etc.).