A verificação de tipos em tempo de compilação é mais vantajosa em projetos grandes porque, conforme o tamanho de um projeto aumenta, a flexibilidade do tipo de dados se torna menos importante do que a rápida detecção de erros de tipo. É por isso que, por padrão, o compilador do ActionScript no Flash Professional e no Flash Builder é definido para ser executado no modo restrito.

Para fornecer a verificação de tipos em tempo de compilação, o compilador precisa conhecer as informações de tipo de dados para as variáveis ou expressões no seu código. Para declarar explicitamente um tipo de dados para uma variável, adicione o operador dois-pontos (:) seguido do tipo de dados como um sufixo para o nome da variável. Para associar um tipo de dados a um parâmetro, use o operador dois-pontos seguido do tipo de dados. Por exemplo, o seguinte código adiciona informações de tipo de dados ao parâmetro xParam e declara uma variável myParam com um tipo de dados explícito:

function runtimeTest(xParam:String) 
{ 
    trace(xParam); 
} 
var myParam:String = "hello"; 
runtimeTest(myParam);

No modo estrito, o compilador do ActionScript relata incompatibilidades de tipos como erros do compilador. Por exemplo, o código a seguir declara um parâmetro de função xParam, do tipo Object, mas depois tenta atribuir valores do tipo String e Number ao parâmetro. Isso gera um erro do compilador no modo estrito.

function dynamicTest(xParam:Object) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; // compiler error in strict mode 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; // compiler error in strict mode 
        trace("Number: " + myNum); 
    } 
}

Mesmo no modo estrito, porém, é possível optar seletivamente pela verificação de tipos em tempo de compilação deixando o lado direito de uma instrução de atribuição sem tipos. Você pode marcar uma variável ou expressão como sem tipo omitindo uma anotação de tipo ou usando a anotação de tipo especial de asterisco (*). Por exemplo, se o parâmetro xParam no exemplo anterior for modificado de forma que não tenha mais uma anotação de tipo, o código é compilado no modo estrito:

function dynamicTest(xParam) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; 
        trace("Number: " + myNum); 
    } 
} 
dynamicTest(100) 
dynamicTest("one hundred");

A verificação de tipos em tempo de execução ocorrerá no ActionScript 3.0 se você compilar em modo restrito ou em modo de padrão. Considere uma situação em que o valor 3 é transmitido como um argumento para uma função que espera uma matriz. No modo estrito, o compilador irá gerar um erro, porque o valor 3 não é compatível com o tipo de dados Array. Se você desabilitar o modo estrito e executar no modo padrão, o compilador não reclamará sobre incompatibilidade de tipos, mas a verificação em tempo de execução resulta em um erro em tempo de execução.

O exemplo a seguir mostra uma função chamada typeTest() que espera um argumento Array mas tem um valor transmitido de 3. Isso gera um erro em tempo de execução no modo padrão, porque o valor 3 não é um membro do tipo de dados (Array) declarado do parâmetro.

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum:Number = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0 standard mode

Também pode haver situações em que há um erro de tipo em tempo de execução mesmo durante a operação no modo estrito. Isso é possível se você usar o modo estrito, mas optar pela verificação de tipos em tempo de compilação, usando uma variável sem tipo. O uso de uma variável sem tipo não elimina a verificação de tipos, mas a suspende até o tempo de execução. Por exemplo, se a variável myNum do exemplo anterior não tiver um tipo de dados declarado, o compilador não pode detectar a incompatibilidade de tipos, mas o código vai gerar um erro de tempo de execução porque compara o valor do tempo de execução de myNum, que está definido como 3 como resultado da instrução de atribuição, com o tipo de xParam, que é definido com o tipo de dados Array.

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0

A verificação de tipos em tempo de execução também permite um uso mais flexível de herança que a verificação em tempo de compilação. Com a suspensão da verificação de tipos para o tempo de execução, o modo padrão permite referenciar as propriedades de uma subclasse mesmo que você a eleve. Uma elevação ocorrerá quando você usar uma classe base para declarar o tipo de uma ocorrência de classe, mas usar uma subclasse para instanciá-la. Por exemplo, você pode criar uma classe chamada ClassBase que pode ser estendida (classes com o atributo final não podem ser estendidas):

class ClassBase 
{ 
}

Depois, você pode criar uma subclasse de uma ClassBase chamada ClassExtender, que tem uma propriedade chamada someString, como a seguir:

class ClassExtender extends ClassBase 
{ 
    var someString:String; 
}

Usando as duas classes, é possível criar uma ocorrência de classe que é declarada usando o tipo de dados ClassBase, mas instanciada usando o construtor ClassExtender. Uma elevação é considerada uma operação segura, porque a classe base não contém nenhuma propriedade ou método que não esteja na subclasse.

var myClass:ClassBase = new ClassExtender();

Uma subclasse, porém, contém propriedades ou métodos que sua classe base não contém. Por exemplo, a classe ClassExtender contém a propriedade someString, que não existe na classe ClassBase. No modo padrão do ActionScript 3.0, é possível referenciar essa propriedade usando a ocorrência myClass sem gerar um erro de tempo de compilação, como mostra o seguinte exemplo:

var myClass:ClassBase = new ClassExtender(); 
myClass.someString = "hello"; 
// no error in ActionScript 3.0 standard mode

O operador is permite testar se uma variável ou expressão é um membro de um determinado tipo de dados. Nas versões anteriores do ActionScript, o operador instanceof fornecia essa funcionalidade, mas, no ActionScript 3.0, o operador instanceof não deve ser usado para testar a associação de tipo de dados. O operador is deve ser usado no lugar do operador instanceof para verificação de tipos manual, porque a expressão x instanceof y apenas verifica a existência de x na cadeia de protótipos y (e, no ActionScript 3.0, a cadeia de protótipos não fornece um retrato completo da hierarquia de herança).

O operador is examina a hierarquia de herança apropriada e pode ser usado para verificar não apenas se um objeto é uma ocorrência de uma classe específica, mas também de uma classe que implementa uma determinada interface. O exemplo a seguir cria uma ocorrência da classe Sprite, chamada mySprite e usa o operador is para testar se mySprite é uma ocorrência das classes Sprite e DisplayObject e se implementa a interface IEventDispatcher:

var mySprite:Sprite = new Sprite(); 
trace(mySprite is Sprite); // true 
trace(mySprite is DisplayObject);// true 
trace(mySprite is IEventDispatcher); // true

O operador is verifica a hierarquia de herança e relata adequadamente que mySprite é compatível com as classes Sprite e DisplayObject (a classe Sprite é uma subclasse da classe DisplayObject). O operador is também verifica se mySprite é herdada de alguma classe que implementa a interface IEventDispatcher. Como a classe Sprite é herdada da classe EventDispatcher, que implementa a interface IEventDispatcher, o operador is relata corretamente que mySprite implementa a mesma interface.

O exemplo a seguir mostra os mesmos testes do exemplo anterior, mas com instanceof em vez do operador is. O operador instanceof identificará corretamente que mySprite é uma ocorrência de Sprite ou DisplayObject, mas retornará false quando usado para testar se mySprite implementa a interface IEventDispatcher.

trace(mySprite instanceof Sprite); // true 
trace(mySprite instanceof DisplayObject);// true 
trace(mySprite instanceof IEventDispatcher); // false

O operador as também permite verificar se uma expressão é um membro de um determinado tipo de dados. Diferentemente do operador is, porém, o operador as não retorna um valor booleano. Em vez disso, o operador as retorna o valor da expressão em vez de true e null em vez de false. O exemplo a seguir mostra os resultados do uso do operador as em vez de is no caso simples de verificar se uma ocorrência de Sprite é um membro dos tipos de dados DisplayObject, IEventDispatcher e Number.

var mySprite:Sprite = new Sprite(); 
trace(mySprite as Sprite);                 // [object Sprite] 
trace(mySprite as DisplayObject);                 // [object Sprite] 
trace(mySprite as IEventDispatcher);                 // [object Sprite] 
trace(mySprite as Number);                                       // null

Durante o uso do operador as, o operando à direita deve ser um tipo de dados. Uma tentativa de usar uma expressão diferente de um tipo de dados como operando à direita resultará em um erro.

O tipo de dados Boolean inclui dois valores: true e false. Nenhum outro valor é válido para variáveis do tipo Boolean. O valor padrão de uma variável Boolean que foi declarada mas não inicializada é false.

O tipo de dados int é armazenado internamente como um inteiro de 32 bits e inclui o conjunto de inteiros de

-2.147.483.648 (-2³¹) a 2.147.483.647 (2³¹ - 1), inclusive. As versões anteriores do ActionScript ofereciam apenas o tipo de dados Number, que era usado para números inteiros e de ponto flutuante. No ActionScript 3.0, agora você tem acesso a tipos de computador de nível baixo para inteiros de 32 bits assinados e não assinados. Se a sua variável não tiver números de ponto flutuante, o uso do tipo de dados int em vez do tipo de dados Number é mais rápido e eficiente.

Para valores inteiros fora do intervalo dos valores int mínimo e máximo, use o tipo de dados Number, que pode manipular valores entre positivo e negativo 9.007.199.254.740.992 (valores inteiros de 53 bits). O valor padrão para variáveis do tipo de dados int é 0.

O tipo de dados Null contém apenas um valor, null. É o valor padrão para o tipo de dados String e todas as classes que definem tipos de dados complexos, inclusive a classe Object. Nenhum outro tipo de dados primitivo, como Boolean, Number, int e uint, contém o valor null. No tempo de execução, o valor null é convertido para o valor padrão apropriado se tentar atribuir null às variáveis do tipo Boolean, Number, int ou uint. Você não pode usar esse tipo de dados como uma anotação de tipo.

No ActionScript 3.0, o tipo de dados Number pode representar inteiros, inteiros não assinados e números de ponto flutuante. Entretanto, para maximizar o desempenho, você deve usar o tipo de dados Number somente para valores inteiros maiores do que os tipos int e uintde 32 bits podem armazenar ou para números de ponto flutuante. Para armazenar um número de ponto flutuante, inclua um ponto decimal no número. Se você omitir um ponto decimal, o número é armazenado como um inteiro.

O tipo de dados Number usa o formato de precisão dupla de 64 bits conforme especificado pelo Padrão IEEE para Aritmética de Ponto Flutuante Binário (IEEE-754). Esse padrão determina como os números de ponto flutuante são armazenados usando os 64 bits disponíveis. Um bit é usado para designar se o número é positivo ou negativo. Onze bits são usados para o expoente, que é armazenado como base 2. Os 52 bits restantes são usados para armazenar o significando (também chamado de mantissa), que é o número elevado à potência indicada pelo expoente.

Com o uso de alguns bits para armazenar um expoente, o tipo de dados Number pode armazenar números de ponto flutuante significativamente maiores do que se usasse todos os bits para o significando. Por exemplo, se o tipo de dados Number usasse os 64 bits para armazenar o significando, ele armazenaria um número tão grande quanto 2⁶⁵ - 1. Com o uso de 11 bits para armazenar um expoente, o tipo de dados Number pode elevar seu significando à potência de 2¹⁰²³.

Os valores máximo e mínimo que o tipo Number pode representar são armazenados em propriedades estáticas da classe Number chamadas Number.MAX_VALUE e Number.MIN_VALUE.

Number.MAX_VALUE == 1.79769313486231e+308 
Number.MIN_VALUE == 4.940656458412467e-324

Embora esse intervalo de números seja enorme, seu custo é a precisão. O tipo de dados Number usa 52 bits para armazenar o significando, por isso os números que exigem mais de 52 bits para fazer uma representação precisa, como a fração 1/3, são apenas aproximações. Se o seu aplicativo exibir precisão absoluta com números decimais, será necessário usar um software que implemente a aritmética de ponto flutuante decimal em vez da aritmética de ponto flutuante binário.

Durante o armazenamento de valore inteiros com o tipo de dados Number, somente os 52 bits do significando são usados. O tipo de dados Number usa esses 52 bits e um bit oculto especial para representar inteiros de -9.007.199.254.740.992 (-2⁵³) a 9.007.199.254.740.992 (2⁵³).

O valor NaN é usado não apenas como o valor padrão para variáveis do tipo Number, mas também como resultado de qualquer operação que deve retornar um número e não retorna. Por exemplo, se você tentar calcular a raiz quadrada de um número negativo, o resultado é NaN. Outros valores Number especiais incluem infinito positivo e infinito negativo.

O tipo de dados String representa uma seqüência de caracteres de 16 bits. Os Strings são armazenados internamente como caracteres Unicode, usando o formato UTF-16, Eles são valores imutáveis, assim como na linguagem de programação Java. Uma operação sobre um valor String retorna uma nova ocorrência da seqüência de caracteres. O valor padrão para uma variável declarada com o tipo de dados String é null. O valor null não é igual ao string vazio (""). O valor null significa que a variável não tem valor armazenado nela, enquanto a sequência vazia de caracteres indica que a variável tem um valor que é um String que não contém caracteres.

O tipo de dados int é armazenado internamente como um inteiro não assinado de 32 bits e inclui o conjunto de inteiros de 0 a 4.294.967.295 (2³² - 1), inclusive. Use o tipo de dados uint para circunstâncias especiais que exigem inteiros não negativos. Por exemplo, você deve usar o tipo de dados uint para representar os valores de cor de pixel, porque o tipo de dados int tem um bit de sinal interno que não é apropriado para manipular valores de cor. Para valores inteiros maiores do que o valor uint máximo, use o tipo de dados Number, que pode manipular valores inteiros de 53 bits. O valor padrão para variáveis do tipo de dados uint é 0.

O tipo de dados void contém apenas um valor, undefined. Nas versões anteriores do ActionScript, undefined era o valor padrão para ocorrências da classe Object. No ActionScript 3.0, o valor padrão para ocorrências de Object é null. Se você tentar atribuir um valor undefined a uma ocorrência da classe Object, o valor é convertido para null. É possível atribuir apenas um valor de undefined a variáveis sem tipo. Variáveis sem tipo são aquelas que não possuem nenhuma anotação de tipo ou usam o símbolo asterisco (*) para a anotação de tipo. Você pode usar void apenas como uma anotação de tipo de retorno.

O tipo de dados Object é definido pela classe Object. A classe Object serve de classe base para todas as definições de classe no ActionScript. A versão do ActionScript 3.0 do tipo de dados Object difere das versões anteriores de três formas. Primeiro, o tipo de dados Object não é mais o tipo de dados padrão atribuído a variáveis sem nenhuma anotação de tipo. Em segundo lugar, o tipo de dados Object não inclui mais o valor undefined, que costumava ser o valor padrão das ocorrências Object. Em terceiro lugar, no ActionScript 3.0, o valor padrão para ocorrências da classe Object é null.

Nas versões anteriores do ActionScript, uma variável sem nenhuma anotação de tipo era automaticamente atribuída ao tipo de dados Object. Isso não acontece mais no ActionScript 3.0, que agora inclui a idéia de uma variável realmente sem tipo. As variáveis sem nenhuma anotação de tipo agora são consideradas sem tipo. Se preferir deixar mais claro para os leitores do código que sua intenção é deixar uma variável sem tipo, você pode usar o símbolo de asterisco (*) para a anotação de tipo, que é equivalente a omitir uma anotação de tipo. O exemplo a seguir mostra duas instruções equivalentes, que declaram uma variável sem tipo x:

var x 
var x:*

Somente variáveis sem tipo podem manter o valor undefined. Se você tentar atribuir o valor undefined a uma variável que possui um tipo de dados, o tempo de execução converte o valor undefined no valor padrão desse tipo de dados. Para as ocorrências do tipo de dados Object, o valor padrão é null, que significa que, se você tentar atribuir undefined a uma ocorrência de Object, o valor é convertido para null.