Casting e verificação de tipos foram, desde sempre, conceitos centrais a qualquer linguagem de programação, especialmente nas linguagens orientadas a objectos como é o caso do Actionscript.

De facto, conhecer que tipo de objecto estamos a receber como parâmetro ou a capacidade de o "tranformar" noutro tipo de forma a poder passá-lo para chamadas a métodos e atribuí-lo a propriedades de objectos são a chave para um dos conceitos mais importantes da programação orientada a objectos: O Polimorfismo

De acordo com este princípio, qualquer classe que estenda de uma determinada linha de herança (herança de classes ou implementação de interfaces) pode ser utilizada em substituição de qualquer um das suas classes ascendentes. Isto resulta do facto das classes descendentes possuirem precisamente o mesmo interface de programação que as super-classes (implicitamente através dos mecanismos de herança de classes ou através da implementação obrigatória de métodos definidos em interfaces).

O Casting automático

Por vez o casting de tipos ocorre automaticamente. Por exemplo, se atribuirmos a uma propriedade definida como sendo do tipo Object, um objecto do tipo DisplayObject (que é um descendente de Object), este vai ser automaticamente convertido para Object. Por outras palavras, sempre que se utilizar um descendente em vez de um dos seus ascendentes, o objecto é automaticamente convertido para o tipo do ascendente em questão.

Isto, no entanto, não quer dizer que o objecto deixa de ser do tipo original descendente. Apenas que, naquela referência específica como propriedade de uma classe ou argumento de um método, é identificada como sendo do tipo do seu ascendente. E mantém esse tipo sempre que for referenciada através dessa propriedade ou parâmetro.

Isto equivale a dizer que o que determina o tipo de um objecto a ser acedido não é o que foi utilizado na criação dessa instância, mas o tipo com que foi identificada a propriedade ou variável usada para o aceder.

O Casting explícito

Uma vez que a instância do objecto não perde o tipo com que foi criada quando é feito o cast para uma classe ascendente, ela pode ser utilizada sempre que uma classe desse tipo é necessária. É aqui que as coisas começam a ficar interessantes: Se atribuirmos a uma propriedade de um determinado tipo usando uma instância de uma classe desse mesmo tipo mas guardada numa propriedade definida com um tipo ascendente, o compilador do Flash vai queixar-se de incompatibilidades de tipos.

Para se poder fazer isto é necessário fazer o cast da instância para o tipo descendente. Fazer este cast de volta para um tipo que nós já sabemos ser o de uma determinada instância parece ser redundante e pouco lógico, mas se nos lembrarmos que o que determina o tipo não é a instância em si, mas a variável através da qual estamos a aceder, começa a fazer sentido.

Em Actionscript podem ser utilizados duas técnicas distintas para se fazer casting e uma para se fazer verificação de tipos. Para o casting pode-se utilizar a operação de casting ou o operador as.

A operação de cast

Realizar um cast recorrendo a esta técnica é bastante simples. Basta envolver expressão cujo resultado é um determinado objecto com parêntesis e precedê-la com o nome da classe para a qual se quer fazer o cast.

 
var variavelDestino:DisplayObject = DisplayObject(expressao);

O operador as

Usar o operador as é igualmente simples. Basta colocar o operador entre a expressão e o nome da classe:

 
var variavelDestino:DisplayObject = expressao as DisplayObject;

Se o cast está apenas a ser feito para aceder a uma determinada propriedade ou método do objecto, pode-se, mesmo assim, utilizar o operador as:

 
(expressao as DisplayObject).alpha = 0;

No entanto, neste caso particular, recomendo a utilização da operação de cast em vez do operador por razões que explicarei mais adiante.

 
DisplayObject(expressao).alpha = 0;

Quando se está a fazer o casting é preciso ter em mente que o mesmo pode falhar devido a uma série de razões que estão fora do âmbito deste artigo. É, no entanto, importante não partir do princípio que um cast é sempre bem sucedido e preparar o código para o caso do mesmo falhar.

Diferenças entre a operação de cast e o operador as

Tanto a operação de cast como o operador as, quando executados com sucesso, têm o mesmo resultado, ou seja, devolvem uma referência para a instância alvo como sendo do tipo da classe para a qual está a ser feito o cast.

De facto, os dois apenas divergem no modo como tratam os erros de casting. Assim, a operação de cast lança um erro em tempo de execução do tipo TypeError quando falha o cast, enquanto que o operador as retorna o valor null na mesma situação.

Quando usar um ou o outro?

Se existe certeza plena de que o cast vai ter sucesso, ou se está disposto a envolver cada cast com expressões try catch, ou então não se importa que a aplicação lance erros de tempo de execução a torto e a direito, então pode-se utilizar a operação de cast sem problemas de maior.

Se, por outro lado, prefere poder lidar com os erros de casting de forma elegante sem ter que recorrer ao uso de expressões try catch, deve utilizar o operador as.

Pessoalmente, tendo a favorecer o operador as, na medida em que torna o código mais legível (a operação de cast pode ser confundida com a utilização de construtores de classes e com operações de conversão de tipos) e está mais de acordo com a sintaxe do operador is utilizado para a verificação de tipos que apresentarei de seguida.

A única altura em que prefiro utilizar a operação de cast é quando estou a fazê-lo apenas para aceder a métodos ou propriedades de uma instância que, de outro modo, estariam inacessíveis. Isto deve-se ao facto do operador as devolver um valor null quando o cast falha e a tentativa de aceder a um método ou propriedade de um valor deste tipo resulta num erro de tempo de execução do tipo de referência para null em vez de um erro de tipo. Como boa prática é preferível fazer com que os erros lançados pela aplicação sejam o mais próximos do erro real que ocorreu, sob pena de se perder tempo nas tentativas de o encontrar em sítios errados.

A verificação de tipos

A verificação de tipos pode muito simplesmente ser realizada utilizando o operador is da mesma maneira que o operador as

var teste:Boolean = expressão is DisplayObject;

O operador is devolve um Booleano com a indicação se a instância é uma extensão da classe ou de uma das suas ascendentes ou uma implementação de um determinado interface.

Próximos passos

Seria interessante verificar se existem impactos na performance e consumo de memória quando se utiliza qualquer uma destas técnicas e qual seria a melhor forma de conseguir extrair toda a performance do código escrito.