ActionScript 3
Los tipos

Tipo de fundición

La conversión de tipos se realiza con el operador as :

var chair:Chair = furniture as Chair;

O envolviendo el valor en Type() :

var chair:Chair = Chair(furniture);

Si el lanzamiento falla con as , el resultado de ese lanzamiento es null . Si la conversión falla al ajustarse en Type() , se lanza un TypeError .

El tipo de función

Las funciones son del tipo Function :

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

Pueden ser referenciadas por otras variables con el tipo Function :

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

Y se pueden pasar como argumentos para parámetros cuyo tipo es Function :

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

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

El tipo de clase

Las referencias a las declaraciones de clase se escriben en Class .

var spriteClass:Class = Sprite;

Puede usar las variables con tipo de Class para crear instancias de esa clase:

var sprite:Sprite = new spriteClass();

Esto puede ser útil para pasar un argumento de tipo Class a una función que podría crear una instancia de la clase proporcionada:

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

Anotando tipos

Puede decirle al compilador el tipo de un valor anotándolo con :Type :

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

Parámetros de función y tipos de retorno también pueden ser anotados:

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

El intento de asignar un valor con un tipo no coincidente resultará en un TypeError :

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

Revisando los tipos

Puede usar el operador is para validar si un valor es de un tipo determinado:

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.

También hay un instanceof operador (en desuso), que funciona casi idéntica a is , excepto que devuelve false en la comprobación de interfaces implementadas y tipos int / uint.

El as operador también se puede utilizar por igual que is operador. Esto es especialmente útil si utiliza algún IDE inteligente como FlashDevelop que le dará una lista de todas las propiedades posibles del tipo de objeto explícito. Ejemplo:

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

Para obtener el mismo efecto con is que iba a escribir (sligthly menos 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);
}

Hemos de tener en cuenta que en la comprobación coditions con as operador, el valor dado será el puño se convirtió al tipo especificado y luego el resultado de esta operación se comprobará si no falsa, así que tenga cuidado al usarlo con posibles falsos valores / NaN:

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

La siguiente tabla muestra algunos valores y tipos básicos con el resultado de los operadores de tipo. Las celdas verdes se evaluarán como verdaderas, las rojas y las falsas causarán errores de compilación / tiempo de ejecución.

Arrays mecanografiados

Desafortunadamente, ActionScript 3 no tiene un concepto de genéricos, por lo que se deduce que no hay manera de definir una matriz tipada como Array<T> . Sin embargo, hay un Vector.<T> clase especial Vector.<T> que funciona de manera similar, excepto que debe proporcionar una referencia a una clase concreta al crear una instancia del vector. Esto significa que no hay forma de crear abstracciones sobre el tipo Vector.<T> (por ejemplo, extenderlo y agregar una nueva funcionalidad), lo que es un gran inconveniente.

Una forma más simple de verlo es como si cada clase que definiera tuviera automáticamente una clase complementaria llamada Vector.<NameOfYourClass> .

Dicho esto, todavía hay enormes ventajas para el tipo Vector.<T> sobre una matriz convencional:

• Hay un aumento en el rendimiento cuando se trabaja con Vector.<T> vs arrays ¹ .
• Recibirá TypeError tipo compilación si intenta insertar valores que no sean T en la colección.
• Los IDE proporcionan información de sugerencias de tipo útil para los objetos dentro de una instancia de Vector.<T> .

Ejemplos de crear un Vector.<T> :

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

^{1 Los} vectores en realidad solo brindan mejoras notables en el rendimiento sobre las matrices cuando se trabaja con tipos primitivos ( String , int , uint , Number , etc.).