Módulo 1 – Indrodução ao Action Script 3.0

Introdução

O ActionScript é a linguagem de programação das plataformas Adobe® Flash® Player e Adobe® AIR™. Sua execução é dada através da AVM (ActionScript Virtual Machine). Seu código em geral é compilado no formato bytecode por um compilador, que é incorporado aos arquivos SWF e executado pelo Flash Player ou pelo AIR.

Os compiladors podem ser encontrados nos editores proprietários da Adobe, tais como Flash Builder e Flash CS4, ou em qualquer outra IDE que utilize o Flex SDK.

Como o ActionScript 3.0 foi criado sobre versões anteriores do ActionScript, achei interessante fazer primeiramente uma análise de como o modelo de objeto da linguagem evoluiu.

Histórico do ActionScript

O ActionScript começou como um mecanismo de script simples, com comandos como play e stop, para versões anteriores da ferramenta de autoria conhecida hoje como Flash.

Com a popularização da plataforma no início do século, programadores começaram utilizar todo o potencial da linguagem, criando aplicativos cada vez mais complexos para a internet, entre eles, os web games. Em resposta a esta demanda, as novas versões do player, traziam melhorias consideráveis na linguagem, que por sua vez  ficava mais robusta e amigável.

Action Script 1

A primeira versão da linguagem, que durou de 2000 à 2003, já apresentava algumas funcionalidades interessantes. O código a seguir cria uma classe denominada Shape e define uma propriedade denominada visible que, por padrão, é definida como true:

// base class
function Shape() {}
// Create a property named visible.
Shape.prototype.visible = true;

Essa função construtora define uma classe Shape que pode ser instanciada com o operador new da seguinte maneira:

myShape = new Shape();

E como funcionava a herança? Bom, tínhamos que usar de um pouco de imaginação. Seria algo assim:

// classe filha
function Circle(id, radius)
{
  this.id = id;
  this.radius = radius;
}

// Fazer de Circle uma subclasse de Shape.
Circle.prototype = new Shape();

Observe na figura abaixo a cadeia de protótipos utilizada por esta versão da linguagem:

A classe base no final de cada cadeia de protótipos é a classe Object. Ela contém uma propriedade estática denominada Object.prototype que aponta para o objeto de protótipo base de todos os objetos criados no ActionScript 1.0. O próximo objeto em nossa cadeia de protótipos de exemplo é o objeto Shape. Isso ocorre porque a propriedade Shape.prototype nunca foi definida explicitamente, portanto ela ainda mantém um objeto genérico (uma ocorrência da classe Object). O link final nessa cadeia é a classe Circle que está vinculada a seu protótipo, a classe Shape (a propriedade Circle.prototype mantém um objeto Shape).

Se criarmos uma ocorrência da classe Circle, como no exemplo, ela herdará a cadeia de protótipos da classe Shape:

// Criando uma instancia da classe Circle.
myCircle = new Circle();

Você recorda que linhas acima criamos uma propriedade denominada visible em Shape, correto? Mas eu posso dizer que neste nosso exemplo, a propriedade visible não existe como parte do objeto myCircle, apesar da linha seguinte do código produzir true:

trace(myCircle.visible); // output: true

Mas como isto ocorre? Não é tão complicado como pode parecer. O Flash Player pode verificar se o objeto myCircle herda a propriedade visible percorrendo a cadeia de protótipos.
Ao executar este código, o Flash Player primeiro analisa o objeto myCircle a procura da propriedade denominada visible, mas não encontra essa propriedade. Em seguida, o Flash Player verifica a propriedade Circle.prototype, mas ainda não encontra uma propriedade denominada visible. Continuando na cadeia de protótipos, o Flash Player finalmente encontra a propriedade visible definida no objeto Shape.prototype e fornece o valor daquela propriedade.

Obviamente, simplificamos aqui o funcionamento, pois nosso objetivo não seria analisar afundo o AS1, mas sim conhecer um pouco sobre a cadeia de protótipos que ajudará a compreender o modelo de objeto do ActionScript 3.0.

Action Script 2

O ActionScript 2.0 introduziu novas palavras-chave, como o Class, extends, public e private. Elas permitiram definir classes de uma maneira que seja familiar a qualquer pessoa que trabalhe com linguagens baseadas em classes como Java e C++. É importante compreender que o mecanismo da herança não foi alterado entre o ActionScript 1.0 e o ActionScript 2.0. A segunda versão simplesmente adicionou uma nova sintaxe para definir classes. A cadeia de protótipos funciona da mesma maneira nas duas versões da linguagem.

A nova sintaxe introduzida pelo ActionScript 2.0, mostrada no trecho a seguir, permite definir classes de uma maneira que é considerada intuitiva por muitos programadores:

// base class
class Shape
{
 var visible:Boolean = true;
}

Observe que o ActionScript 2.0 também introduziu verificação de tipos em tempo de compilação. Isso permite declarar que a propriedade visible, no exemplo anterior, deve conter apenas um valor Boolean. A nova palavra-chave extends também simplifica o processo de criação de uma subclasse. Analise o exemplo a seguir:

// Classe Filha
class Circle extends Shape
{
 var id:Number;
 var radius:Number;
 function Circle(id, radius)
 {
   this.id = id;
   this.radius = radius;
 }
}

O construtor está agora declarado como parte da definição da classe e as propriedades de classes, id e radius, também devem ser declaradas explicitamente.

O ActionScript 2.0 também adicionou suporte para a definição de interfaces, o que permite refinar ainda mais os programas orientados a objetos.

Action Script 3

ActionScript 3 é atualmente a linguagem base para os programas Flash CS, Flex e Adobe AIR. Esta é a versão mais significativa desde ActionScript 1.0. Seu core possui os seguintes objetivos:

• Aumento de performance de 10x até 100x mais rápido;
• Consistência (organização,  API´s,  comportamentos, etc);
• Segue o padrão ECMAScript 4, DOM 3.

Uma nova máquina virtual foi elaborada para AS3, ela contempla a compilação Just in Time do ActionScript Byte Code (ABC) para o código nativo da máquina. Outras significativas adições como runtime types, errors, traits, etc. resultam em uma performance e uso de memória muito mais evoluído do que a AVM1. Estas melhorias causaram um incompatibilidade com conteúdos antigos, que agora quando lidos dentro da AVM2, são encapsulados, e podem ser acessados apenas via local Connection.

Abaixo algumas das maiores mudanças desta versão:

• Run time errors
• Estrutura de classes
• Mudanças e organização da API
• Modificadores de Acesso (comportamento private)
• Void / void
• Requisição de parâmetros
• Escopo e encapsulamento de métodos
• Display list
• Event  model
• Network / loading
• Garbage collection
• Classes Seladas

Bom, agora que já conhecemos o histórico da linguagem, no próximo módulo vamos conhecer como AS3 implementa a Orientação a Objetos.

Postado em Técnico