PARTE I

ActionScript 3.0 Apresentado

A Parte I coloca-o confortavelmente sentado no bistrô ActionScript 3.0, oferece-se para

pegar seu casaco e lhe dá uma cesta grátis de pães quentes do forno. Você terá drinks,
claro, e será presenteado com um menu que revela a variedade de ferramentas que pode
utilizar enquanto explora o ActionScript 3.0. Especiais incluem a ferramenta de criação
Flash e Flash Player 10, com uma incursão de Flex Buider 3. Você também verá editores
de script independentes.
Os primeiros capítulos tocam em alguns conceitos de ActionScript que serão explorados
mais profundamente nas Parte II, III e IV. Estes aperitivos pretendem abrir seu apetite.
Eles lhe darão uma visão geral das novas propriedades do ActionScript 3.0: o que o faz
ser mais fácil de usar e mais poderoso que seu predecessor; como se beneficiar de seus
avisos e mensagens de erro mais ricos; e como a nova linguagem pode melhorar seu
fluxo de trabalho, através da ajuda em organizá-lo.

Capítulo 1, Apresentando ActionScript 3.0

Capítulo 2, Descobrindo o que Você Precisa para Trabalhar com ActionScript 3.0

Capítulo 3, Observando as Mudanças em ActionScript 3.0

Capítulo 4, Explorando os Benefícios do Uso de ActionScript 3.0

teste.indd 1 24/03/2009 16:34:04

 CAPÍTULO I

Apresentando ActionScript 3.0

Se você persegue a perfeição, você geralmente alcança a excelência.

William Fowble

O termo “perfeito” é uma palavra poderosa. De um ponto de vista prático, representa

um estado que discutivelmente não pode ser atingido. Ei, isso é já um alívio! Este livro
não espera o impossível. Esta não é a versão impressa de um ofício “sabe-tudo” que
anseia por seu deslize. Você não irá ouvir nenhum puxão de orelhas ansioso nestas
páginas sobre a razão de não estar ainda atualizado ou, muito menos, ter dominado,
o ActionScript 3.0(sim, ainda que estivesse disponível no Flash CS3 Professional). Ao
invés disso, os próximos capítulos irão tomar como exemplo uma sábia observação de
William Fowble: “Se você persegue a perfeição, você geralmente alcança a excelência”.
Em outras palavras: não desanime! Vise o melhor e aproveite a viagem. ActionScript 3.0
– a versão atual de uma linguagem de programação para a Plataforma Adobe Flash – é
uma linguagem que, de fato, captura a excelência. Este livro é elaborado para explicar
um pouco o porquê de ser assim. Fazendo isso, nossa esperança é ajudar você a caçar a
perfeição, apresentando-lhe a organização melhorada, a sintaxe e os fluxos de trabalho
da nova linguagem. Capturar a excelência para todos nós é uma questão de prática e
vem, por isso, com o tempo.
Este livro irá apresentar a você os novos meios de pensar sobre a Plataforma Flash.
ActionScript 3.0 requer esses novos meios, porque a linguagem é, na verdade, estruturada
acerca deles. Essa é auma grande razãoparte de o porquê dpela qual a nova linguagem
apresentar melhorias significativas em relação às versões anteriores. Como seu precursor,
mas em uma maior escala, ActionScript 3.0 é baseado em uma especificação chamada
ECMAScript, a qual é um padrão proposto por um corpo de especialistas conhecido
como Ecma International. Este grupo é algo como a World Wide Web Consortium
(W3C), cuja responsabilidade inclui HTML, XML, CSS e outras linguagens de marcação
amplamente usadas. O benefício de tal padrão é que o ActionScript 3.0 não é apenas
uma linguagem arbitrária inventada para servir às necessidades de Adobe. ECMAScript
) 3

teste.indd 3 24/03/2009 16:34:05

 é uma especificação relativamente madura, já em sua terceira revisão. O grupo Ecma
International inclui autoridades, fontes influentes na indústria, como: Microsoft, Mozilla
Foundation e Adobe. Tal especificação é construída a partir do critério coletivo e de
sucesso desses diversos especialistas no campo. De todas as versões de ActionScript,
a versão corrente é a que chega mais perto da total adequação a essa especificação –
nesse ponto, chega mais perto até mesmo que a outra variante famosa de ECMAScript,
o JavaScript. Isso faz de ActionScript 3.0 um modelo das melhores práticas e
hábitos que você pode utilizar tanto em Flash CS4 Professional quanto em Flex
Builder 3. Em muitos casos, você pode até achar que tais práticas beneficiam
seu envolvimento com projetos existentes codificados em versões anteriores de
ActionScript. Claro que os detalhes sintáticos mudam, mas as realizações de
programação são primordialmente estrutura e propósito. São os conceitos e bons
hábitos que conduzem você.
De qualquer perspectiva, a relevante ActionScript Language Reference é sempre uma
mera tecla fora (a tecla F1). Mesmo assim, um novo conjunto de docs de Ajuda podem
ser desanimadores, especialmente se você já for bem-versado em ActionScript 2.0.
Felizmente, a documentação ActionScript 3.0 é tão útil quanto costumava ser, mesmo
parecendo diferente. O layout dos docs de Ajuda é organizado ainda em volta do layout
da linguagem em si – em volta das classes que definem os objetos que você utilizará
– e suas entradas de classe ainda resumem os aparatos utilizáveis de cada objeto: suas
características, as chamadas propriedades; as coisas que fazem, os chamados métodos; e
as coisas a que podem reagir, os chamados eventos. Na nova documentação, exemplos
de código são apresentados mais como classes próprias, que scripts de estrutura. Isso
requer que elas sejam testadas antes como arquivos simples de texto, de acordo com
o novo conceito de classe de documento que será descrito no Capítulo 6. Felizmente,
isso também significa que se pode testar tais classes em outros programas, como Flex
Builder. Este livro irá ajudá-lo a se familiarizar não apenas com a nova linguagem, mas
também com a documentação que a explica.
Mantenha sempre em mente que elevar a ActionScript 3.0 não é meramente aprender as
mais recentes sintaxes: é aprender a se tornar um programador melhor, mais eficiente.
Isso não significa mesmo desprezar ActionScript 2.0, contudo, muito tem mudado
desde sua apresentação em fins de 2003. Não é exagero dizer que muitos aspectos
da linguagem foram superados completamente. De fato, ActionScript 3.0 requer uma
máquina virtual, que vem a ser o módulo dentro do Flash Player que interpreta o
ActionScript compilado, inteiramente nova . Assim como o Flash Player 9, o tempo de
execução, que exibe filmes Flash, utiliza-se de duas máquinas virtuais: AVM1, por legado
de arquivos SWF baseado em ActionScript 1.0 e 2.0, e a nova AVM2, para ActionScript
3.0. Isso é uma novidade na história de Flash Player. Graças à nova máquina virtual,
ActionScript 3.0 é executado mais rápida e eficientemente por ordem de magnitude.
Esse é um bom presságio para um alvo desprezado da nova linguagem: facilitar um
grande alcance de mídia interativa e Rich Internet Applications (RIAs) — para fazer
isso simplesmente com melhor performance, e altamente compatível com padrões da

4 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 4 24/03/2009 16:34:05

 indústria. Como você pode imaginar, uma atualização dessa escala significa que você
terá de reformar alguns de seus hábitos correntes. Mas tenha paciência. Reformar não
significa necessariamente demolir e reconstruir. Como ActionScript tem amadurecido,
tem se movido consistentemente na direção que atualmente permanence. Novamente,
afiar suas habilidades sob a luz de ActionScript 3.0 irá ajudá-lo em seus projetos atuais
e também em legado de manutenção de projeto. Migração pode ser intimidadora, mas
muito dessa incerteza vem de tentar achar seu progresso. Uma vez que você dá os
primeiros passos, a cinética mantém você andando.
A seguir damos um olhada em alguns dos novos recursos

Examinando ActionScript 3.0, a Linguagem

A Seção 4 da norma de ECMAScript (http://www.ecma-international.org/publications/files/
ECMA-ST/Ecma-262.pdf) define uma importante faceta de qualquer linguagem que a
implemente. Tais linguagens “irão prover não apenas os objetos e outras facilidades
descritas nesta especificação, mas também certos objetos hospedeiros de ambientes
específicos, de quem o comportamento está além do alcance desta especificação.” Em
outras palavras, qualquer derivado de ECMAScript precisa de uma funcionalidade de
núcleo definida que a suporte em si mesma e que, também, proveja funcionalidade
específica adicional ao ambiente que a interpreta. Isso é exatamente o que ActionScript
3.0 faz, e seus ambientes hospedeiros incluem Flash Player para navegadores de Internet,
pretendidos por Websites com Flash ativado, tais como: http://YouTube.com; Flash Lite
para dispositivos, tais como videogames para celular; e Adobe Integrated Runtime (AIR)
para aplicações instaladas no disco rígido, tais como eBay Desktop (http://desktop.ebay.
com/).
A seguir um pequeno resumo de algumas atualizações de núcleo.

Exceções de Tempo de Execução (Runtime Exceptions)

Em ActionScript 2.0, muitos erros de tempo de execução ocorrem sem atrair atenção a
eles. No lado positivo – e há algo positivo muito fraco – isso significa que erros dessa
natureza ocorrem “graciosamente”. Em outras palavras, eles podem não fazer parar a
experiência de alguém com algo abrupto ou carregar nos jargões técnicos, tais como um
alerta ou uma caixa de diálogo. No lado negativo, isso também significa que tais erros
poderiam ter sido não expostos pelo desenvolvedor – até que reclamações começaram
a aparecer em que pessoas experienciavam reprodução lenta ou mesmo travamentos.
Tais erros podem ser difíceis de ser apontados e reparados pelos desenvolvedores,
precisamente porque são silenciosos.
ActionScript 3.0 permite, para uma variedade de exceções de tempo de execução, ser
tratada com um propósito. Isso inclui objetos Erro gerados tanto pelo ambiente de tempo
de execução, quanto, potencialmente, pelo programador. Em ActionScript 3.0, a classe Erro
é consideravelmente mais sólida que seu precurssor, e objetos Erro , sobmedida, podem ser

Examinando ActionScript 3.0, a Linguagem ) 5

teste.indd 5 24/03/2009 16:34:05

 construídos a partir dessa classe, assim como desejado, herdando e estendendo sua
funcionalidade para prover mensagens de erro altamente personalizadas. Exceções
podem prover arquivo-fonte e informação de número de linha, o que enriquece
grandemente a experiência de depuração, permitindo que desenvolvedores rastreiem
erros rapidamente.

Tipos de Tempo de Execução

ActionScript 2.0 apresentou a habilidade de tipagem forte de variáveis, parâmetros e valores
de retorno de função. Isso era, e ainda é, um meio opcional para deixar Flash saber exatamente
que tipo de dado uma variável particular, parâmetro ou valor de retorno poderia enfrentar.
Essa habilidade foi uma bênção para desenvolvedores em termos de depuração, porque
concedeu uma forma de exibir mensagens de erro em caso de tipagem mal combinada. Por
exemplo, se você estiver para realizar uma operação matemática em dois números fornecidos
pelo usuário, você poderá tomar tais números pelos campos de entrada de texto. Isso poderia
realmente fazê-los encadeados, o que significa que sua operação matemática daria resultados
inesperados (por exemplo, 1+2 se tornaria “12”, ao invés de 3). Ao tipar forte os parâmetros
da função que desempenhou a operação – em outras palavras, ao pretender especificamente
tipos variáveis com dois-pontos (:), então a tipagem – você pode se beneficiar de uma
mensagem de erro significativa no painel de Saída tal como o seguinte:
// ActionScript 2.0
var userVar1:String = inputField1.text;
var userVar2:String = inputField2.text;
function getSum(a:Number, b:Number):Number {
return a + b;
}
trace(getSum(userVar1, userVar2));
// Displays:
**Error** Scene=Scene 1, layer=Layer 1, frame=1:Line 8: Type
mismatch.
getSum(userVar1, userVar2);.
Uma tipagem mal combinada é um grande lembrete para utilizar algo como
parseInt()ou parseFloat()para converter os encadeamentos em valores
numéricos. Útil de fato, mas esse é apenas o primeiro passo em uma boa direção. Em
ActionScript 2.0, esse tipo de checagem de erro apenas ocorreu na hora da compilação.
Sob muitas circunstâncias – tais como dados de avaliação de fontes dinâmicas como
XML – o recurso não era “inteligente” o suficiente para capturar toda contingência. Em
ActionScript 3.0, é.

Classes Fechadas
Seguindo o mesmo estilo, como exceções do tempo de execução e tipos de tempo
de execução, ActionScript 3.0 estabelece o conceito de classes fechadas de uma forma
cuidadosa, mais formalizada que em ActionScript 2.0. Uma classe fechada é a que não

6 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 6 24/03/2009 16:34:06

 pode ter propriedades ou métodos designados a ela na hora da execução, tais como
String. Por padrão, classes em ActionScript 3.0 são fechadas, mas isso pode ser
burlado quando se escreve a sua própria classe.
var str:String = "" // Or: new String();
str.customProperty = "This generates a compiler error.";
// Displays: Access of possibly undefined property customProperty
// through a reference with static type String.

Em contraste, uma classe que realmente pode ter propriedades e métodos designados
à hora de execução é chamada dinâmica. Uma das classes dinâmicas mais familiares é
MovieClip, mas, se falarmos historicamente, muitos desenvolvedores de script de
estrutura não têm considerado clipes de filmes em termos de classe. O mesmo pode
ser dito de botões e campos de texto, porque se pode criar tais elementos com as
ferramentas de desenho de Flash (dos elementos ora mencionados, apenas clipes de
filmes são dinâmicos). Por codificadores de script de estrutura, clipes de filmes são
em geral vistos como simplesmente símbolos ou linhas de tempo, e estas últimas têm
sempre estado aptas a receber novas variáveis à hora de execução. É bem verdade. O
que está realmente ocorrendo, no entanto, é que as variáveis definidas em scripts de
quadro de teclas são, na realidade, propriedades dinâmicas de um objeto MovieClip;
as funções são realmente métodos dinâmicos. Declarar uma variável em um quadro de
teclas de uma linha do tempo principal ou em uma linha de tempo de clipe de filme é,
conceitualmente, o mesmo que no caso a seguir:

var mc:MovieClip = new MovieClip();

mc.customProperty = “Isso é perfeitamente aceitável.”;

Classes personalizadas em ActionScript 3.0 podem se comportar dessa forma também,

se, e apenas, forem declaradas como dotadas do atributo dynamic:
package {
public dynamic class CustomClass() {
// código de classe aqui
}

No papel, isso é como era em ActionScript 2.0, mas de fato, até classes não-dinâmicas
podem ser alteradas com a manipulação da propriedade Object.prototype (herdada
por todos objetos) ou pelo operador de matriz de acesso ([]). Programadores avançados
que utilizaram tal caminho no passado irão entender o que não funciona mais em
ActionScript 3.0 para classes fechadas.
// ActionScript 2.0
var str:String = “”;
str.customProperty = “Porta dos fundos secreta.”;
// Exibe: Não há propriedade com o nome ‘customProperty’.

str[“customProperty”] = “porta dos fundos secreta.”;

// Funciona muito bem em ActionScript 2.0, mas em 3.0 exibe:
não pode criar propriedade customProperty em String.

Examinando ActionScript 3.0, a Linguagem ) 7

teste.indd 7 24/03/2009 16:34:06

 Em ActionScript 3.0, classes não-dinâmicas realmente são o que mostram ser. Isso
resulta em uma checagem de tempo de compilação mais cuidadosa e melhora o uso
de memória, porque exemplos de classe podem agora ser garantidos para requerer não
mais que um montante pré-declarado de memória do sistema. This makes for stricter
compile-time checking and improves memory usage because class instances can now be
guaranteed to require no more than a pre-declared amount of system memory.

Encerramentos de Método
De todas as atualizações de ActionScript 3.0, não surpreende que desenvolvedores, não
obstante seu nível de habilidade, casualmente acharam uma em particular: encerramentos
de método. Por quê? Porque a apresentação de encerramentos de método muda o ponto
de vista, ou alcance, de métodos em ActionScript 3.0.
O objetivo se refere à área conceitual de um programa dentro do qual o código executa.
A disponibilidade de definições de código, tais como variáveis, funções, propriedades
e métodos, dependem do objetivo do código sendo executado. Por exemplo, se uma
variável é declarada em uma estrutura de linha de tempo, aquela variável pode ser
referida por qualquer outro código naquela estrutura, desde que o código apareça após a
declaração. Mesmo a função definida naquela estrutura pode referir à variável objetivada
na linha do tempo, pois escopos podem ser aninhados, e o fluxo do escopo se move de
fora para dentro: as definições da linha de tempo se tornam disponíveis à função.
// Uma variável declarada aqui ...
var favoriteCereal:String = “Star Crunchers!”;

// pode ser referido aqui ...

trace(favoriteCereal); // Exibe: Star Crunchers!

function myFunction():void {
// e aqui ...
trace(favoriteCereal); // Exibe: Star Crunchers!
}
myFunction();

Em contrapartida, uma variável declarada dentro da função pode apenas ser referida por
aquela função, porque o objetivo da função está confinado nela mesma.
function myFunction():void {
// Uma variável declarada aqui ...
var favoriteCereal:String = “Star Crunchers!”;

// pode apenas ser referida aqui ...

trace(favoriteCereal); // Displays: Star Crunchers!
}
myFunction();

// mas não no escopo externo ...

trace(favoriteCereal);
// Exibe:
**Error** Scene=Scene 1, layer=Layer 1, frame=1:Line 10:
Acesso de propriedade indefinida favoriteCereal.
8 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 8 24/03/2009 16:34:06

 Até agora, isso deveria ser familiar aos desenvolvedores de ActionScript 2.0. Como,
então, as coisas têm mudado? Considere alguns exemplos a seguir.
Em ActionScript 2.0, um clique em um botão pode ser manejado assim:

// ActionScript 2.0
myButton.onRelease = buttonHandler;
function buttonHandler():Void {
trace(this); // Exibe: _level0.myButton
// outro código de manejo de evento
}

Anterior a ActionScript 3.0, o objetivo da função exposta pertencia ao objeto myButton.

Nesse caso, o código do botão poderia convenientemente ser abreviado com o uso
da palavra-chave this (isto), a qual se auto-referenciava ao escopo corrente
(myButton). Em alguns casos, isso resultou em um modo acessível para atingir certos
objetivos. Por exemplo, repetir o laço em um objeto de Sound (Som) em ActionScript
2.0, seria o seguinte:

// ActionScript 2.0
var audio:Sound = new Sound();
audio.loadSound(“externalFile.mp3”, true);
audio.onSoundComplete = completeHandler;
function completeHandler():Void {
this.start();
}
Novamente, a função é do âmbito do objeto. Nesse caso, a expressão this.start()
importa para invocar o método Sound.start()no objeto audio. Ainda que
conveniente nesse tipo de situação, dificuldades aparecem quando o manejador do
evento precisa referir a objetos fora do âmbito da função, especialmente em classes sob
medida. Em larga escala, esse tema poderia ser tratado em ActionScript 2.0 com a classe
Delegate, a qual permite que você redirecione o objetivo como desejado:

// ActionScript 2.0
import mx.utils.Delegate;
var audio:Sound = new Sound();
audio.loadSound(“externalFile.mp3”, true);
audio.onSoundComplete = Delegate.create(this, completeHandler);
function completeHandler():Void {
audio.start();
}

O método Delegate.create()aceitou dois parâmetros: primeiro, o âmbito

desejado; segundo, a função ou método a executar naquele âmbito. Note que por
causa dessa mudança, a função invoca audio.start() diretamente. Nesse caso, a
palavra-chave this(isto) não mais se refere ao objeto audio, ao qual o listener

Examinando ActionScript 3.0, a Linguagem ) 9

teste.indd 9 24/03/2009 16:34:06

 estava atrelado, mas sim à estrutura de linha do tempo na qual o listener estava
definido.
Em ActionScript 3.0, encerramentos de método deixam uma função, ou método, recordar
onde estava definido. Em suma: você terá o melhor de dois mundos. No seguinte,
ActionScript 3.0, escrito em um quadro de teclas, a referência a this mostra que o
escopo pertence à linha de tempo principal − a estrutura na qual a função é definida,
mais que no objeto myButton. Nenhuma bagagem extra, como a classe Delegate, é
requisitada.
myButton.addEventListener(MouseEvent.CLICK, buttonHandler);
function buttonHandler(evt:MouseEvent):void {
trace(this); // Exibe: [object MainTimeline]
}
Para referir ao botão e não à estrutura, use a propriedade Event.target do parâmetro
que é passado automaticamente dentro da função pelo evento. Nesse fragmento, o
parâmetro é arbitrariamente nomeado evt:
myButton.addEventListener(MouseEvent.CLICK, buttonHandler);
function buttonHandler(evt:MouseEvent):void {
trace(evt.target); // Exibe: [object SimpleButton]
trace(evt.target.name); // Exibe: myButton
}

ECMAScript for XML (E4X)

Flash há muito suportou XML, mas o acréscimo da sintaxe ECMAScript for XML (E4X) é
um impulso significativo de produtividade. Como ActionScript, E4X é uma especificação
Ecma International, a qual proporciona um poderoso, ainda que conciso, conjunto de
construções de linguagem para recuperar e manipular dados de XML.
Em ActionScript 2.0, você pode certamente navegar por entre os nós de um documento
XML carregado, mas o esforço se torna progressivamente mais tedioso à medida que a
complexidade de XML aumenta. Em ActionScript 2.0, a classe XML provém um punhado
de propriedades necessárias para navegação, tais como firstChild, nextSibling,
lastChild e childNodes. Escolher a partir desses e admitir um documento XML,
já tendo sido carregado e analisado gramaticalmente em um objeto XML, nomeado
myXML. Você poderia selecionar o título da quinta faixa (“Octopus’s Garden”) do álbum
Abbey Road, dos Beatles, desta forma:
// ActionScript 2.0
myXML.firstChild.firstChild.firstChild.childNodes[4].
attributes.¬
title;

// Conteúdo do documento XML carregado

<?xml version=”1.0” encoding=”iso-8859-1”?>
<library>
<artist name=”The Beatles”>
<album name=”Abbey Road”>

10 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 10 24/03/2009 16:34:07

 <track title=”Come Together” />
<track title=”Something” />
<track title=”Maxwell’s Silver Hammer” />
<track title=”Oh! Darling” />
<track title=”Octopus’s Garden” />
<track title=”I Want You (She’s So Heavy)” />
<track title=”Here Comes the Sun” />
<track title=”Because” />
<track title=”You Never Give Me Your Money” />
<track title=”Sun King” />
<track title=”Mean Mr. Mustard” />
<track title=”Polythene Pam” />
<track title=”She Came in Through the Bathroom Window” />
<track title=”Golden Slumbers” />
<track title=”Carry That Weight” />
<track title=”The End” />
<track title=”Her Majesty” />
</album>
</artist>
</library>
Na enorme expressão anterior, myXML se refere ao documento XML analisado
gramaticalmente; as três menções de firstChild referem-se, respectivamente, aos nós
<library(biblioteca)>, <artist (artista)> e <album(disco)>; e
childNodes[4] refere-se ao nó da quinta <track(faixa)> (guarde na memória,
childNodes retorna uma matriz, e matrizes começam em zero). Finalmente, a
propriedade attributes(atributos) leva ao atributo title(título) do nó
selecionado.
E4X deixa analisado XML ser referido como se fosse um objeto nativo. Este deixa você
atravessar os dados arregados inacreditavelmente mais intuitivamente. No equivalente
ActionScript 3.0, a mesma faixa pode ser referida desta forma:
// ActionScript 3.0
myXML.artist[0].album[0].track[4].@title;
ou, graças ao operador accessor descendente (..), até algo tão curto quanto isto:

myXML..track[4].@title;
Qual você preferiria digitar?
Além disso, você pode comparar dados num conjunto familiar de operadores. Por
exemplo, se o documento XML à mão contém vários artistas gravados, o nó The Beatles’
<artist> poderia ser singularizado tão facilmente quanto isto:
myXML.artist.(@name == “The Beatles”)

A especificação E4X está disponível em formato Adobe PDF no website

Ecma International: http://www.ecma-international.org/publications/files/
ECMA-ST/Ecma-357.pdf.

Examinando ActionScript 3.0, a Linguagem ) 11

teste.indd 11 24/03/2009 16:34:07

 Expressões Regulares (Regular Expressions)
A terminologia expressões regulares se refere a um conjunto de constructos especializados
de linguagem para recuperar dados de séries (isto é, conteúdo textual), e manipular
tais dados. A esse respeito, expressões regulares (geralmente abreviadas como regex)
partilham várias semelhanças com E4X: ambos mecanismos são compactos e eficientes
em suas tarefas. A sintaxe de regex tende a ser inicialmente mais difícil de compreender
que E4X − aqui, letras normais e pontuação são usadas para representar conjuntos
inteiros de caracteres, em acréscimo às regras de filtragem − mas os resultados valem o
esforço.
O que se pode fazer com regex? Como resposta, consideremos dois métodos familiares
da classe String, indexOf() e lastIndexOf(), os quais tem estado disponíveis em
ActionScript por anos. Tais métodos aceitam ambos parâmetros: primeiro, uma série
para procurar dentro de uma armazenador de série; segundo, opcionalmente, onde
começar a procurar dentro do armazenador. Cada método toma seu ponto de partida de
fins opostos do armazenador de série.

var pangram:String = “A raposa marrom, rápida, pula sobre o cão

preguiçoso.”;

trace(pangram.indexOf(“o”)); // Exibe 13
trace(pangram.indexOf(“o”, 14)); // Exibe 18
trace(pangram.lastIndexOf(“o”)); // Exibe 40

Na primeira declaração trace(), apenas um parâmetro é fornecido, “o”, e o valor

de retorno é 13, porque a letra “o” faz sua primeira aparição no index 13 (começando
com 0, o décimo terceiro caracter na série pangram). Na segunda declaração, o valor
de retorno é 18 por causa do segundo parâmetro opcional 14, o qual instrui o método
a começar depois do index do primeiro “o”. Na terceira declaração, o valor de retorno é
40, porque o método lastIndexOf() começa sua busca pelo fim da série.
Para buscas simples, indexOf() e lastIndexOf() servem, mas o que fazer
se a requisição for “encontre todos os CEPs dos EUA,” os quais podem ser qualquer
combinação de 5 números, ou “ache todas as palavras neste parágrafo que contenham
três ou mais vogais”? Repentinamente, a tarefa parece consideravelmente mais difícil,
se não impossível. Acredite ou não, a classe RegExp em ActionScript 3.0 maneja essa
requisição muito facilmente. A solução requer um padrão de caracteres especializados,
expressos como um objeto da classe RegExp ou passados como parâmetro para um
dos métodos relacionados a regex da classe String (match(), replace(), ou
search()).
Dada uma variável, paragraph (parágrafo), para definir o conteúdo do texto do
parágrafo anterior, o seguinte código mostra como recuperar as palavras com três ou
mais vogais:

var re:RegExp = /\b(\w*[aeiou]\w*){3}\b/gi;

var result:Object = re.exec(paragraph);

12 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 12 24/03/2009 16:34:07

 while (result != null) {
trace(result[0]);
result = re.exec(paragraph);
}
// Exibe: buscas, indexOf, lastIndexOf, requisição,
// alguma coisa, e outras palavras com três ou mais vogais
Uma discussão inteira de sintaxe de regex está além do objetivo deste livro, mas aqui
vai uma visão geral de como o exemplo anterior funciona. Uma variável, re, está
programada para uma objeto da classe RegExp por meio do operador delimitador
RegExp (/pattern/flags). Entre as duas diagonais desse operador, o padrão \b(\
w*[aeiou]\w*){3}\b soletra a requisição de busca. Depois da segunda diagonal,
as sinalizações (gi) configuram o padrão como global e indiferente ao caso. O método
RegExp.exec() executa o padrão na série paragraph(parágrafo) e devolve um
objeto (result)(Resultado), que contém informação sobre a busca. A busca é repetida
até o result ser null(nulo).
Se o exemplo precedente parece bizarro, imagine o mesmo tipo de poder aplicado à
validação da entrada de usuário. Você pode gerenciar até requisições potencialmente
complexas sem muita dificuldade. Essas incluem buscas como, “Este endereço de email
está corretamente formado?” (Checar o character “@” não é suficiente!). “Esté é um
número de telefone válido?” (Pessoas poderiam inserir qualquer coisa desde (123) 456-
7890 até 123.456.46789 a 123456789). “O usuário terá tentado espiar uma palavra
imprópria usando uma escrita esdrúxula?” Padrões que combinem com estas requisições
não apenas encontram as séries em questão, mas podem também manipulá-las de modo
a, por exemplo, formatar números de telefone consistentemente, ou substituir palavras
questionáveis com Xs.

Para um exaustivo e altamente respeitado tratado em regex, leia Mastering

Regular Expressions, de Jeffrey Friedl. Diversos tutoriais estão também
disponíveis online no website http://www.regular-expressions.info/.

Namespaces
Em cenários avançados de programação, o conceito de namespaces traz um valioso
mecanismo novo a ActionScript 3.0. Em suma, namespaces são essencialmente
especificadores de acesso sob medida − como public (público), private
(privado), protected (protegido) e internal (interno)− exceto
com nomes que você escolher. Namespaces permitem que você controle a visibilidade
de suas propriedades e métodos até o ponto de desprezar estruturas de pacotes de
programas. Eles também permitem que você qualifique membros sob vários estilos.
Como exemplo rápido, você poderia desenvolver um aplicativo AIR que desempenhe
um comportamento, enquanto uma conexão de Internet está presente, e outro quando
não houver conexão. Utilizando namespaces, você pode definir versões múltiplas do

Examinando ActionScript 3.0, a Linguagem ) 13

teste.indd 13 24/03/2009 16:34:08

 mesmo método que, por exemplo, cheque um inventário online quando a conexão WiFi
estiver disponível, mas as definições para uma versão em cache de outra maneira. Ou
você poderia definir uma série de variáveis em diversas línguas, em que o valor de uma
variável depende das definições regionais. Tais distinções são determinadas por prefixos
sob medida e pelo operador qualificado de nome (::):

// Três versões da mesma variável String

english::newFeatures // Valor de “Lots of new stuff”
german::newFeatures // Valor de “Viele neue Sachen”
french::newFeatures // Valor de “Plien de nouvelles choses”

Namespaces são equipados com um Universal Resource Identifier (URI) − Identificador

de Recursos Universal. Para evitar conflito, também são usadas para representar
namespaces XML, quando trabalha com E4X.

Novos Tipos Primitivos

ActionScript 3.0 apresenta dois novos tipos primitivos, int e uint, trazendo a lista
inteira com Boolean, int, Null, Number, String, uint e void(nulo) (note
a diferença da maiúscula de Void). Esses novos tipos numéricos reduzem o uso de
memória de casos em que um valor numérico precisa apenas ser um inteiro. Como?
O familiar dado tipo Number é um IEEE-754, número de precisão-dupla e ponto
flutuante, o qual, graças à sua estrutura, sempre requer 64 bits de memória. Objetos
Number abarcam de 1.79e+308 (1.79 com mais de 300 zeros depois!) até 5e-324. É
uma extensão inimaginavelmente larga, a qual não é sempre necessária. Algumas vezes
você apenas quer contar através de um laço for, e tudo que se precisa é de um número
inteiro.
Insira int, o qual é um número relativamente pequeno de 32-bit (apenas 4 bytes), do
qual a extensão é ainda um impressionante 2.147.483.647 (mais de dois bilhões) até
-2.147.483.648. Essa extensão deveria resolver a maioria dos laços for que você irá
encontrar por acaso. Em contraste, números uint (inteiros sem sinal) tem extensão de 0
a 4.294.967.295, o qual é da mesma distância que int, mas totalmente no lado positivo
da linha de números. Se seu contador de laços for, ou qualquer outro valor inteiro,
precisar de uma extensão maior que a oferecida pela int, uint é uma boa escolha —
fornecendo a extensão que não mergulha abaixo de zero. Nenhum tipo jamais requer
mais que 32 bits de memória do sistema.

Uma nota de atenção: porque os valores uint são sempre positivos, preste
atenção quando tentar subtrair um uint em território negativo. Um uint
vai por volta de 4.294.967.295, se você subtrair passando de zero, como o
código seguinte demonstra.
var n:uint = 0;
trace(n); // Exibe 0

n--;
trace(n); // Exibe 4294967295

14 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 14 24/03/2009 16:34:08

 Explorando Atualizações Flash Player API
Na seção deste capítulo “ActionScript 3.0, a Linguagem”, você aprendeu que a
especificação ECMAScript, na qual ActionScript é baseado, realmente espera que a
linguagem para provenha funcionalidade feita sob medida para a plataforma que o
hospeda. Em caso de ActionScript, hospedeiros incluem Flash Player, AIR e Flash Lite
— todos vários sabores da Plataforma Flash. Apesar de cada hospedeiro ser designado
para encontrar necessidades específicas — websites, aplicativos da área de trabalho e
conteúdo móvel, respectivamente— a superposição é considerável. ActionScript 3.0
institui uma reestruturação significante de sua application programming interface
(API) — interface de programa de aplicação —, resumida facilmente em uma tabela de
migração colossal e disponível no site Adobe LiveDocs website (http://help.adobe.com/
en_US/AS3LCR/Flash_10.0/migration.html) e também no painel de Ajuda, nos apêndices
de ActionScript 3.0 Language and Component Reference, sob o cabeçalho “ActionScript
2.0 Migration”. Em grande parte, a funcionalidade existente tem sido reestruturada em
pacotes de programas que fazem mais sentido de um ponto de vista organizacional. De
qualquer modo, Flash muda sua filosofia um número de mudanças de filosofia na forma
em que traz suas tarefas fundamentais. Os parágrafos seguintes listam algumas das mais
notáveis atualizações.

Até o momento da publicação deste livro, Flash Lite ainda não suporta
ActionScript 3.0, devido ao processador próprio e limitações de memória
de dispositivos móveis. As funções detalhadas aqui se aplicam a Flash
Player 9 (e superior) e AIR, mas não se aplicam a Flash Lite até que o
tempo de execução acrescente suporte para ActionScript 3.0.

Evento Modelo DOM3

Before ActionScript 3.0, you could handle events in Flash in at least five different ways,
some of which were interchangeable:
• O legado controlador on(), disponível desde Flash 2 e ainda em largo uso, mesmo em
cenários ActionScript 2.0, mas acabou em ActionScript 3.0.
• O legado controlador onClipEvent(), também amplamente usado e indisponível em
ActionScript 3.0.
• A sintaxe da notação ponto, que combinou e substituiu on() e onClipevent() (por
exemplo Button.onPress = functionDefinition, MovieClip.onEnterFrame,
e assim por diante).
• O método addListener() de muitas— mas não todas! — classes ActionScript 2.0, tais
como TextField, Mouse e MovieClipLoader.
• O método addEventListener() usado pelo conjunto de componentes v2 (interface de
usuário, dados e componentes de mídia).

Explorando Atualizações Flash Player API ) 15

teste.indd 15 24/03/2009 16:34:09

 A seleção variada foi um resultado dos melhoramentos com incremento a ActionScript
com toda nova versão da ferramenta de criação, com os antigos modos conservados para
retrocompatibilidade. Por muito tempo, para os desenvolvedores Flash, cada técnica
nova era simplesmente um pequeno acréscimo ao fluxo de trabalho, mas novatos das
versões mais novas, tais como Flash 8 ou Flash CS3, ficaram compreensivelmente
confusos com um API com tantas possibilidades aparentemente arbitrárias.

on() e onClipEvent()são tão ruins? De um ponto de vista de fluxo

de trabalho, não. De uma perspectiva prática, eles não são valiosos como
seu substituto em notação de ponto. In ActionScript 2.0, a combinação
de on() e onClipEvent() fornece acesso apenas a um pouco mais
da metade dos eventos disponíveis para clipes de filmes e botões. Além
disso, você não pode delimitar, manipular ou remover seus controladores
de evento na hora da execução. Sua ausência em ActionScript 3.0 marca o
fim de um longo período de transição de ActionScript 1.0 para 2.0.

Pelo fato de ActionScript 3.0 confiar em uma nova máquina virtual, é garantido que
se faça uma ruptura limpa no modo em que manipula eventos. Com uma pequena
exceção (discutida no Capítulo 4), o controle de evento agora está consolidado, através
da placa, em um modo simples e consistente: o método EventDispatcher.
addEventListener(). Este mecanismo é baseado no W3C’s Document Object
Model (DOM) Level 3 Events Specification — Modelo de Objeto de Documento Nível 3
Especificação de Eventos — (http://www.w3.org/TR/DOM-Level-3-Events/). Isso significa
que em ActionScript 3.0, a sintaxe de controle de eventos é a mesma em quase todos os
casos, não importando se o executor de evento é um botão, um clipe de áudio ou um
objeto carregador para arquivos XML ou JPEG. A estrutura básica se parece com isto:

eventDispatchingObject.addEventListener(
EventType,
functionToPerform
);

Lista de Exibição API

Em ActionScript 3.0, clipes de filmes podem ser instantiados com a palavra-chave new
(novo) tão facilmente como a seguir:

var mc:MovieClip = new MovieClip();

o que é mais intuitivo que tomava em ActionScript 2.0:

var mc:MovieClip = existingMovieClip.createEmptyMovieClip(¬
instanceName, depth);
E melhor: o gerenciamento de profundidade é agora automático. Atente que a
expressão new MovieClip()(novo clipe de filme) não requer um parâmetro de

16 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 16 24/03/2009 16:34:09

 profundidade. Essa mudança é devida a um novo modo fundamental de exibição
de objetos visuais em ActionScript 3.0: um conceito chamado lista de exibição, que
representa a exibição hierárquica de todos os objetos gráficos em Flash Player.
Esse conceito é incorporado na classe DisplayObjectContainer, a classe
básica para todos os objetos que servem como armazenadores visuais, incluindo
clipes de música, as novas classes Sprite e Loader, e mais. Graças à herança,
DisplayObjectContainer fornece novos métodos a essas classes por um
controle considerável sobre o gerenciamento do objeto ordem-z. Por exemplo,
enquanto a classe MovieClip em ActionScript 2.0 aperfeiçoou getDepth() e
swapDepths(), a versão ActionScript 3.0 oferece todos estes:

• addChild()
• addChildAt()
• contains()
• getChildAt()
• getChildByName()
• getChildIndex()
• removeChild()
• removeChildAt()
• setChildIndex()
• swapChildren()
• swapChildtenAt()

Como é isso para controle?

Esses métodos também estão disponíveis para Sprite, o qual é efetivamente um clipe
de filmes sem o auxílio de uma linha do tempo; Loader, que carrega arquivos externos
SWF e arquivos de imagem (JPEG, PNG, or GIF) na hora de execução; e qualquer outra
classe no tronco DisplayObjectContainer.
Sob o sistema de lista de exibição, objetos podem ser re-originados a qualquer hora. Tal
habilidade simplifica casos nos quais grupos de objetos que precisam ser manipulados
de uma só vez. Considere um jogo de quebra-cabeças, por exemplo. Se você desejar
combinar áreas parcialmente resolvidas, as partes montadas movem-se como uma
unidade, você pode simplesmente retirar a peça de sua origem corrente e adicioná-
la, como produto, à origem que representa o grupo parcialmente resolvido. Antes de
ActionScript 3.0, tal ação teria requerido a área de registro individual sofisticada de cada
peça de quebra-cabeça.

Explorando Atualizações Flash Player API ) 17

teste.indd 17 24/03/2009 16:34:09

 Novos Sons APIs
Flash Player 8 foi o primeiro a suportar 32 canais de som simultâneos, um aumento
significativo do limite de canal de oito sons. Ainda que presentes pelo tempo que
Flash Player suportou o som, esses canais, como tais, não tiveram representação clara
em código antes de ActionScript 3.0. Em versões anteriores da linguagem, a classe
Sound foi auto-armazenada, controlando toda a sua funcionalidade de uma maneira
relativamente simples, mas pelo preço de alguma clareza de propósito. Por exemplo,
de modo a controlar o volume e seguimento de um som distintamente de outro, você
teria de associar cada som com seu próprio clipe de filme. Você fazia essa associação
por meio de um parâmetro “alvo” opcional na função construtora Sound. Porque alvo
de clipes de filme poderia, ou não, conter outro conteúdo, suas funções ambíguas são
potencialmente confusas.
ActionScript 3.0 clarifica o som programado com a complementação da classe Sound
com três companheiros: SoundChannel, SoundTransform e SoundMixer. Esses
novos APIs dão a você um controle mais explícito sobre sons importados e embutidos.
O método SoundMixer.computeSpectrum() permite que você recobre dados
espectrais de sons, os quais você pode usar para programar respostas para mudanças de
nível e volume de áudio.

Dados Binários e Soquetes

A nova classe ByteArray autoriza interoperabilidade com protocolos existentes
sob medida e permite que desenvolvedores avançados leiam, escrevam e manipulem
dados no nível do byte. Isso tem levado programadores aventureiros a cultivar projetos
anteriormente desatendidos em Flash, tais como o codificador Tinic Uro’s PNG (http://
www.kaourantin.net/2005/10/png-encoder-in-as3.html, agora atualizado e aperfeiçoado
na bilioteca as3corelib em http://code.google.com/p/as3corelib/), e um gerador de sinal
dinâmico de André Michelle e Joa Ebert, capaz de executar arquivos afins a MIDI Amiga
MOD (http://8bitboy.popforge.de/).

Reconhecendo Players e Suporte

Ainda que este livro enfoque primordialmente a ferramenta de criação Flash, é importante
compreender que Adobe oferece dois compiladores oficiais ActionScript 3.0. Um desses
compiladores é construído dentro do próprio Flash CS4. Como se poderia esperar, esse
leva em consideração objetos na Biblioteca de documento, bem como configurações do
arquivo global SWF, tais como cor de fundo e padrão de estrutura, como configurado no
inspetor de Propriedade, podendo também compilar versões anteriores de ActionScript.
Separado daquilo, há o compilador de linha de comando, incluído com o Flex Software
Development Kit (SDK), gratuito disponível em: www.adobe.com/go/flex_trial/. Esse
segundo compilador é usado pelo integrated development environment (IDE) ― ambiente
de desenvolvimento integrado — Flex Builder, o qual não inclui ferramentas de design,

18 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 18 24/03/2009 16:34:10

 linhas do tempo ou uma biblioteca. Além disso em ActionScript 3.0, o compilador Flex
reconhece MXML, a linguagem de marcação declarativa usada para dar organização aos
aplicativos Flex. Pelo desejo de uma biblioteca, o segundo compilador deixa recursos
de metadados inseridos em arquivos SWF resultantes. A ferramenta de criação Flash
suporta apenas metadados limitados, um recurso não-documentado na hora da escrita.
Esses compiladores distintos servem a fluxos de trabalho independentes. Para facilitar
o desenvolvimento de RIAs, Flex SDK mostra uma estrutura elaborada de manejadores
de controle de usuário e dados que não estão disponíveis na ferramenta de criação
Flash, mesmo que a estrutura seja escrita em ActionScript 3.0. Por comparação, Flash
oferece um subconjunto modesto em seu painel de Componentes, incluindo suporte à
reprodução e manipulação de arquivos de vídeo Flash (FLV).
No final, há apenas um ActionScript 3.0, que se comporta da mesma forma quando
compilado sob outra ferramenta. A razão para tal consistência é que ambos, Flash CS4
e Flex SDK, publicam arquivos SWF para o mesmo Flash Player 9 ou superior. É bem
possível — e muitas vezes feito — criar classes personalizadas que possam ser usadas
em qualquer circunstância. O conceito de classe de documento (vide Capítulo 6),
apresentado em Flash CS3, significa que todo um aplicativo, composto por numerosas
classes externas, pode ser compilado por compilador de linha de comandos Flash ou
Flex (incluindo Flex Builder) de idênticos arquivos de origem.
Por causa de ActionScript 3.0 requerer AVM2, como já mencionado neste capítulo,
Flash Player 9 é o mínimo de tempo de execução requerido para exibir tal conteúdo.
Flash Player 9 roda em numerosos sistemas operacionais, incluindo diversas versões
de Windows, Macintosh, Linux e Solaris. Devido à natureza variada desses sistemas
operacionais, e concertos de defeitos ocasionais necessários para cada um, além dos
novos recursos surgidos, Flash Player 9 inclui alguns pontos secundários de versões,
como resumido na Tabela 1-1. Definições de saída de Flash CS4 estão apontadas em Flash
Player 10, o qual pode também, eventualmente, ver uma lista de pontos secundários
de versão. O tempo dirá. Para determinar que versão de Flash Player o usuário tem
instalada, refira a propriedade de versão estática da classe de Capacidades.

Tabela 1-1. Pontos secundários de versões Flash Player 9

Versão
Flash Player Mudanças notáveis

9.0.16.0 ActionScript 3.0, inclindo exceções de tempo de execução e comando de erros, classes
fechadas, fechamento de métodos, ECMAScript para XML (E4X), regex, namespaces,
novos tipos primitivos, evento modelo DOM3, lista de exibição APIs, novo som APIs e
dados binários e soquetes.

9.0.20.0 Reparos de defeito e otimização relacionados à plataforma Macintosh baseada em

Intel.

9.0.28.0 Suporte para sistema operacional Windows Vista. Acréscimo de constante de eventos
ADDED_TO_STAGE e REMOVED_FROM_STAGE, para deixar um monitor
DisplayObject, e saber quando pode, ou não, acessar sua propriedade stage.
Aumentos de segurança.

Capítulo 1: Introdução ao Oracle ) 19

teste.indd 19 24/03/2009 16:34:10

 Versão
Flash Player Mudanças notáveis

9.0.31.0 Suporte para sistema operacional Linux.

9.0.45.0 Reparo de defeitos e melhorias para Adobe Flash CS3 Professional. Afeta apenas
plataformas Windows e Macintosh.

9.0.47.0 Suporte para sistema operacional Solaris. Aumentos de segurança.

9.0.48.0 Aumentos de segurança Linux.

9.0.115.0 Vídeo H.264 e High Efficiency AAC (HE-AAC) suporte de codificador de áudio.
Aceleração de Hardware, conversão de hardware, decodificação de vídeo de exibição
múltitpla e conversão de imagem realçada. O cache Flash Player ativa componentes
comuns, tais como Flex Framework, para ser armazenado localmente e, então, usado
por qualquer SWF de qualquer domínio. O armazenamento Flash Media Server
mantém fluxo de armazenamento, enquanto um fluxo é pausado.

9.0.124.0 Correção de segurança contínua de mídia e atualização de exibição secundária para

Windows Vista.

Uma lista completa com todas as notas de versão de Flash Player, incluindo
correção de defeitos, pode ser encontrada em: http://www.adobe.com/support/
documentation/en/flashplayer/releasenotes.html.

Dominando ActionScript 3.0 Seguindo 2.0

Finja, por um momento, ser um carpinteiro. Por anos, você esteve fazendo sua peça
com uma furadeira manual, mas então a Macromedia Hardware Company apresenta
um modelo elétrico chamado ActionScript 1.0 estampado com letras de ouro no cabo.
Belíssimo! Não há razão para usar outra coisa. Claro, você poderia operar a furadeira
apenas dentro de cinco palmos de uma tomada elétrica (pois é o comprimento do
fio), mas as vantagens eram retumbantemente claras. E mais, você poderia carregar
consigo uma extensão. Alguns anos depois, Macromedia anuncia um novo e melhorado
modelo: ActionScript 2.0. Essa furadeira tem uma bateria opcional. Para alguns, o novo
carregador de bateria foi um presente de Deus, pois os libertaria da anterior limitação
de sete palmos. Eles abraçaram o novo recurso e, literalmente, se viram correndo com
ele. Outros carpinteiros acharam que o carregador de bateria era avançado demais. Não
estavam certos, por exemplo, se eram supostos a terminar a bateria totalmente antes de
recarregar. E, honestamente, isso era bom: a furadeira ainda tem um fio, claro, então
eles continuaram dentro da zona de conforto prévia, o que era ainda uma melhoria
considerável sobre a época da furadeira manual. Os carpinteiros eram um bando feliz.
Eventualmente, a Macromedia Hardware Company se tornou Adobe. Todos ansiavam
pela nova furadeira — ActionScript 3.0 — e quando chegou… eles acharam que o fio foi
substituído por uma estação de atracamento. Repentinamente, carpinteiros que optaram
por não usar o carregador de bateria ActionScript 2.0, sentiram-se em uma cilada. Eles

20 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 20 24/03/2009 16:34:10

 não tinham experiência com baterias, mas se fossem usar o modelo ActionScript 3.0,
não teriam escolha.
Contando que toda analogia tem suas falhas, certamente, as mudanças em ActionScript
3.0 referem-se a algo mais que o óbvio benefício de um carregador de bateria. Claramente,
os novos APIs são mais complexos que a questão de como recarregar um conjunto de
baterias. De qualquer forma, ActionScript faz bem mais que buracos! Mesmo assim,
pode ser útil pensar em ActionScript 2.0 como um período de transição entre, por
um lado, as raízes da linguagem — que é ActionScript 1.0 e até antes — e, por outro
lado, a versão corrente. Como com nossa história de carpinteiro, numerosos recursos
em ActionScript 2.0, tais como tipagem estrita (:Number, :Void etc.) e arquivos
de classes formalizadas personalizadas, eram opcionais. (Diferente da analogia, aqueles
recursos particulares são ainda opcionais em ActionScript 3.0). Voluntários eram, tais
como então novas convenções foram, um convite cedo a praticar um fluxo de trabalhos
mais eficiente. Desenvolvedores que optaram experimentar o object-oriented
programming (OOP) — programação orientada a objetos —, ao ponto de escrever suas
próprias classes personalizadas, podem se sentir mais confortáveis com ActionScript 3.0
que outros. Para aqueles que estavam perfeitamente confortáveis com as convenções
de ActionScript 1.0, eles poderiam, compreensivelmente, sentir a trepidação da luz na
versão atual, especialmente agora que ActionScript 3.0 suspendeu o suporte para alguns
recursos opcionais prévios, tais como, on() e onClipEvent(). Correr as páginas de
ActionScript 3.0 Language and Components Reference leva mais tempo que antes. Tudo
foi organizado em uma nova e assombrosa hierarquia de pacotes. A maior parte do
código de exemplo do painel de Ajuda foi escrito como arquivos de classe, para fazê-
lo aplicável tanto para o quadro de teclas, quanto para programadores de arquivos de
classe.
Tais diferenças são grandes, mas não intransponíveis. Um dos propósitos orientadores
deste livro é ajudar você a se sentir atingido o alvo, tendo você perseguido, ou não, as
novas convenções opcionais de ActionScript 2.0 — recursos que, de alguma forma,
foram uma boa elevação em relação às melhores práticas recomendadas hoje. Uma coisa
importante para se manter em mente é que ActionScript 3.0 é escalável em termos de
complexidade. Se você deseja mergulhar de cabeça em princípios OOP, tais como padrões
de herança e elaboração, ActionScript 3.0 irá obrigar. Se você prefere permanecer com a
codificação tradicional de linha do tempo, ActionScript 3.0 irá forçá-lo — com algumas
ressalvas que serão exploradas nos próximos capítulos.

Decidindo Migrar ou Escrever um Código do Início

Se você trabalha com um conjunto de templates (modelos) caseiros, sejam eles aquivos
FLA, classes personalizadas ou a combinação de ambos, cedo ou tarde você terá de decidir
como atualizá-los. Por causa de discussão, esses arquivos são estáveis que fizeram o
capital de sua companhia por anos, e funcionou muito bem. Apesar disso, você gostaria
de tirar vantagem do aumento de velocidade — ou qualquer um dos outros benefícios

Decidindo Migrar ou Escrever um Código do Início ) 21

teste.indd 21 24/03/2009 16:34:10

 ― assegurados por ActionScript 3.0. Você deveria esmeradamente remendar os arquivos
existentes, adaptando como você vai, ou deveria livrar-se de tudo e começar do início?
Para o bem ou para o mal, não há um caminho certo que determine qual empenho é mais
vantajoso em uma situação dada. Enquanto você pode teoricamente atualizar FLA file’s
Publish Settings — Configurações de Publicação de arquivo FLA —, para ActionScript
3.0, e compilar sem erros ou advertências, a prospecção se torna progressivamente mais
improvável quando o projeto ganha em complexidade. As chances são altas de que uma
incompatibilidade irá ocorrer em combinação com várias; em outras palavras: quando
algo dá errado, tudo dá errado. Tendo isso dito, aqui há alguns pensamentos para você
considerar.
Se todos, ou a maior parte, de seus códigos existem em estruturas em um arquivo FLA,
você pode não ter uma escolha real se não migrar ActionScript no lugar, pela razão óbvia
de que o código é tão justamente atrelado à elaboração visual do arquivo. Começar
do zero poderia requerer transporte cuidadoso de símbolos de um arquivo FLA para
outro, possivelmente incluindo embutimentos intricados, efeitos de linha do tempo.
Para simples anúncios em banner e apresentações em slides lineares, uma atualização
pode não ser tão difícil quanto parece. Autonomia fala para stop(), gotoAndPlay()
e tudo o mais, irá carregar tudo sem uma mancada. Para todos os meios, selecione File
(Arquivo)→Publish Settings (Configurações de Publicação)→Flash→Script→ActionSc
ript 3.0, então, prenda sua respiração e veja o que acontece.
Não deixe de desabafar se a compilação funcionar, e francamente, se prepare agora para
numerosas entradas no painel de Compiler Errors (Erros de Compilador). Se algum dos
códigos de estrutura envolver controladores de evento, carregue recursos externos ou
mesmo solicite uma página da web nova (getURL() é agora navigateToURL()), você
vai ter que atualizá-lo. A boa notícia é: o painel de Compiler Errors é uma das muitas
novas ferramentas úteis em Flash CS4 (apresentado em Flash CS3). Esse painel não diz
a você onde o código errôneo está, por arquivo de classe, cena, nível, quadro de teclas e
número de linha, incluindo uma lista com tema comum de migração.

O painel de Compiler Errors e outras ferramentas de depuração são

examinados no Capítulo 11.

Se a maior parte desse código existe em classes velhas, seu projeto provavelmente
envolveria mais do que falar bobagens de ActionScript. Ainda que a probabilidade
signifique que você passará mais tempo em migração de código (pois há mais disso!),
o fato de seu código estar separado significa que você pode testar e revisar cada classe
individualmente. Em ambos os casos, este livro lhe ajudará a tomar seu rumo.

22 ) Capítulo 1: Apresentando ActionScript 3.0

teste.indd 22 24/03/2009 16:34:11