Вы находитесь на странице: 1из 78

TCNICO/A DE

MULTIMDIA
0142 Action Script
- Manual de formao -

Projeto financiado por:

Regibio

uma

empresa

de

consultoria n 3377,

formao ainda

profissional, acreditada pela Direco Geral do Emprego e das Relaes do Trabalho, processo possui certificao e homologao por parte do Instituto de Emprego e Formao Profissional, Ministrio da Agricultura Direco Regional de Agricultura e do Instituto da Mobilidade e dos Transportes Terrestres. A sua equipa de profissionais conta com mais de uma dcada de experiencia no desenvolvimento, organizao e gesto de sistemas de formao. Em 2006, a convite do Instituto para a Qualidade da Formao (IQF), fez parte do grupo de empresas piloto, que testou, o ento, novo modelo de acreditao (que ainda vigora). membro da Associao Nacional das Entidades Formadoras, ocupando um

QUEM SOMOS

lugar de Direco. Apoiando-se num crescimento sustentado, desenvolve as suas actividades em todo o espao Nacional, com maior incidncia na Regio Norte e Centro, tendo actualmente delegaes em Bragana, Porto e Oliveira do Hospital. misso da Regibio cumprir com rigor os contratos assumidos, excedendo as expectativas dos seus clientes, valorizando os seus colaboradores e contribuindo para a aquisio e consolidao de competncias dos seus formandos, atravs da apresentao de projectos de formao, nas suas vertentes de formao co-financiada e no financiada, intervindo em todos os momentos do processo formativo. Na sua actuao, a Regibio disponibiliza recursos humanos e fsicos que sustentam a organizao, execuo e gesto de aces de formao profissional, numa ptica de prestao de servios tcnicos, logsticos e administrativos. Promove ainda a adopo de comunicao. solues de racionalizao dos processos de trabalho, suportados em sistemas e tecnologias de informao e

FICHA TCNICA
Ttulo: MANUAL DE FORMAO UFCD 0142 Action Script

Domnio de Formao: TECNOLGICO

Curso: TCNICO/A DE MULTIMDIA

Edio: REGIBIO FORMAO E

CONSULTADORIA, LDA

Organizao de Contedos: Bruno Gomes da Costa

Verso: 2/2012

Action Script

ndice
1. Apresentao da linguagem Action Script............................................................................. 5 1.1. Editores de cdigo Action Script .......................................................................................... 5 1.1.1. Adobe Flash .............................................................................................................................. 5 1.1.2. Flex Builder............................................................................................................................... 6 1.1.3. Outros editores ....................................................................................................................... 6 2. A linguagem e sintaxe do Action Script................................................................................... 8 2.1. Variveis e constantes ............................................................................................................... 8 2.2. Tipos de dados ............................................................................................................................10 2.3. Trabalho com objetos ..............................................................................................................11 2.4. Propriedades ...............................................................................................................................12 2.5. Mtodos ..........................................................................................................................................13 2.6. Eventos ...........................................................................................................................................14 2.7. Tratamento de eventos bsico ............................................................................................14 2.8. Exame do processo de tratamento de eventos............................................................16 2.9. Exemplos de tratamento de eventos ................................................................................17 3. Criar ocorrncias de objetos ......................................................................................................18 3.1. Operadores ...................................................................................................................................20 3.2. Comentrios .................................................................................................................................20 3.3. Controle do fluxo .......................................................................................................................21 4. Classes e objectos ............................................................................................................................22 4.1. Escrita do cdigo para uma classe.....................................................................................26 4.2. Criao do seu aplicativo do ActionScript .....................................................................28 4.3. Criao do projeto HelloWorld e da classe Greeter ..................................................28 4.4. Adio de cdigo classe Greeter .....................................................................................29 4.5. Criao de um aplicativo que usa o cdigo do ActionScript .................................29 4.6. Publicao e teste do aplicativo do ActionScript........................................................30 4.7. Melhorias ao aplicativo HelloWorld .................................................................................31 5. Pacotes e namespaces ...................................................................................................................34 5.1. Criao de pacotes ....................................................................................................................36 5.2. Importao de pacotes ............................................................................................................37 5.3. Namespaces - Espaos para nomes ..................................................................................39 5.4. Definio de espaos para nomes ......................................................................................41 5.5. Aplicao de espaos para nomes .....................................................................................42 5.6. Referncia a espaos para nomes ......................................................................................43 5.7. Uso de espaos para nomes ..................................................................................................44 6. Variveis e tipos de dados ...........................................................................................................47 6.1. Noes bsicas sobre o escopo de variveis ................................................................49 6.2. Valores padro ............................................................................................................................51 6.3. Tipos de dados ............................................................................................................................52 7. Verificao de tipos ........................................................................................................................53

Action Script

7.1. Verificao de tipos em tempo de compilao ............................................................53 7.2. Verificao de tipos em tempo de execuo .................................................................55 7.3. O operador is ...............................................................................................................................56 7.4. O operador as ..............................................................................................................................57 7.5. Classes dinmicas ......................................................................................................................58 8. Descries de tipos de dados .....................................................................................................59 8.1. Tipo de dados Boolean ............................................................................................................59 8.2. Tipo de dados int .......................................................................................................................59 8.3. Tipo de dados Null ....................................................................................................................60 8.4. Tipo de dados Number............................................................................................................60 8.5. Tipo de dados String ................................................................................................................61 8.6. Tipo de dados uint.....................................................................................................................62 8.7. Tipo de dados void ....................................................................................................................62 8.8. Tipo de dados Object ...............................................................................................................62 8.9. Converses de tipo ....................................................................................................................63 8.10. Converses implcitas..............................................................................................................63 8.11. Converses explcitas ..............................................................................................................64 8.12. Projeco para int, uint e Number .....................................................................................64 8.13. Projeco para String...............................................................................................................67 9. Sintaxe...................................................................................................................................................68 9.1. Diferenciao entre maisculas e minsculas .............................................................68 9.2. Sintaxe de pontos ......................................................................................................................68 9.3. Sintaxe de barras .......................................................................................................................69 9.4. Literais ............................................................................................................................................69 9.5. Ponto-e-vrgula ...........................................................................................................................70 9.6. Parnteses .....................................................................................................................................71 9.7. Comentrios .................................................................................................................................71 9.8. Palavras-chave e palavras reservadas.............................................................................72 9.9. Constantes .....................................................................................................................................73 10. Estruturas de controlo de deciso...........................................................................................74 10.1. if..else ...............................................................................................................................................74 10.2. if..else if ...........................................................................................................................................74 10.3. Switch ..............................................................................................................................................75 11. Estruturas de controlo de repetio ......................................................................................75 11.1. For .................................................................................................................. 76 11.2. for..in .............................................................................................................. 76 11.3. for each..in ...................................................................................................... 77 11.4. while ............................................................................................................... 78

Action Script

1. Apresentao da linguagem Action Script


A linguagem Action Script uma linguagem orientada por objetos utilizada principalmente na criao de RIAs Rich Internet Application. As RIAs so aplicaes executadas num browser e proporcionam uma interface grfica multimdia ao utilizador semelhante a que estes podem utilizar em aplicaes executadas em sistemas operativos cliente. A linguagem Action Script, desenvolvida pela Macromelia, hoje uma linguagem proprietria da Adobe baseada no standard ECMAScript. ECMAScript uma linguagem de programao baseada em scripts, padronizada pela Ecma International na especificao ECMA-262. A linguagem Action Script, atualmente na sua terceira verso, executada em uma mquina virtual (AVM - "Action Script Virtual Machine"), contida no plug-in Flash que pode ser adicionado a qualquer browser. O Action Script 3.0 pode ser escrito e compilado de vrias formas, inclusive: Com o uso do ambiente de desenvolvimento do Adobe Flex Builder 3 Com o uso de qualquer editor de texto e um compilador de linha de comando, como aquele fornecido com o Flex Builder 3 Com o uso da ferramenta de autoria do Adobe Flash CS4 Professional

1.1. Editores de cdigo Action Script


Segue-se uma descrio detalhada dos editores e ferramentas onde pode ser utilizada a linguagem Action Script:

1.1.1.

Adobe Flash

Alm de seus recursos grficos e de criao de animaes, o Adobe Flash CS4 Professional inclui ferramentas para trabalhar com cdigos do Action Script, anexados a elementos em um arquivo FLA ou em arquivos externos, exclusivos do Action Script. A ferramenta de autoria do Flash ideal para projetos que envolvem grande quantidade de animao ou vdeo, ou quando voc deseja criar a maior parte dos ativos grficos sozinho, especialmente projetos com uma interao mnima do usurio ou funcionalidade que exija o Action Script. Outro motivo para escolher essa ferramenta ao desenvolver projetos do Action Script caso prefira criar ativos visuais e escrever cdigo no mesmo aplicativo. Voc

Action Script

tambm pode usar a autoria do Flash se quiser usar componentes da interface do usurio pr-criados, mas com um SWF menor ou uma atribuio de capa visual mais fcil so prioridades essenciais para seu projeto. O Adobe Flash CS4 Professional inclui duas ferramentas para escrever cdigos do Action Script: Painel Aes: disponvel para trabalhar em um arquivo FLA, este painel permite escrever cdigo do Action Script anexado a quadros em uma linha de tempo. Janela Script: a janela Script um editor de texto dedicado para trabalhar com arquivos de cdigo do Action Script.

1.1.2.

Flex Builder

O Adobe Flex Builder a principal ferramenta para criar projetos com a estrutura do Flex. Alm do layout visual e das ferramentas de edio de MXML, o Flex Builder tambm inclui um editor do Action Script, por isso ele pode ser usado para criar projetos do Flex ou somente Action Script. Os aplicativos do Flex possuem vrias vantagens, incluindo um rico conjunto de controlos pr-criados da interface do usurio, controles flexveis de layout dinmico e mecanismos embutidos para trabalhar com fontes de dados externas e vincular dados externos a elementos da interface do usurio. Entretanto, por causa do cdigo adicional necessrio para fornecer esses recursos, os aplicativos do Flex podem ter um arquivo SWF maior e no podem ser completamente encapados com tanta facilidade quanto seus equivalentes do Flash. Use o Flex Builder se estiver criando aplicativos da Internet avanados, orientados a dados e cheios de recursos com o Flex e quiser editar cdigo do Action Script, cdigo MXML e criar o layout do aplicativo visualmente, tudo com uma nica ferramenta.

1.1.3.

Outros editores

Como os arquivos do Action Script (.as) so armazenados como arquivos de texto simples, qualquer programa capaz de editar arquivos de texto sem formatao pode ser usado para escrever arquivos do Action Script. Alm dos produtos do Action Script da Adobe, foram criados diversos programas de edio de texto de terceiros com recursos especficos do Action Script.

Action Script

Voc pode escrever um arquivo MXML ou classes do Action Script usando qualquer programa de editor de texto. possvel, ento, criar um aplicativo SWF (um aplicativo do Flex ou somente Action Script) a partir desses arquivos usando o SDK do Flex, que inclui as classes de estrutura do Flex, alm do compilador do Flex. Opcionalmente, muitos desenvolvedores usam um editor do Action Script de terceiros para escrever classes do Action Script, junto com a ferramenta de autoria do Flash para criar contedo grfico. Voc pode optar por usar um editor do Action Script de terceiros se: Preferir escrever cdigo do Action Script em um programa separado junto com a criao de elementos visuais no Flash. Usar um aplicativo para programao que no seja do Action Script (como criao de pginas HTML ou de aplicativos em outra linguagem de programao) e quiser usar o mesmo aplicativo para o cdigo do Action Script tambm. Quiser criar projetos do Flex ou somente Action Script usando o SDK do Flex sem o Flash ou o Flex Builder. Exemplo de uma pequena aplicao em Action Script: 1 Selecione Arquivo> Novo. 2 Na caixa de dilogo Novo documento, selecione Documento Flash e clique em OK. Uma nova janela do Flash ser exibida. 3 Selecione Arquivo> Salvar. Selecione uma pasta que contenha o arquivo de classe Greeter.as, chame o documento Flash de HelloWorld.fla e clique em OK. 4 Na paleta Ferramentas do Flash, selecione a ferramenta Texto e arraste at o Palco para definir um novo campo de texto, com aproximadamente 300 pixels de largura e 100 de altura. 5 No painel Propriedades, com o campo de texto ainda selecionado no Palco, defina o tipo de texto como "Texto dinmico" e digite mainText como o nome de ocorrncia do campo de texto. 6 Clique no primeiro quadro da linha de tempo principal. 7 No painel Aes, digite o seguinte script:
var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello();

8 Salve o arquivo.

Action Script

2. A linguagem e sintaxe do Action Script


Em primeiro lugar, bom saber o que um programa de computador e o que ele faz. Um programa de computador consiste em dois aspetos principais: Ele uma srie de instrues ou etapas que o computador deve executar. Cada etapa envolve a manipulao de algumas informaes ou dados. Em termos gerais, um programa de computador apenas uma srie de comandos passo a passo que voc fornece ao computador e ele executa. Cada comando conhecido como instruo. Como voc ver neste manual, no Action Script, cada instruo escrita com um ponto-e-vrgula no final. Em essncia, tudo o que uma determinada instruo faz em um programa manipular alguns dados que esto armazenados na memria do computador. Em um caso simples, voc pode instruir o computador a adicionar dois nmeros e armazenar o resultado na memria. Em um caso mais complexo, imagine que existe um desenho de um retngulo em um lugar na tela e voc quer escrever um programa a fim de mov-lo para outro lugar. O computador est mantendo controlo de determinadas informaes sobre o retngulo (as coordenadas x, y nas quais ele est localizado, sua largura, altura, cor etc.). Cada uma dessas informaes est armazenada em um local na memria do computador. Um programa que move o retngulo para um local diferente deve ter etapas como "alterar a coordenada x para 200; alterar a coordenada y para 150" (ou seja, deve especificar novos valores a serem usados para as coordenadas x e y). claro que o computador faz alguma coisa com esses dados para realmente transformar os nmeros na imagem que aparece na tela; mas, para o nvel de detalhe que nos interessa, basta saber que o processo de "mover um retngulo na tela", na verdade, implica em alterar alguns dados na memria do computador.

2.1. Variveis e constantes


Como a programao envolve principalmente a alterao de algumas informaes na memria do computador, preciso encontrar um meio de representar uma informao isolada no programa. Uma varivel um nome que representa um valor na memria do computador. Durante a escrita de instrues para manipular valores, o nome da varivel escrito no lugar do valor; sempre que se deparar com o nome da varivel no seu programa, o computador consultar a memria e usar o valor que encontrar nela. Por exemplo, se voc tiver duas variveis chamadas value1 e

Action Script

value2, cada uma contendo um nmero, para adicionar esses dois nmeros, voc pode escrever a instruo: value1 + value2. Quando executar as etapas, o computador verificar os valores de cada varivel e os adicionar juntos. No Action Script 3.0, uma varivel consiste em trs partes diferentes: O nome da varivel O tipo de dados que pode ser armazenado nela O valor real armazenado na memria do computador Acabamos de ver como o computador usa o nome como alocador de espao para o valor. O tipo de dados tambm importante. Durante a criao de uma varivel no Action Script, voc especifica o tipo de dados que ela conter; a partir da, as instrues do programa s podem armazenar esse tipo de dados na varivel, e voc pode manipular o valor usando as caractersticas especficas associadas a esse tipo de dados. No Action Script, a criao de uma varivel (conhecida como declarar a varivel) requer o uso da instruo var: var value1:Number; Nesse caso, instrumos o computador a criar uma varivel chamada value1, que contm apenas dados Number (Number um tipo de dados especfico definido no Action Script). Voc tambm pode armazenar um valor na varivel imediatamente: var value2:Number = 17; No Adobe Flash CS4 Professional, existe outro meio de declarar uma varivel. Durante a colocao de um smbolo de clipe de filme, smbolo de boto ou campo de texto no Palco, voc pode-lhe dar um nome de ocorrncia no Inspetor de propriedades. Por baixo do pano, o Flash cria uma varivel com o mesmo nome que o nome de ocorrncia, que voc pode usar no cdigo do Action Script para fazer referncia a esse item do Palco. Assim, por exemplo, se voc der a um smbolo de clipe de filme no Palco o nome de ocorrncia rocketShip, sempre que usar a varivel rocketShip no cdigo do Action Script, na verdade, estar manipulando esse clipe de filme. Uma constante muito semelhante a uma varivel no sentido de que um nome que representa um valor na memria do computador, com um tipo de dados especfico. A diferena que um valor s pode ser atribudo a uma constante uma nica vez no processamento do aplicativo do Action Script. Assim que atribudo, o valor da constante o mesmo em todo o aplicativo. A sintaxe para declarar uma

Action Script

constante a mesma que para declarar uma varivel, exceto que voc usa a palavrachave const em vez da palavra-chave var: const SALES_TAX_RATE:Number = 0.07; Uma constante til para definir um valor que usado em vrios locais em um projeto e que no alterado sob circunstncias normais. O uso de uma constante em vez de um valor literal torna o cdigo mais legvel. Por exemplo, mais fcil entender a finalidade de uma linha de cdigo que multiplica um preo pela SALES_TAX_RATE, comparado a uma linha de cdigo que multiplica o preo por 0,07. Alm disso, se o valor definido por uma constante tiver de ser alterado e voc usar uma constante que represente esse valor em todo o seu projeto, bastar alterar o valor em um nico lugar (a declarao da constante), em vez de alter-lo em vrios locais como aconteceria se voc usasse valores literais codificados.

2.2. Tipos de dados


No Action Script, h vrios tipos de dados que voc pode usar como os tipos de dados da varivel que voc criar. Alguns deles podem ser entendidos como "simples" ou "fundamentais": Sequncia de caracteres: um valor textual, como um nome ou o texto do captulo de um livro Numrico: o Action Script 3.0 inclui trs tipos de dados especficos para dados numricos: Nmero: qualquer valor numrico, incluindo valores com ou sem uma frao int: um inteiro (um nmero inteiro sem uma frao) uint: um inteiro "sem sinal", que significa um nmero inteiro que no pode ser negativo Booleano: um valor do tipo verdadeiro ou falso, tal como se uma opo est ativa ou se dois valores so iguais Os tipos de dados simples representam uma nica informao: por exemplo, um nico nmero ou uma nica sequncia de texto. Entretanto, a maioria dos tipos de dados definidos no Action Script poderia ser descrita como tipos de dados complexos, porque representam um conjunto de valores agrupados. Por exemplo, uma varivel com o tipo de dados Date representa um valor nico: um momento no tempo. No entanto, esse valor de data na verdade representado com diversos valores: dia, ms, ano, horas, minutos, segundos etc., que so todos nmeros individuais. Portanto, embora pensemos em uma data como um valor nico (e a tratemos dessa forma, criando uma varivel Date), internamente, o computador a entende como um grupo de diversos valores que, juntos, definem uma nica data.

10

Action Script

A maioria dos tipos de dados embutidos, bem como os definidos pelos programadores, so tipos de dados complexos. Alguns tipos de dados complexos que talvez voc conhea so: MovieClip: um smbolo de clipe de filme TextField: um campo de texto de entrada ou dinmico SimpleButton: um smbolo de boto Date: informaes sobre um momento nico no tempo (uma data e hora)

Duas palavras que, em geral, so usadas como sinnimos de tipos de dados so classe e objeto. Uma classe simplesmente a definio de um tipo de dados; como um modelo para todos os objetos dos tipos de dados, como dizer "todas as variveis do tipo de dados Example tm estas caractersticas: A, B e C. Um objeto, porm, apenas uma ocorrncia real de uma classe; uma varivel cujo tipo de dados MovieClip poderia ser descrita como um objeto MovieClip. Estas so formas diferentes de dizer a mesma coisa: O tipo de dados da varivel myVariable Number. A varivel myVariable uma ocorrncia de Number. A varivel myVariable um objeto Number. A varivel myVariable uma ocorrncia da classe Number.

2.3. Trabalho com objetos


O Action Script conhecido como uma linguagem de programao orientada a objetos. Programao orientada a objetos simplesmente uma abordagem da programao, nada mais do que uma forma de organizar o cdigo em um programa, usando objetos. Anteriormente, definimos um programa de computador como uma srie de etapas ou instrues que o computador executa. De forma conceitual, ento, podemos imaginar um programa de computador como uma longa lista de instrues. Entretanto, na programao orientada a objetos, as instrues do programa so divididas em objetos diferentes, ou seja, o cdigo agrupado em blocos de funcionalidade, de forma que tipos relacionados de funcionalidade ou partes relacionadas de informao so agrupados em um nico continer. Na verdade, se voc j trabalhou com smbolos no Flash, ento est acostumado a trabalhar com objetos. Imagine que voc definiu um smbolo de clipe de filme (digamos que seja o desenho de um retngulo) e colocou uma cpia dele no

11

Action Script

Palco. Esse smbolo de clipe de filme tambm (literalmente) um objeto no Action Script; uma ocorrncia da classe MovieClip. H diversas caractersticas do clipe de filme que voc pode modificar. Por exemplo, quando ele selecionado, h valores que voc pode alterar no Inspetor de propriedades, como a coordenada x, sua largura ou vrios ajustes de cor, como alterar seu alfa (transparncia) ou aplicar um filtro de sombra. Outras ferramentas do Flash permitem fazer mais alteraes, como usar a ferramenta Transformao livre para girar o retngulo. Tudo o que possvel fazer para modificar um smbolo de clipe de filme no ambiente de autoria do Flash tambm pode ser feito no Action Script, alterando as partes dos dados que so colocadas em um nico pacote chamado objeto MovieClip. Na programao orientada a objetos do Action Script, h trs tipos de caractersticas que qualquer classe pode incluir: Propriedades Mtodos Eventos Juntos, esses elementos ajudam a gerenciar as partes dos dados usados pelo programa e a decidir quais aes so executadas em uma determinada ordem.

2.4. Propriedades
Uma propriedade representa uma das partes dos dados que so compactados em um objeto. Um objeto de msica pode ter propriedades chamadas artist e title; a classe MovieClip tem propriedades como rotation, x, width e alpha. As propriedades so tratadas como variveis individuais; na verdade, elas podem ser entendidas apenas como as variveis "filho" contidas em um objeto. A seguir, apresentamos alguns exemplos de cdigo do Action Script que usa propriedades. Esta linha de cdigo move o MovieClip chamado square para 100 pixels na coordenada x: square.x = 100; Este cdigo usa a propriedade de rotao fazendo com que o MovieClip square gire para corresponder rotao do MovieClip triangle: square.rotation = triangle.rotation;

12

Action Script

Este cdigo altera a escala horizontal do MovieClip square para que ele fique uma vez e meia maior do que antes: square.scaleX = 1.5; Observe a estrutura comum: voc usa uma varivel (square, triangle) como o nome do objeto, seguido de um ponto (.) e, depois, o nome da propriedade (x, rotation, scaleX). O ponto, conhecido como operador ponto, usado para indicar que voc est acedendo um dos elementos filho de um objeto. A estrutura inteira reunida, "nome da varivel- ponto-nome da propriedade", usada como uma nica varivel, como um nome para um nico valor na memria do computador.

2.5. Mtodos
Um method uma ao que pode ser executada por um objeto. Por exemplo, se voc criou um smbolo de clipe de filme no Flash com vrios quadros-chave e animao em sua linha de tempo, esse clipe de filme pode ser reproduzido, parar ou ser instrudo a mover o indicador de reproduo para um quadro especfico. Este cdigo instrui o MovieClip chamado shortFilm a iniciar a reproduo: shortFilm.play(); Esta linha faz o MovieClip chamado shortFilm parar a reproduo (o indicador de reproduo para; como pausar um vdeo): shortFilm.stop(); Este cdigo faz um MovieClip chamado shortFilm mover o indicador de reproduo para o Quadro 1 e parar a reproduo ( como retroceder um vdeo): shortFilm.gotoAndStop(1); Como voc pode ver, os mtodos, assim como as propriedades, so acedidos escrevendo o nome do objeto (uma varivel), um ponto e o nome do mtodo seguido de parnteses. Os parnteses so uma forma de indicar que voc est chamando o mtodo ou, em outras palavras, instruindo o objeto a executar aquela ao. s vezes, os valores (ou as variveis) so colocados entre parnteses, como uma forma de passar adiante informaes adicionais necessrias para executar a ao. Esses valores so conhecidos como parmetros de mtodo. Por exemplo, o mtodo gotoAndStop() precisa saber para qual quadro deve ir, por isso requer um nico parmetro entre parnteses. Outros mtodos, como play() e stop(), so autoexplicativos, por isso no requerem informaes extras. No entanto, eles ainda so escritos com parnteses. Diferentemente das propriedades (e variveis), os mtodos no so usados como alocadores de espao de valor. Entretanto, alguns mtodos podem executar

13

Action Script

clculos e retornar um resultado que pode ser usado como uma varivel. Por exemplo, o mtodo toString() da classe Number converte o valor em sua representao de texto:
var numericData:Number = 9; var textData:String = numericData.toString();

Por exemplo, voc usaria o mtodo toString() se quisesse exibir o valor de uma varivel Number em um campo de texto na tela. A propriedade text da classe TextField (que representa o contedo real do texto exibido na tela) definida como uma String, por isso pode conter apenas valores de texto. Esta linha de cdigo converte o valor numrico na varivel numericData em texto e faz com que aparea na tela, no objeto TextField chamado calculatorDisplay: calculatorDisplay.text = numericData.toString();

2.6. Eventos
Descrevemos um programa de computador como uma srie instrues que o computador executa em etapas. Alguns programas de computador simples consistem em nada mais do que algumas etapas que ele executa e depois encerrado. Entretanto, os programas do Action Script so criados para continuar a execuo e esperar a entrada do usurio ou a ocorrncia de outras coisas. Os eventos so mecanismos que determinam quais instrues o computador executa em um determinado momento. Basicamente, os eventos so fenmeno s que acontecem, sobre os quais o informado e aos quais pode responder. Muitos eventos esto relacionados interao do usurio, como quando um usurio clica em um boto ou pressiona uma tecla no teclado, mas tambm h outros tipos. Por exemplo, se voc usar o para carregar uma imagem externa, h um evento que poder avis-lo quando o carregamento da imagem for concludo. Em essncia, quando um programa executado, o Adobe Flash Player e o Adobe AIR aguardam determinados eventos e, ento, executam o cdigo especfico definido para esses eventos.

2.7. Tratamento de eventos bsico


A tcnica para especificar determinadas aes que devem ser executadas em resposta a eventos especficos conhecida como tratamento de eventos. Durante a escrita do cdigo do para executar o tratamento de eventos, h trs elementos importantes a serem identificados: A origem do evento: para qual objeto o evento dever ocorrer? Por exemplo, qual boto ser clicado ou qual objeto Loader est carregando a imagem? A origem do

14

Action Script

evento tambm conhecida como destino do evento, porque o objeto para o qual o evento destinado pelo Flash Player ou AIR (ou seja, onde o evento realmente acontece). O evento: o que ir acontecer, a qual fenmeno voc deseja responder? importante identificar isso, porque muitos objetos acionam diversos eventos. A resposta: qual ou quais etapa deseja executar quando o evento acontecer? Sempre que voc escrever cdigo do para manipular eventos, ele deve incluir estes trs elementos, e o cdigo deve seguir a estrutura bsica (os elementos em negrito so alocadores de espao que voc preenche conforme o caso especfico):
function eventResponse(eventObject:EventType):void { // Actions performed in response to the event go here. } eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);

Esse cdigo faz duas coisas. Primeiro, ele define uma funo, que a forma de especificar as aes que voc deseja executar em resposta ao evento. Em seguida, o mtodo addEventListener() do objeto de origem chamado basicamente inscrevendo a funo do evento especificado para que, quando o evento acontecer, as aes da funo sejam executadas. Vejamos cada uma dessas partes com mais detalhes. Uma funo fornece um meio de agrupar as aes, com um nico nome, que como um nome de atalho, para executar as aes. Ela idntica a um mtodo, exceto que no est necessariamente associada a uma classe especfica (na verdade, um mtodo poderia ser definido como uma funo associada a uma classe especfica). Durante a criao de uma funo para tratamento de eventos, voc deve escolher o nome da funo (chamada de eventResponse neste caso). Voc tambm deve especificar um parmetro (chamado eventObject neste exemplo). A especificao de um parmetro de funo como declarar uma varivel, por isso voc tambm deve indicar o tipo de dados do parmetro. (Neste exemplo, o tipo de dados do parmetro EventType.) Cada tipo de evento que voc deseja escutar associado a uma classe do. O tipo de dados que voc define para o parmetro de funo sempre a classe associada ao evento especfico ao qual deseja responder. Por exemplo, um evento click (acionado quando o usurio clica em um item com o mouse) associado classe MouseEvent. Para escrever uma funo de ouvinte para um evento click, voc define essa funo com um parmetro com o tipo de dados MouseEvent. Finalmente, entre chaves ({ ... }), voc escreve as instrues que deseja que o computador execute quando o evento ocorrer.

15

Action Script

Depois de escrever a funo de tratamento de eventos, necessrio informar ao objeto de origem de evento (o objeto para o qual o evento acontece, por exemplo, o boto) que voc deseja que a funo seja chamada quando o evento ocorrer. possvel fazer isso chamando o mtodo addEventListener() desse objeto (todos os objetos que possuem eventos tambm tm um mtodo addEventListener()). O mtodo addEventListener() usa dois parmetros: O primeiro o nome do evento especfico ao qual voc deseja responder. Novamente, cada evento afiliado a uma classe especfica, e essa classe ter um valor especial predefinido para cada evento (como se fosse o prprio nome exclusivo do evento, que voc deve usar para o primeiro parmetro). O segundo o nome da funo de resposta do evento. Observe que um nome de funo escrito sem parnteses quando transmitido como um parmetro.

2.8. Exame do processo de tratamento de eventos


Veja a seguir uma descrio passo a passo do processo que acontece durante a criao de um ouvinte de eventos. Neste caso, um exemplo de criao de uma funo de ouvinte que chamada quando um objeto myButton clicado. O cdigo real escrito pelo programador o seguinte:
function eventResponse(event:MouseEvent):void { // Actions performed in response to the event go here. } myButton.addEventListener(MouseEvent.CLICK, eventResponse);

Apresentaremos a seguir o funcionamento desse cdigo, quando executado no Flash Player. O comportamento o mesmo no Adobe AIR: 1 Quando o arquivo SWF carregado, o Flash Player registra o fato de que h uma funo chamada: eventResponse(). 2 Em seguida, o Flash Player executa o cdigo (especificamente, as linhas de cdigo que no esto contidas em uma funo). Neste caso, apenas uma linha de cdigo: chamar o mtodo addEventListener() no objeto de origem do evento (chamado myButton) e transmitir a funo eventResponse como um parmetro. 3 Internamente, myButton tem uma lista de funes que esto ouvindo cada um de seus eventos, por isso quando seu mtodo addEventListener() chamado, myButtonarmazena a funo eventResponse() na lista de ouvintes de eventos.

16

Action Script

4 Em algum momento, o usurio clica no objeto myButton, acionando o evento click (identificado como MouseEvent.CLICK no cdigo). 5 Ento, acontece o seguinte: O Flash Player cria um objeto, uma ocorrncia da classe associada ao evento em questo (MouseEvent, no exemplo citado). Para muitos eventos, essa ser uma ocorrncia da classe Event; para eventos do rato, ser uma ocorrncia de MouseEvent e, para outros eventos, ser uma ocorrncia da classe associada a esse evento. Esse objeto criado conhecido como o objeto de evento e contm informaes especficas sobre o evento que ocorreu: qual o tipo de evento, onde ele ocorreu e outras informaes especficas de evento se aplicvel. 6 Em seguida, o Flash Player verifica a lista de ouvintes de eventos armazenada por myButton. Ele verifica todas essas funes, chamando uma de cada vez e transmitindo o objeto de evento para a funo como um parmetro. Como a funo eventResponse() um dos ouvintes de myButton, como parte desse processo, o Flash Player chama a funo eventResponse(). 7 Quando a funo eventResponse() chamada, o cdigo nela executado e as aes especificadas so realizadas.

2.9. Exemplos de tratamento de eventos


A seguir, mostramos alguns exemplos mais concretos de eventos para lhe dar uma ideia de alguns elementos de eventos comuns e as possveis variaes disponveis durante a escrita do cdigo de tratamento de eventos: Clicar em um boto para iniciar a reproduo do clipe de filme atual. No exemplo a seguir, playButton o nome da ocorrncia do boto, e this um nome especial que significa o objeto atual:
this.stop(); function playMovie(event:MouseEvent):void { this.play(); } playButton.addEventListener(MouseEvent.CLICK, playMovie);

Detetar tipos em um campo de texto: Neste exemplo, entryText um campo de texto de entrada, e outputText um campo de texto dinmico:
function updateOutput(event:TextEvent):void { var pressedKey:String = event.text; outputText.text = "You typed: " + pressedKey; } entryText.addEventListener(TextEvent.TEXT_INPUT, updateOutput);

17

Action Script

Clicar em um boto para navegar em uma URL. Nesse caso, linkButton o nome de ocorrncia do boto:
function gotoAdobeSite(event:MouseEvent):void { var adobeURL:URLRequest = new URLRequest("http://www.adobe.com/"); navigateToURL(adobeURL); } linkButton.addEventListener(MouseEvent.CLICK, gotoAdobeSite);

3. Criar ocorrncias de objetos


Obviamente, para que voc possa usar um objeto no, primeiro, ele deve existir. Uma parte da criao de um objeto declarar uma varivel; porm, a declarao de uma varivel s cria um lugar vazio na memria do computador. Voc deve atribuir um valor real varivel, isto , criar um objeto e armazen-lo na varivel, antes de tentar us-lo ou manipul-lo. O processo de criar um objeto conhecido como instanciar o objeto, em outras palavras, criar uma ocorrncia de uma classe especfica. Existe uma maneira simples de criar uma ocorrncia de objeto que no envolve o. No Flash, quando voc coloca um smbolo de clipe de filme, smbolo de boto ou campo de texto no Palco e lhe atribui um nome de ocorrncia no Inspetor de propriedades, o Flash automaticamente declara uma varivel com esse nome de ocorrncia, cria uma ocorrncia de objeto e armazena o objeto na varivel. Da mesma forma, quando voc usa a linguagem MXML para criar um componente no Adobe Flex Builder (codificando uma tag MXML ou colocando o componente no editor no modo Design) e lhe atribui uma ID (no markup MXML ou na exibio Propriedades do Flex), essa ID se torna o nome de uma varivel do, e uma ocorrncia do componente criada e armazenada nessa varivel. Entretanto, nem sempre voc criar um objeto visualmente. Tambm h vrias formas de criar ocorrncias de objeto usando somente o. Primeiro, com vrios tipos de dados do, voc pode criar uma ocorrncia usando uma expresso literal, um valor escrito diretamente no cdigo do. Eis alguns exemplos: Valor numrico literal (insere o nmero diretamente):
var someNumber:Number = 17.239; var someNegativeInteger:int = -53; var someUint:uint = 22;

Valor da sequncia de caracteres literal (envolve o texto com aspas duplas):


var firstName:String = "George"; var soliloquy:String = "To be or not to be, that is the question...";

18

Action Script

Valor booleano literal (usa os valores literais true ou false):


var niceWeather:Boolean = true; var playingOutside:Boolean = false;

Valor Array literal (envolve uma lista de valores separados por vrgula entre colchetes):
var seasons:Array = ["spring", "summer", "autumn", "winter"];

Valor XML literal (insere o XML diretamente):


var employee:XML = <employee> <firstName>Harold</firstName> <lastName>Webster</lastName> </employee>;

O tambm define expresses literais para os tipos de dados Array, RegExp, Object e Function. Para qualquer outro tipo de dados, para criar uma ocorrncia de objeto, use o operador new como o nome da classe, desta forma:
var raceCar:MovieClip = new MovieClip(); var birthday:Date = new Date(2006, 7, 9);

O ato de criar de um objeto usando o operador new, muitas vezes, descrito como chamar o construtor da classe Um construtor um mtodo especial que chamado como parte do processo de criar uma ocorrncia de uma classe. Observe que, ao criar uma ocorrncia dessa forma, voc coloca parnteses depois do nome da classe e, s vezes, especifica valores de parmetro (duas aes que tambm so executadas ao chamar um mtodo). Observe que, mesmo para esses tipos de dados que permitem criar ocorrncias usando uma expresso literal, voc ainda pode usar o operador new para criar uma ocorrncia de objeto. Por exemplo, as duas linhas de cdigo a seguir fazem exatamente a mesma coisa:
var someNumber:Number = 6.33; var someNumber:Number = new Number(6.33);

importante se familiarizar com a forma como new ClassName() cria objetos. Se for necessrio criar uma ocorrncia de qualquer tipo de dados que no tenha uma representao visual (e no possa ser criada colocando um item no Palco do Flash ou no modo Design do editor XML do Flex Builder), isso s ser possvel criando o objeto diretamente no pelo uso do operador new.

19

Action Script

No Flash especificamente, o operador new tambm pode ser usado para criar uma ocorrncia de um smbolo de clipe de filme que definido na Biblioteca mas no colocado no Palco. Alm de declarar variveis, criar ocorrncias de objetos e manipular objetos usando suas propriedades e mtodos, h outros blocos de construo que voc precisa usar para criar um programa do.

3.1. Operadores
Os operadores so smbolos (ou, ocasionalmente, palavras) essenciais que so usados para executar clculos. Eles so muito usados em operaes matemticas e tambm para comparar valores. Como regra geral, um operador usa um ou mais valores e "obtm" um nico resultado. Por exemplo: O operador de adio (+) adiciona dois valores, tendo como resultado um nico nmero:
var sum:Number = 23 + 32;

O operador de multiplicao (*) multiplica dois valores, tendo como resultado um nico nmero:
var energy:Number = mass * speedOfLight * speedOfLight;

O operador de igualdade (==) compara se dois valores so iguais, tendo como resultado um nico valor verdadeiro ou falso (booleano):
if (dayOfWeek == "Wednesday") { takeOutTrash(); }

Conforme mostrado aqui, o operador de igualdade e os outros operadores de "comparao", em geral, so usados com a instruo if para determinar se algumas instrues devem ser executadas.

3.2. Comentrios
Durante a escrita do, muitas vezes, voc desejar fazer anotaes, talvez para explicar como algumas linhas de cdigo funcionam e por que escolheu uma determinada opo. Os comentrios de cdigo so uma ferramenta que voc pode usar para escrever um texto que o computador deve ignorar no seu cdigo. O inclui dois tipos de comentrios:

20

Action Script

Comentrio de uma linha: um comentrio de uma linha criado colocando duas barras em qualquer lugar de uma linha. Tudo que vier depois das barras at o fim da linha, ser ignorado pelo computador:
// This is a comment; it's ignored by the computer. var age:Number = 10; // Set the age to 10 by default.

Comentrio de vrias linhas: um comentrio de vrias linhas inclui um marcador de comentrio inicial (/*), o contedo do comentrio e um marcador de comentrio final (*/). Tudo entre os marcadores inicial e final ignorado pelo computador, independentemente do nmero de linhas que o comentrio contm:
/* This might be a really long description, perhaps describing what a particular function is used for or explaining a section of code. In any case, these lines are all ignored by the computer. */

Outro uso comum dos comentrios "desativar" temporariamente uma ou mais linhas de cdigo, por exemplo, se voc estiver testando uma forma diferente de fazer algo ou tentando descobrir por que um cdigo do ActionScript no est funcionando conforme o esperado.

3.3. Controle do fluxo


Muitas vezes em um programa, voc desejar repetir determinadas aces, executar apenas algumas e outras no, executar aces conforme condies especficas etc. O controle de fluxo o controlo sobre as aces que so executadas. H vrios tipos de elementos de controlo de fluxo disponveis no ActionScript. Funes: as funes so como atalhos: fornecem um meio de agrupar uma srie de aces sob um nico nome e podem ser usadas para realizar clculos. As funes so especialmente importantes para tratar eventos, mas tambm so usadas como uma ferramenta geral para agrupar uma srie de instrues. Loops: as estruturas de loop permitem designar um conjunto de instrues que o computador executar por um determinado nmero de vezes ou at que alguma condio seja alterada. Com freqncia, os loops so usados para manipular vrios itens relacionados, empregando uma varivel cujo valor alterado sempre que o computador completa o loop. Instrues condicionais: as instrues condicionais fornecem um meio de designar algumas instrues que so executadas somente sob determinadas circunstncias ou de fornecer conjuntos alternativos de instrues para condies diferentes. O tipo mais comum de instruo condicional a instruo if. A instruo if verifica um valor

21

Action Script

ou uma expresso entre parnteses. Se o valor for true, as linhas de cdigo entre chaves so executadas; caso contrrio, elas so ignoradas. Por exemplo:
if (age < 20) { // show special teenager-targeted content }

A parceira da instruo if, a instruo else, permite designar instrues alternativas a serem executadas caso a condio no seja true:
if (username == "admin") { // do some administrator-only things, like showing extra options } else { // do some non-administrator things }

4. Classes e objectos
Os objectos so a base da linguagem do ActionScript 3.0, seus os blocos de construo fundamentais. Cada varivel declarada, cada funo escrita e cada ocorrncia de classe criada um objecto. Pense em um programa do Action Script 3.0 como um grupo de objectos que realizam tarefas, respondem a eventos e se comunicam. Os programadores acostumados OOP (Programao orientada a objectos) em Java ou C++ podem pensar nos objectos como mdulos que contm dois tipos de membros: dados armazenados em variveis ou propriedades de membros e comportamento acessvel por meio de mtodos. O ActionScript 3.0 define objectos de modo similar, com pequenas particularidades. No ActionScript 3.0, os objectos so apenas conjuntos de propriedades. Essas propriedades so contineres que podem manter no apenas dados, mas tambm funes ou outros objectos. Se uma funo for anexada a um objecto dessa forma, ela ser chamada de mtodo. Embora a definio do ActionScript 3.0 possa parecer um pouco estranha aos programadores com experincia em Java ou C++, na prtica, a definio dos tipos de objecto com classes do ActionScript 3.0 bastante semelhante forma como as classes so definidas em Java ou C++. A distino entre as duas definies de objecto importante ao discutir o modelo de objecto do ActionScript e outros tpicos avanados, mas, na maioria das situaes, o termo propriedades significa variveis de membro de classe, e no mtodos. A Referncia dos componentes e da linguagem do ActionScript 3.0, por exemplo, usa o termo propriedades para se referir a variveis ou

22

Action Script

propriedades getter-setter. Ela usa o termo mtodos para se referir s funes que fazem parte de uma classe. Uma diferena sutil entre as classes no ActionScript e as classes em Java ou C++ que, no ActionScript, as classes no so apenas entidades abstratas. As classes do ActionScript so representadas por objectos de classe que armazenam propriedades e mtodos da classe. Isso permite o uso de tcnicas que podem parecer estranhas aos programadores de Java e C++, como incluir instrues ou cdigo executvel no nvel superior de uma classe ou um pacote. Outra diferena entre as classes do ActionScript e as de Java ou C++ que toda classe do ActionScript tem o que chamamos de objecto deprottipo. Nas verses anteriores do ActionScript, os objectos de prottipo, vinculados em cadeias de prottipos, serviam coletivamente como a base de toda a hierarquia de herana de classes. No ActionScript 3.0, contudo, os objectos de prottipo desempenham um papel secundrio no sistema de herana. Apesar disso, eles podero ser teis como uma alternativa s propriedades e aos mtodos estticos se voc quiser compartilhar uma propriedade e seu valor com todas as ocorrncias de uma classe. Anteriormente, os programadores de ActionScript avanados podiam manipular diretamente a cadeia de prottipos com elementos de linguagem embutidos especiais. Agora que essa linguagem fornece uma implementao mais madura de uma interface de programao baseada em classes, muitos desses elementos de linguagem especiais, como _proto_ e _resolve_, no fazem mais parte da linguagem. Alm disso, as otimizaes do mecanismo de herana interno que fornece melhorias de desempenho significativas no Flash Player e no Adobe AIR impedem o acesso direto ao mecanismo de herana. No Action Script 3.0, cada objecto definido por uma classe. Uma classe pode ser entendida como um modelo ou uma cpia de um tipo de objecto. As definies de classe podem incluir variveis e constantes, que mantm valores de dados, e mtodos, que so funes de encapsulamento de comportamento vinculadas classe. Os valores armazenados em propriedades podem ser valores primitivos ou outros objectos. Os valores primitivos so nmeros, seqncias de caracteres ou valores booleanos. O Action Script contm diversas classes embutidas que fazem parte da linguagem central. Algumas delas, como Number, Boolean e String, representam os valores primitivos disponveis no Action Script. Outras classes, como Array, Math e XML, definem objectos mais complexos.

23

Action Script

Todas as classes, incorporadas ou definidas pelo usurio, derivam da classe Object. Para os programadores com experincia no ActionScript, importante observar que o tipo de dados Object no mais o tipo de dados padro, muito embora todas as outras classes ainda derivem dessa. No ActionScript 2.0, as duas linhas de cdigo a seguir eram equivalentes porque a falta de uma anotao de tipo significava que uma varivel seria do tipo Object:
var someObj:Object; var someObj;

O Action Script 3.0, porm, apresenta o conceito de variveis sem tipo, que podem ser designadas destas duas formas:
var someObj:*; var someObj;

Uma varivel sem tipo no igual a uma varivel do tipo Object. A principal diferena que as variveis sem tipo podem manter o valor especial undefined, enquanto uma varivel do tipo Object no pode. Voc pode definir suas prprias classes usando a palavra-chave class. As propriedades de classe podem ser declaradas de trs formas: as constantes podem ser definidas com a palavra-chave const, as variveis so definidas com a palavra- chave var e as propriedades getter e setter so definidas usando os atributos get e set em uma declarao de mtodo. Os mtodos podem ser declarados com a palavra-chave function. Uma ocorrncia de uma classe criada usando o operador new. O exemplo a seguir cria uma ocorrncia da classe Date chamada myBirthday.
var myBirthday:Date = new Date();

O processo de criar as classes que sero usadas nos projetos pode parecer assustador. Entretanto, a parte mais difcil da criao de uma classe a tarefa de crila, identificando os mtodos, as propriedades e os eventos que ela incluir. O tpico de criao orientada a objectos complexo; existem cargos totalmente dedicados ao estudo acadmico e prtica profissional dessa disciplina. No entanto, apresentamos algumas sugestes de abordagens que podem ajud-lo a comear. 1 Pense na funo que as ocorrncias dessa classe exercero no aplicativo. Em geral, os objectos cumprem uma destas trs funes:

24

Action Script

Objecto de valor: esses objectos servem basicamente como contineres de dados, isto , eles costumam ter diversas propriedades e menos mtodos (ou, s vezes, nenhum mtodo). Em geral, eles so representaes de cdigo de itens definidos claramente, como uma classe Song (representando uma nica msica do mundo real) ou classe Playlist (representando um grupo conceitual de msicas) em um aplicativo de player de msica. Objecto de exibio: so os objectos que realmente aparecem na tela. Exemplos incluem elementos da interface do usurio como uma lista suspensa ou exibio de status, elementos grficos como criaturas em um videogame etc. Estrutura do aplicativo: esses objectos exercem uma ampla gama de funes de suporte na lgica ou no processamento executados pelos aplicativos. Exemplos incluem um objecto que executa determinados clculos em uma simulao biolgica, um que responsvel por sincronizar valores entre um controle de mostrador e uma exibio de volume em um aplicativo de player de msica, um que gerencia as regras em um videogame ou um que carrega uma imagem salva em um aplicativo de desenho. 2 Escolha a funcionalidade especfica de que a classe precisar. Os diferentes tipos de funcionalidade, em geral, se tornam mtodos da classe. 3 Se a classe for servir como um objecto de valor, decida quais dados as ocorrncias incluiro. Esses itens so bons candidatos para propriedades. 4 Como a classe est sendo criada especificamente para seu projeto, o mais importante fornecer a funcionalidade de que o aplicativo precisa. Talvez ajude responder a estas questes: Que informaes o aplicativo ir armazenar, controlar e manipular? Decidir isso ajuda a identificar os objectos de valor e as propriedades que voc deseja. Quais conjuntos de aes devero ser executados, por exemplo, quando o aplicativo for carregado pela primeira vez, um boto for clicado, um filme parar de ser reproduzido etc.? Esses so bons candidatos para mtodos (ou propriedades, se as "aes" envolverem apenas a alterao de valores individuais). Quais informaes a classe deve saber para executar cada ao especfica? Essas informaes se tornam os parmetros do mtodo. Conforme o aplicativo executar seu trabalho, o que mudar na sua classe que outras partes do aplicativo dever saber? Esses itens so bons candidatos para eventos. 5 Se houver um objecto existente semelhante quele de que voc precisa, mas que no tenha alguma funcionalidade adicional que voc deseja adicionar, considere a criao de uma subclasse (uma classe que aproveite a funcionalidade de uma classe

25

Action Script

existente, em vez de definir todas as suas prprias funcionalidades). Por exemplo, se voc quiser criar uma classe que seja um objecto visual na tela, pode usar o comportamento de um dos objectos de exibio existentes (por exemplo, Sprite ou MovieClip) como base para sua classe. Nesse caso, MovieClip (ou Sprite) seria a classe base, e sua classe estenderia essa classe.

4.1. Escrita do cdigo para uma classe


Depois de fazer um plano de criao para sua classe ou, pelo menos, ter uma idia das informaes sobre as quais ela dever ter controlo e quais aes devero ser executadas, a sintaxe real da escrita de uma classe bem direta. Veja as etapas mnimas para criar sua prpria classe do ActionScript: 1 Abra um novo documento de texto, em um programa especfico do ActionScript como o Flex Builder ou o Flash, em uma ferramenta de programao geral como o Dreamweaver ou em qualquer programa que permita trabalhar com documento de texto sem formatao. 2 Insira uma ocorrncia de class para definir o nome da classe. Para isso, digite as palavras public class, o nome da classe e as chaves que envolvero o contedo da classe (as definies de mtodo e propriedade). Por exemplo:
public class MyClass { }

A palavra public indica que a classe pode ser acessada de qualquer outro cdigo. 3 Digite uma instruo package para indicar o nome do pacote no qual sua classe se encontrar. A sintaxe a palavra package, seguida do nome completo do pacote e das chaves (que envolvero o bloco da instruo class). Por exemplo, o cdigo na etapa anterior seria alterado da seguinte forma:
package mypackage { public class MyClass { } }

4 Defina cada propriedade na classe usando a instruo var dentro do corpo da classe; a sintaxe a mesma usada para declarar qualquer varivel (com a adio do

26

Action Script

modificador public). Por exemplo, a adio destas linhas entre as chaves de definio da classe criar propriedades chamadas textVariable, numericVariable e dateVariable:
public var textVariable:String = "some default value"; public var numericVariable:Number = 17; public var dateVariable:Date;

5 Defina cada mtodo na classe usando a mesma sintaxe usada para definir uma funo. Por exemplo: Para criar um mtodo myMethod(), digite:
public function myMethod(param1:String, param2:Number):void { // do something with parameters }

Para criar um construtor (o mtodo especial que chamado como parte do processo de criar uma ocorrncia de uma classe), crie um mtodo cujo nome corresponda exatamente ao nome da classe:
public function MyClass() { // do stuff to set initial values for properties // and otherwise set up the object textVariable = "Hello there!"; dateVariable = new Date(2001, 5, 11); }

Se voc no incluir um mtodo construtor na classe, o compilador criar automaticamente um construtor vazio. (sem nenhum parmetro e nenhuma instruo) na sua classe. H mais alguns elementos de classe que voc pode definir, que so mais complexos. Assessores so um cruzamento especial entre um mtodo e uma propriedade. Durante a escrita do cdigo para definir a classe, voc escreve o assessor como um mtodo para poder executar vrias aes (em vez de apenas ler ou atribuir um valor, que tudo o que voc pode fazer ao definir uma propriedade). Entretanto, na criao de uma ocorrncia da classe, voc trata o assessor como uma propriedade, usando apenas o nome para ler ou atribuir o valor. Os eventos no ActionScript no so definidos usando uma sintaxe especfica. Em vez disso, voc define eventos na classe usando a funcionalidade da classe EventDispatcher para manter controle de ouvintes de evento e notific-los dos eventos. Exemplo: Criao de um aplicativo bsico Voc pode criar arquivos de cdigo do ActionScript externo com uma extenso .as usando o Flash, Flex Builder, Dreamweaver ou qualquer editor de texto.

27

Action Script

O ActionScript 3.0 pode ser usado em diversos ambientes de desenvolvimento de aplicativo, incluindo as ferramentas de autoria do Flash e o Flex Builder. Esta seo apresenta as etapas de criao e de aprimoramento de um aplicativo ActionScript 3.0 simples usando a ferramenta de autoria do Flash ou o Flex Builder. O aplicativo que voc criar apresentar um padro simples para usar arquivos externos de classe do ActionScript 3.0 nos aplicativos Flash e Flex. Esse padro se aplicar a todos os outros aplicativos de exemplo deste manual.

4.2. Criao do seu aplicativo do ActionScript


Voc deve ter uma idia do aplicativo que deseja ter antes de comear a cri-lo. A representao do seu design pode ser to simples quanto o nome do aplicativo e uma breve instruo de sua finalidade ou to complicado quanto um conjunto de documentos de requisitos contendo vrios diagramas UML (Unified Modeling Language). Este manual no discute a disciplina do design de software em detalhes, mas importante ter em mente que ele uma etapa essencial no desenvolvimento de aplicativos do ActionScript. Nosso primeiro exemplo de um aplicativo do ActionScript ser um aplicativo Hello World padro, pois seu design muito simples: O aplicativo ser chamado de HelloWorld. Ele exibir um nico campo de texto contendo as palavras Hello World!. Para ser reutilizado facilmente, ele usar uma nica classe orientada a objectos, chamada Greeter, que pode ser usada de dentro de um documento Flash ou um aplicativo do Flex. Depois de criar uma verso bsica do aplicativo, voc adicionar uma nova funcionalidade que exija do usurio a insero de um nome de usurio e faa o aplicativo verificar esse nome em relao a uma lista de usurios conhecidos. Com essa definio concisa estabelecida, voc pode comear a criar o aplicativo em si.

4.3. Criao do projeto HelloWorld e da classe Greeter


A instruo do design para o aplicativo Hello World dizia que seu cdigo deve ser fcil de reutilizar. Com esse objetivo em mente, o aplicativo usa uma nica classe

28

Action Script

orientada a objectos, chamada Greeter, que usada de dentro de um aplicativo criado no Flex Builder ou na ferramenta de autoria do Flash. Para criar a classe Greeter na ferramenta de autoria do Flash: 1 Na ferramenta autoria do Flash, selecione Arquivo > Novo. 2 Na caixa de dilogo Novo documento, selecione o arquivo do ActionScript e clique em OK. Uma nova janela de edio do ActionScript ser exibida. 3 Selecione Arquivo> Salvar. Selecione uma pasta para conter o aplicativo, chame o arquivo do ActionScript de Greeter.as e clique em OK.

4.4. Adio de cdigo classe Greeter


A classe Greeter define um objecto, Greeter, que poder ser usado no aplicativo HelloWorld. Para adicionar cdigo classe Greeter: 1 Digite o seguinte cdigo no novo arquivo:
package { public class Greeter { public function sayHello():String { var greeting:String; greeting = "Hello World!"; return greeting; } } }

A classe Greeter inclui um nico mtodo sayHello() , que retorna uma seqncia de caracteres que diz Hello World!. 2 Clique em Arquivo> Salvar para salvar esse arquivo do ActionScript. A classe Greeter agora est pronta para ser usada em um aplicativo.

4.5. Criao de um aplicativo que usa o cdigo do ActionScript


A classe Greeter que voc criou define um conjunto independente de funes de software, mas no representa um aplicativo completo. Para usar a classe, necessrio criar um documento do Flash ou aplicativo do Flex. O aplicativo HelloWorld cria uma nova ocorrncia da classe Greeter. Veja como anexar a classe Greeter ao seu aplicativo.

29

Action Script

Para criar um aplicativo do ActionScript usando a ferramenta de autoria do Flash: 1 Selecione Arquivo> Novo. 2 Na caixa de dilogo Novo documento, selecione Documento Flash e clique em OK. Uma nova janela do Flash ser exibida. 3 Selecione Arquivo> Salvar. Selecione uma pasta que contenha o arquivo de classe Greeter.as, chame o documento Flash de HelloWorld.fla e clique em OK. 4 Na paleta Ferramentas do Flash, selecione a ferramenta Texto e arraste at o Palco para definir um novo campo de texto, com aproximadamente 300 pixels de largura e 100 de altura. 5 No painel Propriedades, com o campo de texto ainda selecionado no Palco, defina o tipo de texto como "Texto dinmico" e digite mainText como o nome de ocorrncia do campo de texto. 6 Clique no primeiro quadro da linha de tempo principal. 7 No painel Aes, digite o seguinte script:
var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello();

8 Salve o arquivo.

4.6. Publicao ActionScript

teste

do

aplicativo

do

O desenvolvimento de software um processo interativo. Voc escreve um cdigo, tenta compil-lo e o edita at obter uma compilao limpa. Depois, voc executa o aplicativo compilado, testa-o para ver se ele cumpre o design pretendido e, caso negativo, edita o cdigo novamente at que o faa. Os ambientes de desenvolvimento do Flash e do Flex Builder oferecem vrios meios de publicar, testar e depurar aplicativos. Veja as etapas bsicas para testar o aplicativo HelloWorld em cada ambiente. Para publicar e testar um aplicativo do Action Script usando a ferramenta de autoria do Flash:

30

Action Script

1 Publique seu aplicativo e observe se h erros de compilao. Na ferramenta de autoria do Flash, seleccione Controlar> Testar filme para compilar o cdigo do Action Script e executar o aplicativo HelloWorld. 2 Se forem exibidos erros ou avisos na janela Sada durante o teste do aplicativo, corrija as causas dos erros nos arquivos HelloWorld.fla ou HelloWorld.as e tente testar o aplicativo novamente. 3 Se no houver nenhum erro de compilao, voc ver uma janela do Flash Player mostrando o aplicativo Hello World. Voc acabou de criar um aplicativo orientado a objectos simples, mas completo, que usa o Action Script 3.0.

4.7. Melhorias ao aplicativo HelloWorld


Para tornar o aplicativo um pouco mais interessante, agora voc o far solicitar e validar um nome de usurio em relao a uma lista de nomes predefinida. Primeiro, voc actualizar a classe Greeter para adicionar nova funcionalidade. Depois, voc actualizar o aplicativo para usar a nova funcionalidade. Para actualizar o arquivo Greeter.as: 1 Abra o arquivo Greeter.as. 2 Altere o contedo do arquivo com o seguinte (as linhas novas e alteradas so mostradas em negrito):
package { public class Greeter { /** * Defines the names that should receive a proper greeting. */ public static var validNames:Array = ["Sammy", "Frank", "Dean"]; /** * Builds a greeting string using the given name. */ public function sayHello(userName:String = ""):String { var greeting:String; if (userName == "") { greeting = "Hello. Please type your user name, and then press the Enter key."; } else if (validName(userName)) { greeting = "Hello, " + userName + "."; } else

31

Action Script

{ greeting = "Sorry " + userName + ", you are not on the list."; } return greeting; } /** * Checks whether a name is in the validNames list. */ public static function validName(inputName:String = ""):Boolean { if (validNames.indexOf(inputName) > -1) { return true; } else { return false; } } } }

A classe Greeter agora tem vrios novos recursos: A matriz validNames lista os nomes de usurios vlidos. A matriz inicializada com uma lista de trs nomes quando a classe Greeter carregada. O mtodo sayHello() agora aceita um nome de usurio e altera a saudao com base em algumas condies. Se userName for uma seqncia de caracteres vazia (""), a propriedade greeting ser definida para solicitar um nome ao usurio. Se o nome do usurio for vlido, a saudao se tornar "Hello, userName". Finalmente, se as duas condies no forem atendidas, a varivel greeting ser definida como "Sorry userName, you are not on the list". O mtodo validName() retornar true se inputName for encontrado na matriz validNames e false se no for encontrado. A instruo validNames.indexOf(inputName) verifica cada seqncia de caracteres na matriz validNames em relao seqncia de caracteres inputName. O mtodo Array.indexOf() retornar a posio de ndice da primeira ocorrncia de um objecto em uma matriz ou o valor -1 se o objecto no for encontrado nela. Em seguida, voc editar o arquivo Flash ou Flex que faz referncia a essa classe do Action Script. 1 Abra o arquivo HelloWorld.fla. 2 Modifique o script no Quadro 1 para que uma seqncia de caracteres ("") seja transmitida ao mtodo sayHello() da classe Greeter:
var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello("");

32

Action Script

3 Selecione a ferramenta Texto na paleta Ferramentas e crie dois novos campos de texto no Palco, lado a lado e diretamente sob o campo de texto mainText existente. 4 No primeiro campo de texto novo, digite o texto User Name: para servir de rtulo. 5 No outro campo de texto novo, e no Inspetor de propriedades, selecione InputText como o tipo de campo de texto. Selecione Linha nica como o Tipo de linha. Digite textIn como o nome de ocorrncia. 6 Clique no primeiro quadro da linha de tempo principal. 7 No painel Aes, adicione as seguintes linhas no final do script existente:
mainText.border = true; textIn.border = true; textIn.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed); function keyPressed(event:KeyboardEvent):void { if (event.keyCode == Keyboard.ENTER) { mainText.text = myGreeter.sayHello(textIn.text); } }

O novo cdigo adiciona a seguinte funcionalidade: As primeiras duas linhas simplesmente definem bordas para os dois campos de texto. Um campo de texto de entrada, como o campo textIn, possui um conjunto de eventos que ele pode despachar. O mtodo addEventListener() permite definir uma funo que executada quando um tipo de evento ocorre. Neste caso, o evento o pressionamento de uma tecla no teclado. A funo personalizada keyPressed() verifica se a tecla que foi pressionada a tecla Enter. Caso afirmativo, ela chama o mtodo sayHello() do objecto myGreeter , transmitindo o texto do campo de texto textIn como um parmetro. Esse mtodo retorna uma seqncia de caracteres de saudao com base no valor transmitido. A seqncia de caracteres retornada atribuda propriedade text do campo de texto mainText. O script completo para o Quadro 1 o seguinte:
var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello(""); mainText.border = true; textIn.border = true; textIn.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed); function keyPressed(event:KeyboardEvent):void { if (event.keyCode == Keyboard.ENTER)

33

Action Script

{ mainText.text = myGreeter.sayHello(textIn.text); } }

8 Salve o arquivo. 9 Selecione Controlar> Testar filme para executar o aplicativo. Durante a execuo do aplicativo, voc ser solicitado a inserir um nome de usurio. Se for vlido (Sammy, Frank ou Dean), o aplicativo exibir a mensagem de confirmao "hello".

5. Pacotes e namespaces
Os pacotes e espaos para nomes so conceitos relacionados. Os pacotes permitem compactar definies de classe juntas de uma forma que facilita o compartilhamento de dados e minimiza conflitos de nome. Os espaos para nomes permitem controlar a visibilidade de identificadores, como nomes de propriedades e mtodos, e podem ser aplicados ao cdigo quer ele residam dentro ou fora de um pacote. Os pacotes permitem organizar os arquivos de classe, e os espaos para nomes permitem gerenciar a visibilidade de propriedades e mtodos individuais. Os pacotes no Action Script 3.0 so implementados com espaos para nomes, mas eles no so sinnimos. Ao declarar um pacote, voc cria implicitamente um tipo especial de espao para nomes que ser conhecido em tempo de compilao. Os espaos para nomes, quando criados explicitamente, no so necessariamente conhecidos em tempo de compilao. O seguinte exemplo usa a diretiva package para criar um pacote simples contendo uma classe:
package samples { public class SampleCode { public var sampleGreeting:String; public function sampleFunction() { trace(sampleGreeting + " from sampleFunction()"); } } }

O nome da classe neste exemplo SampleCode. Como a classe est dentro do pacote de amostras, o compilador automaticamente qualifica o nome da classe em tempo de compilao em seu nome totalmente qualificado: samples.SampleCode. O compilador tambm qualifica os nomes de quaisquer propriedades e mtodos, para

34

Action Script

que sampleGreeting e samples.SampleCode.sampleGreeting respectivamente.

sampleFunction() se tornem e samples.SampleCode.sampleFunction(),

Muitos desenvolvedores, especialmente aqueles com experincia em programao Java, podem optar por colocar apenas classes no nvel superior de um pacote. O Action Script 3.0, no entanto, oferece suporte no apenas a classes no nvel superior de um pacote, mas tambm a variveis, funes e at mesmo instrues. Uma utilizao avanada desse recurso definir um espao para nomes no nvel superior de um pacote de forma que fique disponvel para todas as classes desse pacote. Observe, porm, que somente dois especificadores de acesso, public e internal, so permitidos no nvel superior de um pacote. Diferentemente de Java, que permite declarar classes aninhadas como particulares, o ActionScript 3.0 no oferece suporte a classes aninhadas nem a particulares. Entretanto, de muitas outras formas, os pacotes do Action Script 3.0 so semelhantes aos pacotes na linguagem de programao Java. Como voc pode ver no exemplo anterior, as referncias aos pacotes totalmente qualificados so expressas usando o operador dot (.), da mesma forma que em Java. Voc pode usar pacotes para organizar seu cdigo em uma estrutura hierrquica intuitiva para ser usada por outros programadores. Isso facilita o compartilhamento de cdigo, permitindo criar seu prprio pacote para compartilhar com outros e usar pacotes criados por outros em seu cdigo. O uso de pacotes tambm ajuda a garantir que os nomes de identificadores usados sejam exclusivos e no entrem em conflito com outros. Na verdade, alguns acham que essa a maior vantagem dos pacotes. Por exemplo, dois programadores que desejam compartilhar cdigo entre si criam uma classe chamada SampleCode. Sem pacotes, ela cria um conflito de nome e a nica soluo seria renomear uma das classes. Com pacotes, porm, o conflito de nomes facilmente evitado colocando uma classe, ou de preferncia as duas, em pacotes com nomes exclusivos. Tambm possvel incluir pontos incorporados no nome do pacote para criar pacotes aninhados. Isso permite criar uma organizao hierrquica de pacotes. Um bom exemplo disso o pacote flash.xml fornecido pelo Action Script 3.0. O pacote flash.xml aninhado dentro do pacote flash. O pacote flash.xml contm o analisador XML herdado que era usado em verses anteriores do Action Script. Um dos motivos para que agora ele resida no pacote flash.xml que o nome da classe XML herdada entra em conflito com o nome

35

Action Script

da nova classe XML que implementa a funcionalidade XML da especificao ECMAScript (E4X) disponvel no ActionScript 3.0. Embora o acto de mover a classe XML herdada para um pacote seja uma boa medida inicial, a maioria dos usurios das classes XML herdadas importa o pacote flash.xml, o que ir gerar o conflito de nomes a menos que voc se lembre de sempre usar o nome totalmente qualificado da classe XML herdada (flash.xml.XML). Para evitar essa situao, a classe XML herdada agora se chama XMLDocument, como mostra o seguinte exemplo:
package flash.xml { class XMLDocument {} class XMLNode {} class XMLSocket {} }

Grande parte do Action Script 3.0, organizado com base no pacote flash. Por exemplo, o pacote flash.display contm a API de lista de exibio, e o pacote flash.events contm o novo modelo de eventos.

5.1. Criao de pacotes


O Action Script 3.0 fornece uma flexibilidade significativa na forma de organizar pacotes, classes e arquivos de origem. As verses anteriores do Action Script permitiam somente uma classe por arquivo de origem e exigiam que o nome do arquivo de origem correspondesse ao nome da classe. O Action Script 3.0 permite incluir diversas classes em um nico arquivo de origem, mas somente uma classe em cada arquivo pode ser disponibilizada para um cdigo externo ao arquivo. Em outras palavras, somente uma classe em cada arquivo pode ser declarada dentro de uma declarao de pacote. As classes adicionais devem ser declaradas fora da definio do pacote, o que torna as classes invisveis ao cdigo fora do arquivo de origem. O nome da classe declarada dentro da definio do pacote deve corresponder ao nome do arquivo de origem. O Action Script 3.0 tambm oferece mais flexibilidade na forma de declarar pacotes. Nas verses anteriores do Action Script, os pacotes simplesmente representavam diretrios nos quais os arquivos de origem eram colocados e os pacotes no eram declarados com a instruo package, mas incluam o nome do pacote como parte do nome da classe totalmente qualificada na sua declarao de classe. Embora ainda representem diretrios no Action Script 3.0, os pacotes podem conter mais do que apenas classes. No Action Script 3.0, a instruo package usada para declarar um pacote, o que significa que voc tambm pode declarar variveis, funes e espaos para nomes no nvel superior de um pacote. possvel at incluir

36

Action Script

instrues executveis no nvel superior de um pacote. Se voc declarar variveis, funes ou espaos para nomes no nvel superior de um pacote, os nicos atributos disponveis nesse nvel sero public e internal, e somente uma declarao de nvel de pacote por arquivo poder usar o atributo public, quer a declarao seja uma classe, varivel, funo ou um espao para nomes. Os pacotes so teis para organizar o cdigo e evitar conflitos de nome. No confunda o conceito de pacotes com o conceito no relacionado de herana de classe. Duas classes que residem no mesmo pacote tm um espao para nomes em comum, mas no esto necessariamente relacionadas de outra forma. Da mesma forma, um pacote aninhado pode no ter nenhuma relao semntica com o pacote pai.

5.2. Importao de pacotes


Para usar uma classe que est dentro de um pacote, voc deve importar o pacote ou a classe especfica. Isso difere do Action Script 2.0, em que a importao de classes era opcional. Por exemplo, considere o exemplo de classe SampleCode apresentado anteriormente neste captulo. Se a classe residir em um pacote chamado sample, voc dever usar uma das seguintes instrues de importao usando a classe SampleCode:
import samples.*; ou import samples.SampleCode;

Em geral, as instrues import devem ser to especficas quanto possvel. Se voc pretende usar apenas a classe SampleCode do pacote samples, dever importar somente a classe SampleCode e no o pacote inteiro ao qual ela pertence. A importao de pacotes inteiros pode gerar conflitos de nome inesperados. Voc tambm deve colocar o cdigo-fonte que define o pacote ou a classe no caminho de classe. O caminho de classe uma lista definida pelo usurio de caminhos de diretrio locais que determina onde o compilador pesquisar as classes e os pacotes importados. O caminho de classe, s vezes, chamado de caminho de criao ou caminho de origem. Depois de importar adequadamente a classe ou o pacote, voc pode usar o nome totalmente qualificado da classe (samples.SampleCode) ou apenas o nome da classe em si (SampleCode).

37

Action Script

Os nomes totalmente qualificados so teis quando classes, mtodos ou propriedades com nomes idnticos geram cdigo ambguo, mas podem ser difceis de gerenciar se usados para todos os identificadores. Por exemplo, o uso do nome totalmente qualificado gera um cdigo detalhado ao instanciar uma ocorrncia da classe SampleCode:
var mySample:samples.SampleCode = new samples.SampleCode();

Conforme os nveis de pacotes aninhados crescem, a legibilidade do cdigo diminui. Nas situaes em que certamente no haver identificadores ambguos, voc pode tornar seu cdigo mais fcil de ler usando identificadores simples. Por exemplo, a instanciao de uma nova ocorrncia da classe SampleCode ser bem menos detalhada se voc usar somente o identificador de classe:
var mySample:SampleCode = new SampleCode();

Se voc tentar usar os nomes de identificador sem primeiro importar o pacote ou a classe apropriados, o compilador no conseguir encontrar as definies de classe. Entretanto, se voc importar um pacote ou uma classe, qualquer tentativa de definir um nome que entre em conflito com um nome importado ir gerar um erro. Durante a criao de um pacote, o especificador de acesso padro para todos os seus membros internal, o que significa que, por padro, os membros do pacote so visveis apenas por outros membros do mesmo pacote. Para que uma classe fique disponvel para o cdigo fora do pacote, necessrio declar-la como public. Por exemplo, o seguinte pacote contm duas classes, SampleCode e CodeFormatter:
// SampleCode.as file package samples { public class SampleCode {} } // CodeFormatter.as file package samples { class CodeFormatter {} }

A classe SampleCode visvel fora do pacote porque declarada como uma classe public. A classe CodeFormatter, porm, visvel somente dentro do prprio pacote de amostras. Se voc tentar acessar a classe CodeFormatter fora do pacote de amostras, ir gerar um erro, como mostra o exemplo a seguir:
import samples.SampleCode; import samples.CodeFormatter; var mySample:SampleCode = new SampleCode(); // okay, public class var myFormatter:CodeFormatter = new CodeFormatter(); // error

38

Action Script

Para que as duas classes fiquem disponveis fora do pacote, necessrio declar-las como public. Voc no pode aplicar o atributo public declarao do pacote. Os nomes totalmente qualificados so teis para resolver conflitos de nome que podem ocorrer durante o uso de pacotes. Esse cenrio pode surgir na importao de dois pacotes que definem classes com o mesmo identificador. Por exemplo, considere o seguinte pacote, que tambm tem uma classe chamada SampleCode:
package langref.samples { public class SampleCode {} }

Se voc importar as duas classes, como a seguir, ter um conflito de nomes ao fazer referncia classe SampleCode:
import samples.SampleCode; import langref.samples.SampleCode; var mySample:SampleCode = new SampleCode(); // name conflict

O compilador no tem como saber qual classe SampleCode deve usar. Para resolver o conflito, voc deve usar o nome totalmente qualificado de cada classe, como a seguir:
var sample1:samples.SampleCode = new samples.SampleCode(); var sample2:langref.samples.SampleCode = new langref.samples.SampleCode();

Nota: Os programadores com experincia em C++ costumam confundir a instruo importcom #include. A diretiva #include necessria em C++ porque os compiladores de C++ processam um arquivo por vez e no pesquisam definies de classes em outros arquivos a menos que um arquivo de cabealho seja includo explicitamente. O ActionScript 3.0 tem uma diretiva include, mas no foi criado para importar classes e pacotes. Para importar classes ou pacotes no ActionScript 3.0, necessrio usar a instruo import e colocar o arquivo de origem que contm o pacote no caminho da classe.

5.3. Namespaces - Espaos para nomes


Os espaos para nomes fornecem controlo sobre a visibilidade das propriedades e dos mtodos criados. Pense nos especificadores de controlo de acesso public, private, protected e internal como espaos para nomes embutidos. Se esses especificadores de controlo de acesso predefinidos no atenderem s suas necessidades, voc poder definir seus prprios espaos para nomes.

39

Action Script

Se voc est familiarizado com espaos para nomes XML, boa parte desta discusso no ser novidade, embora a sintaxe e os detalhes da implementao do ActionScript sejam ligeiramente diferentes do XML. Se nunca trabalhou com espaos para nomes antes, o conceito em si simples, mas a implementao tem uma terminologia especfica que voc dever aprender. Para entender como os espaos para nomes funcionam, bom saber que o nome de uma propriedade ou mtodo sempre contm duas partes: um identificador e um espao para nomes. O identificador o que normalmente entendemos como um nome. Por exemplo, os identificadores na seguinte definio de classe so sampleGreeting e sampleFunction():
class SampleCode { var sampleGreeting:String; function sampleFunction () { trace(sampleGreeting + " from sampleFunction()"); } }

Sempre que as definies no forem precedidas por um atributo de espao para nomes, seus nomes sero qualificados pelo espao para nomes internal padro, o que significa que ficam visveis apenas para os chamadores no mesmo pacote. Se o compilador estiver definido no modo estrito, o compilador emitir um aviso de que o espao para nomes internal se aplica a qualquer identificador sem um atributo de espao para nomes. Para garantir que um identificador fique disponvel em todo lugar, necessrio que seu nome especificamente seja precedido pelo atributo public. No cdigo anterior, sampleGreeting e sampleFunction() tm um valor de espao para nomes internal. H trs etapas bsicas que devem ser seguidas ao usar espaos para nomes: Primeiro, defina o espao para nomes usando a palavra-chave namespace. Por exemplo, o cdigo a seguir define o espao para nomes version1:
namespace version1;

Em segundo lugar, voc deve aplicar o espao para nomes usando-o no lugar de um especificador de controlo de acesso em uma declarao de propriedade ou mtodo. O exemplo a seguir coloca uma funo chamada myFunction() no espao para nomes version1:
version1 function myFunction() {}

40

Action Script

Por ltimo, depois de aplicar o espao para nomes, voc pode fazer referncia a ele com a diretiva use ou qualificando o nome de um identificador com um espao para nomes. O exemplo a seguir faz referncia funo myFunction() por meio da diretiva use:
use namespace version1; myFunction();

Tambm possvel usar um nome qualificado para fazer referncia funo myFunction(), como mostra o exemplo a seguir:
version1::myFunction();

5.4. Definio de espaos para nomes


Os espaos para nomes contm um valor, o URI (Localizador uniforme de recursos), que s vezes chamado de nome do espao para nomes. Um URI permite garantir que a definio do espao para nomes seja exclusiva. Voc cria um espao para nomes declarando uma definio para ele de duas formas. Voc pode definir um espao para nomes com um URI explcito, assim como definiria um espao para nomes XML, ou pode omitir o URI. O exemplo a seguir mostra como um espao para nomes pode ser definido usando um URI:
namespace flash_proxy = "http://www.adobe.com/flash/proxy";

O URI funciona como uma seqncia de caracteres de identificao exclusiva para o espao para nomes. Se voc omitir o URI, como no exemplo a seguir, o compilador criar uma seqncia de caracteres de identificao interna exclusiva no lugar do URI. Voc no possui acesso a essa seqncia de caracteres de identificao interna.
namespace flash_proxy;

Depois de definido, com ou sem um URI, o espao para nomes no poder ser redefinido no mesmo escopo. Atentativa de definir um espao para nomes definido anteriormente no mesmo escopo ir gerar um erro de compilao. Se for definido dentro de um pacote ou uma classe, talvez o espao para nomes no fique visvel para o cdigo fora do pacote ou da classe, a menos que seja usado o especificador de controlo de acesso apropriado. Por exemplo, o seguinte cdigo mostra o espao para nomes flash_proxy definido com o pacote flash.utils. No exemplo a seguir, a falta de um especificador de controlo de acesso significa que o

41

Action Script

espao para nomes flash_proxy deve ser visvel apenas para o cdigo dentro do pacote flash.utils e no para qualquer outro cdigo fora do pacote:
package flash.utils { namespace flash_proxy; }

O cdigo a seguir usa o atributo public para tornar o espao para nomes flash_proxy visvel para o cdigo fora do pacote:
package flash.utils { public namespace flash_proxy; }

5.5. Aplicao de espaos para nomes


Aplicar um espao para nomes significa colocar uma definio em um espao para nomes. As definies que podem ser colocadas em espaos para nomes incluem funes, variveis e constantes (no possvel colocar uma classe em um espao para nomes personalizado). Considere, por exemplo, uma funo declarada usando o espao para nomes de controlo de acesso public. O uso do atributo public em uma definio de funo coloca a funo no espao para nomes pblico, tornando-a disponvel para todo o cdigo. Depois de definir um espao para nomes, voc pode us-lo da mesma forma que usa o atributo public, e a definio ficar disponvel para o cdigo que pode referenciar o seu espao para nomes personalizado. Por exemplo, se voc definir um espao para nomes example1, poder adicionar um mtodo chamado myFunction() usando example1 como um atributo, como mostra este exemplo:
namespace example1; class someClass { example1 myFunction() {} }

A declarao do mtodo myFunction() usando o espao para nomes example1 como um atributo significa que o mtodo pertence ao espao para nomes example1. Tenha em mente o seguinte durante a aplicao de espaos para nomes: Voc s pode aplicar um espao para nomes por declarao. No h como aplicar um atributo de espao para nomes a mais de uma definio por vez. Em outras palavras, se voc quiser aplicar seu espao para nomes a dez

42

Action Script

funes diferentes, dever adicion-lo como um atributo a cada uma das dez definies de funo. Se aplicar um espao para nomes, tambm no ser possvel definir um especificador de controlo de acesso porque espaos para nomes e especificadores de acesso so mutuamente exclusivos. Ou seja, no possvel declarar uma funo ou propriedade como public, private, protected ou internal e aplicar o espao para nomes.

5.6. Referncia a espaos para nomes


No necessrio fazer referncia a um espao para nomes explicitamente durante o uso de um mtodo ou uma propriedade declarados com qualquer um dos espaos para nomes de controle de acesso, como public, private, protected e internal. Isso porque o acesso a esses espaos para nomes especiais controlado por contexto. Por exemplo, as definies colocadas no espao para nomes private ficam disponveis automaticamente para o cdigo dentro da mesma classe. Para os espaos para nomes que voc definir, porm, essa diferenciao de contexto no existe. Para usar um mtodo ou uma propriedade colocados em um espao para nomes personalizado, necessrio fazer referncia ao espao para nomes. Voc pode fazer referncia a espaos para nomes com a diretiva use namespace ou pode qualificar o nome com o espao para nomes usando o pontuador do qualificador de nome (::). A referncia a um espao para nomes com a diretiva use namespace "abre" o espao para nomes, para que ele possa ser aplicado a quaisquer identificadores no qualificados. Por exemplo, se definir o espao para nomes example1, voc poder acessar seus nomes usando use namespace example1:
use namespace example1; myFunction();

possvel abrir mais de um espao para nomes por vez. Quando aberto com use namespace, o espao para nomes permanece aberto em todo o bloco de cdigo no qual se encontra. No h como fechar explicitamente um espao para nomes. O uso de mais de um espao para nomes, contudo, aumenta a probabilidade de conflitos de nome. Se preferir no abrir um espao para nomes, voc poder evitar a diretiva use namespace qualificando o nome do mtodo ou da propriedade com o espao para nomes e o pontuador do qualificador de nome. Por exemplo, o seguinte cdigo mostra como qualificar o nome myFunction() com o espao para nomes example1:
example1::myFunction();

43

Action Script

5.7. Uso de espaos para nomes


Um exemplo real de um espao para nomes usado para evitar conflitos de nome a classe flash.utils.Proxy que faz parte do ActionScript 3.0. A classe Proxy, que a substituio para a propriedade Object. resolve do Action Script 2.0, permite interceptar diferenas em propriedades ou mtodos no definidos antes da ocorrncia de um erro. Todos os mtodos da classe Proxy residem no espao para nomes flash_proxy para evitar conflitos de nome. Para entender melhor como o espao para nomes flash_proxy usado, preciso entender como usar a classe Proxy. A funcionalidade da classe Proxy est disponvel somente para suas classes herdadas. Em outras palavras, se quiser usar os mtodos da classe Proxy em um objeto, a definio de classe do objeto deve estender a classe Proxy. Por exemplo, para interceptar as tentativas de chamar um mtodo no definido, necessrio estender a classe Proxy e substituir seu mtodo callProperty(). Voc deve se lembrar de que a implementao de espaos para nomes, em geral, um processo de trs etapas: definir, aplicar e referenciar um espao para nomes. Como os mtodos da classe Proxy nunca so chamados explicitamente, o espao para nomes flash_proxy definido e aplicado, mas no referenciado. O ActionScript 3.0 define o espao para nomes flash_proxy e o aplica na classe Proxy. O cdigo precisa apenas aplicar o espao para nomes flash_proxy s classes que estendem a classe Proxy. O espao para nomes flash_proxy definido no pacote flash.utils de forma semelhante seguinte:
package flash.utils { public namespace flash_proxy; }

O espao para nomes aplicado aos mtodos da classe Proxy como mostrado no seguinte trecho dessa classe:
public class Proxy { flash_proxy function callProperty(name:*, ... rest):* flash_proxy function deleteProperty(name:*):Boolean ... }

Como mostra o cdigo a seguir, primeiro voc deve importar a classe Proxy e o espao para nomes flash_proxy. Depois, deve declarar sua classe de forma que estenda a classe Proxy (voc tambm deve adicionar o atributo dynamic se estiver

44

Action Script

compilando no modo estrito). Ao substituir o mtodo callProperty(), o espao para nomes flash_proxy deve ser usado.
package { import flash.utils.Proxy; import flash.utils.flash_proxy; dynamic class MyProxy extends Proxy { flash_proxy override function callProperty(name:*, ...rest):* { trace("method call intercepted: " + name); } } }

Se criar uma ocorrncia da classe MyProxy e chamar um mtodo no definido, tal como o mtodo testing() chamado no exemplo a seguir, seu objeto Proxy ir interceptar a chamada de mtodo e executar as instrues dentro do mtodo callProperty() (neste caso, uma instruo trace() simples).
var mySample:MyProxy = new MyProxy(); mySample.testing(); // method call intercepted: testing

H duas vantagens em ter os mtodos da classe Proxy dentro do espao para nomes flash_proxy. Primeiro, ter um espao para nomes separado reduz a desordem na interface pblica de qualquer classe que estende a classe Proxy. (H aproximadamente uma dzia de mtodos na classe Proxy que podem ser substitudos e nenhum foi criado para ser chamado diretamente. Coloc-los no espao para nomes pblico poderia gerar confuso.) Em segundo lugar, o uso do espao para nomes flash_proxy evita os conflitos de nome caso a subclasse Proxy contenha mtodos de ocorrncia com nomes que correspondem a qualquer mtodo da classe Proxy. Por exemplo, voc pode querer chamar um de seus mtodos de callProperty(). O cdigo a seguir aceitvel, porque sua verso do mtodo callProperty() est em um espao para nomes diferente:
dynamic class MyProxy extends Proxy { public function callProperty() {} flash_proxy override function callProperty(name:*, ...rest):* { trace("method call intercepted: " + name); } }

Os espaos para nomes tambm podem ser teis para fornecer acesso a mtodos ou propriedades de uma forma que no seria possvel com os quatro especificadores de controlo de acesso (public, private, internal e protected). Por exemplo, voc pode ter alguns mtodos utilitrios espalhados em vrios pacotes. Voc quer disponibilizar esses mtodos para todos os pacotes, mas no quer que sejam

45

Action Script

pblicos. Para fazer isso, voc pode criar um novo espao para nomes e us-lo como seu prprio especificador de controlo de acesso especial. O exemplo a seguir usa um espao para nomes definido pelo usurio para agrupar duas funes que residem em pacotes diferentes. Ao agrup-las no mesmo espao para nomes, voc pode tornar as duas funes visveis para uma classe ou um pacote por meio de uma nica instruo use namespace. Este exemplo usa quatro arquivos para demonstrar a tcnica. Todos os arquivos devem estar no caminho de classe. O primeiro deles, myInternal.as, usado para definir o espao para nomes myInternal. Como o arquivo est em um pacote chamado example, voc deve coloc-lo em uma pasta chamada example. O espao para nomes marcado como public para que possa ser importado para outros pacotes.
// myInternal.as in folder example package example { public namespace myInternal = "http://www.adobe.com/2006/actionscript/examples"; }

O segundo e terceiro arquivos, Utility.as e Helper.as, definem as classes que contm os mtodos que devem estar disponveis para outros pacotes. A classe Utility um pacote example.alpha, o que significa que o arquivo deve ser colocado dentro de uma pasta chamada alpha, que uma subpasta da pasta example. A classe Helper um pacote example.beta, o que significa que o arquivo deve ser colocado dentro de uma pasta chamada beta, que tambm uma subpasta da pasta example. Os dois pacotes, example.alpha e example.beta, devem importar o espao para nomes antes de us-lo.
// Utility.as in the example/alpha folder package example.alpha { import example.myInternal; public class Utility { private static var _taskCounter:int = 0; public static function someTask() { _taskCounter++; } myInternal static function get taskCounter():int { return _taskCounter; } } } // Helper.as in the example/beta folder package example.beta { import example.myInternal; public class Helper { private static var _timeStamp:Date; public static function someTask()

46

Action Script

{ _timeStamp = new Date(); } myInternal static function get lastCalled():Date { return _timeStamp; } } }

O quarto arquivo, NamespaceUseCase.as, a classe de aplicativo principal e deve ser uma irm da pasta example. No Adobe Flash CS4 Professional, essa classe deveria ser usada como a classe de documento para o FLA. A classe NamespaceUseCase tambm importa o espao para nomes myInternal e o usa para chamar os dois mtodos estticos que residem nos outros pacotes. O exemplo usa mtodos estticos apenas para simplificar o cdigo. Os mtodos estticos e de ocorrncia podem ser colocados no espao para nomes myInternal.
// NamespaceUseCase.as package { import flash.display.MovieClip; import example.myInternal; // import namespace import example.alpha.Utility;// import Utility class import example.beta.Helper;// import Helper class public class NamespaceUseCase extends MovieClip { public function NamespaceUseCase() { use namespace myInternal; Utility.someTask(); Utility.someTask(); trace(Utility.taskCounter); // 2 Helper.someTask(); trace(Helper.lastCalled); // [time someTask() was last called] } } }

6. Variveis e tipos de dados


As variveis permitem armazenar valores usados no programa. Para declarar uma varivel, voc deve usar a instruo var com o nome da varivel. No ActionScript 2.0, o uso da instruo var s necessrio se voc usar anotaes de tipo. No ActionScript 3.0, o uso da instruo var sempre necessrio. Por exemplo, a seguinte linha do ActionScript declara uma varivel chamada i:
var i;

Se omitir a instruo var ao declarar uma varivel, voc obter um erro de compilador no modo estrito e um erro de tempo de execuo no modo padro. Por exemplo, a seguinte linha de cdigo resultar em um erro se a varivel i no for definida antes:

47

Action Script

i; // error if i was not previously defined

A associao de uma varivel a um tipo de dados deve ser feita durante a declarao da varivel. A declarao de uma varivel sem designar seu tipo legal, mas gera um aviso do compilador no modo estrito. Um tipo de varivel designado anexando o nome da varivel ao caractere dois-pontos (:) seguido do tipo da varivel. Por exemplo, o seguinte cdigo declara uma varivel i que do tipo int:
var i:int;

Voc atribui um valor varivel usando o operador de atribuio (=). Por exemplo, o seguinte cdigo declara uma varivel i e lhe atribui o valor 20:
var i:int; i = 20;

Pode ser mais conveniente atribuir um valor a uma varivel ao mesmo que em que ela declarada, como no exemplo a seguir:
var i:int = 20;

A tcnica de atribuir um valor a uma varivel no momento em que ela declarada comumente usado no apenas para atribuir valores primitivos, como inteiros e seqncias de caracteres, mas tambm para criar uma matriz ou instanciao de uma ocorrncia de uma classe. O exemplo a seguir mostra a declarao e a atribuio de um valor a uma matriz usando uma nica linha de cdigo:
var numArray:Array = ["zero", "one", "two"];

possvel criar uma ocorrncia de uma classe usando o operador new. O exemplo a seguir cria uma ocorrncia de uma classe chamada CustomClass e atribui uma referncia para a ocorrncia de classe recm-criada varivel chamada customItem:
var customItem:CustomClass = new CustomClass();

Se tiver mais de uma varivel a declarar, voc poder declar-las em uma nica linha de cdigo usando o operador vrgula (,) para separar as variveis. Por exemplo, o seguinte cdigo declara trs variveis em uma nica linha de cdigo:
var a:int, b:int, c:int;

Voc tambm pode atribuir valores a cada varivel na mesma linha de cdigo. Por exemplo, o seguinte cdigo declara trs variveis (a, b e c), e atribui um valor a cada uma:
var a:int = 10, b:int = 20, c:int = 30;

48

Action Script

Embora voc possa usar o operador vrgula para agrupar declaraes de variveis em uma instruo, isso pode reduzir a legibilidade do cdigo.

6.1. Noes variveis

bsicas

sobre

escopo

de

O escopo de uma varivel a rea do cdigo em que a varivel pode ser acessada por uma referncia lxica. Uma varivel global aquela definida em todas as reas do seu cdigo, enquanto uma varivel local aquela definida apenas em uma parte dele. No ActionScript 3.0, s variveis sempre atribudo o escopo da funo ou classe em que elas so declaradas. Uma varivel global aquela especificada fora de qualquer definio de funo ou classe. Por exemplo, o seguinte cdigo cria uma varivel global i declarando-a fora de qualquer funo: O exemplo mostra que uma varivel global est disponvel tanto dentro quanto fora da definio da funo.
var strGlobal:String = "Global"; function scopeTest() { trace(strGlobal); // Global } scopeTest(); trace(strGlobal); // Global

A varivel local declarada dentro de uma definio de funo. A menor rea de cdigo para a qual possvel definir uma varivel local uma definio de funo. Uma varivel local declarada dentro de uma funo existir somente nessa funo. Por exemplo, se voc declarar uma varivel chamada str2 dentro de uma funo chamada localScope(), essa varivel no ficar disponvel fora da funo.
function localScope() { var strLocal:String = "local"; } localScope(); trace(strLocal); // error because strLocal is not defined globally

Se o nome de varivel usado para a varivel local j estiver declarado como uma varivel global, a definio local ocultar (ou obscurecer) a definio global enquanto a varivel local estiver no escopo. A varivel global ainda existir fora da funo. Por exemplo, o cdigo a seguir cria uma varivel de seqncia de caracteres global chamada str1 e uma varivel local de mesmo nome dentro da funo scopeTest(). A instruo trace dentro da funo gera o valor local da varivel, mas a instruo trace fora da funo gera o valor global da varivel.
var str1:String = "Global"; function scopeTest ()

49

Action Script

{ var str1:String = "Local"; trace(str1); // Local } scopeTest(); trace(str1); // Global

As variveis do Action Script, diferentemente de C++ e Java, no possuem escopo em nvel de bloqueio. Um cdigo de bloqueio qualquer grupo de instrues entre uma chave de abertura ( { ) e uma de fechamento ( } ). Em algumas linguagens de programao, como C++ e Java, as variveis declaradas dentro de um bloco de cdigo no ficam disponveis fora dele. Essa restrio de escopo chamada de escopo em nvel de bloqueio e no existe no Action Script. Se voc declarar uma varivel dentro de um bloco de cdigo, ela ficar disponvel no apenas nesse bloco, mas tambm em outras partes da funo qual o bloco pertence. Por exemplo, a seguinte funo contm variveis que so definidas em vrios escopos de bloco. Todas as variveis esto disponveis na funo.
function blockTest (testArray:Array) { var numElements:int = testArray.length; if (numElements > 0) { var elemStr:String = "Element #"; for (var i:int = 0; i < numElements; i++) { var valueStr:String = i + ": " + testArray[i]; trace(elemStr + valueStr); } trace(elemStr, valueStr, i); // all still defined } trace(elemStr, valueStr, i); // all defined if numElements > 0 } blockTest(["Earth", "Moon", "Sun"]);

Uma implicao interessante da falta de escopo em nvel de bloco que voc pode ler ou gravar em uma varivel antes que ela seja declarada, contanto que ela seja declarada antes que a funo termine. Isso possvel por causa de uma tcnica chamada iamento, que significa que o compilador move todas as declaraes de varivel para o incio da funo. Por exemplo, o cdigo a seguir compilado muito embora a funo inicial trace() para a varivel num ocorra antes que a varivel num seja declarada:
trace(num); // NaN var num:Number = 10; trace(num); // 10

O compilador, porm, no iar nenhuma instruo de atribuio. Isso explica por que o trace() inicial de num resulta em NaN (e no um nmero), que o valor padro para as variveis do tipo de dados Number. Isso significa que voc pode atribuir valores a variveis mesmo antes que elas sejam declaradas, como mostra o seguinte exemplo:

50

Action Script

num = 5; trace(num); // 5 var num:Number = 10; trace(num); // 10

6.2. Valores padro


Um valor padro o valor que uma varivel contm antes que seu valor seja definido. Uma varivel inicializada quando seu valor definido pela primeira vez. Se voc declarar uma varivel, mas no definir seu valor, ela ser uma varivel no inicializada. O valor de uma varivel no inicializada depende de seu tipo de dados. A tabela a seguir descreve os valores padro de variveis, organizados por tipo de dados:

Para variveis do tipo Number, o valor padro NaN (e no um nmero), que um valor especial definido pelo padro IEEE-754 para indicar um valor que no representa um nmero. Se voc declarar uma varivel, mas no seu tipo de dados, o tipo de dados padro * ser aplicado, o que significa que, na verdade, a varivel sem tipo. Se voc tambm no inicializar uma varivel sem tipo com um valor, seu valor padro ser undefined. Para tipos de dados que no forem Boolean, Number, int e uint, o valor padro de qualquer varivel no inicializada ser null. Isso se aplica a todas as classes definidas pelo Action Script 3.0, bem como a quaisquer classes personalizadas que voc criar. O valor null no um valor vlido para variveis do tipo Boolean, Number, int ou uint. Se voc tentar atribuir um valor null a esse tipo de varivel, o valor ser convertido no valor padro para esse tipo de dados. Para variveis do tipo Object,

51

Action Script

possvel atribuir um valor null. Se voc tentar atribuir um valor undefined a uma varivel do tipo Object, o valor ser convertido em null. Para variveis do tipo Number, existe uma funo especial de nvel superior chamada isNaN() que retorna o valor booleano true se a varivel no for um nmero e false se for.

6.3. Tipos de dados


Um tipo de dados define um conjunto de valores. Por exemplo, o tipo de dados Boolean o conjunto de exatamente dois valores: true e false. Alm do tipo de dados Boolean, o ActionScript 3.0 define vrios tipos de dados mais comumente usados, como String, Number e Array. Voc pode escolher seus prprios tipos de dados usando classes ou interfaces para definir um conjunto de valores personalizado. Todos os valores no Action Script 3.0, sejam primitivos ou complexos, so objetos. Um valor primitivo aquele que pertence a um dos seguintes tipos de dados: Boolean, int, Number, String e uint. Trabalhar com valores primitivos, em geral, mais rpido do que trabalhar com valores complexos, porque o Action Script armazena valores primitivos de uma forma especial que torna as otimizaes de memria e velocidade possveis. Nota: Para os leitores interessados nos detalhes tcnicos, o Action Script armazena valores primitivos internamente como objetos imutveis. O fato de serem armazenados como objetos imutveis significa que transmitir por referncia, na prtica, o mesmo que transmitir por valor. Isso reduz o uso de memria e aumenta a velocidade de execuo, porque as referncias so significativamente menores do que os valores em si. Um valor complexo um valor que no primitivo. Os tipos de dados que definem conjuntos de valores complexos incluem Array, Date, Error, Function, RegExp, XML e XMLList. Muitas linguagens de programao distinguem os valores primitivos dos objetos delimitadores. Java, por exemplo, tem um primitivo int e a classe java.lang.Integer que o delimita. Os primitivos Java no so objetos, mas seus delimitadores so, o que torna os primitivos teis para algumas operaes e os objetos delimitadores mais adequados para outras operaes. No Action Script 3.0, os valores primitivos e seus objetos delimitadores so, na prtica, indistinguveis. Todos os valores, mesmo os primitivos, so objetos. O Flash Player e o Adobe AIR tratam esses

52

Action Script

tipos primitivos como casos especiais que se comportam como objetos mas no exigem a sobrecarga normal associada criao de objetos. Isso significa que as duas linhas de cdigo a seguir so equivalentes:
var someInt:int = 3; var someInt:int = new int(3);

Todos os tipos de dados primitivos e complexos listados acima so definidos pelas classes centrais do ActionScript 3.0. As classes centrais permitem criar objetos usando os valores literais em vez do operador new. Por exemplo, voc pode criar uma matriz usando um valor literal ou o construtor de classe Array, como a seguir:
var someArray:Array = [1, 2, 3]; // literal value var someArray:Array = new Array(1,2,3); // Array constructor

7. Verificao de tipos
A verificao de tipos pode ocorrer em tempo de compilao ou de execuo. Linguagens tipificadas estatisticamente, como C++ e Java, executam a verificao de tipos em tempo de compilao. Linguagens tipificadas dinamicamente, como Smalltalk e Python, manipulam a verificao de tipos em tempo de execuo. Como uma linguagem tipificada dinamicamente, o ActionScript 3.0 tem uma verificao de tipos em tempo de execuo, mas tambm oferece suporte verificao de tipos em tempo de compilao com um modo de compilador especial chamado modo estrito. No modo estrito, a verificao de tipos ocorre em tempo de compilao e de execuo, mas no modo padro, ela ocorre apenas em tempo de execuo. Linguagens tipificadas dinamicamente oferecem grande flexibilidade na estruturao do cdigo, mas s custas de permitir que erros de tipo se manifestem em tempo de execuo. Linguagens tipificadas estatisticamente relatam erros de tipo em tempo de compilao, mas exigem que as informaes de tipo sejam conhecidas em tempo de compilao.

7.1. Verificao compilao

de

tipos

em

tempo

de

A verificao de tipos em tempo de compilao 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 rpida deteco de erros de tipo. por isso que, por padro, o compilador do ActionScript no Adobe Flash CS4 Professional e no Adobe Flex Builder definido para ser executado no modo restrito.

53

Action Script

Para fornecer a verificao de tipos em tempo de compilao, o compilador precisa conhecer as informaes de tipo de dados para as variveis ou expresses no seu cdigo. Para declarar explicitamente um tipo de dados para uma varivel, adicione o operador dois-pontos (:) seguido do tipo de dados como um sufixo para o nome da varivel. Para associar um tipo de dados a um parmetro, use o operador dois-pontos seguido do tipo de dados. Por exemplo, o seguinte cdigo adiciona informaes de tipo de dados ao parmetro xParam e declara uma varivel myParam com um tipo de dados explcito:
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 cdigo a seguir declara um parmetro de funo xParam, do tipo Object, mas depois tenta atribuir valores do tipo String e Number ao parmetro. 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, porm, possvel optar seletivamente pela verificao de tipos em tempo de compilao deixando o lado direito de uma instruo de atribuio sem tipos. Voc pode marcar uma varivel ou expresso como sem tipo omitindo uma anotao de tipo ou usando a anotao de tipo especial de asterisco (*). Por exemplo, se o parmetro xParam no exemplo anterior for modificado de forma que no tenha mais uma anotao de tipo, o cdigo compilar 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;

54

Action Script

trace("Number: " + myNum); } } dynamicTest(100) dynamicTest("one hundred");

7.2. Verificao execuo

de

tipos

em

tempo

de

A verificao de tipos em tempo de execuo ocorrer no ActionScript 3.0 se voc compilar em modo restrito ou em modo de padro. Considere uma situao em que o valor 3 transmitido como um argumento para uma funo que espera uma matriz. No modo estrito, o compilador ir gerar um erro, porque o valor 3 no compatvel com o tipo de dados Array. Se voc desabilitar o modo estrito e executar no modo padro, o compilador no reclamar sobre incompatibilidade de tipos, mas a verificao em tempo de execuo do Flash Player e do Adobe AIR resultar em um erro em tempo de execuo. O exemplo a seguir mostra uma funo chamada typeTest() que espera um argumento Array mas tem um valor transmitido de 3. Isso gera um erro em tempo de execuo no modo padro, porque o valor 3 no um membro do tipo de dados (Array) declarado do parmetro.
function typeTest(xParam:Array) { trace(xParam); } var myNum:Number = 3; typeTest(myNum); // run-time error in ActionScript 3.0 standard mode

Tambm pode haver situaes em que h um erro de tipo em tempo de execuo mesmo durante a operao no modo estrito. Isso possvel se voc usar o modo estrito, mas optar pela verificao de tipos em tempo de compilao, usando uma varivel sem tipo. O uso de uma varivel sem tipo no elimina a verificao de tipos, mas a suspende at o tempo de execuo. Por exemplo, se a varivel myNum do exemplo anterior no tiver um tipo de dados declarado, o compilador no poder detectar a incompatibilidade de tipos, mas o Flash Player e o Adobe AIR iro gerar um erro de tempo de execuo porque comparam o valor do tempo de execuo de myNum, que est definido como 3 como resultado da instruo de atribuio, com o tipo de xParam, que definido com o tipo de dados Array.
function typeTest(xParam:Array) { trace(xParam); }

55

Action Script

var myNum = 3; typeTest(myNum); // run-time error in ActionScript 3.0

A verificao de tipos em tempo de execuo tambm permite um uso mais flexvel de herana que a verificao em tempo de compilao. Com a suspenso da verificao de tipos para o tempo de execuo, o modo padro permite referenciar as propriedades de uma subclasse mesmo que voc a eleve. Uma elevao ocorre quando voc usa uma classe base para declarar o tipo de uma ocorrncia de classe mas usa uma subclasse para instanci-la. Por exemplo, voc pode criar uma classe chamada ClassBase que pode ser estendida (classes com o atributo final no 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, possvel criar uma ocorrncia de classe que declarada usando o tipo de dados ClassBase, mas instanciada usando o construtor ClassExtender. Uma elevao considerada uma operao segura, porque a classe base no contm nenhuma propriedade ou mtodo que no esteja na subclasse.
var myClass:ClassBase = new ClassExtender();

Uma subclasse, porm, contm propriedades ou mtodos que sua classe base no contm. Por exemplo, a classe ClassExtender contm a propriedade someString, que no existe na classe ClassBase. No modo padro do ActionScript 3.0, possvel referenciar essa propriedade usando a ocorrncia myClass sem gerar um erro de tempo de compilao, como mostra o seguinte exemplo:
var myClass:ClassBase = new ClassExtender(); myClass.someString = "hello"; // no error in ActionScript 3.0 standard mode

7.3. O operador is
O operador is, que novo no Action Script 3.0, permite testar se uma varivel ou expresso um membro de um determinado tipo de dados. Nas verses anteriores do Action Script, o operador instanceof fornecia essa funcionalidade, mas, no Action

56

Action Script

Script 3.0, o operador instanceof no deve ser usado para testar a associao de tipo de dados. O operador is deve ser usado no lugar do operador instanceof para verificao de tipos manual, porque a expresso x instanceof y apenas verifica a existncia de x na cadeia de prottipos y (e, no Action Script 3.0, a cadeia de prottipos no fornece um retrato completo da hierarquia de herana). O operador is examina a hierarquia de herana apropriada e pode ser usado para verificar no apenas se um objeto uma ocorrncia de uma classe especfica, mas tambm de uma classe que implementa uma determinada interface. O exemplo a seguir cria uma ocorrncia da classe Sprite, chamada mySprite e usa o operador is para testar se mySprite uma ocorrncia 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 herana e relata adequadamente que mySprite compatvel com as classes Sprite e DisplayObject (a classe Sprite uma subclasse da classe DisplayObject). O operador is tambm 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 identifica corretamente que mySprite uma ocorrncia de Sprite ou DisplayObject, mas retorna false quando usado para testar se mySprite implementa a interface IEventDispatcher.
trace(mySprite instanceof Sprite); // true trace(mySprite DisplayObject);// true trace(mySprite instanceof IEventDispatcher); // false instanceof

7.4. O operador as
O operador as, que novo no Action Script 3.0, tambm permite verificar se uma expresso um membro de um determinado tipo de dados. Diferentemente do operador is, porm, o operador as no retorna um valor booleano. Em vez disso, o operador as retorna o valor da expresso 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 ocorrncia de Sprite um membro dos tipos de dados DisplayObject, IEventDispatcher e Number.

57

Action Script

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 expresso diferente de um tipo de dados como operando direita resultar em um erro.

7.5. Classes dinmicas


Uma classe dynamic define um objeto que pode ser alterado em tempo de execuo adicionando ou alterando propriedades e mtodos. Uma classe que no dinmica, como a classe String, uma classe selada. No possvel adicionar propriedades ou mtodos a uma classe selada em tempo de execuo. As classes dinmicas so criadas com o uso do atributo dynamic ao declarar uma classe. Por exemplo, o cdigo a seguir cria uma classe dinmica chamada Protean:
dynamic class Protean { private var privateGreeting:String = "hi"; public var publicGreeting:String = "hello"; function Protean() { trace("Protean instance created"); } }

Se, posteriormente, voc instanciar uma ocorrncia da classe Protean, poder adicionar propriedades ou mtodos a ela fora da definio da classe. Por exemplo, o cdigo a seguir cria uma ocorrncia da classe Protean e adiciona uma propriedade chamada aString e outra chamada aNumber ocorrncia:
var myProtean:Protean = new Protean(); myProtean.aString myProtean.aNumber = 3; trace(myProtean.aString, myProtean.aNumber); // testing 3 = "testing";

As propriedades adicionadas a uma ocorrncia de uma classe dinmica so entidades de tempo de execuo, por isso qualquer tipo de verificao feito em tempo de execuo. No possvel adicionar uma anotao de tipo a uma propriedade adicionada dessa forma. Voc tambm pode adicionar um mtodo ocorrncia myProtean definindo uma funo e anexando-a a uma propriedade da ocorrncia myProtean. O cdigo a seguir move a instruo de rastreamento para um mtodo chamado traceProtean():
var myProtean:Protean = new Protean(); myProtean.aString myProtean.aNumber = 3; myProtean.traceProtean = function () { = "testing";

58

Action Script

trace(this.aString, this.aNumber); }; myProtean.traceProtean(); // testing 3

Os mtodos criados dessa forma, entretanto, no tm acesso a qualquer propriedade ou mtodo particular da classe Protean. Alm disso, mesmo as referncias s propriedades ou mtodos pblicos da classe Protean devem ser qualificados com a palavra-chave this ou o nome da classe. O exemplo a seguir mostra a tentativa do mtodo traceProtean() de acessar as variveis particulares e pblicas da classe Protean.
myProtean.traceProtean = function () { trace(myProtean.privateGreeting); // // hello }; myProtean.traceProtean();

undefined

trace(myProtean.publicGreeting);

8. Descries de tipos de dados


Os tipos nativos primitivos incluem Boolean, int, Null, Number, String, uint e void. As classes base do ActionScript tambm definem os seguintes tipos de dados complexos: Object, Array, Date, Error, Function, RegExp, XML e XMLList.

8.1. Tipo de dados Boolean


O tipo de dados Boolean compreende dois valores: true e false. Nenhum outro valor vlido para variveis do tipo Boolean. O valor padro de uma varivel Boolean que foi declarada mas no inicializada false.

8.2. Tipo de dados int


O tipo de dados int armazenado internamente como um inteiro de 32 bits e compreende o conjunto de inteiros de -2.147.483.648 (-231) a 2.147.483.647 (231 - 1), inclusive. As verses anteriores do ActionScript ofereciam apenas o tipo de dados Number, que era usado para nmeros inteiros e de ponto flutuante. No ActionScript 3.0, agora voc tem acesso a tipos de computador de nvel baixo para inteiros de 32 bits assinados e no assinados. Se a sua varivel no tiver nmeros de ponto flutuante, o uso do tipo de dados int em vez do tipo de dados Number dever ser mais rpido e eficiente. Para valores inteiros fora do intervalo dos valores int mnimo e mximo, use o tipo de dados Number, que pode manipular valores entre positivo e negativo

59

Action Script

9.007.199.254.740.992 (valores inteiros de 53 bits). O valor padro para variveis do tipo de dados int 0.

8.3. Tipo de dados Null


O tipo de dados Null contm apenas um valor, null. o valor padro 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, contm o valor null. O Flash Player e o Adobe AIR convertero o valor null no valor padro apropriado se voc tentar atribuir null a variveis do tipo Boolean, Number, int ou uint. Voc no pode usar esse tipo de dados como uma anotao de tipo.

8.4. Tipo de dados Number


No Action Script 3.0, o tipo de dados Number pode representar inteiros, inteiros no assinados e nmeros 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 nmeros de ponto flutuante. Para armazenar um nmero de ponto flutuante, inclua um ponto decimal no nmero. Se voc omitir um ponto decimal, o nmero ser armazenado como um inteiro. O tipo de dados Number usa o formato de preciso dupla de 64 bits conforme especificado pelo Padro IEEE para Aritmtica de Ponto Flutuante Binrio (IEEE-754). Esse padro determina como os nmeros de ponto flutuante so armazenados usando os 64 bits disponveis. Um bit usado para designar se o nmero positivo ou negativo. Onze bits so usados para o expoente, que armazenado como base 2. Os 52 bits restantes so usados para armazenar o significando (tambm chamado de mantissa), que o nmero elevado potncia indicada pelo expoente. Com o uso de alguns bits para armazenar um expoente, o tipo de dados Number pode armazenar nmeros 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 nmero to grande quanto 265 - 1. Com o uso de 11 bits para armazenar um expoente, o tipo de dados Number pode elevar seu significando potncia de 21023.

60

Action Script

Os valores mximos e mnimo que o tipo Number pode representar so armazenados em propriedades estticas 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 nmeros seja enorme, seu custo a preciso. O tipo de dados Number usa 52 bits para armazenar o significando, por isso os nmeros que exigem mais de 52 bits para fazer uma representao precisa, como a frao 1/3, so apenas aproximaes. Se o seu aplicativo exibir preciso absoluta com nmeros decimais, ser necessrio usar um software que implemente a aritmtica de ponto flutuante decimal em vez da aritmtica de ponto flutuante binrio. Durante o armazenamento de valore inteiros com o tipo de dados Number, somente os 52 bits do significando so 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 (253) a 9.007.199.254.740.992 (253). O Flash Player e o Adobe AIR usam o valor NaN no apenas como o valor padro para variveis do tipo Number, mas tambm como resultado de qualquer operao que deve retornar um nmero e no retorna. Por exemplo, se voc tentar calcular a raiz quadrada de um nmero negativo, o resultado ser NaN. Outros valores Number especiais incluem infinito positivo e infinito negativo. Nota: O resultado da diviso por 0 ser apenas NaN se o divisor tambm for 0. A diviso por 0 produz infinity quando o dividendo positivo ou -infinity quando o dividendo negativo.

8.5. Tipo de dados String


O tipo de dados String representa uma seqncia de caracteres de 16 bits. Os Strings so armazenados internamente como caracteres Unicode, usando o formato UTF-16, Eles so valores imutveis, assim como na linguagem de programao Java. Uma operao sobre um valor String retorna uma nova ocorrncia da seqncia de caracteres. O valor padro para uma varivel declarada com o tipo de dados String null. O valor null no o mesmo que a seqncia de caracteres vazia (""), muito embora ambos representem a ausncia de caracteres.

61

Action Script

8.6. Tipo de dados uint


O tipo de dados int armazenado internamente como um inteiro no assinado de 32 bits e compreende o conjunto de inteiros de 0 a 4.294.967.295 (232 - 1), inclusive. Use o tipo de dados uint para circunstncias especiais que exigem inteiros no 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 no apropriado para manipular valores de cor. Para valores inteiros maiores do que o valor uint mximo, use o tipo de dados Number, que pode manipular valores inteiros de 53 bits. O valor padro para variveis do tipo de dados uint 0.

8.7. Tipo de dados void


O tipo de dados void contm apenas um valor, undefined. Nas verses anteriores do Action Script, undefined era o valor padro para ocorrncias da classe Object. No Action Script 3.0, o valor padro para ocorrncias de Object null. Se voc tentar atribuir um valor undefined a uma ocorrncia da classe Object, o Flash Player ou o Adobe AIR convertero o valor em null. possvel atribuir apenas um valor de undefined a variveis sem tipo. Variveis sem tipo so aquelas que no possuem nenhuma anotao de tipo ou usam o smbolo asterisco (*) para a anotao de tipo. Voc pode usar void apenas como uma anotao de tipo de retorno.

8.8. Tipo de dados Object


O tipo de dados Object definido pela classe Object. A classe Object serve de classe base para todas as definies de classe no ActionScript. A verso do ActionScript 3.0 do tipo de dados Object difere das verses anteriores de trs formas. Primeiro, o tipo de dados Object no mais o tipo de dados padro atribudo a variveis sem nenhuma anotao de tipo. Em segundo lugar, o tipo de dados Object no inclui mais o valor undefined, que costumava ser o valor padro das ocorrncias Object. Em terceiro lugar, no ActionScript 3.0, o valor padro para ocorrncias da classe Object null. Nas verses anteriores do ActionScript, uma varivel sem nenhuma anotao de tipo era automaticamente atribuda ao tipo de dados Object. Isso no acontece mais no Action Script 3.0, que agora inclui a idia de uma varivel realmente sem tipo. As variveis sem nenhuma anotao de tipo agora so consideradas sem tipo. Se preferir deixar mais claro para os leitores do cdigo que sua inteno deixar uma varivel sem tipo, voc pode usar o novo smbolo de asterisco (*) para a anotao de

62

Action Script

tipo, que equivalente a omitir uma anotao de tipo. O exemplo a seguir mostra duas instrues equivalentes, que declaram uma varivel sem tipo x:
var x var x:*

Somente variveis sem tipo podem manter o valor undefined. Se voc tentar atribuir o valor undefined a uma varivel que possui um tipo de dados, o Flash Player ou o Adobe AIR convertero o valor undefined no valor padro desse tipo de dados. Para ocorrncias do tipo de dados Object, o valor padro null, o que significa que o Flash Player ou o Adobe AIR convertero o valor undefined em null se voc tentar atribuir undefined a uma ocorrncia de Object.

8.9. Converses de tipo


Uma converso de tipo ocorre quando um valor transformado em um valor de um tipo de dados diferente. As converses de tipo podem ser implcitas ou explcitas. A converso implcita, que tambm chamada de coero, s vezes, executada pelo Flash Player ou Adobe AIR em tempo de execuo. Por exemplo, se o valor 2 for atribudo a uma varivel do tipo de dados Boolean, o Flash Player ou o Adobe AIR converter o valor 2 no valor booleano true antes de atribuir o valor varivel. A converso explcita, tambm chamada de projeo, ocorre quando o cdigo instrui o compilador a tratar uma varivel de um tipo de dados como se pertencesse a um tipo de dados diferente. Quando os valores primitivos esto envolvidos, a projeo realmente converte os valores de um tipo de dados para outro. Para projetar um objeto em um tipo diferente, use parnteses para delimitar o nome do objeto e preceda-o com o nome do novo tipo. Por exemplo, o seguinte cdigo usa um valor booleano e projeta-o em um inteiro:
var myBoolean:Boolean = true; var myINT:int = int(myBoolean); trace(myINT); // 1

8.10. Converses implcitas


As converses implcitas acontecem em tempo de execuo em diversos contextos: Em instrues de atribuio Quando os valores so transmitidos como argumentos de funo Quando os valores so retornados de funes Em expresses que usam determinados operadores, como o operador de adio (+)

63

Action Script

Para tipos definidos pelo usurio, as converses implcitas so bem-sucedidas quando o valor a ser convertido uma ocorrncia da classe de destino ou de uma classe derivada dela. Se uma converso implcita no for bem- sucedida, ocorrer um erro. Por exemplo, o seguinte cdigo contm uma converso implcita bem-sucedida e outra mal sucedida:
class A {} class B extends A {} var objA:A = new A(); var objB:B = new B(); var arr:Array = new Array(); objA = objB; // Conversion succeeds. objB = arr; // Conversion fails.

Para os tipos primitivos, as converses implcitas so tratadas chamando os mesmos algoritmos de converso internos que so chamados pelas funes de converso explcitas. As sees a seguir discutem essas converses de tipo primitivas em detalhes.

8.11. Converses explcitas


til usar converses explcitas, ou projeo, ao compilar no modo estrito, porque pode haver situaes em que voc no deseja que uma incompatibilidade de tipos gere um erro em tempo de compilao. Pode ser o caso de quando voc sabe que a coero converter os valores corretamente em tempo de execuo. Por exemplo, ao trabalhar com dados recebidos de um formulrio, voc pode querer contar com a coero para converter determinados valores de seqncia de caracteres em valores numricos. O cdigo a seguir gera um erro em tempo de compilao, muito embora o cdigo seja executado corretamente no modo padro:
var quantityField:String = "3"; var quantity:int = quantityField; // compile time error in strict mode

Se quiser continuar a usar o modo estrito, mas preferir converter a seqncia de caracteres em um inteiro, voc pode usar a converso explcita da seguinte forma:
var quantityField:String = "3"; var quantity:int = int(quantityField); // Explicit conversion succeeds.

8.12. Projeco para int, uint e Number


possvel projetar qualquer tipo de dados em um dos trs tipos de nmeros: int, uint e Number. Se o Flash Player ou o Adobe AIR no conseguir converter o nmero por algum motivo, o valor padro de 0 ser atribudo aos tipos de dados int e uint, e o valor padro de NaN ser atribudo para o tipo de dados Number. Se voc

64

Action Script

converter um valor Boolean em um nmero, true se tornar o valor 1 e false se tornar o valor 0.
var myBoolean:Boolean = true; var myUINT:uint = uint(myBoolean); var myINT:int = int(myBoolean); var myNum:Number = Number(myBoolean); trace(myUINT, myINT, myNum); // 1 1 1 myBoolean = false; myUINT = uint(myBoolean); myINT = int(myBoolean); myNum = Number(myBoolean); trace(myUINT, myINT, myNum); // 0 0 0

Os valores String que contm apenas dgitos podem ser convertidos com xito em um dos tipos de nmero. Os tipos de nmero tambm podem converter seqncias de caracteres que parecem nmeros negativos ou que representam um valor hexadecimal (por exemplo, 0x1A). O processo de converso ignora os caracteres de espao em branco esquerda e direita no valor da seqncia de caracteres. Tambm possvel projetar seqncias de caracteres que se parecem com nmeros de ponto flutuante usando Number(). A incluso de um ponto decimal faz com que uint() e int() retornem um inteiro, truncando o decimal e os caracteres seguintes. Por exemplo, os seguintes valores de seqncia de caracteres podem ser projetados em nmeros:
trace(uint("5")); // 5 trace(uint("-5")); // 4294967291. It wraps around from MAX_VALUE trace(uint(" 27 ")); // 27 trace(uint("3.7")); // 3 trace(int("3.7")); // 3 trace(int("0x1A")); // 26 trace(Number("3.7")); // 3.7

Os valores String que contm caracteres no numricos retornam 0 quando projetados com int() ou uint() e NaN quando projetados com Number(). O processo de converso ignora espao em branco esquerda e direita, mas retorna 0 ou NaN se uma seqncia de caracteres tiver espao em branco separando dois nmeros.
trace(uint("5a")); // 0 trace(uint("ten")); // 0 trace(uint("17 63")); // 0

No Action Script 3.0, a funo Number() no suporta mais nmeros octais, ou de base 8. Se voc fornecer uma seqncia de caracteres com um zero esquerda para a funo Number() do Action Script 2.0, o nmero ser interpretado como um nmero octal e convertido em seu equivalente decimal. Isso no acontece com a funo Number() no Action Script 3.0, que em vez disso ignora o zero esquerda. Por exemplo, o seguinte cdigo gera uma sada diferente quando compilado usando verses diferentes do Action Script:
trace(Number("044")); // ActionScript 3.0 44 // ActionScript 2.0 36

A projeco no necessria quando um valor de um tipo numrico atribudo a uma varivel de um tipo numrico diferente. Mesmo no modo estrito, os tipos

65

Action Script

numricos so implicitamente convertidos em outros tipos numricos. Isso significa que, em alguns casos, quando o intervalo de um tipo for excedido, o resultado poder gerar valores inesperados. Os seguintes exemplos compilam no modo estrito, embora alguns gerem valores inesperados:
var myUInt:uint = -3; // Assign int/Number value to uint variable trace(myUInt); // 4294967293 var myNum:Number = sampleUINT; // Assign int/uint value to Number variable trace(myNum) // 4294967293 var myInt:int = uint.MAX_VALUE + 1; // Assign Number value to uint variable trace(myInt); // 0 myInt = int.MAX_VALUE + 1; // Assign uint/Number value to int variable trace(myInt); // -2147483648

A tabela a seguir resume os resultados da projeco para os tipos de dados Number, int ou uint a partir de outros tipos de dados.

A projeco para Boolean a partir de qualquer tipo de dados numrico (uint, int e Number) resultar em false se o valor numrico for 0 e em true se no for. Para o tipo de dados Number, o valor NaN tambm resulta em false. O exemplo a seguir mostra os resultados da projeco dos nmeros em -1, 0 e 1:
var myNum:Number; for (myNum = -1; myNum<2; myNum++) { trace("Boolean(" + myNum +") is " + Boolean(myNum)); }

A sada do exemplo mostra que, dos trs nmeros, somente 0 retorna um valor false:
Boolean(-1) is true Boolean(0) is false Boolean(1) is true

A projeco para Boolean de um valor String retornar false se a seqncia de caracteres for null ou vazia (""). Do contrrio, retornar null.
var str1:String; // Uninitialized string is null. trace(Boolean(str1)); // false

66

Action Script

var str2:String = ""; // empty string trace(Boolean(str2)); // false var str3:String = " "; // white space only trace(Boolean(str3)); // true

A projeco para Boolean de uma ocorrncia da classe Object retornar false se a ocorrncia for null; do contrrio, retornar true:
var myObj:Object; // Uninitialized object is null. trace(Boolean(myObj)); // false myObj = new Object(); // instantiate trace(Boolean(myObj)); // true

As variveis Boolean obtm tratamento especial no modo estrito no que se refere a atribuir valores de qualquer tipo de dados a uma varivel Boolean sem projeo. A coero implcita de todos os tipos de dados para o tipo de dados Boolean ocorre mesmo no modo estrito. Em outras palavras, diferentemente de quase todos os outros tipos de dados, a projeco para Boolean no necessria para evitar erros no modo estrito. Os seguintes exemplos compilam no modo estrito e se comportam conforme o esperado em tempo de execuo:
var myObj:Object = new Object(); // instantiate var bool:Boolean = myObj; trace(bool); // true bool = "random string"; trace(bool); // true bool = new Array(); trace(bool); // true bool = NaN; trace(bool); // false

A tabela a seguir resume os resultados da projeco para o tipo de dados Boolean a partir de outros tipos de dados:

8.13. Projeco para String


A projeco para o tipo de dados String de qualquer tipo de dados numrico retorna uma representao de seqncia de caracteres do nmero. A projeco para o tipo de dados String de um valor Boolean retornar a seqncia de caracteres "true" se o valor for true e retornar a seqncia de caracteres "false" se o valor for false. A projeco para String de uma ocorrncia da classe Object retornar a seqncia de caracteres "null" se a ocorrncia for null. Caso contrrio, a projeco para o tipo String da classe Object retornar a seqncia de caracteres "[object Object]" .

67

Action Script

A projeco para String de uma ocorrncia da classe Array retorna uma seqncia de caracteres incluindo uma lista delimitada por vrgula de todos os elementos da matriz. Por exemplo, a seguinte projeco para o tipo de dados String retorna uma seqncia de caracteres contendo os trs elementos da matriz:
var myArray:Array = ["primary", "secondary", "tertiary"]; trace(String(myArray)); // primary,secondary,tertiary

A projeco para String de uma ocorrncia da classe Date retorna uma representao da seqncia de caracteres da data que a ocorrncia contm. Por exemplo, o seguinte exemplo retorna uma representao da seqncia de caracteres da ocorrncia da classe Date (a sada mostra o resultado para o Horrio de Vero do Pacfico):
var myDate:Date = new Date(2005,6,1); trace(String(myDate)); // Fri Jul 1 00:00:00 GMT-0700 2005

9. Sintaxe
A sintaxe de uma linguagem define um conjunto de regras que deve ser seguido durante a escrita de cdigo executvel.

9.1. Diferenciao minsculas

entre

maisculas

O Action Script 3.0 uma linguagem que diferencia maisculas e minsculas. Os identificadores que diferem somente em maisculas e minsculas so considerados identificadores diferentes. Por exemplo, o cdigo a seguir cria duas variveis diferentes:
var num1:int; var Num1:int;

9.2. Sintaxe de pontos


O operador dot (.) fornece uma maneira de acessar as propriedades e os mtodos de um objeto. Com o uso da sintaxe de pontos, possvel fazer referncia a uma propriedade ou um mtodo de classe usando um nome de ocorrncia, seguido do operador dot e do nome da propriedade ou do mtodo. Por exemplo, considere a seguinte definio de classe:

68

Action Script

class DotExample { public var prop1:String; public function method1():void {} }

Com o uso da sintaxe de pontos, possvel acessar a propriedade prop1 e o mtodo method1() usando o nome de ocorrncia criado no seguinte cdigo:
var myDotEx:DotExample = new DotExample(); myDotEx.prop1 = "hello"; myDotEx.method1();

possvel usar a sintaxe de pontos para definir pacotes. O operador dot usado para fazer referncia a pacotes aninhados. Por exemplo, a classe EventDispatcher reside em um pacote chamado eventos que aninhado dentro do pacote chamado flash. Voc pode fazer referncia aos pacotes de eventos usando a seguinte expresso:
flash.events

Voc tambm pode fazer referncia classe EventDispatcher usando esta expresso:
flash.events.EventDispatcher

9.3. Sintaxe de barras


A sintaxe de barras no suportada no Action Script 3.0. Ela foi usada nas verses anteriores do ActionScript para indicar o caminho de um clipe de filme ou varivel.

9.4. Literais
Um literal um valor que aparece directamente em seu cdigo. Os seguintes exemplos so de literais:
17 "hello" -3 9.4 null undefined true False

Os literais tambm podem ser agrupados para formar literais compostos. Os literais de matriz so colocados entre colchetes ([]) e usam a vrgula para separar elementos de matriz.

69

Action Script

Um literal de matriz pode ser usado para inicializar uma matriz. Os exemplos a seguir mostram duas matrizes que so inicializadas usando literais de matriz. possvel usar a instruo new e transmitir o literal composto como um parmetro para o construtor de classe Array, mas voc tambm pode atribuir valores literais diretamente ao instanciar ocorrncias das seguintes classes centrais do ActionScript: Object, Array, String, Number, int, uint, XML, XMLList e Boolean.
// Use new statement. var myStrings:Array = new Array(["alpha", "beta", "gamma"]); var myNums:Array = new Array([1,2,3,5,8]); // Assign literal directly. var myStrings:Array = ["alpha", "beta", "gamma"]; var myNums:Array = [1,2,3,5,8];

Os literais tambm podem ser usados para inicializar um objeto genrico. Um objeto genrico uma ocorrncia da classe Object. Os literais Object so colocados entre chaves ({}) e usam a vrgula para separar propriedades de objetos. Cada propriedade declarada com o caractere dois-pontos (:), que separa o nome da propriedade do valor da propriedade. possvel criar um objeto genrico usando a instruo new e transmitir o literal de objeto como um parmetro para o construtor de classe Objeto ou atribuir o literal de objeto diretamente ocorrncia que voc est declarando. O exemplo a seguir demonstra duas formas alternativas de criar um novo objeto genrico e inicializar o objeto com trs propriedades (propA, propB e propC), cada uma com valores definidos como 1, 2, e 3, respectivamente:
// Use new statement and add properties. var myObject:Object = new Object(); myObject.propA = 1; myObject.propB = 2; myObject.propC = 3; // Assign literal directly. var myObject:Object = {propA:1, propB:2, propC:3};

9.5. Ponto-e-vrgula
Voc pode usar o caracter ponto-e-vrgula (;) para encerrar uma instruo. Opcionalmente, se omitir o caractere ponto-e-vrgula, o compilador presumir que cada linha de cdigo representa uma nica instruo. Como muitos programadores esto acostumados a usar o ponto-e-vrgula para denotar o fim de uma instruo, seu cdigo poder ser mais fcil de ler se voc usar consistentemente ponto-e-vrgula para encerrar as instrues. O uso de um ponto-e-vrgula para encerrar uma instruo permite colocar mais de uma instruo em uma nica linha, mas isso pode tornar o cdigo mais difcil de ler.

70

Action Script

9.6. Parnteses
Voc pode usar parnteses (()) de trs formas no ActionScript 3.0. Primeiro, voc pode usar parnteses para alterar a ordem das operaes em uma expresso. As operaes que so agrupadas dentro de parnteses so sempre executadas primeiro. Por exemplo, os parnteses so usados para alterar a ordem das operaes no seguinte cdigo:
trace(2 + 3 * 4); // 14 trace((2 + 3) * 4); // 20

Em segundo lugar, voc pode usar parnteses com o operador vrgula (,) para avaliar uma srie de expresses e retornar o resultado da expresso final, como mostra o seguinte exemplo:
var a:int = 2; var b:int = 3; trace((a++, b++, a+b)); // 7

Em terceiro lugar, voc pode usar parnteses para transmitir um ou mais parmetros para funes ou mtodos, como mostra o exemplo a seguir, que transmite um valor String para a funo trace():
trace("hello"); // hello

9.7. Comentrios
O cdigo do Action Script 3.0 oferece suporte a dois tipos de comentrios: comentrios de uma nica linha e de vrias linhas. Esses mecanismos de comentrios so semelhantes aos do C++ e Java. O compilador ir ignorar o texto marcado com um comentrio. Os comentrios de uma nica linha comeam com dois caracteres de barra inclinada (//) e continuam at o fim da linha. Por exemplo, o seguinte cdigo contm um comentrio de uma nica linha:
var someNumber:Number = 3; // a single line comment

Os comentrios de vrias linhas comeam com uma barra inclinada e um asterisco (/*) e terminam com um asterisco e uma barra inclinada (*/).
/* This is multiline comment that can span more than one line of code. */

71

Action Script

9.8. Palavras-chave e palavras reservadas


As palavras reservadas so palavras que no podem ser usadas como identificadores no cdigo porque so para uso do ActionScript. Elas incluem palavraschave lxicas, que so removidas do espao para nomes do programa pelo compilador. O compilador relatar um erro se voc usar uma palavra-chave lxica como identificador. A seguinte tabela lista as palavras-chave lxicas do Action Script 3.0.
as class delete false if instanceof native private super to use with break const do finally implements interface new protected switch true var case continue else for import internal null public this try void catch default extends function in is package return throw typeof while

H um pequeno conjunto de palavras-chave, chamado palavras-chave sintticas, que pode ser usado como identificador, mas tm um significado especial em determinados contextos. Tambm h vrios identificadores que, s vezes, so referidos como palavras reservadas futuras. Eles no so reservados pelo Action Script 3.0, embora alguns sejam tratados como palavras-chave pelo software que incorpora o Action Script 3.0. Voc pode usar vrios desses identificadores no seu cdigo, mas a Adobe no recomenda essa prtica porque eles podem aparecer como palavras-chave em uma verso subseqente da linguagem.
abstract char export long throws virtual boolean debugger float prototype to volatile byte double goto short transient cast enum intrinsic synchronized type

72

Action Script

9.9. Constantes
O Action Script 3.0 oferece suporte instruo const, que voc pode usar para criar constantes. As constantes so propriedades com um valor fixo que no pode ser alterado. Voc pode atribuir um valor a uma constante apenas uma vez, e a atribuio deve ocorrer prxima declarao da constante. Por exemplo, se uma constante for declarada como um membro de uma classe, voc poder atribuir-lhe um valor somente como parte da declarao ou dentro do construtor de classe. O seguinte cdigo declara duas constantes. A primeira, MINIMUM, tem um valor atribudo como parte da instruo de declarao. A segunda, MAXIMUM, tem um valor atribudo no construtor. Observe que este exemplo compilado apenas no modo padro porque o modo estrito s permite que um valor de constante seja atribudo em tempo de inicializao.
class A { public const MINIMUM:int = 0; public const MAXIMUM:int; public function A() { MAXIMUM = 10; } } var a:A = new A(); trace(a.MINIMUM); // 0 trace(a.MAXIMUM); // 10

Um erro ser gerado se voc tentar atribuir um valor inicial a uma constante de qualquer outra forma. Por exemplo, se voc tentar definir o valor inicial de MAXIMUM fora da classe, ocorrer um erro de tempo de execuo.
class A { public const MINIMUM:int = 0; public const MAXIMUM:int; } var a:A = new A(); a["MAXIMUM"] = 10; // run-time error

O Action Script 3.0 define uma ampla gama de constantes para sua convenincia. Por conveno, as constantes do ActionScript usam tudo em letras maisculas, com as palavras separadas pelo caractere de sublinhado (_). Por exemplo, a definio de classe MouseEvent usa essa conveno de nomenclatura para suas constantes, cada uma representando um evento relacionado entrada do rato:
package flash.events { public class MouseEvent extends Event { public static const CLICK:String = "click";

73

Action Script

public static const DOUBLE_CLICK:String = "doubleClick"; public static const MOUSE_DOWN:String = "mouseDown"; public static const MOUSE_MOVE:String = "mouseMove"; ... } }

10.

Estruturas de controlo de deciso

10.1. if..else
A instruo condicional if..else permite testar uma condio e executar um bloco de cdigo se essa condio existir, ou executar um bloco de cdigo alternativo se ela no existir. Por exemplo, o seguinte cdigo testa se o valor x excede 20, gera uma funo trace() em caso afirmativo ou gera uma funo trace() diferente em caso negativo:
if (x > 20) { trace("x is > 20"); } else { trace("x is <= 20"); }

Se no quiser executar um bloco de cdigo alternativo, voc poder usar a instruo if sem a instruo else.

10.2. if..else if
possvel testar mais de uma condio usando a instruo condicional if..else if. Por exemplo, o cdigo a seguir no apenas testa se o valor x excede 20, mas tambm se o valor x negativo:
if (x > 20) { trace("x is > 20"); } else if (x < 0) { trace("x is negative"); }

Se uma instruo if ou else for seguida de apenas uma instruo, a instruo no precisa ficar entre chaves. Por exemplo, o cdigo a seguir no usa chaves:
if (x > 0) trace("x is positive"); else if (x < 0) trace("x is negative");

74

Action Script

else trace("x is 0");

Entretanto, a Adobe recomenda que voc sempre use chaves, porque poder ocorrer um comportamento inesperado se instrues forem adicionadas posteriormente a uma instruo condicional sem chaves. Por exemplo, no cdigo a seguir, o valor positiveNums aumentado em 1 quer a condio seja ou no avaliada como true:
var x:int; var positiveNums:int = 0; if (x > 0) trace("x is positive"); positiveNums++; trace(positiveNums); // 1

10.3. Switch
A instruo switch ser til se voc tiver vrios caminhos de execuo que dependam da mesma expresso de condio. Ela fornece uma funcionalidade semelhante a uma longa srie de instrues if..else if, mas mais fcil de ler. Em vez de testar uma condio quanto a um valor booleano, a instruo switch avalia uma expresso e usa o resultado para determinar qual bloco de cdigo ser executado. Os blocos de cdigo comeam com uma instruo case e terminam com uma instruo break. Por exemplo, a seguinte instruo switch imprime o dia da semana, com base no nmero de dias retornado pelo mtodo Date.getDay():
var someDate:Date = new Date(); var dayNum:uint = someDate.getDay(); switch(dayNum) { case 0: trace("Sunday"); break; case 1: trace("Monday"); break; case 2: trace("Tuesday"); break; case 3: trace("Wednesday"); break; case 4: trace("Thursday"); break; case 5: trace("Friday"); break; case 6: trace("Saturday"); break; default: trace("Out of range"); break; }

11.

Estruturas de controlo de repetio

As instrues de repetio permitem executar um bloco especfico de cdigo repetidamente usando uma srie de valores ou variveis. A Adobe recomenda que o bloco de cdigo seja sempre colocado entre chaves ({}). Embora seja possvel omitir as chaves caso o bloco de cdigo contenha apenas uma instruo, essa prtica no

75

Action Script

recomendada pelo mesmo motivo que para as condicionais: ela aumenta as chances de que as instrues adicionadas em um momento posterior sejam excludas inadvertidamente do bloco de cdigo. Se, mais tarde, voc adicionar uma instruo que deseja incluir no bloco de cdigo, mas esquecer de adicionar as chaves necessrias, a instruo no ser executada como parte da repetio.

11.1. For
A repetio for, permite fazer a iterao por meio de uma varivel para um intervalo especfico de valores. Voc deve fornecer trs expresses em uma instruo for: uma varivel que definida com um valor inicial, uma instruo condicional que determina quando a repetio termina e uma expresso que altera o valor da varivel a cada repetio. Por exemplo, o cdigo a seguir repetido cinco vezes. O valor da varivel i comea com 0 e termina com 4, e a sada ser os nmeros de 0 a 4, cada um em sua prpria linha.
var i:int; for (i = 0; i < 5; i++) { trace(i); }

11.2. for..in
A repetio for..in itera por meio das propriedades de um objeto ou dos elementos de uma matriz. Por exemplo, voc pode usar uma repetio for..in para iterar por meio das propriedades de um objeto genrico (as propriedades de objeto no so mantidas em uma ordem especfica, por isso elas podem aparecer em uma ordem aparentemente aleatria):
var myObj:Object = {x:20, y:30}; for (var i:String in myObj) { trace(i + ": " + myObj[i]); } // output: // x: 20 // y: 30

Tambm possvel iterar por meio dos elementos de uma matriz:


var myArray:Array = ["one", "two", "three"]; for (var i:String in myArray) { trace(myArray[i]); } // output: // one

76

Action Script

// two // three

O que voc no pode fazer iterar por meio das propriedades de um objeto se ele for uma ocorrncia de uma classe definida pelo usurio, a menos que a classe seja dinmica. Mesmo com ocorrncias de classes dinmicas, ser possvel iterar somente por meio de propriedades adicionadas dinamicamente.

11.3. for each..in


A repetio for each..in itera por meio dos itens de um conjunto, que podem ser tags em um objeto XML ou XMLList, os valores mantidos pelas propriedades do objeto ou os elementos de uma matriz. Por exemplo, como mostra o trecho a seguir, voc pode usar uma repetio for each..in para iterar por meio das propriedades de um objeto genrico, mas diferentemente da repetio for..in, a varivel do iterador em uma repetio for each..in contm o valor mantido pela propriedade em vez do nome da propriedade:
var myObj:Object = {x:20, y:30}; for each (var num in myObj) { trace(num); } // output: // 20 // 30

Voc pode iterar por meio de um objeto XML ou XMLList, como mostra o seguinte exemplo:
var myXML:XML = <users> <fname>Jane</fname> <fname>Susan</fname> <fname>John</fname> </users>; for each (var item in myXML.fname) { trace(item); } /* output Jane Susan John */

Tambm possvel iterar por meio dos elementos de uma matriz, como mostra este exemplo:
var myArray:Array = ["one", "two", "three"]; for each (var item in myArray) { trace(item); } // output:

77

Action Script

// one // two // three

Voc no poder iterar por meio das propriedades de um objeto se o objeto for uma ocorrncia de uma classe selada. Mesmo para ocorrncias de classes dinmicas, no possvel iterar por meio de uma propriedade fixa, que a propriedade especificada como parte da definio de classe.

11.4. while
A repetio while como uma instruo if que repetida desde que a condio seja true. Por exemplo, o cdigo a seguir produz a mesma sada que o exemplo da repetio for:
var i:int = 0; while (i < 5) { trace(i); i++; }

Uma desvantagem do uso de uma repetio while em vez de for que repeties infinitas so mais fceis de escrever com repeties while. O exemplo da repetio for no ser compilado se voc omitir a expresso que incrementa a varivel do contador, mas o exemplo da repetio while ser compilado se essa etapa for omissa. Sem a expresso que incrementa i, a repetio se torna infinita. A repetio do..while uma repetio while que garante que o bloco de cdigo seja executado pelo menos uma vez, porque a condio verificada depois que o bloco executado. O cdigo a seguir mostra um exemplo simples de uma repetio do..while que gera sada mesmo que a condio no seja atendida:
var i:int = 5; do { trace(i); i++; } while (i < 5); // output: 5

78