Anda di halaman 1dari 870

Aprendendo ActionScript 2.

0 no Flash
Marcas comerciais
1 Step RoboPDF, ActiveEdit, ActiveTest, Authorware, Blue Sky Software, Blue Sky, Breeze, Breezo, Captivate, Central,
ColdFusion, Contribute, Database Explorer, Director, Dreamweaver, Fireworks, Flash, FlashCast, FlashHelp, Flash Lite,
FlashPaper, Flash Video Encoder, Flex, Flex Builder, Fontographer, FreeHand, Generator, HomeSite, JRun, MacRecorder,
Macromedia, MXML, RoboEngine, RoboHelp, RoboInfo, RoboPDF, Roundtrip, Roundtrip HTML, Shockwave, SoundEdit,
Studio MX, UltraDev e WebHelp são marcas comerciais registradas ou marcas comerciais da Macromedia, Inc. e podem estar
registradas nos Estados Unidos ou em outras jurisdições, inclusive internacionais. Outros nomes de produtos, logotipos, designs,
títulos, palavras ou frases mencionados nesta publicação podem ser marcas comerciais, marcas de serviço ou nomes comerciais da
Macromedia, Inc. ou de outras entidades e podem estar registrados em certas jurisdições, inclusive internacionais.

Informações de terceiros
Este guia contém links para sites da Web de terceiros que não estão sob o controle da Macromedia. Nesses casos, a Macromedia
não é responsável pelo conteúdo de nenhum site vinculado. Se acessar um dos sites da Web de terceiros mencionados neste guia,
você estará assumindo os riscos inerentes. A Macromedia oferece esses links apenas como uma conveniência, e a inclusão de um
link não significa que a Macromedia apóia ou aceita qualquer responsabilidade pelo conteúdo apresentado nos sites de terceiros.

Tecnologia de compactação e descompactação de voz licenciada da Nellymoser, Inc. (www.nellymoser.com).

Tecnologia Sorenson™ Spark™ de compactação e descompactação de vídeo licenciada da Sorenson


Media, Inc.

Navegador Opera ® Copyright © 1995-2002 Opera Software ASA e seus fornecedores. Todos os
direitos reservados.

O vídeo Macromedia Flash 8 possui tecnologia de vídeo On2 TrueMotion. © 1992-2005 On2 Technologies, Inc. Todos os
direitos reservados. http://www.on2.com.

Visual SourceSafe é uma marca comercial ou comercial registrada da Microsoft Corporation nos Estados Unidos e/ou em outros
países.

Copyright © 2005 Macromedia, Inc. Todos os direitos reservados. Este manual não pode ser copiado, fotocopiado,
reproduzido, traduzido ou convertido em nenhum formato eletrônico ou que possa ser lido por máquina, por inteiro ou
em parte, sem o consentimento prévio por escrito da Macromedia, Inc. Não obstante o precedente, o proprietário ou
usuário autorizado de uma cópia válida do software com que este manual foi fornecido pode imprimir uma cópia deste
manual a partir de uma versão eletrônica com a finalidade única de ele próprio ou um usuário autorizado aprender a usar
este software, desde que nenhuma parte deste manual seja impressa, reproduzida, distribuída, revendida ou transmitida
para qualquer outro fim, incluindo, sem limitação, fins comerciais, como vendas de cópias desta documentação ou
fornecimento de serviços de suporte pré-pagos.

Agradecimentos
Gerenciamento de projetos: Sheila McGinn
Criação do texto: Jen deHaan; Peter deHaan, Joey Lott
Editora geral: Rosana Francescato
Editora chefe: Lisa Stanziano
Edição: Linda Adler, Geta Carlson, Evelyn Eldridge, John Hammett, Mary Kraemer, Noreen Maher, Jessie Wood, Anne Szabla
Gerenciamento de produção: Patrice O’Neill, Kristin Conradi, Yuko Yagi
Projeto de mídia e produção: Adam Barnett, Aaron Begley, Paul Benkman. John Francis, Geeta Karmarkar, Masayo Noda,
Paul Rangel, Arena Reed, Mario Reynoso
Agradecimentos especiais a Jody Bleyle, Mary Burger, Lisa Friendly, Stephanie Gowin, Bonnie Loo, Mary Ann Walsh, Erick Vera,
aos testadores beta e a toda a equipe de engenharia e controle de qualidade do Flash e do Flash Player.
Primeira edição: Setembro de 2005
Macromedia, Inc.
601 Townsend St.
San Francisco, CA 94103
Conteúdo

Introdução. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Público-alvo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Requisitos de sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Atualizando arquivos XML para Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Sobre a documentação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Recursos adicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Capítulo 1: Novidades do ActionScript no Flash 8 . . . . . . . . . . . . 19


Novidades do ActionScript 2.0 e do Flash 8 . . . . . . . . . . . . . . . . . . . . . . 19
Alterações no modelo de segurança para arquivos SWF instalados
localmente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Capítulo 2: Escrevendo e editando o ActionScript 2.0 . . . . . . . . 31


Sobre o ActionScript e eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Organizando o código ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Usando o painel Actions e a janela Script. . . . . . . . . . . . . . . . . . . . . . . . 36
Sobre o painel Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37
Sobre a janela Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Sobre a codificação no painel Actions e na janela Script . . . . . . . . . . 39
Sobre recursos do painel Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Sobre comportamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Sobre as configurações de publicação do ActionScript . . . . . . . . . . . 66

Capítulo 3: Sobre o ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . 71


O que é ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .72
Sobre a opção entre o ActionScript 1.0 e o ActionScript 2.0 . . . . . . .73
Noções básicas do ActionScript e do Flash Player . . . . . . . . . . . . . . . .74

3
Capítulo 4: Dados e tipos de dados . . . . . . . . . . . . . . . . . . . . . . . . 75
Sobre dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Sobre tipos de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Sobre variáveis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Organizando dados em objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
Sobre a conversão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116

Capítulo 5: Fundamentos da sintaxe e da linguagem . . . . . . . . 119


Sobre sintaxe, instruções e expressões . . . . . . . . . . . . . . . . . . . . . . . . . 120
Sobre sintaxe de ponto e caminhos de destino . . . . . . . . . . . . . . . . . . 124
Sobre pontuadores de linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Sobre constantes e palavras-chave . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Sobre instruções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Sobre arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Sobre operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

Capítulo 6: Funções e métodos . . . . . . . . . . . . . . . . . . . . . . . . . . 213


Sobre funções e métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Noções básicas sobre métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .235

Capítulo 7: Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239


Sobre a programação orientada a objeto e o Flash . . . . . . . . . . . . . 240
Criando arquivos de classes personalizados. . . . . . . . . . . . . . . . . . . . 249
Sobre como trabalhar com classes personalizadas em um
aplicativo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .252
Exemplo: Criando classes personalizadas. . . . . . . . . . . . . . . . . . . . . . . 278
Exemplo: Usando arquivos de classes personalizados no Flash . . . 291
Atribuindo uma classe a símbolos no Flash. . . . . . . . . . . . . . . . . . . . . 295
Compilando e exportando classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .296
Noções básicas sobre classes e escopo . . . . . . . . . . . . . . . . . . . . . . . 299
Sobre classes de nível superior e internas . . . . . . . . . . . . . . . . . . . . . . 302
Sobre como trabalhar com classes internas . . . . . . . . . . . . . . . . . . . . . 312

Capítulo 8: Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319


Sobre herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Sobre a criação de subclasses no Flash . . . . . . . . . . . . . . . . . . . . . . . . 321
Usando o polimorfismo em um aplicativo . . . . . . . . . . . . . . . . . . . . . . . 327

4 Conteúdo
Capítulo 9: Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Sobre interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331
Criando interfaces como tipos de dados. . . . . . . . . . . . . . . . . . . . . . . . 337
Noções básicas sobre herança e interfaces . . . . . . . . . . . . . . . . . . . . . 339
Exemplo: Usando interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
Exemplo: Criando uma interface complexa . . . . . . . . . . . . . . . . . . . . . 342

Capítulo 10: Manipulando eventos . . . . . . . . . . . . . . . . . . . . . . . 347


Usando métodos manipuladores de eventos . . . . . . . . . . . . . . . . . . . . 348
Usando ouvintes de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .351
Usando ouvintes de eventos com componentes . . . . . . . . . . . . . . . . 353
Usando manipuladores de eventos de botão e de clipe de filme. . . 355
Transmitindo eventos de instâncias de componentes . . . . . . . . . . . . 360
Criando clipes de filme com estados de botão . . . . . . . . . . . . . . . . . . .361
Escopo do manipulador de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Escopo da palavra-chave this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
Usando a classe Delegate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366

Capítulo 11: Trabalhando com clipes de filme . . . . . . . . . . . . . . 369


Sobre o controle de clipes de filme com o ActionScript . . . . . . . . . . 370
Chamando vários métodos em um único clipe de filme. . . . . . . . . . . 372
Carregando e descarregando arquivos SWF . . . . . . . . . . . . . . . . . . . 373
Alterando a posição e a aparência de um clipe de filme . . . . . . . . . . 376
Arrastando clipes de filme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
Criando clipes de filme durante a execução . . . . . . . . . . . . . . . . . . . . . 378
Adicionando parâmetros aos clipes de filme criados
dinamicamente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Gerenciando profundidades do clipe de filme . . . . . . . . . . . . . . . . . . . 385
Sobre o armazenamento em cache e a rolagem de clipes
de filme com o ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Usando clipes de filme como máscaras . . . . . . . . . . . . . . . . . . . . . . . . 397
Manipulando eventos de clipes de filme . . . . . . . . . . . . . . . . . . . . . . . . 399
Atribuindo uma classe a um símbolo de clipe de filme . . . . . . . . . . . . 399
Inicializando as propriedades de classe . . . . . . . . . . . . . . . . . . . . . . . . .401

Capítulo 12: Trabalhando com texto e seqüências


de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Sobre campos de texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
Sobre o carregamento de texto e variáveis em campos de texto . . .415
Usando fontes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Sobre a renderização de fontes e texto sem serrilhado. . . . . . . . . . . 430

Conteúdo 5
Sobre o layout e a formatação de texto . . . . . . . . . . . . . . . . . . . . . . . . 439
Formatando texto com estilos CSS . . . . . . . . . . . . . . . . . . . . . . . . . . . .447
Usando texto em formato HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
Exemplo: Criando texto de rolagem . . . . . . . . . . . . . . . . . . . . . . . . . . . .475
Sobre seqüências de caracteres e a classe String. . . . . . . . . . . . . . . . 477

Capítulo 13: Animação, filtros e desenhos . . . . . . . . . . . . . . . . . 497


Scripts de animação com o ActionScript 2.0 . . . . . . . . . . . . . . . . . . 498
Sobre cache de bitmap, rolagem e desempenho . . . . . . . . . . . . . . . 508
Sobre as classes Tween e TransitionManager . . . . . . . . . . . . . . . . . 509
Usando efeitos de filtro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .526
Trabalhando com filtros usando ActionScript . . . . . . . . . . . . . . . . . . .534
Manipulando efeitos de filtro com código . . . . . . . . . . . . . . . . . . . . . . .557
Criando bitmaps com a classe BitmapData . . . . . . . . . . . . . . . . . . . . . 561
Modos de mistura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .564
Sobre a ordem de operação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
Desenhando com o ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
Noções básicas sobre dimensionamento e guias de trecho . . . . . . .583

Capítulo 14: Criando interação com o ActionScript . . . . . . . . . 589


Sobre eventos e interação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
Controlando a reprodução de arquivos SWF . . . . . . . . . . . . . . . . . . . 590
Criando interatividade e efeitos visuais. . . . . . . . . . . . . . . . . . . . . . . . . 593
Criando vinculações de dados durante a execução com
o ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .607
Desconstruindo um script de exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . 616

Capítulo 15: Trabalhando com imagens, som e vídeo . . . . . . . . 619


Sobre o carregamento e o trabalho com mídia externa . . . . . . . . . . 620
Carregando arquivos SWF e de imagem externos . . . . . . . . . . . . . . . 621
Sobre o carregamento e o uso de arquivos MP3 externos . . . . . . . .626
Atribuindo vinculação a recursos da biblioteca. . . . . . . . . . . . . . . . . . . 631
Sobre o uso de vídeo FLV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .632
Sobre a criação de animações do progresso para arquivos
de mídia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .654

6 Conteúdo
Capítulo 16: Trabalhando com dados externos . . . . . . . . . . . . . 663
Enviando e carregando variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664
Usando HTTP para conectar a scripts do servidor . . . . . . . . . . . . . . . 668
Sobre upload e download de arquivos . . . . . . . . . . . . . . . . . . . . . . . . . 674
Sobre XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
Enviando mensagens para o Flash Player e a partir deste . . . . . . . . 692
Sobre a API External . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696

Capítulo 17: Noções básicas de segurança . . . . . . . . . . . . . . . . 707


Sobre compatibilidade com os modelos de segurança
anteriores do Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708
Sobre segurança do arquivo local e o Flash Player . . . . . . . . . . . . . . 709
Sobre domínios, segurança entre domínios e arquivos SWF . . . . . 727
Arquivos de diretivas de servidor para autorizar o acesso a dados. 736
Acesso de protocolo HTTP para HTTPS entre arquivos SWF . . . . . 741

Capítulo 18: Depurando aplicativos . . . . . . . . . . . . . . . . . . . . . . 745


Depurando scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
Usando o painel Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759

Capítulo 19: Melhores práticas e convenções de codificação


para ActionScript 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .767
Convenções de atribuição de nome . . . . . . . . . . . . . . . . . . . . . . . . . . . . 769
Usando de comentários no código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779
Convenções de codificação do ActionScript . . . . . . . . . . . . . . . . . . . . 782
Otimização do ActionScript e do Flash Player . . . . . . . . . . . . . . . . . . 798
Formatando a sintaxe do ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . 799

Apêndice A: Mensagens de erro . . . . . . . . . . . . . . . . . . . . . . . . . 809

Apêndice B: Operadores Flash 4 obsoletos . . . . . . . . . . . . . . . . 815

Apêndice C: Teclas do teclado e valores de códigos


de teclas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 817

Apêndice D: Criando scripts para versões anteriores do Flash


Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 825
Sobre a especificação de versões anteriores do Flash Player . . . . 825
Usando o Flash 8 para criar conteúdo para o Flash Player 4 . . . . . 826

Conteúdo 7
Apêndice E: Programação orientada a objeto com
o ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829
Sobre o ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 830
Criando um objeto personalizado no ActionScript 1.0 . . . . . . . . . . . . 831
Atribuindo métodos a um objeto personalizado no
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .832
Definindo métodos manipuladores de eventos no
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .834
Criando herança no ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . .836
Adicionando propriedades getter/setter a objetos no
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
Usando as propriedades do objeto Function no ActionScript 1.0 . .838

Apêndice F: Terminologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841

Índice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851

8 Conteúdo
Introdução

O Macromedia Flash Basic 8 e o Macromedia Flash Professional 8 são as ferramentas de


criação padrão profissionais para a produção de experiências de grande impacto na Web. O
ActionScript é a linguagem utilizada para adicionar interatividade aos aplicativos Flash, sejam
os aplicativos arquivos SWF animados simples ou aplicativos de Internet avançados mais
complexos. Para usar o Flash, não é necessário o ActionScript, mas, se você desejar fornecer
interatividade básica ou complexa com o usuário, trabalhar com objetos diferentes daqueles
contidos no Flash (como botões e clipes de filme) ou então transformar um arquivo SWF em
uma experiência de usuário mais eficiente, deverá usar o ActionScript.
Para obter mais informações, consulte os tópicos a seguir:
Público-alvo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Atualizando arquivos XML para Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Requisitos de sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Sobre a documentação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Recursos adicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Público-alvo
Este manual pressupõe que você já tenha instalado o Flash Basic 8 ou o Flash Professional 8 e
saiba como usar a interface de usuário.É preciso que saiba posicionar objetos no Stage e
manipulá-los no ambiente de criação do Flash. Se já tiver usado uma linguagem de criação, o
ActionScript lhe parecerá familiar. No entanto, se for iniciante em programação, saiba que os
fundamentos do ActionScript são fáceis de aprender. Você pode começar com comandos
simples e criar mais complexidade com o tempo. Pode adicionar muita interatividade aos seus
arquivos sem precisar aprender (ou escrever) muito código.

Requisitos de sistema
O ActionScript 2.0 não tem qualquer requisito de sistema além do Flash 8 .

9
Este manual pressupõe que você esteja utilizando as configurações de publicação padrão para
os arquivos do Flash: Flash Player 8 e ActionScript 2.0. Se você alterar qualquer uma dessas
configurações, as explicações e exemplos de código apresentados na documentação poderão
não funcionar corretamente. Caso desenvolva aplicativos para versões anteriores do Flash
Player, consulte o Apêndice D, “Criando scripts para versões anteriores do Flash Player”, na
página 825.

Atualizando arquivos XML para Flash


É importante que estejam sempre instalados os arquivos XML para Flash mais recentes. A
Macromedia algumas vezes apresenta recursos em versões com ponto (versões menores) do
Flash Player. Quando uma versão dessas se encontrar disponível, atualize sua versão do Flash
para obter os arquivos XML mais recentes. Caso contrário, o compilador do Flash 8 poderá
gerar erros caso você use novas propriedades ou métodos indisponíveis na versão do Flash
Player que veio com a instalação do Flash.
Por exemplo, o Flash Player 7 (7.0.19.0) continha um novo método para o objeto System ,
System.security.loadPolicyFile. Para acessar esse método, use o instalador Player
Updater (Atualizador de player) para atualizar todos os players instalados com o Flash. Caso
contrário, o compilador do Flash exibirá erros.
Lembre-se de que é possível instalar um Player Updater que seja de uma ou mais versões
maiores mais recentes que a sua do Flash. Fazendo isso, obterá os arquivos XML necessários,
mas não deverá receber mensagens de erro do compilador quando publicar versões mais
antigas do Flash Player. Algumas vezes, novos métodos ou propriedades encontram-se
disponíveis para versões mais antigas, e ter os arquivos XML mais recentes minimiza os erros
de compilação quando você tenta acessar métodos ou propriedades mais antigos.

Sobre a documentação
Este manual oferece uma visão geral da sintaxe do ActionScript e informações sobre como usá-
lo quando trabalhar com diferentes tipos de objetos. Para obter detalhes sobre a sintaxe e o uso
de cada elemento da linguagem, consulte o ActionScript 2.0 Language Reference.
Para obter mais informações, consulte os seguintes tópicos:
■ “Visão geral do manual Aprendendo ActionScript 2.0” na página 11
■ “Sobre os arquivos de exemplo” na página 15
■ “Termos usados neste documento” na página 13
■ “Copiar e colar código” na página 13

10 Introdução
Visão geral do manual Aprendendo ActionScript 2.0
A lista a seguir resume o conteúdo deste manual:
■ O Capítulo 1, “Novidades do ActionScript no Flash 8,” descreve recursos que são novos
no ActionScript, alterações no compilador e no depurador e o novo modelo de
programação para a linguagem ActionScript 2.0.
■ O Capítulo 2, “Escrevendo e editando o ActionScript 2.0,” descreve recursos do editor do
ActionScript dentro do Flash que facilitam a escrita de código.
■ O Capítulo 3, “Sobre o ActionScript,” descreve o que é a linguagem ActionScript e
detalha como escolher qual versão utilizar.
■ O Capítulo 4, “Dados e tipos de dados,” descreve a terminologia e os conceitos básicos
sobre dados, tipos de dados e variáveis. Esses conceitos serão usados em todo o manual.
■ O Capítulo 5, “Fundamentos da sintaxe e da linguagem,” descreve a terminologia e os
conceitos básicos da linguagem ActionScript. Esses conceitos serão usados em todo o
manual.
■ O Capítulo 6, “Funções e métodos,” descreve como escrever diferentes tipos de funções e
métodos e como usá-los no seu aplicativo.
■ O Capítulo 7, “Classes,” descreve como criar classes e objetos personalizados no
ActionScript. Esse capítulo também lista as classes internas do ActionScript e oferece uma
visão geral de como utilizá-las para acessar recursos avançados do ActionScript.
■ O Capítulo 8, “Herança,” descreve a herança na linguagem ActionScript e como estender
classes internas ou personalizadas.
■ O Capítulo 9, “Interfaces,” descreve como criar interfaces e trabalhar com elas no
ActionScript.
■ O Capítulo 10, “Manipulando eventos,” descreve várias formas de manipular eventos:
métodos manipuladores de eventos, ouvintes de eventos e manipuladores de eventos de
botão e de clipe de filme.
■ O Capítulo 11, “Trabalhando com clipes de filme,” descreve clipes de filme e o
AcionScript que você pode usar para crontrolá-los.
■ O Capítulo 12, “Trabalhando com texto e seqüências de caracteres,” descreve os diferentes
modos como você pode controlar o texto e as seqüências de caracteres no Flash e inclui
informações sobre formatação de texto e o FlashType (renderização de texto avançada,
como texto sem serrilhado).
■ O Capítulo 13, “Animação, filtros e desenhos,” descreve como criar animação e imagens
baseadas em código, adicionar filtros a objetos e desenhar usando o ActionScript.

Sobre a documentação 11
■ O Capítulo 14, “Criando interação com o ActionScript,” descreve alguns modos simples
de criar aplicativos mais interativos, incluindo o controle quando os arquivos SWF são
executados e a criação de ponteiros personalizados e de controles de som.
■ O Capítulo 15, “Trabalhando com imagens, som e vídeo,” descreve como importar
arquivos de mídia externos, como imagens de bitmap, arquivos MP3, arquivos Flash
Video (FLV) e outros arquivos SWF, nos aplicativos Flash. Esse capítulo também oferece
uma visão geral de como trabalhar com o vídeo nos aplicativos e como criar animações
para o carregamento da barra de progresso.
■ O Capítulo 16, “Trabalhando com dados externos,” descreve como processar dados de
fontes externas usando scripts de servidor ou de cliente nos aplicativos. Esse capítulo
descreve como integrar os dados com os aplicativos.
■ O Capítulo 17, “Noções básicas de segurança,” explica a segurança no Flash Player, na
medida em que se relaciona com o trabalho com arquivos SWF localmente no disco
rígido. Esse capítulo também explica questões de segurança entre domínios e como
carregar dados de servidores ou através de domínios.
■ O Capítulo 18, “Depurando aplicativos,” descreve o depurador do ActionScript dentro do
Flash, que facilita a escrita de aplicativos.
■ O Capítulo 19, “Melhores práticas e convenções de codificação para ActionScript 2.0,”
explica as melhores práticas para usar o Flash e para escrever o ActionScript. Esse capítulo
também lista convenções de codificação padronizadas, como variáveis de atribuição de
nome e outras convenções.
■ O Apêndice A, “Mensagens de erro,” lista as mensagens de erro que o compilador do Flash
pode gerar.
■ O Apêndice B, “Operadores Flash 4 obsoletos,” lista todos os operadores obsoletos do
Flash 4 e sua associatividade.
■ O Apêndice C, “Teclas do teclado e valores de códigos de teclas,” lista todas as teclas de
um teclado padrão e os valores de códigos de teclas ASCII correspondentes usados para
identificar as teclas no ActionScript.
■ O Apêndice D, “Criando scripts para versões anteriores do Flash Player,” fornece diretrizes
para ajudá-lo a criar scripts sintaticamente corretos para a versão do Flash Player desejada.
■ O Apêndice E, “Programação orientada a objeto com o ActionScript 1.0,” fornece
informações sobre o uso do modelo de objeto ActionScript 1.0 para escrver scripts.
■ O Apêndice F, “Terminologia,” lista a terminologia comumente usada ao trabalhar com a
linguagem ActionScript e fornece descrições para os termos.
Este manual explica como usar a linguagem ActionScript. Para obter informações sobre os
elementos de linguagem propriamente ditos, consulte o ActionScript 2.0 Language Reference.

12 Introdução
Convenções tipográficas
Este manual usa as seguintes convenções tipográficas:
■ Fonte Code indica código do ActionScript.
■ Fonte Code negrito, normalmente em um procedimento, indica código que você
precisa modificar ou adicionar a um código já adicionado ao arquivo FLA. Em alguns
casos, pode ser usado para realçar o código a ser observado.
■ Texto em negrito indica dados que você precisa digitar na interface de usuário, como
nome de arquivo ou nome de instância.
■ Texto em itálico indica um novo termo definido no texto que se segue. Em um caminho de
arquivo, pode indicar um valor que deve ser substituído (por exemplo, por um nome de
diretório no seu próprio disco rígido).

Termos usados neste documento


Os seguintes termos são usados neste manual:
■ Você refere-se ao desenvolvedor que escreve um script ou aplicativo.
■ O usuário refere-se à pessoa que executará os scripts e aplicativos.
■ Tempo de compilação é o momento em que você publica, exporta, testa ou depura o
documento.
■ Tempo de execução é o momento em que o script é executado no Flash Player.
Termos do ActionScript como método e objeto são definidos no Apêndice F, “Terminologia”,
na página 841.

Copiar e colar código


Quando você colar o ActionScript do painel Help (Ajuda) para o FLA ou o arquivo do
ActionScript, preste atenção aos caracteres especiais. São caracteres especiais as aspas especiais
(também chamadas de aspas curvas ou aspas inglesas). Esses caracteres não são interpretados
pelo editor do ActionScript, então o código lança um erro quando você tenta compilá-lo no
Flash.

Sobre a documentação 13
Você pode identificar se os caracteres de aspas são especiais quando eles não são codificados
por cores de forma correta. Ou seja, se nenhuma seqüência de caracteres mudar de cor no
editor de cores, será preciso substituir os caracteres especiais por caracteres de aspas retas
comuns. Se você digitar um caractere de aspa simples ou dupla diretamente no editor do
ActionScript, sempre digitará um caractere de aspa reta. O compilador (quando você testa ou
publica um arquivo SWF) lança um erro e permite que você saiba que há um tipo errado
(marcas de aspas especiais ou curvas) de caracteres no seu código.
N OT A

Você também pode encontrar aspas especiais se colar o ActionScript de outros locais,
como de uma página da Web ou um documento do Microsoft Word.

Cuidado com quebras de linha ao copiar e colar código. Ao colar o seu código de alguns
locais, a linha de código poderá se quebrar em um local inapropriado. Certifique-se de que a
codificação de cores da sua sintaxe esteja correta no editor do ActionScript se achar que as
quebras de linha representam um problema. Compare o código do painel Actions (Ações)
com o do painel Help para ver se correspondem. Procure ativar o Word Wrap (quebra
automática de linha) no editor do ActionScript para ajudar a solucionar quebras de linha
excedentes no código (selecione View (Exibir) > Word Wrap (quebra automática de linha) na
janela Script ou Word Wrap no menu pop-up do painel Actions.)

Recursos adicionais
Além deste manual sobre o ActionScript, existem outros sobre outros tópicos do Flash, como
componentes e o Macromedia Flash Lite. Você pode acessar cada manual no painel Help
(Help > Flash Help (Ajuda do Flash)), exibindo o sumário padrão. Clique no botão Clear
(Limpar) para ver os manuais disponíveis; para obter mais informações, consulte “Onde
encontrar documentação sobre outros assuntos” na página 17.
Para obter mais informações sobre outros recursos disponíveis, consulte os seguintes tópicos:
■ “Sobre os arquivos de exemplo” na página 15
■ “Onde encontrar arquivos PDF ou documentação impressa” na página 15
■ “Sobre o LiveDocs” na página 16
■ “Recursos on-line adicionais” na página 17
■ “Onde encontrar documentação sobre outros assuntos” na página 17

14 Introdução
Sobre os arquivos de exemplo
Há vários arquivos de exemplo baseados no ActionScript que são instalados com o Flash. Esses
arquivos de exemplo mostram como o código funciona em um arquivo FLA; geralmente
servem como uma ferramenta de aprendizado bem útil. Os capítulos deste manual muitas
vezes fazem referência a esses arquivos, mas recomendamos que você consulte também a pasta
de arquivos de exemplo do seu disco rígido.
Os arquivos de exemplo incluem arquivos FLA de aplicativo que usam funções comuns do
Flash instaladas com ele. Esses aplicativos foram projetados para apresentar aos novos
desenvolvedores do Flash as capacidades dos aplicativos Flash assim como para mostrar aos
desenvolvedores avançados como funcionam os recursos do Flash no contexto.
Você pode encontrar os arquivos de origem de exemplo com foco no ActionScript na pasta
Samples (Exemplos) do disco rígido.
■ No Windows, navegue até a unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\.
■ No Macintosh, navegue até Macintosh HD/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/.
Você verá como são úteis os seguintes arquivos de exemplo com foco em componentes, pois
eles contêm vários códigos ActionScript. Eles também podem ser encontrados na pasta
Samples do disco rígido:
■ No Windows, navegue até a unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\Components\.
■ No Macintosh, navegue até Macintosh HD/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/Components/.
Você também pode encontrar arquivos de exemplo adicionais para download na Internet. A
página da Web a seguir contém links e descrições de arquivos de exemplo adicionais:
www.macromedia.com/go/flash_samples/.

Onde encontrar arquivos PDF ou documentação


impressa
Caso prefira ler a documentação em formato impresso, as versões PDF de cada manual
encontram-se disponíveis para download. Vá até www.macromedia.com/support/
documentation/ e selecione o produto em que está interessado. Você pode exibir ou fazer o
download do PDF ou acessar o link da versão LiveDocs do manual.

Recursos adicionais 15
Muitas vezes você também pode adquirir a documentação impressa. Para obter informações
atualizadas, vá até o site de suporte da documentação e selecione Flash Basic 8 ou Flash
Professional 8.

Sobre o LiveDocs
Você pode acessar a documentação no site LiveDocs ou pelo painel Help. O site LiveDocs
contém todas as páginas de ajuda do Flash e pode conter comentários que esclareçam,
atualizem ou corrijam partes da documentação. Clique em View Comments (Exibir
comentários) em LiveDocs na parte inferior de uma página do painel Help para exibir a
página equivalente no site LiveDocs. Vá até http://livedocs.macromedia.com para ver uma
lista de toda a documentação disponível no formato LiveDocs.
Escritores técnicos monitoram o site LiveDocs. Uma das vantagens do LiveDocs é ver
comentários que esclarecem a documentação ou corrigir erros ou problemas que surgem após
o lançamento de um software. Não é no LiveDocs que você faz solicitações de ajuda, como
perguntas sobre seu código que não funciona, comentários sobre problemas com software ou
instalação ou perguntas sobre como criar algo com o Flash. Nele você fornece informações
sobre a documentação (por exemplo, você aponta uma frase ou parágrafo que requer
esclarecimento).
Quando você clica no botão para adicionar um comentário sobre o LiveDocs, há diversos
pontos sobre os tipos de comentários que são aceitáveis no sistema. Leia essas diretrizes
atentamente para que seu comentário não seja removido do site.
Se tiver alguma dúvida sobr eo Flash, faça sua pergunta nos fóruns da Web da Macromedia:
www.macromedia.com/support/forums/. Os fóruns da Web são o melhor local para fazer
perguntas, pois há vários funcionários da Macromedia lá, voluntários da equipe Macromedia,
gerentes e membros de grupos de usuário da Macromedia e até escritores técnicos que
monitoram esses fóruns.
Engenheiros não monitoram o sistema LiveDocs, mas a lista de tarefas do Flash. Se achar que
encontrou um erro (bug) no software ou se quiser solicitar um aprimoramento para o Flash,
preencha o formulário em www.macromedia.com/go/wish. Se você relatar o bug ou a
solicitação de aprimoramento no LiveDocs, eles não serão adicionados de forma oficial ao
banco de dados de bugs. Use o formulário apropriado se quiser que um engenheiro dê atenção
ao bug reportado ou à sua solicitação.
Lembre-se de dar atenção aos caracteres especiais e às quebras de linha quando colar da Web,
incluindo do LiveDocs. A Macromedia vem se esforçando para remover todos os caracteres
especiais dos exemplos de código, mas, se você tiver dificuldades para colar o código, consulte
“Copiar e colar código” na página 13.

16 Introdução
Recursos on-line adicionais
Existem vários recursos on-line que oferecem várias instruções, ajuda e orientação para
facilitar o uso do Macromedia Flash 8. Consulte com freqüência os seguintes sites para obter
atualizações:
O site The Macromedia Developer Center (www.macromedia.com/devnet) é atualizado
regularmente com as informações mais recentes sobre o Flash, além de oferecer
aconselhamentos de usuários experientes, tópicos avançados, exemplos, dicas, tutoriais
(incluindo tutoriais com várias partes) e outras atualizações. Visite com freqüência o site da
Web para saber das últimas novidades sobre o Flash e como obter o máximo do programa.
O site The Macromedia Flash Support Center (www.macromedia.com/support/flash)
fornece TechNotes (Notas Técnicas), atualizações de documentação e links para recursos
adicionais na comunidade Flash.
O site The Macromedia Weblogs (http://weblogs.macromedia.com) fornece uma lista dos
weblogs (também chamados de blogs) de funcionários e da comunidade Macromedia .
Os fóruns da Web da Macromedia (http://webforums.macromedia.com) oferecem vários
fóruns para perguntas específicas sobre o Flash, seus aplicativos ou a linguagem ActionScript.
Os fóruns são monitorados por voluntários da equipe Macromedia e muitas vezes são visitados
por funcionários de lá também. Se não souber a quem recorrer ou como resolver um
problema, comece por um fórum do Flash.
O site The Macromedia Community (www.macromedia.com/community) hospeda
regularmente Macrochats, uma série de apresentações ao vivo sobre uma variedade de tópicos
feitas por funcionários ou membros da comunidade Macromedia. Consulte regulamente o site
à procura de atualizações e para registrar-se nos Macrochats.

Onde encontrar documentação sobre outros


assuntos
Os manuais a seguir oferecem informações adicionais sobre assuntos comumente associados
ao ActionScript 2.0:
■ Para obter informações sobre os elementos que compõem a linguagem ActionScript,
consulte o ActionScript 2.0 Language Reference.
■ Para obter informações sobre como trabalhar no ambiente de criação do Flash, consulte o
How to Use Help (Como usar a Ajuda).
■ Para obter informações sobre como trabalhar com componentes, consulte o Using
Components (Usando componentes).

Recursos adicionais 17
18 Introdução
CAPÍTULO 1

Novidades do ActionScript
no Flash 8
1
O Macromedia Flash Basic 8 e o Macromedia Flash Professional 8 oferecem vários
aprimoramentos que facilitam a criação de scripts mais eficientes com uso da linguagem
ActionScript. Os novos recursos, analisados neste capítulo, incluem novos elementos de
linguagem (consulte “Acréscimos à linguagem ActionScript” na página 22), ferramentas de
edição aprimoradas (consulte “Alterações de edição do ActionScript” na página 28), alterações
no modelo de segurança e outros aprimoramentos do ActionScript relacionados à ferramenta
de criação.
Para obter mais informações, consulte os seguintes tópicos:
Novidades do ActionScript 2.0 e do Flash 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Alterações no modelo de segurança para arquivos SWF instalados localmente . 29

Novidades do ActionScript 2.0 e do


Flash 8
A linguagem ActionScript cresceu e desenvolveu-se desde sua introdução, há vários anos. Com
cada nova versão do Flash, mais palavras-chave, objetos, métodos e outros elementos foram
adicionados à linguagem. Existem também aprimoramentos do ActionScript relacionados aos
ambientes de criação do Flash 8. O Flash Basic 8 e o Flash Professional 8 introduzem vários
novos elementos de linguagem para recursos expressivos, como filtros e modos de mistura,
além do desenvolvimento de aplicativos, como integração do JavaScript (ExternalInterface) e
entrada e saída de arquivo (FileReference e FileReferenceList).
Esta seção fornece uma visão geral dos elementos e classes da linguagem ActionScript que são
novos ou foram alterados no Flash 8 e aprimoramentos do ActionScript relacionados à
ferramenta de criação. Para obter uma lista de adições específicas ao ActionScript 2.0, consulte
“Acréscimos à linguagem ActionScript” na página 22. Para usar qualquer dos novos elementos
da linguagem nos seus scripts, tenha em mente o Flash Player 8 (o padrão) quando publicar
seus documentos.

19
Os recursos a seguir foram adicionados ao Flash Basic 8 e ao Flash Professional 8 (a menos que
explicitado de forma diferente):
■ Os aprimoramentos do editor do ActionScript permitem a exibição de caracteres ocultos
nos scripts. Para obter mais informações, consulte “Exibindo caracteres ocultos”
na página 57.
■ As opções de depuração agora encontram-se disponíveis na janela Script, assim como no
painel Actions, para arquivos do ActionScript.
■ O diretório Configuration que inclui arquivos XML e arquivos de classes está
reorganizado. Para obter detalhes, consulte “Arquivos de configuração instalados com o
Flash 8” na página 69.
■ É possível definir uma preferência para recarregar arquivos de script modificados ao
trabalhar em um aplicativo, o que ajuda a evitar o trabalho com versões mais antigas de
arquivos de script e a substituição de arquivos de script mais novos. Para obter mais
informações, consulte “Sobre as preferências do ActionScript” na página 44.
■ O recurso da janela Script encontra-se disponível no Flash Basic 8 e no Flash Professional
8. Isso significa que você pode criar um arquivo do ActionScript nos dois programas.
■ O Script Assist (Assistência de script), semelhante ao Normal Mode (Modo Normal) em
edições anteriores do Flash, ajuda você a codificar sem que precise ter noções de sintaxe.
Para obter mais informações sobre o Script Assist, consulte “Sobre o Script Assist”
na página 62.
■ É possível carregar novos tipos de arquivos de imagem durante a execução, o que inclui
imagens JPEG progressivas e arquivos GIF e PNG não-animados. Se você carregar um
arquivo animado, o primeiro quadro da animação será exibido.
■ É possível atribuir identificadores de vinculação a arquivos de bitmap e de som
armazenados na biblioteca (Library), o que significa que você pode anexar imagens ao
Stage ou trabalhar com esses recursos em bibliotecas compartilhadas.
■ O cache de bitmap permite o aumento do desempenho dos aplicativos durante a execução
por meio do cache de uma representação de bitmap de suas instâncias. Você pode usar o
ActionScript para acessar essa propriedade. Para obter mais informações, consulte “Sobre
cache de bitmap, rolagem e desempenho” na página 508.

20 Novidades do ActionScript no Flash 8


■ O dimensionamento em 9 trechos permite o dimensionamento de instâncias de clipe de
filme sem expansão dos traços que contornam o clipe de filme. Você pode usar o código
ActionScript para acessar esse recurso no Flash Basic 8 e no Flash Professional 8 ou na
ferramenta de criação do Flash 8. Para obter mais informações, consulte “Trabalhando
com dimensionamento de 9 trechos no ActionScript” na página 585. Para obter
informações sobre como acessar o dimensionamento em 9 trechos na ferramenta de
criação, consulte “Sobre dimensionamento em 9 trechos e símbolos de clipe de filme”
na página 91 em Usando o Flash.
■ Agora você pode adicionar informações de metadados para os arquivos FLA na caixa de
diálogo Publish Settings (Configurações de publicação). Pode adicionar um nome e uma
descrição ao arquivo FLA usando a caixa de diálogo para ajudar a aumentar a visibilidade
da pesquisa on-line.
■ O painel Strings (Seqüências de caracteres) está aprimorado e agora inclui suporte
multilinha no campo String e um arquivo de linguagem XML. Para obter mais
informações, consulte “Sobre o painel Strings” na página 479.
■ Um novo coletor de lixo faz parte do Flash Player, que usa um coletor incremental para
melhorar o desempenho.
■ O fluxo de trabalho para a criação de aplicativos acessíveis está aprimorado. No Flash
Player 8 não há mais necessidade de os desenvolvedores adicionarem todos os objetos ao
índice de tabulação para que o conteúdo seja lido corretamente por um leitor de tela. Para
obter mais informações sobre o índice de tabulação, consulte tabIndex
(Button.tabIndex property), tabIndex (MovieClip.tabIndex property) e
tabIndex (TextField.tabIndex property) em ActionScript 2.0 Language Reference.
■ O Flash Player aumentou a segurança dos arquivos locais; agora há mais segurança quando
os arquivos SWF são executados no disco rígido. Para obter informações sobre segurança
de arquivos locais, consulte “Sobre segurança do arquivo local e o Flash Player”
na página 709.
■ Usando o código ActionScript, você pode usar a API Drawing (API de desenho) para
controlar o estilo de linhas dos traços desenhados. Para obter informações sobre novos
estilos de linha, consulte “Usando estilos de linha” na página 574.
■ Usando o código ActionScript, você poderá usar a API Drawing para criar gradientes mais
complexos com os quais preencherá as formas. Para obter informações sobre
preenchimentos de gradiente, consulte “Usando preenchimentos de gradiente complexos”
na página 573.
■ Você pode usar o código ActionScript para aplicar muitos filtros a objetos no Stage (como
instâncias de clipe de filme). Para obter informações sobre filtros e o ActionScript,
consulte “Trabalhando com filtros usando ActionScript” na página 534.

Novidades do ActionScript 2.0 e do Flash 8 21


■ Para fazer o upload dos arquivos para um servidor, use as APIs FileReference e
FileReferenceList. Para obter mais informações, consulte “Sobre upload e download de
arquivos” na página 674.
■ Você pode usar o código ActionScript para acessar meios novos e avançados de aplicar e
manipular cores. Para obter mais informações, consulte “Definindo valores de cores”
na página 599 e ColorTransform (flash.geom.ColorTransform) em ActionScript 2.0
Language Reference.
■ Foram feitos diversos aprimoramentos no texto, incluindo novas opções, propriedades e
parâmetros nas classes TextField e TextFormat. Para obter mais informações, consulte
TextField e TextFormat em ActionScript 2.0 Language Reference.
■ Para acessar os recursos avançados de eliminação de serrilhado (FlashType), use o código
ActionScript. Para obter mais informações, consulte “Sobre a renderização de fontes e
texto sem serrilhado” na página 430.
■ Quando testar o aplicativo, você poderá excluir os arquivos ASO. Selecione Control
(Controlar) > Delete ASO files (Excluir arquivos ASO) ou Control > Delete ASO files e
Test Movie (Testar filme) na ferramenta de criação. Para obter informações, consulte
“Usando arquivos ASO” na página 298.
Para obter uma lista de classes, elementos de linguagem, métodos e propriedades específicas
adicionadas ao ActionScript 2.0 no Flash 8, consulte “Acréscimos à linguagem ActionScript”
na página 22.

Acréscimos à linguagem ActionScript


Esta seção lista acréscimos aos elementos e classes da linguagem ActionScript novos ou
alterados no Flash 8. As classes e os elementos de linguagem a seguir são novos acréscimos ao
Flash Player 8 ou passaram a ter suporte recentemente nesse programa.
As classes a seguir foram adicionadas ao ActionScript 2.0 no Flash 8:
■ A classe BevelFilter (do pacote flash.filters) permite a adição de efeitos de chanfro a
objetos.
■ A classe BitmapData (do pacote flash.display) permite a criação e a manipulação de
imagens de bitmap transparentes ou opacas dimensionadas arbitrariamente.
■ A classe BitmapFilter (do pacote flash.display) é uma classe base para efeitos de filtro.
■ A classe BlurFilter permite a aplicação de embaçamentos a objetos no Flash.
■ A classe ColorMatrixFilter (do pacote flash.filters) permite a aplicação de transformações a
cores ARGB e valores alfa.
■ A classe ColorTransform (do pacote flash.geom) permite o ajuste de valores de cores em
clipes de filme. A classe Color é obsoleta em relação a esta classe.

22 Novidades do ActionScript no Flash 8


■ A classe ConvolutionFilter (do pacote flash.filters) permite a aplicação de efeitos de filtro
de torção de matriz.
■ A classe DisplacementMapFilter (do pacote flash.filters) permite o uso de valores em pixels
de um objeto BitmapData para o deslocamento de um objeto.
■ A classe DropShadowFilter (do pacote flash.filters) permite a adição de sombreamentos a
objetos.
■ A classe ExternalInterface (do pacote flash.external) permite que você se comunique
usando o ActionScript com o recipiente do Flash Player (o sistema que contém o
aplicativo Flash, como um navegador com JavaScript, ou o aplicativo desktop).
■ A classe FileReference (do pacote flash.net ) permite o upload e o download de arquivos
entre o computador do usuário e um servidor.
■ A classe FileReferenceList (do pacote flash.net) permite a seleção de um ou mais arquivos
para upload.
■ A classe GlowFilter (do pacote flash.filters) permite a adição de efeitos de brilho a objetos.
■ A classe GradientBevelFilter (do pacote flash.filters) permite a adição de chanfros
gradientes a objetos.
■ A classe GradientGlowFilter (do pacote flash.filters) permite a adição de efeitos de brilho
gradiente a objetos.
■ A classe IME (da classe System) permite a manipulação do IME (Input Method Editor,
Editor de método de entrada) do sistema operacional no Flash Player.
■ A classe Locale (do pacote mx.lang) permite o controle do modo de exibição de texto
multilíngüe em um arquivo SWF.
■ A classe Matrix (do pacote flash.geom) representa uma matriz de transformação que
determina como mapear pontos de um espaço de coordenada para o outro.
■ O objeto Point (do pacote flash.geom) representa um local em um sistema de coordenadas
bidimensional, onde x representa o eixo horizontal e y representa o eixo vertical.
■ A classe Rectangle (do pacote flash.geom) permite a criação e a modificação de objetos
Rectangle.
■ A classe TextRenderer (do pacote flash.text) oferece funcionalidade para fontes
incorporadas sem serrilhado.
■ A classe Transform (do pacote flash.geom) coleta dados sobre transformações de cores e
manipulações de coordenadas aplicadas a uma instância MovieClip.
N O TA

No Flash 8 foi adicionado suporte oficial para a classe AsBroadcaster.

Novidades do ActionScript 2.0 e do Flash 8 23


Os novos elementos, métodos e funções da linguagem adicionados a classes existentes no
ActionScript incluem:
■ A função global showRedrawRegions permite que o player do depurador indique as
regiões da tela que estão sendo redesenhadas (ou seja, regiões problemáticas que estão
sendo atualizadas). A função faz o player mostrar o que foi redesenhado, mas não permite
que você controle as regiões de redesenho.
■ A propriedade blendMode da classe Button, que define o modo de mistura para a instância
do botão.
■ A propriedade cacheAsBitmap da classe Button, que permite o cache do objeto como
representação interna de bitmap da instância.
■ A propriedade filters da classe Button, que é um array indexado que contém cada
objeto filtro associado ao botão.
■ A propriedade scale9Grid da classe Button, que é a região retangular que define nove
regiões de dimensionamento para a instância.
■ A propriedade hasIME da classe System.capabilities, que indica se o sistema possui um
IME instalado.
■ A propriedade getUTCYear da classe Date, que retorna o ano dessa data, de acordo com a
hora universal.
■ A constante ALT da classe Key.
■ O método isAccessible() da classe Key retorna um valor booleano que indica se a
última tecla pressionada pode ser acessada por outros arquivos SWF, dependendo das
restrições de segurança.
■ O manipulador de eventos onHTTPStatus da classe LoadVars retorna o código de status
retornado do servidor (por exemplo, o valor 404 para página não encontrada). Para obter
mais informações, consulte onHTTPStatus (LoadVars.onHTTPStatus handler) em
ActionScript 2.0 Language Reference.
■ O método attachBitmap() da classe MovieClip, que anexa uma imagem de bitmap a um
clipe de filme. Para obter mais informações, consulte BitmapData
(flash.display.BitmapData) em ActionScript 2.0 Language Reference.
■ O método beginBitmapFill() da classe MovieClip, que preenche um clipe de filme com
uma imagem de bitmap.
■ Os parâmetros spreadMethod, interpolationMethod e focalPointRatio do método
beginGradientFill() da classe MovieClip. Esse método preenche uma área de desenho
com uma imagem de bitmap, e o bitmap pode ser repetido ou colocado lado a lado para
preencher a área.

24 Novidades do ActionScript no Flash 8


■ A propriedade blendMode da classe MovieClip, que permite a definição do modo de
mistura para a instância.
■ A propriedade cacheAsBitmap da classe MovieClip, que permite o cache do objeto como
uma representação interna de bitmap da instância.
■ A propriedade filters da classe MovieClip, que é um array indexado que contém cada
objeto filtro associado no momento à instância.
■ O método getRect() da classe MovieClip, que retorna propriedades que são os valores de
coordenada mínimo e máximo da instância especificada.
■ O método lineGradientStyle() da classe MovieClip, que especifica um estilo de linha
gradiente que o Flash usa quando desenha um caminho.
■ Os parâmetros pixelHinting, noScale, capsStyle, jointStyle e miterLimit do
método lineStyle() da classe MovieClip. Esses parâmetros especificam tipos de estilos
de linha que você pode usar ao desenhar linhas.
■ A propriedade opaqueBackground da classe MovieClip, que define a cor de fundo opaca
(não transparente) do clipe de filme como a cor que o valor hexadecimal RGB especifica.
■ A propriedade scale9Grid da classe MovieClip, que é a região retangular que define nove
regiões de dimensionamento para a instância.
■ A propriedade scrollRect da classe MovieClip, que permite que você role rapidamente o
conteúdo do clipe de filme e que a janela exiba um conteúdo maior.
■ A propriedade transform da classe MovieClip, que permite configurações em relação aos
limites de matriz, transformação de cores e pixels de um clipe de filme. Para obter mais
informações, consulte Transform (flash.geom.Transform) em ActionScript 2.0
Language Reference.
■ O parâmetro status da classe MovieClipLoader. O manipulador de eventos
onLoadComplete retorna o código de status retornado do servidor (por exemplo, o valor
404 para página não encontrada). Para obter mais informações, consulte onLoadComplete
(MovieClipLoader.onLoadComplete event listener) em ActionScript 2.0 Language
Reference.
■ O manipulador de eventos onLoadError da classe MovieClipLoader é chamado quando
um arquivo carregado com MovieClipLoader.loadClip() não pode ser carregado.
■ O parâmetro secure do método SharedObject.getLocal() determina se o acesso a esse
objeto compartilhado se restringe a arquivos SWF transmitidos por uma conexão
HTTPS. Para obter mais informações, consulte getLocal (SharedObject.getLocal
method) em ActionScript 2.0 Language Reference.
■ A constante ID3 da classe Sound.

Novidades do ActionScript 2.0 e do Flash 8 25


■ A propriedade sandboxType da classe System.security indica o tipo de sandbox de
segurança em que o arquivo SWF de chamada está operando. Para obter mais
informações, consulte sandboxType (security.sandboxType property) em
ActionScript 2.0 Language Reference.
■ O método parse() da classe TextField.StyleSheet.
■ A propriedade antiAliasType da classe TextField, que define o tipo de eliminação de
serrilhado utilizada na instância TextField.
■ A propriedade filters da classe TextField, que é um array indexado que contém cada
objeto filtro associado no momento à instância TextField.
■ A propriedade gridFitType da classe TextField, que define o tipo de ajuste à grade usado
na instância. Para obter informações sobre ajuste à grade e TextField.gridFitType, consulte
gridFitType (TextField.gridFitType property) em ActionScript 2.0 Language
Reference.
■ A propriedade sharpness da classe TextField, que estabelece a definição das bordas de
glifo para a instância TextField. Se usar essa propriedade, terá de definir o método
antiAliasType() como avançado.
■ A propriedade thickness da classe TextField, que define a espessura das bordas de glifo
na instância TextField. Se usar essa propriedade, terá de definir o método
antiAliasType() como avançado.
■ O valor justify da propriedade align da classe TextFormat, que permite a justificação
de um parágrafo específico.
■ A propriedade indent da classe TextFormat, que permite o uso de valores negativos.
■ A propriedade kerning da classe TextFormat, que permite a ativação ou desativação do
kerning para o objeto TextFormat.
■ A propriedade leading da classe TextFormat, que permite o uso de entrelinhamento
negativo, ou seja, que o espaço entre as linhas seja inferior à altura do texto. Isso permite
que você coloque linhas de texto juntas nos aplicativos.
■ A propriedade letterSpacing da classe TextFormat, que permite a especificação da
quantidade de espaço distribuída uniformemente entre os caracteres.
■ A propriedade _alpha da classe Video, que é a quantidade especificada de transparência
para o objeto vídeo.
■ A propriedade _height da classe Video, que indica a altura da instância do vídeo.
■ A propriedade _name da classe Video, que indica o nome de instância do vídeo.
■ A propriedade _parent da classe Video, que indica a instância ou objeto de clipe de vídeo
que contém a instância do vídeo.

26 Novidades do ActionScript no Flash 8


■ A propriedade _rotation da classe Video, que permite a definição do valor de rotação da
instância do vídeo em graus.
■ A propriedade _visible da classe Video, que permite a definição da visibilidade de uma
instância de vídeo.
■ A propriedade _width da classe Video, que permite a definição da largura da instância do
vídeo.
■ A propriedade _x da classe Video, que permite a definição da coordenada x da instância do
vídeo.
■ A propriedade _xmouse da classe Video, que permite a definição da coordenada x da
posição do ponteiro do mouse.
■ A propriedade _xscale da classe Video, que permite a definição do percentual de
dimensionamento horizontal da instância do vídeo.
■ A propriedade _y da classe Video, que permite a definição da coordenada y da instância do
vídeo.
■ A propriedade _ymouse da classe Video, quer permite a definição da coordenada y da
posição do ponteiro do mouse.
■ A propriedade _yscale da classe Video, que permite a definição do percentual de
dimensionamento vertical da instância do vídeo.
■ O manipulador de eventos onHTTPStatus da classe XML retorna o código de status
retornado do servidor (por exemplo, o valor 404 para página não encontrada). Para obter
mais informações, consulte onHTTPStatus (XML.onHTTPStatus handler) em
ActionScript 2.0 Language Reference.
■ A propriedade localName da classe XMLNode, que retorna o nome completo do objeto
nó XML (incluindo o prefixo e o nome local).
■ A propriedade namespaceURI da classe XMLNode, que lê o URI do namespace para o
qual o prefixo do nó XML resolve. Para obter mais informações, consulte namespaceURI
(XMLNode.namespaceURI property) em ActionScript 2.0 Language Reference.
■ A propriedade prefix da classe XMLNode, que lê o prefixo do nome do nó.
■ O método getNamespaceForPrefix() da classe XMLNode, que retorna o URI do
namespace associado ao prefixo especificado para o nó.
■ O método getPrefixForNamespace da classe XMLNode, que retorna o prefixo associado
a um URI de namespace especificado para o nó.

Novidades do ActionScript 2.0 e do Flash 8 27


Sobre elementos de linguagem obsoletos
Alguns elementos de linguagem estão obsoletos no Flash Player 8. Para obter uma lista dos
elementos de linguagem obsoletos e alternativas para uso no Flash Player 8, consulte as seções
a seguir do ActionScript 2.0 Language Reference:
■ Deprecated Class summary
■ Deprecated Function summary
■ Deprecated Property summary
■ Deprecated Operator summary

Alterações de edição do ActionScript


O editor do ActionScript no painel Actions e na janela Script foi atualizado de várias maneiras
para ficar mais eficiente e fácil de usar do que nas versões anteriores da ferramenta. Essas
alterações são resumidas nesta seção.
View hidden characters (Exibir caracteres ocultos) Agora você pode usar o menu pop-up
Options (Opções) dos painéis Script, Debugger (Depurador) e Output (Saída) para exibir ou
ocultar caracteres quando escrever arquivos de script no painel Actions ou na janela Script.
Para obter informações sobre esse recurso, consulte “Exibindo caracteres ocultos”
na página 57.
Script assist added to Actions panel (Script assist adicionado ao painel Actions) Nas
versões anteriores do Flash, você podia trabalhar no painel Actions tanto no modo normal, em
que você preenchia opções e parâmetros para criar código, quanto no modo especialista, em
que você adicionava comandos diretamente ao painel Script. Essas opções não estavam
disponíveis no Flash MX 2004 e no Flash MX Professional 2004. No entanto, no Flash Basic
8 e no Flash Professional 8, você pode trabalhar no modo Script Assist, que é semelhante ao
modo normal e muito mais eficiente que ele. Para obter informações sobre o modo Script
Assist, consulte Capítulo 13, “Criando ActionScript com o Script Assist” em Usando o Flash.
Para ver um tutorial sobre o Script Assist, consulte o Capítulo 13, “Criando um evento
startDrag/stopDrag com o Script Assist” do manual Usando o Flash.

28 Novidades do ActionScript no Flash 8


Reload modified files (Recarregar arquivos modificados) Você pode recarregar os
arquivos de script modificados quando trabalhar em um aplicativo. É exibida uma mensagem
de aviso, solicitando o recarregamento dos arquivos de script modificados associados ao
aplicativo em que você está trabalhando. Esse recurso é especialmente vantajoso para equipes
que trabalham simultaneamente em aplicativos. Ele ajuda a evitar o trabalho com scripts
desatualizados ou que versões mais recentes de um script acabem sendo substituídas. Se um
arquivo de script tiver sido movido ou excluído, uma mensagem de aviso será exibida e
solicitará o salvamento dos arquivos conforme necessário. Para obter mais informações,
consulte “Sobre as preferências do ActionScript” na página 44.

Alterações no modelo de segurança para


arquivos SWF instalados localmente
O Flash Player 8 possui um modelo de segurança novo e aperfeiçoado por meio do qual os
aplicativos Flash e os arquivos SWF de um computador local podem se comunicar com a
Internet e o sistema de arquivos local, em vez de serem executados de um servidor remoto da
Web. Ao desenvolver um aplicativo Flash, você precisa indicar se um arquivo SWF pode se
comunicar com uma rede ou com um sistema de arquivos local.
N OT A

Nesta descrição, um arquivo SWF local é um arquivo SWF instalado localmente no


computador de um usuário (e não disponibilizado a partir de um site) e não inclui
arquivos de projetor (EXE).

Nas versões anteriores do Flash Player, os arquivos SWF locais podiam interagir com outros
arquivos SWF e carregar dados de qualquer computador remoto ou local sem configurar
definições de segurança. No Flash Player 8, um arquivo SWF não pode fazer conexões com o
sistema de arquivos local e a rede (como a Internet) no mesmo aplicativo sem fazer uma
configuração de segurança. Isso é para sua segurança. Dessa forma, um arquivo SWF não pode
ler arquivos no seu disco rígido e depois enviar o conteúdo deles pela Internet.
A restrição de segurança afeta todo o conteúdo implantado localmente, seja um conteúdo
herdado (um arquivo FLA criado em uma versão anterior do Flash) ou criado no Flash 8.
Usando o Flash MX 2004 ou uma ferramenta de criação anterior, você pode testar um
aplicativo Flash que seja executado localmente e também acesse a Internet. No Flash Player 8,
esse aplicativo agora solicita permissão ao usuário para se comunicar com a Internet.

Alterações no modelo de segurança para arquivos SWF instalados localmente 29


Quando você testa um arquivo no disco rígido, são necessárias várias etapas para determinar se
ele é um documento local confiável (seguro) ou um documento potencialmente não-confiável
(sem segurança). Se você criar o arquivo no ambiente de criação do Flash (por exemplo,
quando selecionar Control > Test Movie), seu arquivo será considerado confiável, pois ele se
encontra no ambiente de teste.
No Flash Player 7 e anteriores, os arquivos SWF locais tinham permissões para acessar o
sistema de arquivos local e a rede. No Flash Player 8, os arquivos SWF locais podem ter três
níveis de permissão:
■ Access the local file system only (Acessar somente o sistema de arquivos local), o nível
padrão. O arquivo SWF local pode ser lido no sistema de arquivos local e em caminhos de
rede de convenção universal de atribuição de nomes (UNC, Universal Naming
Convention) e não pode se comunicar com a Internet.
■ Access the network only (Acessar somente a rede). O arquivo SWF local pode acessar
somente a rede (como a Internet) e não o sistema de arquivos local onde o arquivo SWF
está instalado.
■ Access to both the local file system and the network (Acessar o sistemas de arquivos local e
a rede). O arquivo SWF local pode ser lido no sistema de arquivos local onde o arquivo
está instalado, pode ser lido em qualquer servidor que lhe conceda permissão (e gravar
nele) e pode criar vários scripts para outros arquivos SWF na rede ou no sistema de
arquivos local que lhe conceda permissão.
Para obter mais detalhes sobre cada nível de permissão, consulte “Sobre segurança do arquivo
local e o Flash Player” na página 709.
Há também pequenas alterações em System.security.allowDomain e aprimoramentos em
System.security.allowInsecureDomain. Para obter mais informações sobre segurança de
arquivos locais, consulte o Capítulo 17, “Noções básicas de segurança.”

30 Novidades do ActionScript no Flash 8


CAPÍTULO 2

Escrevendo e editando o
ActionScript 2.0
2
Ao escrever o código ActionScript no Macromedia Flash Basic 8 ou no Macromedia Flash
Professional 8, use o painel Actions (Ações) ou a janela Script. O painel Actions e a janela
Script contêm um editor de código completo (o editor do ActionScript) que inclui referências
de código e sinalização por cores, formatação de código, realce de sintaxe, verificação de
sintaxe, depuração, números de linha, quebra automática de linha e suporte a Unicode em
duas exibições diferentes. Para obter mais informações sobre o editor do ActionScript,
consulte “Usando o painel Actions e a janela Script” na página 36.
Use um dos dois métodos para escrever o código ActionScript no Flash. Você pode criar
scripts que façam parte de seu documento do Flash (ou seja, scripts incorporados ao arquivo
FLA) ou criar scripts externos (scripts ou classes armazenadas em arquivos externos). Não é
possível usar o painel Actions para criar scripts externos.
Use o editor do ActionScript no painel Actions ao criar scripts em um arquivo FLA. O painel
Actions contém o editor do ActionScript em um painel Script e ferramentas de suporte para
facilitar a criação de scripts. Essas ferramentas incluem a caixa de ferramentas Actions (Ações)
que oferece um acesso rápido aos elementos básicos da linguagem ActionScript; o navegador
Script que ajuda na navegação por todos os scripts do documento; e o modo Script Assist
(Assistência de script) que solicita os elementos necessários para a criação de scripts. Para obter
mais informações sobre o painel Actions, consulte “Sobre o painel Actions” na página 37. Para
obter mais informações sobre o Script Assist, consulte “Sobre o Script Assist” na página 62.
Quando precisar criar um script externo, use o editor do ActionScript na janela Script para
criar um novo arquivo do ActionScript. (Você também pode usar o seu editor de texto favorito
para criar um arquivo externo do AS.) Na janela Script, o editor do Action Script inclui
recursos de assistência a código, como referências de código e sinalização por cores, verificação
de sintaxe etc., da mesma forma que no painel Actions. Para obter mais informações sobre a
janela Script, consulte “Sobre a janela Script” na página 38.

31
O Flash oferece assistência adicional a scripts através de comportamentos. Os
comportamentos são funções predefinidas do ActionScript que você pode anexar a objetos no
documento do Flash sem precisar criar o código ActionScript. Para obter mais informações
sobre comportamentos, consulte “Sobre comportamentos” na página 65.
Para obter mais informações sobre como manipular eventos, consulte as seguintes seções:
Sobre o ActionScript e eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Organizando o código ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Usando o painel Actions e a janela Script. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Sobre o painel Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Sobre a janela Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Sobre a codificação no painel Actions e na janela Script . . . . . . . . . . . . . . . . . . . . . . 39
Sobre recursos do painel Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Sobre comportamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Sobre as configurações de publicação do ActionScript . . . . . . . . . . . . . . . . . . . . . . . 66

Sobre o ActionScript e eventos


No Macromedia Flash Basic 8 e no Macromedia Flash Professional 8, o código ActionScript é
executado quando ocorre um evento: por exemplo, quando um clipe de filme é carregado,
quando um quadro-chave é inserido na timeline ou quando o usuário clica em um botão. Os
eventos podem ser ativados pelo usuário ou pelo sistema. Os usuários clicam em botões do
mouse e pressionam teclas; o sistema ativa eventos quando condições específicas são atendidas
ou quando processos são concluídos (o arquivo SWF é carregado, a timeline alcança um
determinado quadro, um elemento gráfico conclui o download etc.).
Quando ocorre um evento, você cria um manipulador de eventos para responder ao evento com
uma ação. Compreender quando e onde ocorrerão os eventos o ajudará a determinar como e
onde você responderá a eles com uma ação e quais ferramentas do ActionScript utilizará em
cada caso. Para obter mais informações, consulte “Sobre a criação de scripts para manipular
eventos” na página 35.
Os eventos podem ser agrupados em várias categorias: eventos de mouse e teclado, que
ocorrem quando o usuário interage com seu aplicativo Flash através do mouse e do teclado;
eventos de clipe, que ocorrem em clipes de filme; e eventos de quadro, que ocorrem em
quadros na timeline.
Para obter informações sobre os tipos de scripts que podem ser criados para manipular
eventos, consulte “Sobre a criação de scripts para manipular eventos” na página 35.

32 Escrevendo e editando o ActionScript 2.0


Eventos de mouse e teclado
Quando o usuário interage com seu aplicativo ou arquivo SWF, ele ativa eventos de mouse e
teclado. Por exemplo, quando ele rola sobre um botão, ocorre o evento Button.onRollOver
ou on(rollOver); quando ele clica em um botão, o evento Button.onRelease é ativado; se
uma tecla do teclado for pressionada, o evento on(keyPress) ocorrerá. Você pode criar um
código em um quadro ou anexar scripts a uma instância para manipular esses eventos e
adicionar toda a interatividade desejada.

Eventos de clipe
Em um clipe de filme, você pode reagir a diversos eventos de clipe ativados quando o usuário
entra ou sai da cena ou interagir com a cena usando o mouse ou o teclado. Por exemplo, você
pode carregar uma imagem externa SWF ou JPG no clipe de filme quando o usuário entrar na
cena ou permitir que os movimentos do mouse do usuário reposicionem elementos na cena.

Eventos de quadro
Em uma timeline principal ou de clipe de filme, um evento de sistema ocorre quando a
reprodução entra em um quadro-chave — conhecido como evento de quadro. Os eventos de
quadro são úteis para ativar ações baseadas na passagem de tempo (que se movem pela
timeline) ou para interagir com elementos visíveis no momento no Stage. Quando você
adiciona um script a um quadro-chave, ele é executado quando o quadro-chave é alcançado
durante uma reprodução. Os script anexados a um quadro são chamados scripts de quadro.
Uma das utilizações mais comuns dos scripts de quadro é interromper a reprodução quando
um determinado quadro-chave é alcançado. Isso é feito com a função stop(). Selecione um
quadro-chave e adicione a função stop() como um elemento de script no painel Actions.

Ao interromper arquivo SWF em um quadro-chave específico, você precisará executar uma


ação. Você pode, por exemplo, usar um script de quadro para atualizar dinamicamente o valor
de um rótulo, gerenciar a interação dos elementos no Stage etc.

Sobre o ActionScript e eventos 33


Organizando o código ActionScript
É possível anexar scripts a quadros-chave e instâncias de objeto (clipes de filme, botões e
outros símbolos). Entretanto, se o seu código ActionScript for distribuído por vários quadros-
chave e instâncias de objeto, a depuração de seu aplicativo ficará muito mais difícil. Também
será difícil compartilhar o código com diferentes aplicativos Flash. Portanto, é importante que
você siga as práticas recomendadas de codificação ao criar o ActionScript no Flash.
Em vez de anexar scripts aos elementos, como quadros-chave, clipes de filme e botões,
responda aos eventos chamando as funções residentes em um local central. Um dos métodos
consiste em anexar o ActionScript incorporado ao primeiro ou ao segundo quadro da
timeline, sempre que possível, para que você não precise pesquisar o arquivo FLA a fim de
localizar todo o código. Uma prática comum envolve a criação de uma camada denominada
actions e a inclusão do código ActionScript nessa camada.

Ao anexar todos os scripts a elementos individuais, você incorpora todo o código ao arquivo
FLA. Se o compartilhamento de seu código com outros aplicativos do Flash for um requisito
importante para você, use a janela Script ou o seu editor de texto favorito para criar um
arquivo externo do ActionScript (AS).
A criação de um arquivo externo torna o seu código mais modular e bem organizado. À
medida que seu projeto for se desenvolvendo, essa conveniência terá cada vez mais utilidade
do que você imagina. Um arquivo externo ajudará na depuração e também no gerenciamento
do controle de origem caso você esteja trabalhando em um projeto junto com outros
desenvolvedores.
Para usar o código ActionScript contido em um arquivo externo do AS, crie um script no
arquivo FLA e use a instrução #include para acessar o código armazenado externamente,
como mostrado no exemplo a seguir:
#include "../core/Functions.as"

34 Escrevendo e editando o ActionScript 2.0


Também é possível usar o ActionScript 2.0 para criar classes personalizadas. Armazene as
classes personalizadas em arquivos externos do AS e use instruções import em um script para
exportar as classes para o arquivo SWF, em vez de usar instruções #include. Para obter mais
informações sobre como criar arquivos de classe, consulte “Criando arquivos de classes
personalizados” na página 249 e “Sobre a importação de arquivos de classes” na página 254
que tratam da importação desses arquivos. Você também pode usar componentes (clipes de
filme predefinidos) para compartilhar código e funcionalidade, como scripts e elementos de
UI.
NO T A

O código do ActionScript em arquivos externos é compilado em um arquivo SWF


quando você publica, exporta, testa ou depura um arquivo FLA. Portanto, se você fizer
qualquer alteração em um arquivo externo, será preciso salvá-lo e recompilar os
arquivos FLA que o utilizam.

Ao criar o ActionScript no Flash 8, use o painel Actions, a janela Script ou ambos. O uso do
painel Actions ou da janela Script é determinado pelo modo de resposta aos eventos, pelo
modo de organização do código e, principalmente, pelas práticas recomendadas de
codificação.
Para obter mais informações sobre convenções e práticas recomendadas de codificação,
consulte “Convenções de codificação do ActionScript” na página 782.
Outros problemas relacionados a fluxo de trabalho e organização de código deverão ser
considerados quando você usar comportamentos, que são funções predefinidas do
ActionScript (consulte “Sobre comportamentos” na página 65).

Sobre a criação de scripts para manipular eventos


A criação de código para eventos pode ser categorizada em dois grupos principais: eventos que
ocorrem na timeline (em quadros-chave) e eventos que ocorrem em instâncias de objeto
(clipes de filme, botões e componentes). A interatividade de seu aplicativo ou arquivo SWF
pode ser distribuída pelos vários elementos de seu projeto; você também pode optar por
adicionar scripts diretamente a esses elementos. Entretanto, a Macromedia recomenda a não
adição direta de scripts a esses elementos (quadros-chave e objetos). Nesse caso, você deve
responder aos eventos chamando as funções residentes em um local central, conforme descrito
em “Organizando o código ActionScript”.

Organizando o código ActionScript 35


Usando o painel Actions e a janela Script
Para criar scripts em um arquivo FLA, insira o ActionScript diretamente no painel Actions.
Para criar scripts externos a serem incluídos ou importados para o seu aplicativo, você pode
usar a janela Script (File [Arquivo] > New [Novo] e selecionar ActionScript File [Arquivo do
ActionScript]) ou o seu editor de texto preferido.
A utilização do painel Actions ou da janela Script equivale ao uso dos recursos do editor do
ActionScript para criar, formatar e editar o código. O painel Actions e a janela Script possuem
o painel Script (onde o código é digitado) e a caixa de ferramentas Actions. O painel Actions
oferece mais alguns recursos de assistência a código do que a janela Script. O Flash oferece
esses recursos no painel Actions por eles serem especialmente úteis no contexto de edição do
ActionScript em um arquivo FLA.

Para exibir o painel Actions, siga um destes procedimentos:


■ Selecione Window (Janela) > Actions (Ações).
■ Pressione F9.

Para exibir a janela Script, siga um destes procedimentos:


■ Para começar a escrever um novo script, selecione File (Arquivo) > New (Novo) e
ActionScript File (Arquivo do ActionScript).
■ Para abrir um script existente, selecione File > Open (Abrir) e abra um arquivo do AS.
■ Para editar um script já aberto, clique na guia do documento que exibe o nome do script.
Para obter mais informações, consulte os tópicos a seguir:
■ “Sobre o painel Actions” na página 37
■ “Sobre a janela Script” na página 38

36 Escrevendo e editando o ActionScript 2.0


Sobre o painel Actions
Use o painel Actions para criar o ActionScript em um documento do Flash (arquivo FLA). O
painel consiste em três painéis, e cada um deles oferece suporte à criação e ao gerenciamento
de scripts.
Actions (Ações), caixa
de ferramentas Navegador Script Script, painel Menu pop-up

Caixa de ferramentas Actions Use esta caixa de ferramentas para pesquisar uma lista
categórica de elementos da linguagem ActionScript (funções, classes, tipos etc.) e, em
seguida, insira-os no painel Script. Para inserir um elemento de script no painel Script,
clique duas vezes nele ou arraste-o diretamente para esse painel. Você também pode
adicionar elementos de linguagem aos scripts usando o botão Add (+) (Adicionar)
localizado na barra de ferramentas do painel Actions. Para obter mais informações,
consulte “Sobre as barras de ferramentas do painel Actions e da janela Script”
na página 40.
Navegador Script Exibe uma lista hierárquica de elementos do Flash (clipes de filme,
quadros e botões) contendo scripts. Use o navegador Script para se mover rapidamente
entre todos os scripts do documento do Flash.
Se você clicar em um item no navegador Script, o script associado a esse item aparecerá no
painel Script e a reprodução passará para essa posição na timeline. Se você clicar duas vezes
em um item do navegador Script, o script ficará preso (travado no lugar). Para obter mais
informações, consulte “Prendendo scripts no painel Actions” na página 63.

Sobre o painel Actions 37


Painel Script No painel Script, você digita seu código. O painel fornece ferramentas
para a criação de scripts em um editor completo (o editor do ActionScript) que inclui
verificação e formatação de sintaxe, referências de código, sinalização por cores, depuração
e outros recursos que simplificam a criação. Para obter mais informações, consulte
“Usando o painel Actions e a janela Script” na página 36.
Para obter informações sobre cada botão da barra de ferramentas do painel Actions,
consulte “Sobre a codificação no painel Actions e na janela Script” na página 39. Para
obter mais informações sobre os recursos do painel Actions, consulte os seguintes tópicos:
■ “Sobre as barras de ferramentas do painel Actions e da janela Script” na página 40
■ “Sobre as opções de edição do ActionScript” na página 42
■ “Sobre as referências de código no Flash” na página 47
■ “Formatando código” na página 53
■ “Usando o realce de sintaxe” na página 54
■ “Usando números de linha e quebra automática de linha” na página 55
■ “Usando teclas de atalho de Escape” na página 56
■ “Exibindo caracteres ocultos” na página 57
■ “Usando a ferramenta Find” na página 58
■ “Verificando sintaxe e pontuação” na página 59
■ “Importando e exportando scripts” na página 60

Sobre a janela Script


Você pode criar e editar o ActionScript na janela Script ao criar um novo arquivo do
ActionScript, do Flash Communication ou do Flash JavaScript. Use a janela Script para criar e
editar arquivos de script externos. A janela oferece suporte à sinalização da sintaxe por cores, a
referências de código e a outras opções de editor.
Nessa janela, é possível criar um ActionScript externo, a comunicação do ActionScript e
arquivos do Flash JavaScript. Dependendo do tipo de arquivo de script externo criado, a caixa
de ferramentas Actions fornecerá uma lista completa dos elementos de linguagem disponíveis
para cada um deles.
Ao usar a janela Script, você perceberá que alguns dos outros recursos de assistência a código,
como o navegador Script, o modo Script Assist e os comportamentos, não estarão disponíveis.
Isso ocorre porque esses recursos são úteis apenas no contexto de criação de um documento do
Flash, e não de criação de um arquivo de script externo.

38 Escrevendo e editando o ActionScript 2.0


Você também observará que várias opções disponíveis no painel Actions não estão disponíveis
na janela Script. A janela Script oferece suporte às seguintes opções de editor: caixa de
ferramentas Actions, recursos localizar e substituir, verificação de sintaxe, formatação
automática, referências de código e opções de depuração (somente arquivos do ActionScript).
Além disso, ela oferece suporte à exibição de números de linha, caracteres ocultos e quebra
automática de linha.

Para exibir a janela Script:


1. Selecione File (Arquivo) > New (Novo).
2. Selecione o tipo de arquivo externo que deseja criar (arquivo do ActionScript, arquivo do
Flash Communication ou arquivo do Flash JavaScript).
É possível abrir vários arquivos externos ao mesmo tempo; os nomes dos arquivos são exibidos
em guias na parte superior da janela Script. Para obter mais informações sobre os recursos da
janela Script, consulte os seguintes tópicos:
■ “Sobre as barras de ferramentas do painel Actions e da janela Script” na página 40
■ “Sobre as opções de edição do ActionScript” na página 42
■ “Sobre as referências de código no Flash” na página 47
■ “Formatando código” na página 53
■ “Usando o realce de sintaxe” na página 54
■ “Usando números de linha e quebra automática de linha” na página 55
■ “Usando teclas de atalho de Escape” na página 56
■ “Exibindo caracteres ocultos” na página 57
■ “Usando a ferramenta Find” na página 58
■ “Verificando sintaxe e pontuação” na página 59
■ “Importando e exportando scripts” na página 60

Sobre a codificação no painel Actions e


na janela Script
O painel Script, local de edição do código, é o principal elemento do painel Actions e da
janela Script. O painel Actions e a janela Script oferecem recursos básicos de assistência a
código e de edição de script, como referências de código, sinalização por cores, formatação
automática etc.
Os recursos que ajudam na edição do código podem ser acessados na barra de ferramentas do
painel Actions ou da janela Script, através do sistema de menu e no próprio painel Script.

Sobre a codificação no painel Actions e na janela Script 39


Os tópicos a seguir apresentam os vários recursos do editor do ActionScript (painel Actions e
janela Script):
■ “Sobre as barras de ferramentas do painel Actions e da janela Script” na página 40
■ “Sobre as opções de edição do ActionScript” na página 42
■ “Sobre as preferências do ActionScript” na página 44
■ “Sobre as referências de código no Flash” na página 47
■ “Formatando código” na página 53
■ “Usando o realce de sintaxe” na página 54
■ “Usando números de linha e quebra automática de linha” na página 55
■ “Usando teclas de atalho de Escape” na página 56
■ “Exibindo caracteres ocultos” na página 57
■ “Usando a ferramenta Find” na página 58
■ “Verificando sintaxe e pontuação” na página 59
■ “Importando e exportando scripts” na página 60
Para obter os recursos específicos apenas do painel Actions, por exemplo, prender o script e
navegador Script, consulte “Sobre recursos do painel Actions” na página 62.

Sobre as barras de ferramentas do painel Actions e


da janela Script
As barras de ferramentas do painel Actions e da janela Script contêm links para os recursos de
assistência a código que ajudam a simplificar e agilizar a codificação no ActionScript. Elas
serão diferentes caso você utilize o editor do ActionScript no painel Actions ou no painel
Script. A imagem a seguir exibe os recursos localizados na barra de ferramentas do painel
Actions. As opções marcadas estão disponíveis apenas no painel Actions.
Add a new item to the script (Adicionar um novo item ao script) Menu pop-up*
Find (Localizar) Debug Options (Opções de depuração)*
Insert target path (Inserir caminho de destino)* Script Assist *

Show Code Hint (Mostrar referência de código) Referência


Auto Format (Formatação automática)
Check Syntax (Verificar sintaxe)
* Somente no painel Actions

40 Escrevendo e editando o ActionScript 2.0


Os recursos localizados na barra de ferramentas serão discutidos em detalhes em “Usando o
painel Actions e a janela Script” na página 36. Veja a seguir um breve resumo dos botões
disponíveis nas barras de ferramentas do painel Actions e da janela Script.
NO TA

Algumas opções a seguir estão localizadas apenas no painel Actions. Esses recursos
estão marcados como Somente no painel Actions.

Add a new item to the script (Adicionar um novo item ao script) Exiba todos os
elementos de linguagem também existentes na caixa de ferramentas do ActionScript. A
seleção de um item na lista categorizada de elementos de linguagem adiciona-o ao script.
Find (Localizar) Localize e substitua qualquer texto no código ActionScript. Para obter
mais informações, consulte “Usando a ferramenta Find” na página 58.
Insert target path (Inserir caminho de destino) Somente no painel Actions. Ajuda na
configuração de um caminho de destino relativo ou absoluto de uma ação no script. Para
obter mais informações, consulte “Inserindo caminhos de destino” na página 65.
Check Syntax (Verificar sintaxe) Verifique erros na sintaxe do script atual. Os erros de
sintaxe são listados no painel Output (Saída). Para obter mais informações, consulte
“Verificando sintaxe e pontuação” na página 59.
Auto Format (Formatação automática) Formate seu script para uma sintaxe de
codificação apropriada e para melhorar a legibilidade. Você pode definir as preferências de
formatação automática na caixa de diálogo Preferences (Preferências), disponível no menu
Edit (Editar) ou no menu pop-up do painel Actions. Para obter mais informações,
consulte “Formatando código” na página 53.
Show Code Hint (Mostrar referência de código) Se tiver desativado a referência de
código automática, você poderá usar o comando Show Code Hint para exibir
manualmente uma referência de código relativa à linha de código na qual estiver
trabalhando. Para obter mais informações, consulte “Sobre o Script Assist” na página 62.
Debug Options (Opções de depuração) Defina e remova pontos de interrupção no
script, para que, ao depurar seu documento do Flash, você possa parar e, em seguida,
percorrer o script linha por linha. As opções de depuração agora estão disponíveis na janela
Script e também no painel Actions, mas somente para arquivos do ActionScript. Essa
opção está desativada para arquivos do ActionScript Communication e do Flash
JavaScript. Para obter mais informações sobre como depurar documentos do Flash,
consulte “Depurando scripts” na página 745. Para obter informações sobre como definir e
remover pontos de interrupção, consulte “Definindo e removendo pontos de interrupção”
na página 755.

Sobre a codificação no painel Actions e na janela Script 41


Script Assist Somente no painel Actions. No modo Script Assist, você é solicitado a
inserir os elementos necessários à criação de scripts. Para obter mais informações, consulte
“Sobre o Script Assist” na página 62.
Reference (Referência) Exiba um tópico da Ajuda de referência para o elemento da
linguagem ActionScript selecionado no painel Script. Por exemplo, se você clicar em uma
instrução import e, em seguida, clicar em Reference, o tópico da Ajuda relativo à import
será exibido no painel Help (Ajuda).
Menu pop-up Somente no painel Actions. Contém os vários comandos e preferências que
se aplicam ao painel Actions ou à janela Script. Por exemplo, você pode definir números
de linha e quebra automática de linha no editor do ActionScript; acessar as preferências do
ActionScript e importar ou exportar scripts. Para obter mais informações, consulte “Sobre
as opções de edição do ActionScript” na página 42.

Sobre as opções de edição do ActionScript


A janela Script e o painel Actions oferecem vários recursos de assistência a código —
ferramentas que facilitam bastante a criação e a manutenção de scripts. Essas opções de
ferramenta estão disponíveis na barra de ferramentas do painel Actions ou da janela Script e
no menu pop-up do painel Actions. Durante a edição do ActionScript na janela Script, essas
opções estarão disponíveis na barra de ferramentas e no sistema de menu do Flash.
O painel Actions oferece mais opções do que as disponíveis na janela Script. Isso ocorre
porque essas opções adicionais são úteis no contexto de criação do ActionScript incorporado a
um documento do Flash — e não na criação de arquivos externos do ActionScript. Para obter
informações sobre quais dessas opções estão disponíveis na janela Script, consulte “Sobre a
janela Script” na página 38.
As opções disponíveis na janela Script e no painel Actions são discutidas em “Sobre as barras
de ferramentas do painel Actions e da janela Script” na página 40.
As opções a seguir estão disponíveis no menu pop-up do painel Actions e em diversos menus
da janela Script.
N OT A

Algumas opções a seguir estão localizadas apenas no painel Actions. Esses recursos
estão marcados como Somente no painel Actions.

Reload code hints (Recarregar referências de código) Somente no painel Actions. Se


personalizar o modo Script Assist criando métodos personalizados, você poderá recarregar
as referências de código sem reiniciar o Flash 8.

42 Escrevendo e editando o ActionScript 2.0


Pin script (Prender script) Somente no painel Actions. Prende (trava no lugar) o script
exibido no momento no painel Script. Para obter mais informações, consulte “Prendendo
scripts no painel Actions” na página 63.
Close script (Fechar script) Somente no painel Actions. Fecha o script aberto no
momento.
Close all scripts (Fechar todos os scripts) Somente no painel Actions. Fecha todos os
scripts abertos no momento.
Go to line (Ir para linha) Localiza e realça a linha especificada no painel Script.
Find and replace (Localizar e substituir) Localiza e substitui qualquer texto contido
nos scripts do painel Script. Para obter mais informações, consulte “Usando a ferramenta
Find” na página 58.
Find again (Localizar novamente) Repete a ação de busca para a última seqüência de
caracteres de pesquisa digitada na ferramenta Find. Para obter mais informações, consulte
“Usando a ferramenta Find” na página 58.
Import script (Importar script) Permite importar um arquivo de script (ActionScript)
para o painel Script. Para obter mais informações, consulte “Importar e exportar
preferências” na página 61.
Export script (Exportar script) Exporta o script atual para um arquivo externo do
ActionScript (AS). Para obter mais informações, consulte “Importar e exportar
preferências” na página 61.
Esc shortcut keys (Teclas de atalho de Esc) Insira rapidamente elementos de
linguagem e estruturas de sintaxe comuns nos scripts. Por exemplo, quando você
pressionar Esc+g+p no painel Script, a função gotoAndPlay() será inserida no script.
Quando você seleciona a opção Esc Shortcut Keys no menu pop-up do painel Actions,
todas as teclas de atalho disponíveis de Escape são exibidas na caixa de ferramentas
Actions. Para obter mais informações, consulte “Usando teclas de atalho de Escape”
na página 56.
Hidden characters (Caracteres ocultos) Exiba os caracteres ocultos em seu script que
podem ser espaços, tabulações e quebras de linha. Para obter mais informações, consulte
“Exibindo caracteres ocultos” na página 57.
Line numbers (Números de linha) Exibe números de linha no painel Script. Para obter
mais informações, consulte “Usando números de linha e quebra automática de linha”
na página 55.
Preferences (Preferências) Somente no painel Actions. Exibe a caixa de diálogo de
preferências do ActionScript. Para obter mais informações, consulte “Sobre as preferências
do ActionScript” na página 44.

Sobre a codificação no painel Actions e na janela Script 43


Word wrap (Quebra automática de linha) Para quebrar as linhas do script que
excedem o tamanho atual da janela Script, selecione Word Wrap (Quebra automática de
linha) no menu pop-up do painel Actions. Quando você usar a janela Script, selecione
Word Wrap no menu View (Exibir). Para obter mais informações, consulte “Usando
números de linha e quebra automática de linha” na página 55.
Group Actions with (Agrupar ações com) Somente no painel Actions. Permite agrupar o
painel Actions (que inclui a caixa de ferramentas Actions e o navegador Script) com outros
painéis dentro do ambiente de criação do Flash.
O menu pop-up do painel Actions também inclui os comandos Print (Imprimir), Help
(Ajuda) e comandos de redimensionamento de painel.

Sobre as preferências do ActionScript


A edição de um código no painel Actions ou na janela Script permite definir e modificar um
único conjunto de preferências. Por exemplo, você pode controlar o recuo automático, as
referências de código e a sinalização por cores, além de vários outros recursos básicos de edição
de código.

Para acessar as preferências do ActionScript:


1. Para acessar as preferências do ActionScript em um arquivo FLA através do painel Actions,
selecione Preferences (Preferências) no menu pop-up ou Edit (Editar) > Preferences
(Preferências) (Windows) ou Flash > Preferences (Macintosh) e clique em ActionScript na
lista Category (Categoria).
2. Para acessar as preferências do ActionScript na janela Script, selecione Edit > Preferences e
clique em ActionScript (Windows) ou escolha Flash > Preferences e clique em ActionScript
(Macintosh).

44 Escrevendo e editando o ActionScript 2.0


A imagem a seguir mostra as configurações do ActionScript que podem ser alteradas no Flash
8.

Você pode definir as seguintes preferências:


Automatic indentation (Recuo automático) Quando o recuo automático estiver ativado,
o texto digitado após um parêntese de abertura [(] ou uma chave de abertura ({) será recuado
automaticamente conforme a configuração Tab Size (Tamanho da tabulação) nas preferências
do ActionScript. Para obter mais informações, consulte “Formatando código” na página 53.
Tab size (Tamanho da tabulação) Especifica o número de caracteres segundo o qual a
linha será deslocada quando o recuo automático estiver ativado.
Code hints (Referências de código) Permite referências de código no painel Script. Para
obter mais informações sobre como usar referências de código, consulte “Sobre as referências
de código no Flash” na página 47.
Delay (Atraso) Especifica o atraso (em segundos) antes da exibição das referências de
código.
Font (Fonte) Especifica a fonte usada no painel Script.

Sobre a codificação no painel Actions e na janela Script 45


Use dynamic font mapping (Usar mapeamento dinâmico de fontes) Executa uma
verificação para assegurar que a família de fontes selecionada possui os glifos necessários para
renderizar cada caractere. Caso não haja os glifos necessários, o Flash substituirá uma família
de fontes contendo os caracteres necessários. Para obter mais informações, consulte
“Formatando código” na página 53.
Encoding (Codificação) Especifica a codificação de caracteres usada quando você abre,
salva, importa e exporta arquivos do ActionScript. Para obter mais informações, consulte
“Importando e exportando scripts” na página 60.
Reload modified files (Recarregar arquivos modificados) Permite que você selecione o
momento de exibição de avisos sobre a modificação, a movimentação ou a exclusão de um
arquivo de script. Selecione Always (Sempre), Never (Nunca) ou Prompt.
■ Always (Sempre) Nenhum aviso é exibido quando uma alteração é detectada e o
arquivo é automaticamente recarregado.
■ Never (Nunca) Nenhum aviso é exibido quando uma alteração é detectada e o arquivo
permanece no estado atual.
■ Prompt (Padrão) Um aviso é exibido quando uma alteração é detectada e você pode
optar por recarregar ou não o arquivo.
Quando você criar aplicativos que envolvam arquivos de script externos, esse recurso ajudará a
evitar a substituição de um script modificado por um membro da equipe desde a abertura do
aplicativo ou a publicação do aplicativo com versões antigas de scripts. Os avisos permitem
fechar automaticamente um script e reabrir a versão mais atual modificada.
Syntax colors (Cores da sintaxe) Especifica as cores da sinalização por cores nos scripts.
Com o recurso de sinalização por cores ativado, é possível selecionar as cores para exibição no
painel Script.
Language (Idioma) Abre a caixa de diálogo ActionScript Settings (Configurações do
ActionScript). Para obter mais informações, consulte “Modificando o caminho de classe”
na página 68.

46 Escrevendo e editando o ActionScript 2.0


Sobre as referências de código no Flash
No painel Actions ou na janela Script, é possível usar vários recursos para ajudar na criação de
um código sintaticamente correto. As referências de código ajudam a criar um código com
rapidez e precisão. As referências de código incluem dicas de ferramenta contendo a sintaxe
correta e menus que permitem selecionar nomes de método e de propriedade. As seções a
seguir mostram como criar um código que utiliza esses recursos.
■ “Sobre a ativação de referências de código” na página 47
■ “Usando referências de código” na página 48
■ “Sobre a atribuição de tipo a objetos para ativar referências de código” na página 51
■ “Sobre o uso de sufixos para ativar referências de código” na página 51
■ “Sobre o uso de comentários para ativar referências de código” na página 53

Sobre a ativação de referências de código


Quando você trabalha no painel Actions ou na janela Script, o Flash pode detectar a ação que
está sendo inserida e exibir uma referência de código. Os dois estilos diferentes de referência de
código são uma dica de ferramenta que contém a sintaxe completa da ação e um menu pop-up
que lista possíveis nomes de método ou de propriedade (algumas vezes usado como uma
forma de conclusão do código). Um menu pop-up é exibido para parâmetros, propriedades e
eventos quando você usa a atribuição de tipo estrita ou nomeação para objetos, conforme
discutido no restante desta seção.
As referências de código algumas vezes serão exibidas se você clicar duas vezes em um item na
caixa de ferramentas Actions ou clicar em Add (+) na barra de ferramentas do painel Actions
ou da janela Script para adicionar ações ao painel Script. Para obter informações sobre como
usar referências de código quando elas aparecerem, consulte “Usando referências de código”
na página 48.
N OT A

A exibição das referências de código é ativada automaticamente para classes nativas


que não exigem a criação de uma instância da classe e a atribuição de nome a ele, como
Math, Key, Mouse etc.

Para assegurar a ativação das referências de código, é necessário que as opções de Code Hints
(Referências de código) estejam selecionadas na caixa de diálogo Preferences do ActionScript.
Para obter mais informações, consulte “Sobre o painel Actions” na página 37.

Sobre a codificação no painel Actions e na janela Script 47


Usando referências de código
As referências de código são ativadas por padrão. Ao definir preferências, é possível desativar
referências de código ou determinar a rapidez com que elas são exibidas. Quando as
referências de código estão desativadas nas preferências, ainda é possível exibir uma referência
de código para um comando específico.

Para especificar configurações de referências de código automáticas, siga um


destes procedimentos:
■ No painel Actions ou na janela Script, selecione Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh), clique em ActionScript na lista Category e ative ou desative
Code Hints.
■ No painel Actions, selecione Preferences no menu pop-up (na parte superior direita do
painel) e ative ou desative Code Hints nas preferências do ActionScript.
Se você ativar as referências de código, poderá também especificar um atraso, em segundos,
antes que elas apareçam. Por exemplo, se você não estiver familiarizado com o ActionScript,
poderá preferir não usar atrasos, para que as referências de código sempre apareçam
imediatamente. No entanto, se você geralmente souber o que quer digitar e só precisar das
referências de código ao usar elementos de linguagem desconhecidos, poderá especificar um
atraso para que elas não apareçam quando não desejar usá-las.

Para especificar um atraso para as referências de código:


1. No painel Actions ou na janela Script, selecione Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh) no menu principal.
2. Clique em ActionScript na lista Category.
3. Use o controle deslizante para selecionar o tempo de atraso.
Esse tempo é definido em segundos.

Para trabalhar com referências de código no estilo de dica de ferramenta:


1. Para exibir a referência de código, digite um parêntese de abertura [(] após um elemento
que exija parênteses (por exemplo, após o nome de um método, um comando, como if ou
do..while etc.

48 Escrevendo e editando o ActionScript 2.0


A referência de código será exibida.
NO TA

Se nenhuma referência de código for exibida, verifique se você não desativou Code
Hints nas preferências do ActionScript (Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh)) e clique em ActionScript na lista Category). Para exibir
referências de código para uma variável ou um objeto criado, verifique se você
atribuiu nome à variável ou ao objeto corretamente (consulte “Sobre o uso de sufixos
para ativar referências de código” na página 51) ou se usou a atribuição de tipo
estrita para a variável ou o objeto (consulte “Sobre a atribuição de tipo a objetos para
ativar referências de código” na página 51).

2. Digite um valor para o parâmetro.


Se houver mais de um parâmetro, separe os valores por vírgulas. Para funções ou
instruções, por exemplo, for loop, separe os parâmetros por ponto-e-vírgula.
Os comandos superpostos (funções ou métodos que podem ser chamados com conjuntos
diferentes de parâmetros), como gotoAndPlay() ou for, exibem um indicador que
permite selecionar o parâmetro a ser definido. Clique nos pequenos botões de seta ou
pressione Control+seta para a esquerda e Control+seta para a direita para selecionar o
parâmetro.

3. Para desconsiderar a referência de código, siga um destes procedimentos:


■ Digite um parêntese de fechamento [)].
■ Clique fora da instrução.
■ Pressione Escape.

Para trabalhar com referências de código no estilo de menu:


1. Para exibir a referência de código, digite um ponto após o nome da variável ou objeto.

Sobre a codificação no painel Actions e na janela Script 49


O menu de referências de código é exibido.
N OT A

Se nenhuma referência de código for exibida, verifique se você não desativou as


referências de código nas preferências do ActionScript (Edit > Preferences
(Windows) ou Flash > Preferences (Macintosh)) e clique em ActionScript na lista
Category). Para exibir referências de código para uma variável ou um objeto criado,
verifique se você atribuiu nome à variável ou ao objeto corretamente (consulte
“Sobre o uso de sufixos para ativar referências de código” na página 51) ou se usou
a atribuição de tipo estrita para a variável ou o objeto (consulte “Sobre a atribuição
de tipo a objetos para ativar referências de código” na página 51).

2. Para percorrer as referências de código, use as teclas de seta para cima e de seta para baixo.
3. Para selecionar um item no menu, pressione Enter ou Tab ou clique duas vezes no item.
4. Para desconsiderar a referência de código, siga um destes procedimentos:
■ Selecione um dos itens de menu.
■ Clique acima ou abaixo da janela de menu.
■ Digite um parêntese de fechamento [)] se já tiver digitado um parêntese de abertura
[(].
■ Pressione Escape.

Para exibir manualmente uma referência de código:


1. Clique em um local no código onde é possível exibir as referências de código, como nos
seguintes locais:
■ Após o ponto (.) que segue uma instrução ou um comando, onde uma propriedade ou
um método deve ser digitado
■ Entre parênteses [()] em um nome de método
2. Siga um destes procedimentos:
■ Clique em Show Code Hint (Mostrar referência de código) na barra de ferramentas do
painel Actions ou da janela Script.
■ Pressione Control+Barra de espaços (Windows) ou Command+Barra de espaços
(Macintosh).
■ Se estiver trabalhando no painel Actions, selecione Show Code Hint no menu pop-up.

50 Escrevendo e editando o ActionScript 2.0


Sobre a atribuição de tipo a objetos para ativar referências de
código
Com o ActionScript 2.0, você pode usar a atribuição de tipo estrita para uma variável que tem
como base uma classe interna, como Button, Array etc. Nesse caso, o painel Script exibirá
referências de código para a variável. Por exemplo, suponha que você defina o seguinte código:
var names:Array = new Array();
names.

Assim que você digita o ponto (.), o Flash exibe uma lista de métodos e propriedades
disponíveis para objetos Array em um menu pop-up, porque você digitou a variável como se
fosse um array. Para obter mais informações sobre como atribuir tipos de dados, consulte
“Sobre a atribuição de tipos de dados e a atribuição estrita de tipos de dados” na página 85.
Para obter informações sobre como usar referências de código quando elas aparecerem,
consulte “Usando referências de código” na página 48.

Sobre o uso de sufixos para ativar referências de código


Se você usa o ActionScript 1 ou deseja exibir referências de código para objetos criados por
você sem atribuir um tipo estritamente a eles (consulte “Sobre a atribuição de tipo a objetos
para ativar referências de código” na página 51), adicione um sufixo especial ao nome de cada
objeto ao criá-lo. Por exemplo, os sufixos que ativam referências de código para a classe Array
e a classe Camera são, respectivamente, _array e _cam. Por exemplo, se digitar o seguinte
código
var my_array = new Array();
var my_cam = Camera.get();
você poderá digitar um dos elementos a seguir (o nome de variável seguido por um ponto):
my_array.
my_cam.

Referências de código serão exibidas para os objetos Array e Camera.


Para objetos que aparecem no Stage, use o sufixo na caixa de texto Instance Name (Nome de
instância) no inspetor Properties (Propriedades). Por exemplo, para exibir referências de
código de objetos MovieClip, use o inspetor Properties para atribuir nomes de instância com o
sufixo _mc a todos os objetos MovieClip. Assim, sempre que você digitar o nome da instância
seguido por um ponto, as referências de código aparecerão.
Embora não sejam necessários sufixos para ativar as referências de código quando você usar a
atribuição de tipo estrita a um objeto, usá-los de forma consistente ajudará a entender seu
código.

Sobre a codificação no painel Actions e na janela Script 51


A tabela abaixo lista os sufixos necessários para o suporte a referências de código automáticas:

Tipo de objeto Sufixo da variável


Array _array

Button _btn

Camera (Câmera) _cam


Color _color

ContextMenu _cm

ContextMenuItem _cmi

Date _date

Error _err

LoadVars _lv

LocalConnection _lc

Microphone (Microfone) _mic

MovieClip _mc

MovieClipLoader _mcl
PrintJob _pj

NetConnection _nc

NetStream _ns

SharedObject _so

Sound _sound

String _str

TextField _txt

TextFormat _fmt

Video _video
XML _xml

XMLNode _xmlnode

XMLSocket _xmlsocket

Para obter informações sobre como usar referências de código quando elas aparecerem,
consulte “Usando referências de código” na página 48.

52 Escrevendo e editando o ActionScript 2.0


Sobre o uso de comentários para ativar referências de código
Você também pode usar os comentários do ActionScript a fim de especificar a classe de um
objeto para referências de código. O exemplo a seguir informa ao ActionScript que a classe da
instância theObject é Object e assim por diante. Se você digitar mc e ponto após esses
comentários, serão exibidas as referências de código com a lista de métodos e propriedades de
MovieClip. Se você digitar theArray e ponto, será exibido um menu com uma lista de
métodos e propriedades de Array.
// Object theObject;
// Array theArray;
// MovieClip theMc;

Entretanto, a Macromedia recomenda que você utilize a atribuição estrita de tipos de dados
(consulte “Sobre a atribuição de tipo a objetos para ativar referências de código” na página 51)
ou sufixos (consulte “Sobre o uso de sufixos para ativar referências de código” na página 51)
em vez dessa técnica, porque eles ativam automaticamente as referências de código e tornam o
código mais compreensível. Para obter mais informações sobre como usar referências de
código, consulte “Usando referências de código” na página 48.

Formatando código
Você pode especificar configurações para determinar se o código será formatado e recuado
automática ou manualmente. Você também pode optar por usar o mapeamento dinâmico de
fontes, que assegura o uso de fontes corretas durante o trabalho com texto multilíngüe.

Para definir opções de formato:


1. No painel Actions, selecione Preferences no menu pop-up (na parte superior direita do
painel). Na caixa de diálogo Preferences, selecione Auto Format (Formatação automática).
Como alternativa, na janela Script, selecione Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh). Na caixa de diálogo Preferences, selecione Auto Format.
2. Selecione uma das opções de Auto Format.
Para verificar o efeito de cada seleção, observe o painel Preview (Visualizar).
Depois de definir as opções de Auto Format, as configurações serão aplicadas
automaticamente ao código que você escrever, e não ao código existente; você deverá aplicar
suas configurações manualmente ao código existente. Formate manualmente o código que foi
formatado com configurações diferentes, importado de outro editor etc.

Sobre a codificação no painel Actions e na janela Script 53


Para formatar o código de acordo com as configurações de Auto Format, siga
um destes procedimentos:
■ Clique no botão Auto Format na barra de ferramentas do painel Actions ou da janela
Script.
■ No painel Actions, selecione Auto Format no menu pop-up.
■ Pressione Control+Shift+F (Windows) ou Command+Shift+F (Macintosh).
■ Na janela Script, selecione Tools (Ferramentas) > Auto Format (Formatação automática).

Para usar o mapeamento dinâmico de fontes:


■ Para ativar ou desativar o mapeamento dinâmico de fontes, marque ou desmarque Use
dynamic font mapping (Usar mapeamento dinâmico de fontes) na caixa de diálogo
Preferences.
Por padrão, o mapeamento dinâmico de fontes está desativado para melhorar o
desempenho durante a edição de scripts. Se estiver trabalhando com texto multilíngüe,
ative o mapeamento dinâmico de fontes para assegurar o uso das fontes corretas.

Para usar o recuo automático:


■ Para ativar ou desativar o recuo automático, marque ou desmarque Automatic indentation
(Recuo automático) na caixa de diálogo Preferences.
Quando o recuo automático estiver ativado, o texto digitado após um parêntese de
abertura [(] ou uma chave de abertura ({) será recuado automaticamente conforme a
configuração Tab Size (Tamanho da tabulação) nas preferências do ActionScript.
Nos scripts, selecione uma linha e pressione Tab para recuá-la. Para remover o recuo,
selecione a linha e pressione Shift+Tab.

Usando o realce de sintaxe


No ActionScript, assim como em qualquer linguagem, a sintaxe é a maneira como os
elementos são reunidos para terem significado. Se for usada uma sintaxe incorreta do
ActionScript, os scripts não funcionarão.
Quando você escreve scripts no Flash Basic 8 e no Flash Professional 8, os comandos não
suportados pela versão do exibidor especificado aparecerão em amarelo na caixa de
ferramentas Actions. Por exemplo, se a versão do arquivo SWF do Flash Player estiver definida
como Flash 7, o ActionScript que só é suportado pelo Flash Player 8 aparecerá em amarelo na
caixa de ferramentas Actions. (Para obter informações sobre como definir a versão do arquivo
SWF do Flash Player, consulte Capítulo 17, “Definindo opções de publicação para o formato
de arquivo SWF do Flash” em Using Flash (Usando o Flash).

54 Escrevendo e editando o ActionScript 2.0


Também é possível definir uma preferência para que o Flash destaque com cores partes dos
scripts enquanto você os escreve a fim de realçar erros de digitação. Por exemplo, imagine que
você definiu a preferência de sinalização da sintaxe por cores para que as palavras-chave
apareçam em azul-escuro. Ao criar o código, se você digitar var, a palavra var aparecerá em
azul. Entretanto, se, por engano, você digitar vae, a palavra vae continuará na cor preta,
indicando que houve erro de digitação. Para obter informações sobre palavras-chave, consulte
“Sobre palavras-chave” na página 146.

Para definir preferências de sinalização de sintaxe por cores enquanto digita,


siga um destes procedimentos:
■ Selecione Edit > Preferences (Windows) ou Flash > Preferences (Macintosh), clique em
ActionScript na lista Category e especifique as configurações Syntax coloring (Sinalização
de sintaxe por cores).
■ No painel Actions, selecione Preferences no menu pop-up (na parte superior direita do
painel) e especifique as configurações Syntax coloring nas preferências do ActionScript.
■ Com o ponteiro do mouse focalizado no painel Script, pressione Control-U (Windows)
ou Command-U (Macintosh).
É possível alterar as configurações de cor para palavras-chave, comentários, identificadores e
seqüências de caracteres. Para obter informações sobre identificadores e seqüências de
caracteres, consulte “Terminologia” na página 841 e “Tipo de dados String” na página 83.
Para obter informações sobre comentários, consulte “Sobre comentários” na página 139.

Usando números de linha e quebra automática de


linha
Você pode optar por exibir números de linha e quebrar as linhas longas de código.
Geralmente, você dever ativar os números de linha e a quebra automática de linha para
facilitar a edição do código. Os números de linha facilitam a análise do código e a rolagem por
ele durante sua edição ou modificação. A quebra automática de linha ajuda a evitar a rolagem
horizontalmente por longas linhas de código (principalmente durante o trabalho no ambiente
de criação ou em baixas resoluções de tela).

Para ativar ou desativar números de linha, siga um destes procedimentos:


■ No painel Actions, selecione Line Numbers (Números de linha) no menu pop-up.
■ Na janela Script, selecione Tools > Line Numbers.
■ Pressione Control+Shift+L (Windows) ou Command+Shift+L (Macintosh).

Sobre a codificação no painel Actions e na janela Script 55


Para ativar ou desativar a quebra automática de linha, siga um destes
procedimentos:
■ No painel Actions, selecione Word Wrap (Quebra automática de linha) no menu pop-up.
■ Na janela Script, selecione Tools > Word Wrap.
■ Pressione Control+Shift+W (Windows) ou Command+Shift+W (Macintosh).

Usando teclas de atalho de Escape


Você pode adicionar vários elementos a um script usando as teclas de atalho de Escape
(pressionando a tecla Escape e, em seguida, duas outras teclas).
NO T A

Esses atalhos são diferentes dos atalhos de teclado que iniciam determinados
comandos de menu.

Por exemplo, se você estiver trabalhando no painel Script e pressionar Escape+d+o, o código a
seguir será inserido no seu script:
do {
} while ();
O ponto de inserção é inserido imediatamente após a palavra while, para que você possa
começar a digitar sua condição. Da mesma forma, se você pressionar Escape+c+h, o código a
seguir será inserido no script, e o ponto de inserção será posicionado entre os parênteses [()],
para que você possa começar a digitar a condição:
catch () {
}

Para aprender (ou ser lembrado de) quais comandos possuem teclas de atalho de Escape,
exiba-os ao lado dos elementos na caixa de ferramentas do ActionScript.

56 Escrevendo e editando o ActionScript 2.0


Para exibir ou ocultar as teclas de atalho de Escape:
■ No menu pop-up do painel Actions, marque ou desmarque Esc Shortcut Keys (Teclas de
atalho de Esc).
As teclas de atalho de Escape são exibidas ao lado dos elementos na caixa de ferramentas
do ActionScript.

Exibindo caracteres ocultos


Quando você cria e formata o código do ActionScript, insere espaços, tabulações e quebras de
linha no script. Eles obviamente são úteis e necessários à organização visual do código.
Entretanto, o compilador do Flash gera erros quando encontra espaços de bytes duplos que
não fazem parte de um valor de seqüência de caracteres. A exibição de caracteres ocultos no
painel Script permite ver e remover esses espaços.
Os símbolos a seguir são usados para exibir cada caractere oculto:

espaço de um byte .
espaço de bytes l
duplos
tabulação >>

quebra de linha

Para exibir caracteres ocultos, siga um destes procedimentos :


■ Selecione Hidden Characters (Caracteres ocultos) no menu pop-up.
■ Pressione Control+Shift+8 (Windows) ou Command+Shift+8 (Macintosh).

Sobre a codificação no painel Actions e na janela Script 57


O painel Script terá esta aparência quando forem exibidos caracteres ocultos:

Usando a ferramenta Find


A ferramenta Find (Localizar) permite localizar e, opcionalmente, substituir uma seqüência de
caracteres nos scripts. Você pode substituir a primeira ocorrência, ou todas, do texto no script.
Também pode fazer a correspondência de maiúsculas e minúsculas do texto.

Para localizar um texto no script:


1. Na barra de ferramentas do painel Actions ou da janela Script, selecione a ferramenta Find
ou pressione Control+F (Windows) ou Command+F (Macintosh).
2. Digite a seqüência de caracteres de pesquisa que deseja localizar no script.
3. Clique em Find Next (Localizar próximo).
Se o texto ou os caracteres estiverem presentes no script, as palavras ou os caracteres serão
realçados no painel Script.

Para localizar e substituir um texto no script:


1. Na barra de ferramentas do painel Actions ou da janela Script, clique na ferramenta Find
ou pressione Control+F (Windows) ou Command+F (Macintosh).
2. Digite a seqüência de caracteres de pesquisa que deseja localizar e substituir no script.
3. Na caixa de texto Replace (Substituir), digite a nova seqüência de caracteres.
4. Clique em Find Next.
Se a seqüência de caracteres estiver presente no script, ela será realçada.

58 Escrevendo e editando o ActionScript 2.0


5. Clique em Replace (Substituir) para substituir a seqüência de caracteres ou em Replace All
(Substituir todos) para substituir todas as ocorrências da seqüência.
Após digitar uma seqüência de caracteres de pesquisa na ferramenta Find, você poderá repetir
a pesquisa selecionando Find Again (Localizar novamente) no menu pop-up.

Verificando sintaxe e pontuação


Para determinar se o código escrito tem o desempenho planejado, publique ou teste o arquivo.
Entretanto, você pode verificar rapidamente o código do ActionScript sem sair do arquivo
FLA. Os erros de sintaxe são listados no painel Output (Saída). Você também pode verificar se
um conjunto de parênteses, chaves ou colchetes em torno de um bloco de código está
equilibrado.
O script atual é verificado quando você verifica a sintaxe. Se o script atual chamar classes do
ActionScript 2.0, elas serão compiladas e sua sintaxe também será verificada. Outros scripts
possivelmente existentes no arquivo FLA não serão verificados.

Para verificar a sintaxe, siga um destes procedimentos:


■ Clique em Check Syntax (Verificar sintaxe) na barra de ferramentas do painel Actions ou
da janela Script.
■ No painel Actions, selecione Check Syntax no menu pop-up.
■ Selecione o painel Script (para que ele tenha o foco) e pressione Control+T (Windows) ou
Command+T (Macintosh).
N OT A

Se você clicar em Check Syntax em um arquivo de classe externo do ActionScript


2.0 na janela Script window, o caminho de classe global afetará esse processo.
Algumas vezes, você irá gerar erros — mesmo que o caminho de classe global esteja
definido corretamente — pelo fato de o compilador não saber que essa classe está
sendo compilada. Para obter mais informações sobre como compilar classes,
consulte “Compilando e exportando classes” na página 296.

Para verificar o equilíbrio da pontuação, siga um destes procedimentos:


■ Clique entre chaves ({}), colchetes ([]) ou parênteses (()) no script.
■ Pressione Control+' (aspas simples) no Windows ou Command+' (aspas simples) no
Macintosh para realçar o texto entre chaves, colchetes ou parênteses.
O realce ajuda a verificar se a pontuação de abertura possui a pontuação de fechamento
correspondente.

Sobre a codificação no painel Actions e na janela Script 59


Importando e exportando scripts
Você pode importar um script para o painel Actions ou para a janela Script e exportar os
scripts para arquivos externos do ActionScript. Os dois procedimentos podem ser úteis para o
compartilhamento do código entre diferentes aplicativos Flash e várias equipes de
desenvolvimento.

Para importar um arquivo externo do AS:


■ Para importar um script externo para um script no qual esteja trabalhando no painel
Script, coloque o ponto de inserção no local em que deseja posicionar a primeira linha do
script externo e, em seguida, siga um destes procedimentos:
■ No painel Actions, selecione Import Script (Importar script) no menu pop-up ou
pressione Control+Shift+I (Windows) ou Command+Shift+I (Macintosh).
■ Na janela Script, selecione Import Script no menu File (Arquivo) ou pressione
Control+Shift+I (Windows) ou Command+Shift+I (Macintosh).
Você pode exportar um script do painel Actions. Quando a janela Script é usada, a exportação
é desnecessária já que você pode salvar o arquivo do AS.

Para exportar um script do painel Actions:


1. Selecione o script para exportação e escolha Export Script (Exportar script) no menu pop-
up ou pressione Control+Shift+X (Windows) ou Command+Shift+X (Macintosh).
A caixa de diálogo Save As (Salvar como) é exibida.
2. Salve o arquivo do ActionScript (AS).
O Flash oferece suporte a vários formatos de codificação de caracteres diferentes (incluindo
Unicode) e você pode especificar o formato a ser usado ao importar e exportar scripts. Para
obter mais informações, consulte “Importando e exportando scripts” na página 60 e
“Importar e exportar preferências” na página 61.

60 Escrevendo e editando o ActionScript 2.0


Suporte a Unicode para ActionScript
O Flash 8 oferece suporte à codificação de texto Unicode para o ActionScript. Isso significa
que é possível incluir texto em diferentes idiomas em um arquivo do ActionScript. Por
exemplo, você pode incluir texto em inglês, japonês e francês no mesmo arquivo.
AT E N ÇÃ O

Quando você usa um aplicativo em um idioma que não está em inglês em um sistema em
inglês, o comando Test Movie (Testar filme) (consulte “Depurando scripts”
na página 745) falha quando qualquer parte do caminho do arquivo SWF possui
caracteres que não podem ser representados usando o esquema de codificação MBCS
(Multibyte Character Sets, conjuntos de caracteres de vários bytes). Por exemplo,
caminhos em japonês, que funcionam em um sistema em japonês, não funcionarão em
um sistema em inglês. Todas as áreas do aplicativo que usarem o exibidor externo
estarão sujeitas a esta limitação.

Importar e exportar preferências


Você pode definir as preferências do ActionScript para especificar o tipo de codificação a ser
usada na importação ou exportação de arquivos do ActionScript. Você pode selecionar UTF-8
Encoding (Codificação UTF-8) ou Default Encoding (Codificação padrão). UTF-8 é o
formato Unicode de 8 bits; Default Encoding é a forma de codificação suportada pelo idioma
utilizado por seu sistema, também chamada página de código tradicional.
Em geral, ao importar ou exportar arquivos do ActionScript em formato UTF-8, use a
preferência UTF-8. Se você estiver importando ou exportando arquivos na página de código
tradicional do sistema, deverá usar a preferência Default Encoding.
Se o texto dos scripts não tiver a aparência esperada quando você abrir ou importar um
arquivo, altere a preferência de codificação de importação. Se receber uma mensagem de aviso
ao exportar arquivos do ActionScript, você poderá alterar a preferência de codificação de
exportação ou desativar o aviso nas preferências do ActionScript.

Para selecionar opções de codificação de texto para importação ou


exportação de arquivos do ActionScript:
1. Na caixa de diálogo Preferences (Edit > Preferences (Windows) ou Flash > Preferences
(Macintosh)), clique em ActionScript na lista Category.
2. Em Editing Options (Opções de edição), siga uma ou ambas as instruções:
■ Em Open/Import (Abrir/importar), selecione UTF-8 Encoding para abrir ou
importar usando a codificação Unicode ou selecione Default Encoding para abrir ou
importar usando a forma de codificação do idioma usado no momento por seu
sistema.

Sobre a codificação no painel Actions e na janela Script 61


■ Em Save/Export (Salvar/exportar), selecione UTF-8 Encoding para salvar ou exportar
usando a codificação Unicode ou selecione Default Encoding para salvar ou exportar
usando a forma de codificação de idioma usada no momento por seu sistema.

Para ativar ou desativar o aviso de codificação de exportação:


1. No sistema de menu do Flash, selecione Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh) e clique em Warnings (Avisos) na lista Category.
2. Marque ou desmarque Warn on encoding conflicts when exporting ActionScript files
(Avisar em conflitos de codificação ao exportar arquivos do ActionScript).

Sobre recursos do painel Actions


Os recursos a seguir estão disponíveis apenas no painel Actions. Eles não estão disponíveis na
janela Script. Embora o painel Actions tenha todos os recursos da janela Script, essa janela é
usada para uma funcionalidade diferente. O painel Actions deve oferecer suporte a algumas
funcionalidades relacionadas ao arquivo FLA, que serão abordadas posteriormente nas
próximas seções. Para obter informações sobre os recursos disponíveis na janela Script e no
painel Actions, consulte as seções em “Sobre a codificação no painel Actions e na janela
Script” na página 39.
Para obter informações sobre os recursos disponíveis apenas no painel Actions, consulte estas
seções:
■ “Sobre o Script Assist” na página 62
■ “Prendendo scripts no painel Actions” na página 63
■ “Inserindo caminhos de destino” na página 65

Sobre o Script Assist


O Script Assist solicita a inserção dos elementos de um script, ajudando a adicionar mais
facilmente uma interatividade simples ao aplicativo ou arquivo do Flash SWF. O modo Script
Assist é ideal para usuários que não estão familiarizados com a escrita de seus próprios scripts
ou que simplesmente apreciam a conveniência oferecida pela ferramenta.
Usado em conjunto com o painel Actions, o Script Assist solicita a seleção de opções e a
inserção de parâmetros. Por exemplo, em vez de criar um novo script, você pode selecionar um
elemento de linguagem na caixa de ferramentas Actions (ou o comando Add (+) na barra de
ferramentas), arrastá-lo para o painel Script e usar o Script Assist para ajudar na conclusão do
script.

62 Escrevendo e editando o ActionScript 2.0


No exemplo a seguir, a função gotoAndPlay foi adicionada ao painel Script. O Script Assist
exibe todos os prompts necessários à utilização dessa função do ActionScript — neste caso, o
nome da cena, o tipo e o número do quadro.

Prendendo scripts no painel Actions


Se você não centralizar o código de um arquivo FLA em um local (discutido em
“Organizando o código ActionScript” na página 34) ou se estiver usando comportamentos
(consulte “Sobre comportamentos” na página 65), você poderá prender vários scripts no painel
Actions para facilitar a passagem por eles. Prender um script significa que você mantém o local
do código aberto no painel Actions e clica facilmente entre cada script aberto.
Na figura a seguir, o script associado ao local atual na timeline está no Frame (Quadro) 1 da
camada denominada Cleanup (Limpeza). (A guia na extremidade esquerda sempre segue sua
localização na timeline). Esse script também está preso (ele é mostrado na guia mais à direita).
Dois outros scripts estão presos: um no Frame 1 e o outro no Frame 15 da camada Intro
(Introdução). Você pode mover-se entre os scripts presos clicando nas guias ou usando atalhos
de teclado, como Control+Shift+. (ponto). Mover-se por scripts presos não altera sua posição
atual na timeline. Como você pode ver na figura a seguir, vários scripts estão abertos no painel
Actions e você pode clicar em cada guia para mover-se entre eles.
DICA

Se o conteúdo no painel Script não mudar para refletir o local selecionado na timeline, o
painel Script provavelmente estará exibindo um script preso. Clique na guia à esquerda
localizada na parte inferior esquerda do painel Script para exibir o ActionScript
associado ao seu local na timeline.

Para prender um script:


1. Posicione o ponteiro do mouse na Timeline para que o script apareça em uma guia na parte
inferior esquerda do painel Script no painel Actions.

Sobre recursos do painel Actions 63


2. Siga um destes procedimentos:
■ Clique no ícone de tachinha à direita da guia.
■ Clique com o botão direito do mouse (Windows) ou, pressionando Control, clique
(Macintosh) na guia e selecione Pin Script (Prender script).
■ Selecione Pin Script (Prender script) no menu pop-up (na parte superior direita do
painel Actions).
■ Com o ponteiro do mouse focalizado no painel Script, pressione Control+= (sinal de
igual) no Windows ou Command+= no Macintosh.

Para liberar um ou mais scripts, siga um destes procedimentos:


■ Se um script preso aparecer em uma guia na parte inferior esquerda do painel Script no
painel Actions, clique no ícone de tachinha à direita da guia.
■ Clique com o botão direito (Windows) ou, pressionando Control, clique (Macintosh) em
uma guia e selecione Close Script (Fechar script) ou Close All Scripts (Fechar todos os
scripts).
■ Selecione Close Script (Fechar script) ou Close All Scripts (Fechar todos os scripts) no
menu pop-up (na parte superior direita do painel Actions).
■ Com o ponteiro do mouse focalizado no painel Script, pressione Control+- (sinal de
menos) no Windows ou Command+- no Macintosh.

Para usar atalhos de teclado com scripts presos:


■ É possível usar os seguintes atalhos de teclado para trabalhar com scripts presos:

Ação tecla de atalho no tecla de atalho no


Windows Macintosh
Prender script Control+= (sinal de igual) Command+=
Liberar script Control+- (sinal de menos) Command+-

Mover o foco para a guia da Control+Shift+. (ponto) Command+Shift+.


direita

Mover o foco para a guia da Control+Shift+, (vírgula) Command+Shift+,


esquerda

Liberar todos os scripts Control+Shift+- (menos) Command+Shift+-

64 Escrevendo e editando o ActionScript 2.0


Inserindo caminhos de destino
Várias ações criadas no script afetarão clipes de filme, botões e outras instâncias de símbolos.
Para aplicar ações a instâncias em uma timeline, defina um caminho de destino — o endereço
da instância que você deseja especificar como destino. Você pode definir um caminho de
destino absoluto ou relativo.
A ferramenta Target Path (Caminho de destino), disponível no painel Actions, solicita que
você insira o caminho de destino da ação selecionada no script.

Para inserir um caminho de destino:


1. Selecione e posicione o ponteiro em uma ação no script.
2. Clique em Target Path na barra de ferramentas do painel Actions.
A caixa de diálogo Insert Target Path (Inserir caminho de destino) é exibida.
3. Siga um destes procedimentos:
■ Insira manualmente o caminho da instância de destino.
■ Selecione o destino na lista de destinos disponíveis.
4. Selecione a opção de caminho Absolute (Absoluto) ou Relative (Relativo).
5. Clique em OK.
O caminho é anexado à ação.

Sobre comportamentos
Os comportamentos são funções predefinidas do ActionScript que você pode anexar a objetos
no documento do Flash sem precisar criar o código ActionScript. Eles oferecem uma
funcionalidade predefinida do ActionScript, como navegação por quadros, carregamento de
arquivos SWF e JPEGs externos, controle da ordem de empilhamento dos clipes de filme,
além de uma funcionalidade que permite arrastar clipes de filme.
Os comportamentos podem ser usados de modo conveniente na criação do aplicativo Flash —
como uma forma de evitar a escrita do ActionScript ou, inversamente, como um meio de
aprender sobre o funcionamento do ActionScript em determinadas situações.

Sobre comportamentos 65
Eles somente estão disponíveis quando você trabalha em um documento do Flash, e não em
um arquivo de script externo. Em geral, você seleciona um objeto de ativação em seu
documento, um clipe de filme ou um botão, seleciona o botão Add (Adicionar) no painel
Behaviors (Comportamentos) para exibir os comportamentos disponíveis e, em seguida,
seleciona o comportamento desejado, como mostrado no exemplo a seguir:

O comportamento é adicionado ao objeto e exibido no painel Actions.

Sobre as configurações de publicação do


ActionScript
Você pode editar o ActionScript de duas maneiras. Você pode editar o ActionScript
incorporado a um documento do Flash usando o painel Actions. Você também pode editar o
ActionScript localizado em um arquivo de script separado, externo ao documento do Flash,
usando a janela Script. Como o painel Actions e a janela Script são basicamente duas exibições
diferentes que utilizam o mesmo editor do ActionScript, as configurações e as preferências do
ActionScript no Flash aplicam-se a ambos.
Edite as configurações de publicação do documento do Flash para alterar a versão do
ActionScript que será usada na publicação do documento. Você também pode definir o
caminho de classe do documento atual, ignorando o caminho de classe global do
ActionScript.
Para obter mais informações sobre como modificar as configurações de publicação do
ActionScript, consulte “Modificando as configurações de publicação do ActionScript”
na página 67. Para obter mais informações sobre como definir um caminho de classe em nível
de documento ou no nível global, consulte “Modificando o caminho de classe” na página 68.

66 Escrevendo e editando o ActionScript 2.0


Modificando as configurações de publicação do
ActionScript
Por padrão, quando você publica um documento do Flash, a versão do ActionScript é definida
como 2.0 e o caminho de classe é herdado da configuração do caminho de classe global. Se
precisar alterar a versão do ActionScript ou especificar um caminho de classe em nível de
documento, edite as configurações de publicação.

Para alterar a versão do ActionScript:


1. Selecione File (Arquivo) > Publish Settings (Configurações de publicação) e clique na guia
Flash.

2. Selecione a versão do ActionScript no menu pop-up.


O ActionScript 2.0 está selecionado por padrão. Se criar seus scripts no ActionScript 1.0,
em vez de no 2.0, altere essa configuração antes de publicar seu documento do Flash.
O compilador do ActionScript 2.0 compila todo o código ActionScript 1.0, exceto: a sintaxe
de barra (/) usada para indicar caminhos de clipes de filme (por exemplo, parentClip/
testMC:varName= "olá mundo") gera erros de compilação quando você seleciona o
ActionScript 2.0 como a versão do ActionScript. Para solucionar esse problema, reescreva o
código usando a notação de ponto (.), em vez de barras, ou selecione o compilador do
ActionScript 1.0.
Use o botão Settings (Configurações) (próximo ao menu pop-up da versão do ActionScript)
para modificar o caminho de classe em nível de documento. Para obter mais informações,
consulte “Modificando o caminho de classe” na página 68.

Sobre as configurações de publicação do ActionScript 67


Modificando o caminho de classe
Ao usar o ActionScript 2.0, você também pode definir um caminho de classe em nível de
documento. Isso será útil quando você criar suas próprias classes e desejar substituir o caminho
de classe global do ActionScript definido nas preferências do ActionScript.
A alteração do caminho de classe nas configurações de publicação somente será aplicada ao
arquivo do Flash atual.
Você pode usar a caixa de diálogo Preferences para modificar o caminho de classe global. Para
modificar a configuração do caminho de classe em nível de documento, use a caixa de diálogo
Publish Settings para o arquivo FLA. Em ambos os casos, você pode adicionar caminhos de
diretório absolutos (por exemplo, C:/my_classes) e caminhos de diretório relativos (por
exemplo, ../my_classes ou ".").

Para modificar o caminho de classe global:


1. Selecione Edit > Preferences (Windows) ou Flash > Preferences (Macintosh) para abrir a
caixa de diálogo Preferences.
2. Clique em ActionScript na lista Category e, em seguida, clique em ActionScript 2.0
Settings (Configurações do ActionScript 2.0).
3. Siga um destes procedimentos:
■ Para adicionar um diretório ao caminho de classe, clique em Browse to Path (Navegar
até caminho), navegue até o diretório que deseja adicionar e clique em OK.
Uma outra alternativa é clicar em Add New Path (+) (Adicionar novo caminho) para
adicionar uma nova linha à lista Classpath (Caminho de classe). Clique duas vezes na
nova linha, digite um caminho relativo ou absoluto e clique em OK.
■ Para editar um diretório de caminho de classe existente, selecione o caminho na lista
Classpath, clique em Browse to Path, navegue até o diretório que deseja adicionar e
clique em OK.
Ou então, clique duas vezes no caminho na lista Classpath, digite o caminho desejado
e clique em OK.
■ Para excluir um diretório do caminho de classe, selecione o caminho na lista Classpath
e clique em Remove from Path (Remover do caminho).
N OT A

Não exclua o caminho de classe global absoluto (consulte Caminhos de classe


globais e em nível de documento). O Flash utiliza esse caminho de classe para
acessar as classes internas. Se você acidentalmente excluir esse caminho de
classe, restabeleça-o adicionando $(LocalData)/Classes como um novo
caminho de classe.

68 Escrevendo e editando o ActionScript 2.0


Para modificar o caminho de classe em nível de documento:
1. Selecione File > Publish Settings para abrir a caixa de diálogo Publish Settings.
2. Clique na guia Flash.
3. Clique em Settings próximo ao menu pop-up ActionScript Version (Versão do
ActionScript).
4. Siga um destes procedimentos:
■ Para adicionar um diretório ao caminho de classe, clique em Browse to Path, navegue
até o diretório que deseja adicionar e clique em OK.
Uma outra alternativa é clicar em Add New Path (+) para adicionar uma nova linha à
lista Classpath. Clique duas vezes na nova linha, digite um caminho relativo ou
absoluto e clique em OK.
■ Para editar um diretório de caminho de classe existente, selecione o caminho na lista
Classpath, clique em Browse to Path, navegue até o diretório que deseja adicionar e
clique em OK.
Ou então, clique duas vezes no caminho na lista Classpath, digite o caminho desejado
e clique em OK.
■ Para excluir um diretório do caminho de classe, selecione o caminho na lista Classpath
e clique em Remove from Path.
Para obter mais informações sobre como definir e modificar caminhos de classe, consulte
“Sobre a definição e a modificação do caminho de classe” na página 255.

Arquivos de configuração instalados com o Flash 8


Quando você instala o Flash Basic 8 ou o Flash Professional 8, vários arquivos e pastas de
configuração relacionados ao ActionScript são incluídos no sistema. Você pode utilizar esses
arquivos para definir determinadas configurações no ambiente de criação. Como sempre,
modifique cuidadosamente e salve um backup dos arquivos alterados.
Pasta de classes do ActionScript Contém todas as classes do ActionScript (arquivos do
AS) incluídas no Flash Professional 8 ou no Flash Basic 8. Caminhos típicos da pasta:
■ Windows: Hard Disk\Documents and Settings\usuario\Local Settings\Application
Data\Macromedia\Flash 8\idioma\Configuration\Classes.
■ Macintosh: Hard Disk/Users/usuario/Library/Application Support/Macromedia/Flash 8/
idioma/Configuration/Classes.

Sobre as configurações de publicação do ActionScript 69


A pasta Classes é organizada em pastas contendo diretórios com as classes do Flash Player
7 (FP7) e do Flash Player 8 (FP8). Ela também contém um diretório para o pacote (mx),
usado nos dois exibidores e em arquivos do ASO (aso). Para obter mais informações sobre
arquivos do ASO, consulte “Usando arquivos ASO” na página 298. Para obter mais
informações sobre a organização desse diretório, consulte o arquivo readme na pasta
Classes.
Pasta de inclusão de classes Contém todos os arquivos de inclusão globais do
ActionScript e está localizada em:
■ Windows: Hard Disk\Documents and Settings\usuario\Local Settings\Application
Data\Macromedia\Flash 8\idioma\Configuration\Include.
■ Macintosh: Hard Disk/Users/usuario/Library/Application Support/Macromedia/Flash 8/
idioma/Configuration/Include.
Arquivo de configuração ActionsPanel.xml Inclui o arquivo de configuração das
referências do código ActionScript e está localizado em:
■ Windows: Hard Disk\Documents and Settings\usuario\Local Settings\Application
Data\Macromedia\Flash 8\idioma\Configuration\ActionsPanel\ActionScript_1_2.
■ Macintosh: Hard Disk/Users/usuario/Library/Application Support/Macromedia/Flash 8/
idioma/Configuration/ActionsPanel/ActionScript_1_2.
Arquivo de configuração AsColorSyntax.xml É o arquivo de configuração para realce da
sintaxe por cores do código ActionScript, localizado em:
■ Windows: Hard Disk\Documents and Settings\usuario\Local Settings\Application
Data\Macromedia\Flash 8\idioma\Configuration\ActionsPanel\.
■ Macintosh: Hard Disk/Users/usuario/Library/Application Support/Macromedia/Flash 8/
idioma/Configuration/ActionsPanel.

70 Escrevendo e editando o ActionScript 2.0


CAPÍTULO 3

Sobre o ActionScript 3
Os recursos OOP (object-oriented programming, programação orientada a objeto) no
ActionScript 2.0 tem como base a proposta ECMAScript 4 desenvolvidas no momento pela
ECMA TC39-TG1 (consulte www.mozilla.org/js/language/es4/index.html). Como a
proposta ECMA-4 ainda não se tornou padrão e está em processo de alteração, o
ActionScript 2.0 baseia-se nessa especificação com menos rigidez.
O ActionScript 2.0 oferece suporte a todos os elementos padrão da linguagem ActionScript;
ele permite escrever scripts que atendem melhor aos padrões usados em outras linguagens
orientadas a objeto, como Java. O ActionScript 2.0 deve interessar principalmente a
desenvolvedores de Flash intermediários ou avançados autores de aplicativos que precisam da
implementação de classes e subclasses. O ActionScript 2.0 também permite que você declare o
tipo de objeto de uma variável ao criá-la (consulte “Sobre a atribuição de tipos de dados e a
atribuição estrita de tipos de dados” na página 85) e fornece erros de compilador bem
aprimorados (consulte Apêndice A, “Mensagens de erro”, na página 809).
As principais considerações sobre o ActionScript 2.0 incluem os seguintes pontos:
■ Scripts que usam o ActionScript 2.0 para definir classes ou interfaces devem ser
armazenados como arquivos de script externos, com uma única classe definida em cada
script, ou seja, classes e interfaces não podem ser definidas no painel Actions (Ações).
■ Você pode importar arquivos de classes individuais implicitamente (armazenando-os em
um local especificado por caminhos de pesquisa globais ou específicos de documentos e
depois utilizando-os em um script) ou explicitamente (usando o comando import). É
possível importar pacotes (coleções de arquivos de classe em um diretório) usando
caracteres curinga.

71
■ Os aplicativos desenvolvidos com o ActionScript 2.0 são suportados pelo Flash Player 6 e
versões posteriores.
A T E NÇ Ã O

A configuração padrão de publicação para os novos arquivos criados no Flash 8 é


ActionScript 2.0. Se você planeja modificar um arquivo FLA existente com
ActionScript 1.0 para usar a sintaxe do ActionScript 2.0, verifique se o arquivo
especifica ActionScript 2.0 em suas configurações de publicação. Caso contrário,
seu arquivo será compilado incorretamente, apesar de o Flash não gerar
necessariamente erros de compilador.

Para obter mais informações sobre como usar o ActionScript 2.0 para escrever programas
orientados a objeto no Flash, consulte o Capítulo 7, “Classes”, na página 239.
Embora a Macromedia recomende o uso do ActionScript 2.0, você pode continuar usando a
sintaxe do ActionScript 1.0, especialmente se estiver realizando um trabalho mais tradicional
do Flash, por exemplo, uma animação simples, que não requer a interação do usuário.

O que é ActionScript
Os principais recursos do ActionScript 2.0 incluem:
Modelo familiar OOP (Object-Oriented Programming, Programação orientada a
objeto) O recurso primário do ActionScript 2.0 é um modelo familiar para a criação de
programas orientados a objeto. O ActionScript 2.0 implementa vários conceitos e palavras-
chave orientados a objeto, como class, interface e packages, que parecerão familiares se você já
tiver programado com Java.
O modelo OOP fornecido pelo ActionScript 2.0 é uma “formalização sintática” do método de
encadeamento de protótipo usado em versões anteriores do Macromedia Flash para criar
objetos e estabelecer herança. Com o ActionScript 2.0, é possível criar classes personalizadas e
estender as classes internas do Flash.
Atribuição estrita de tipos de dados O ActionScript 2.0 também permite especificar
explicitamente os tipos de dados para variáveis, parâmetros de função e tipos de retorno de
função. Por exemplo, o código a seguir declara uma variável chamada userName de tipo String
(um tipo de dados interno do ActionScript, ou classe).
var userName:String = "";

Avisos e erros do compilador Os dois recursos anteriores (modelo OOP e atribuição


estrita de tipos de dado) permitem que a ferramenta de criação e o compilador forneçam
mensagens de erro e avisos do compilador que ajudam a localizar falhas nos aplicativos de
forma mais rápida que anteriormente no Flash.

72 Sobre o ActionScript
Ao usar o ActionScript 2.0, verifique se as configurações de publicação para o arquivo FLA
especificam ActionScript 2.0. Esse é o padrão para arquivos criados em Flash MX 2004 e
Flash 8. Entretanto, se você abrir um arquivo FLA antigo que usa ActionScript 1.0 e começar
a reescrevê-lo em ActionScript 2.0, altere suas configurações de publicação para
ActionScript 2.0. Caso contrário, seu arquivo FLA não será compilado corretamente e não
serão gerados erros.

Sobre a opção entre o ActionScript 1.0 e


o ActionScript 2.0
Ao iniciar um novo documento ou aplicativo no Flash, você deve decidir como organizará os
arquivos associados. Você pode usar classes em alguns projetos, por exemplo, ao criar
aplicativos ou arquivos FLA complexos, mas nem todos os documentos utilizam classes. Por
exemplo, vários exemplos pequenos na documentação não utilizam classes. O uso de classes
para armazenar funcionalidade não é a mais fácil ou melhor solução para aplicativos pequenos
ou arquivos FLA simples. Em geral, é mais eficiente incluir o ActionScript dentro do
documento. Nesse caso, tente colocar todo o código naTimeline, no menor número de
quadros possível, e evite incluir código em instâncias (como botões ou clipes de filme) de um
arquivo FLA.
Quando você cria um projeto pequeno, em geral é mais produtivo usar classes ou arquivos de
código externos para organizar o ActionScript, em vez de adicioná-lo ao arquivo FLA.
Algumas vezes, é mais fácil manter todo o código ActionScript no arquivo FLA, em vez de
inseri-lo em uma classe importada. Isso não significa que você deve usar necessariamente o
ActionScript 1.0. Você pode optar por incluir o código no arquivo FLA usando o ActionScript
2.0 com sua atribuição estrita de tipos de dados e seus novos métodos e propriedades. O
ActionScript 2.0 também oferece uma sintaxe que segue os padrões de outras linguagens de
programação, o que torna a linguagem mais fácil e valiosa para ser aprendida. Por exemplo,
você se sentirá familiarizado com o ActionScript caso tenha encontrado outra linguagem
baseada na mesma estrutura e padrões de sintaxe. Ou então, você poderá aplicar esse
conhecimento a outras linguagens a serem aprendidas no futuro. O ActionScript 2.0 permite
o uso de uma abordagem orientada a objeto para o desenvolvimento de aplicativos através de
um conjunto adicional de elementos de linguagem, que pode ser vantajoso para o
desenvolvimento de seu aplicativo.
Em alguns casos, não é possível escolher a versão do ActionScript a ser usada. Se estiver
criando um arquivo SWF destinado a uma versão antiga do Flash Player, por exemplo, um
aplicativo de dispositivo móvel, use o ActionScript 1.0, que é compatível com o Flash Player
no caso de vários dispositivos.

Sobre a opção entre o ActionScript 1.0 e o ActionScript 2.0 73


Independentemente da versão do ActionScript, lembre-se de seguir as práticas recomendadas.
Várias delas, como manter-se consistente com a distinção entre maiúsculas e minúsculas, usar
a conclusão de código, melhorar a legibilidade, evitar palavras-chave para nomes de instância e
manter uma convenção de nomeação consistente, aplicam-se às duas versões.
Se planeja atualizar o aplicativo em versões futuras do Flash ou torná-lo maior e mais
complexo, use o ActionScript 2.0 e classes para facilitar a atualização e a modificação do
aplicativo.

Noções básicas do ActionScript e do


Flash Player
Se você compilar um arquivo SWF que contenha o ActionScript 2.0 com configurações de
publicação definidas para o Flash Player 6 e o ActionScript 1.0, o código funcionará desde que
não use classes do ActionScript 2.0. Não há distinção entre maiúsculas e minúsculas no
código, somente no Flash Player. Portanto, se você compilar o arquivo SWF com
Configurações de Publicação definidas para o Flash Player 7 ou 8 e o ActionScript 1.0, o Flash
irá impor a distinção entre maiúsculas e minúsculas.
As anotações de tipos de dados (tipos de dados estritos) são impostas durante a compilação
para o Flash Player 7 e 8 quando você publica as configurações definidas para o ActionScript
2.0.
O ActionScript 2.0 realiza a compilação para o bytecode do ActionScript 1.0 na publicação de
aplicativos, portanto, você pode usar o Flash Player 6, 7, ou 8 ao trabalhar com o ActionScript
2.0.

74 Sobre o ActionScript
CAPÍTULO 4

Dados e tipos de dados 4


Este capítulo é o primeiro de vários que descrevem e demonstram alguns dos conceitos
fundamentais do ActionScript. Você praticará algumas técnicas básicas de codificação para
aprender a criar aplicativos complexos. Neste capítulo, você também aprenderá a trabalhar
com dados em um arquivo FLA e verá os tipos de dados com os quais é possível trabalhar. No
próximo capítulo, Capítulo 5, “Fundamentos da sintaxe e da linguagem,” você descobrirá
como usar a sintaxe do ActionScript e instruções de formulário. Em seguida, o Capítulo 6,
“Funções e métodos” demonstra como usar funções e métodos na linguagem ActionScript.
Para obter mais informações sobre dados e tipos de dados, consulte estas seções:
Sobre dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Sobre tipos de dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Sobre variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Organizando dados em objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
Sobre a conversão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116

Sobre dados
Dados referem-se a números, seqüências de caracteres e outras informações que você pode
manipular no Flash. O uso de dados é geralmente essencial durante a criação de aplicativos ou
sites da Web. Você também pode usar dados ao criar gráficos avançados e animação gerada
com script e possivelmente terá de manipular os valores usados para controlar seus efeitos.
É possível definir dados em variáveis no Flash ou carregar dados de sites ou arquivos externos
usando XML, serviços da Web, classes internas do ActionScript etc. Você pode armazenar
dados em um banco de dados e representar as informações de diversas maneiras em um
arquivo SWF. Por exemplo, você pode exibir as informações em campos de texto ou
componentes ou exibir imagens em instâncias de clipe de filme.
Alguns dos tipos de dados mais comuns incluem seqüências de caracteres (como nomes e
partes de texto), números, objetos (como clipes de filme), valores booleanos (true e false)
etc. Neste capítulo, você também aprenderá sobre os tipos de dados do Flash e como usá-los.

75
Para obter informações sobre tipos de dados, consulte “Sobre tipos de dados” na página 76.
Para obter informações sobre variáveis, consulte “Sobre variáveis” na página 91.

Sobre tipos de dados


Um tipo de dados descreve um dado e os tipos de operações que podem ser executados nele. Os
dados são armazenados em uma variável. Você usa tipos de dados ao criar variáveis, instâncias
de objetos e definições de funções para atribuir o tipo de dados com o qual está trabalhando.
Ao criar um código ActionScript, você usa diversos tipos de dados.
O ActionScript 2.0 define vários tipos de dados comumente usados. Os tipos de dados
descrevem o tipo de valor que uma variável ou um elemento do ActionScript pode conter.
Uma variável atribuída a um tipo de dados pode armazenar somente um valor contido no
conjunto de valores desse tipo de dados. Para obter informações sobre variáveis, consulte
“Sobre variáveis” na página 91.
O ActionScript contém vários tipos de dados básicos que você provavelmente usará com
freqüência em seus aplicativos. Consulte a tabela em “Sobre tipos de dados primitivos e
complexos” na página 77 para obter mais informações.
O ActionScript também contém classes básicas, como Array e Date, que são consideradas
tipos de dados complexos ou de referência. Para obter mais informações sobre tipos de dados
complexos e de referência, consulte “Sobre tipos de dados primitivos e complexos”
na página 77. Além disso, todos os tipos de dados e classes são totalmente definidos em
ActionScript 2.0 Language Reference (Referência da linguagem ActionScript 2.0).
Você também pode criar classes personalizadas para seus aplicativos. Toda classe definida com
o uso de declarações de classe é considerada um tipo de dados. Para obter mais informações
sobre classes básicas e outras classes internas, consulte “Sobre classes de nível superior e
internas” na página 302. Para obter mais informações sobre como criar classes personalizadas,
consulte o Capítulo 7, “Classes”, na página 239.
No ActionScript 2.0, é possível atribuir tipos de dados a variáveis ao declará-las. Os tipos de
dados atribuídos podem ser qualquer um dos tipos básicos ou representar uma classe
personalizada criada por você. Para obter mais informações, consulte “Sobre a atribuição de
tipos de dados e a atribuição estrita de tipos de dados” na página 85.
Ao depurar scripts, talvez você precise determinar os tipos de dados de uma expressão ou
variável para entender seu comportamento. Isso pode ser feito com os operadores instanceof
e typeof (consulte “Sobre a determinação do tipo de dados” na página 90).
Você pode converter um tipo de dados em outro durante a execução usando uma das seguintes
funções de conversão: Array(), Boolean(), Number(), Object(), String().

76 Dados e tipos de dados


Você pode localizar um arquivo de origem de exemplo, datatypes.fla, na pasta Samples do seu
disco rígido, que mostra como usar os tipos de dados em um aplicativo.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\DataTypes.
■ No Macintosh, navegue até HD Macintosh/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/DataTypes.

Sobre tipos de dados primitivos e complexos


Os diversos valores de tipos de dados podem ser divididos em duas categorias principais:
primitivos ou complexos.
Um valor primitivo (ou tipo de dados primitivo) é um valor que o ActionScript armazena no
nível mais baixo de abstração; isso significa que as operações executadas em tipos de dados
primitivos geralmente são mais rápidas e eficientes do que as executadas em tipos de dados
complexos. Os seguintes tipos de dados definem um conjunto de um ou mais valores
primitivos: Boolean, null, Number, String e undefined.
Um valor complexo (ou tipo de dados complexo) é um valor que não é primitivo e faz
referência aos valores primitivos. Em geral, eles são chamados tipos de dados de referência. Os
valores complexos pertencem ao tipo de dados Object ou a um tipo que se baseia no tipo de
dados Object. Os tipos de dados que definem conjuntos de valores complexos incluem Array,
Date, Error, Function e XML. Para obter mais informações sobre esses tipos de dados
complexos, consulte as entradas correspondentes em ActionScript 2.0 Language Reference.
Em determinadas situações, as variáveis que contêm tipos de dados primitivos se comportam
de maneira diferente das que contêm tipos de dados complexos. Para obter mais informações,
consulte “Usando variáveis em um projeto” na página 111.
O ActionScript possui os seguintes tipos de dados básicos que você pode usar em seus
aplicativos:

Tipo de dados Descrição


Boolean Primitivo. O tipo de dados Boolean consiste em dois valores: true e
false. Nenhum outro valor é válido para variáveis desse tipo. O valor
padrão de uma variável Boolean declarada, mas não inicializada é
false. Para obter mais informações, consulte “Tipo de dados Boolean”
na página 79.

MovieClip Complexo. O tipo de dados MovieClip permite controlar símbolos de


clipes de filme com os métodos da classe MovieClip. Para obter mais
informações, consulte “Tipo de dados MovieClip” na página 80.

Sobre tipos de dados 77


Tipo de dados Descrição
null Primitivo. O tipo de dados null contém o valor null. Esse valor significa
nenhum valor — ou seja, uma falta de dados. Você pode atribuir o valor
null em inúmeras situações para indicar que não há um valor atribuído
a uma propriedade ou a uma variável. O tipo de dados null é o padrão de
todas as classes que definem tipos de dados complexos. Uma exceção
a essa regra é a classe Object, cujo padrão é undefined. Para obter mais
informações, consulte “Tipo de dados null” na página 81.

Number Primitivo. Esse tipo de dados pode representar inteiros, inteiros sem
sinal e números de ponto flutuante. Para armazenar um número de
ponto flutuante, inclua um ponto decimal no número. Sem o ponto
decimal, o número é armazenado como um inteiro. O tipo de dados
Number pode armazenar desde um valor Number.MAX_VALUE (muito alto)
até Number.MIN_VALUE (muito baixo). Para obter mais informações,
consulte, ActionScript 2.0 Language Reference e “Tipo de dados
Number” na página 82.

Object Complexo. O tipo de dados Object é definido pela classe Object. Essa
classe serve como base para todas as definições de classe do
ActionScript e permite organizar os objetos uns dentro dos outros
(objetos aninhados). Para obter mais informações, consulte “Tipo de
dados Object” na página 83.
String Primitivo. O tipo de dados String representa uma seqüência de
caracteres de 16 bits que pode incluir letras, números e sinais de
pontuação. As seqüências de caracteres são armazenadas como
caracteres Unicode, usando o formato UTF-16. Uma operação em um
valor String retorna uma nova instância da seqüência de caracteres.
Para obter mais informações, consulte “Tipo de dados String”
na página 83.

undefined Primitivo. O tipo de dados undefined contém um valor: undefined. Esse


é o valor padrão das instâncias da classe Object. Somente é possível
atribuir o valor undefined às variáveis pertencentes à classe Object. Para
obter mais informações, consulte “Tipo de dados undefined”
na página 85.

Void Complexo. O tipo de dados Void contém somente um valor: void. Use
esse tipo de dados para designar funções que não retornam um valor.
Void é um tipo de dados complexo que faz referência ao tipo de dados
primitivo Void. Para obter mais informações, consulte “Tipo de dados
Void” na página 85.

78 Dados e tipos de dados


Você pode localizar um arquivo de origem de exemplo, datatypes.fla, na pasta Samples do seu
disco rígido, que mostra como usar os tipos de dados em um aplicativo.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\DataTypes.
■ No Macintosh, navegue até HD Macintosh/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/DataTypes.

Tipo de dados Boolean


Um valor booleano é true ou false. O ActionScript também converte os valores true e
false em 1 e 0 quando apropriado. Os valores booleanos são freqüentemente usados com
operadores lógicos em instruções do ActionScript que fazem comparações para controlar o
fluxo de um script.
O exemplo a seguir carrega um arquivo de texto em um arquivo SWF e exibe uma mensagem
no painel Output (Saída) caso o arquivo de texto não seja carregado corretamente ou os
parâmetros se ele for carregado com êxito. Consulte os comentários no exemplo de código
para obter mais detalhes.
var my_lv:LoadVars = new LoadVars();
//sucess é um valor booleano
my_lv.onLoad = function(sucess:Boolean) {
//se sucess for true, rastrear monthNames
if (sucess) {
trace(my_lv.monthNames);
//se sucess for false, rastrear uma mensagem
} else {
trace("unable to load text file");
}
};
my_lv.load("http://www.helpexamples.com/flash/params.txt");

O exemplo a seguir verifica se os usuários inserem valores em duas instâncias do componente


TextInput. Duas variáveis Boolean são criadas, userNameEntered e isPasswordCorrect e, se
ambas resultarem em true, uma mensagem de boas-vindas será atribuída à variável String
titleMessage.
// Adicionar dois componentes TextInput, um componente Label e um componente
Button no Stage.
// Atribuir um tipo de dados estrito às três instâncias do componente
var userName_ti:mx.controls.TextInput;
var password_ti:mx.controls.TextInput;
var submit_button:mx.controls.Button;
var welcome_lbl:mx.controls.Label;

//Ocultar o rótulo
welcome_lbl.visible = false;

Sobre tipos de dados 79


// Criar um objeto ouvinte, que é usado com o componente Button.
// Quando o Button é clicado, procura um nome de usuário e uma senha.
var loadListener:Object = new Object();
btnListener.click = function(evt:Object) {
// Verifica se o usuário insere pelo menos um caractere nas instâncias do
componente TextInput
// e retorna um valor true/false booleano.
var userNameEntered:Boolean = (userName_ti.text.length > 0);
var isPasswordCorrect:Boolean = (password_ti.text == "vertigo");
if (userNameEntered && isPasswordCorrect) {
var titleMessage:String = "Welcome " + userName_ti.text + "!";
welcome_lbl.text = titleMessage;
//exibir o rótulo
welcome_lbl.visible = true;
}
};
submit_button.addEventListener("click", btnListener);

Para obter mais informações, consulte “Usando funções no Flash” na página 227 e “Sobre
operadores lógicos” na página 205.

Tipo de dados MovieClip


Clipes de filme são símbolos que podem reproduzir animações em um aplicativo Flash. Eles
são os únicos tipos de dados que fazem referência a elementos gráficos. O tipo de dados
MovieClip permite controlar símbolos de clipes de filme com os métodos da classe
MovieClip.
Os métodos da classe MovieClip não são chamados com um construtor. Você pode criar uma
instância de clipe de filme no Stage (Palco) ou dinamicamente. Em seguida, basta chamar os
métodos da classe MovieClip com o operador ponto (.).
Trabalhando com clipes de filme no Stage O exemplo a seguir chama os métodos
startDrag() e getURL() para instâncias diferentes de clipe de filme existentes no Stage:
my_mc.startDrag(true);
parent_mc.getURL("http://www.macromedia.com/support/" + product);

O segundo exemplo retorna a largura do clipe de filme chamado my_mc no Stage. A instância
especificada como destino deve ser um clipe de filme, e o valor retornado deve ser numérico.
function getMCWidth(target_mc:MovieClip):Number {
return target_mc._width;
}
trace(getMCWidth(my_mc));

80 Dados e tipos de dados


Criando clipes de filme dinamicamente O uso do ActionScript para criar clipes de filme
dinamicamente é útil quando você não deseja criar manualmente clipes de filme no Stage ou
anexá-los a partir da biblioteca. Por exemplo, você pode criar uma galeria de imagens com um
grande número de miniaturas que deseja organizar no Stage. Com
MovieClip.createEmptyMovieClip() , é possível criar um aplicativo usando apenas o
ActionScript.
Para criar um clipe de filme dinamicamente, use MovieClip.createEmptyMovieClip(),
como mostra o seguinte exemplo:
// Cria um clipe de filme para armazenar o recipiente.
this.createEmptyMovieClip("image_mc", 9);
// Carrega uma imagem em image_mc.
image_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");

O segundo exemplo cria um clipe de filme chamado square_mc que usa a API (Application
Programming Interface, Interface de programação de aplicativos) Drawing para desenhar um
retângulo. Os manipuladores de eventos e os métodos startDrag() e stopDrag() da classe
MovieClip são adicionados para tornar o retângulo arrastável.
this.createEmptyMovieClip("square_mc", 1);
square_mc.lineStyle(1, 0x000000, 100);
square_mc.beginFill(0xFF0000, 100);
square_mc.moveTo(100, 100);
square_mc.lineTo(200, 100);
square_mc.lineTo(200, 200);
square_mc.lineTo(100, 200);
square_mc.lineTo(100, 100);
square_mc.endFill();
square_mc.onPress = function() {
this.startDrag();
};
square_mc.onRelease = function() {
this.stopDrag();
};

Para obter mais informações, consulte Capítulo 11, “Trabalhando com clipes de filme”, na
página 369 e a entrada %{MovieClip}% em ActionScript 2.0 Language Reference.

Tipo de dados null


O tipo de dados null possui apenas um valor: null. Esse valor significa nenhum valor — ou
seja, uma falta de dados. Você pode atribuir o valor null em inúmeras situações para indicar
que ainda não há valor atribuído a uma propriedade ou a uma variável. Por exemplo, é
possível atribuir o valor null nas seguintes situações:
■ Para indicar que uma variável existe, mas ainda não recebeu um valor
■ Para indicar que uma variável existe, mas não contém mais um valor

Sobre tipos de dados 81


■ Como resultado de uma função, para indicar que não havia valor disponível a ser
retornado pela função
■ Como parâmetro de uma função, para indicar a omissão de um parâmetro
Vários métodos e funções retornarão null se nenhum valor tiver sido definido. O exemplo a
seguir demonstra como usar null para testar se os campos de formulário têm foco de
formulário:
if (Selection.getFocus() == null) {
trace("no selection");
}

Tipo de dados Number


O tipo de dados Number é um número de dupla precisão e ponto flutuante. O valor mínimo
de um objeto Number é aproximadamente 5e-324, e o máximo é aproximadamente
1,79E+308.
É possível manipular números usando os operadores aritméticos de adição (+), subtração (-),
multiplicação (*), divisão (/), módulo (%), incremento (++) e decremento (--). Para obter
mais informações, consulte “Usando operadores numéricos” na página 198.
Também é possível usar métodos das classes internas Math e Number para manipular
números. Para obter mais informações sobre os métodos e as propriedades dessas classes,
consulte as entradas %{Math}% e %{Number}% em ActionScript 2.0 Language Reference.
O exemplo a seguir usa o método sqrt() (square root - raiz quadrada) da classe Math para
retornar a raiz quadrada do número 100:
Math.sqrt(100);

O exemplo a seguir retorna um inteiro aleatório entre 10 e 17 (inclusive):


var bottles:Number = 0;
bottles = 10 + Math.floor(Math.random() * 7);
trace("There are " + bottles + " bottles");

O exemplo a seguir localiza a porcentagem do clipe de filme intro_mc carregada e a


representa como um inteiro:
var percentLoaded:Number = Math.round((intro_mc.getBytesLoaded() /
intro_mc.getBytesTotal()) * 100);

82 Dados e tipos de dados


Tipo de dados Object
Um objeto é uma coleção de propriedades. Uma propriedade é um atributo que descreve o
objeto. Por exemplo, a transparência de um objeto (como um clipe de filme) é um atributo
que descreve sua aparência. Portanto, _alpha (transparência) é uma propriedade. Cada
propriedade possui um nome e um valor. O valor de uma propriedade pode ser qualquer tipo
de dados do Flash, até mesmo o tipo de dados Object. Isso permite aninhar objetos, ou seja,
organizá-los uns dentro dos outros.
Para especificar os objetos e suas propriedades, use o operador ponto (.). Por exemplo, no
código a seguir, hoursWorked é uma propriedade de weeklyStats, que, por sua vez, é uma
propriedade de employee:
employee.weeklyStats.hoursWorked

O objeto MovieClip do ActionScript possui métodos que permitem controlar instâncias de


símbolos de clipes de filme no Stage. Este exemplo usa os métodos play() e nextFrame():
mcInstanceName.play();
mc2InstanceName.nextFrame();

Você também pode criar objetos personalizados para organizar informações em seu aplicativo
Flash. Para adicionar interatividade a um aplicativo com o ActionScript, você precisará de
muitas informações, por exemplo, o nome, a idade e o telefone do usuário; a velocidade de
uma bola; os nomes dos itens de um carrinho de compras; o número de quadros carregados;
ou a última tecla pressionada pelo usuário. A criação de objetos personalizados permite que
você organize essas informações em grupos, simplifique e reutilize scripts.
O código ActionScript apresentado a seguir mostra como usar objetos personalizados para
organizar informações. Ele cria um novo objeto chamado user e três propriedades, name, age
e phone, que são tipos de dados String e Numeric.
var user:Object = new Object();
user.name = "Irving";
user.age = 32;
user.phone = "555-1234";

Para obter mais informações, consulte “Exemplo: Criando classes personalizadas”


na página 278.

Tipo de dados String


Uma seqüência de caracteres é uma seqüência de letras, números e sinais de pontuação. Insira
seqüências de caracteres em instruções do ActionScript colocando-as entre aspas simples (') ou
duplas (").

Sobre tipos de dados 83


Uma forma comum de usar o tipo String é atribuir uma seqüência de caracteres a uma
variável. Por exemplo, na instrução a seguir, "L7" é uma seqüência de caracteres atribuída à
variável favoriteBand_str:
var favoriteBand_str:String = "L7";

Você pode usar o operador de adição (+) para concatenar, ou unir, duas seqüências de
caracteres. O ActionScript trata os espaços no início ou no final de uma seqüência de
caracteres como uma parte literal dessa seqüência. A expressão a seguir inclui um espaço
depois da vírgula:
var greeting_str:String = "Welcome, " + firstName;

Para incluir aspas em uma seqüência de caracteres, coloque uma barra invertida (\) antes delas.
Isso é chamado escape de caractere. Há outros caracteres que só podem ser representados no
ActionScript por seqüências de escape especiais. A tabela a seguir lista todos os caracteres de
escape do ActionScript:

Seqüência de Caractere
escape
\b Caractere Backspace (ASCII 8)
\f Caractere de alimentação de formulário (ASCII 12)
\n Caractere de alimentação de linha (ASCII 10)
\r Caractere de retorno de carro (ASCII 13)
\t Caractere Tab (ASCII 9)
\" Aspas duplas
\' Aspas simples
\\ Barra invertida
\000 - \377 Um byte especificado em octal
\x00 - \xFF Um byte especificado em hexadecimal
\u0000 - \uFFFF Um caractere Unicode de 16 bits especificado em hexadecimal

Assim como em Java, as seqüências de caracteres são imutáveis no ActionScript. Qualquer


operação que modifique uma seqüência de caracteres retorna uma nova seqüência.
A classe String é uma classe interna do ActionScript. Para obter informações sobre os métodos
e as propriedades da classe String, consulte a entrada %{String}% em ActionScript 2.0
Language Reference.

84 Dados e tipos de dados


Tipo de dados undefined
O tipo de dados undefined possui um valor, undefined, e é atribuído automaticamente a
uma variável à qual um valor não foi atribuído, tanto pelo seu código como pela interação do
usuário.
O valor undefined é atribuído automaticamente; diferentemente de null, um valor
undefined não é atribuído a uma variável ou a uma propriedade. Use o tipo de dados
undefined para verificar se uma variável está definida. Esse tipo de dados permite criar um
código que é executado somente quando o aplicativo está em execução, como mostra o
exemplo a seguir:
if (init == undefined) {
trace("initializing app");
init = true;
}

Se o aplicativo tiver vários quadros, o código não será executado uma segunda vez porque a
variável init não será mais undefined.

Tipo de dados Void


O tipo de dados Void possui um valor, void, usado em uma definição de função para indicar
que a função não retorna um valor, como mostra o exemplo a seguir:
//Cria uma função com o tipo de retorno Void
function displayFromURL(url:String):Void {}

Sobre a atribuição de tipos de dados e a atribuição


estrita de tipos de dados
No Flash, as variáveis são usadas para armazenar valores no código. Você pode declarar
explicitamente o tipo de objeto de uma variável ao criá-la; isso é chamado atribuição estrita de
tipos de dados.
Se você não definir explicitamente que um item armazena um número, uma seqüência de
caracteres ou outro tipo de dados, durante a execução, o Flash Player tentará determinar o tipo
de dados do item quando ele for atribuído. Se você atribuir um valor a uma variável, como no
exemplo a seguir, o Flash Player avaliará, durante a execução, o elemento à direita do operador
e determinará que ele é do tipo Number:
var x = 3;

Sobre tipos de dados 85


Como x não foi declarado com a atribuição estrita de tipos de dados, o compilador não pode
determinar o tipo; para o compilador, a variável x pode ter qualquer tipo de valor. (Consulte
“Atribuindo um tipo de dados” na página 87.) Uma atribuição posterior pode alterar o tipo de
x; por exemplo, a instrução x = "hello" altera o tipo de x para String.

O ActionScript sempre converte automaticamente tipos de dados primitivos (como Boolean,


Number, String, null ou undefined) quando uma expressão exige a conversão e a atribuição
estrita de tipos de dados não é aplicada às variáveis.
A atribuição estrita de tipos de dados oferece vários benefícios durante a compilação. A
declaração de tipos de dados (atribuição estrita de tipos de dados) pode ajudar a evitar ou a
diagnosticar erros no código durante a compilação. Para declarar uma variável usando a
atribuição estrita de dados, use o seguinte formato:
var variableName:datatype;
NO T A

Algumas vezes, a atribuição estrita de tipos de dados é chamada atribuição forte de


tipos de dados a uma variável.

Como a incompatibilidade de tipos de dados gera erros do compilador, a atribuição estrita de


tipos de dados ajuda a identificar erros no código durante a compilação e evita a atribuição do
tipo de dados incorreto a uma variável existente. Durante a criação, a atribuição estrita de
tipos de dados ativa as referências de código no editor do ActionScript (mas ainda assim é
necessário usar sufixos de nomes de instância para elementos visuais).
A atribuição estrita de tipo de dados ajuda a garantir a não atribuição inadvertida de um tipo
incorreto de valor a uma variável. O Flash verifica se há erros de incompatibilidade de tipos
durante a compilação e exibirá uma mensagem de erro se você usar o tipo incorreto de valor.
Portanto, o uso da atribuição estrita também ajuda a impedir sua tentativa de acesso a
propriedades ou métodos que não façam parte do tipo de um objeto. A atribuição estrita de
tipos de dados significa que o editor do ActionScript mostra automaticamente as referências
de código dos objetos.
Para obter mais informações sobre como criar variáveis, consulte “Sobre variáveis”
na página 91. Para obter informações sobre como atribuir nomes a variáveis, consulte “Sobre a
atribuição de nomes a variáveis” na página 96. Para obter mais informações sobre como
atribuir tipos de dados e os tipos que podem ser atribuídos, consulte “Atribuindo um tipo de
dados” na página 87.

86 Dados e tipos de dados


Você pode localizar um arquivo de origem de exemplo, datatypes.fla, na pasta Samples do seu
disco rígido, que mostra como usar os tipos de dados em um aplicativo.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\DataTypes.
■ No Macintosh, navegue até HD Macintosh/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/DataTypes.

Atribuindo um tipo de dados


Atribua tipos de dados sempre que definir uma variável, quer você a declare usando a palavra-
chave var, crie um argumento de função, defina o tipo de retorno da função ou defina uma
variável para ser usada em um loop for ou for..in. Para atribuir um tipo de dados, use a
sintaxe pós-dois-pontos, a qual indica que, após o nome da variável, são acrescentados dois-
pontos e o tipo de dados:
var my_mc:MovieClip;

Há vários tipos de dados possíveis, incluindo desde tipos nativos, como Number, String e
Boolean, ou classes internas fornecidas com o Flash Player 8, como BitmapData e
FileReference, ou até mesmo classes personalizadas criadas por você ou outros
desenvolvedores. Os tipos mais comuns de dados que precisam ser especificados são os
internos, como Number, String, Boolean, Array ou Object, que são mostrados nos exemplos
de código apresentados a seguir.
Para atribuir um tipo de dados específico a um item, defina seu tipo usando a palavra-chave
var e a sintaxe pós-dois-pontos, como no exemplo a seguir:
// Atribuição estrita de tipo de dados a uma variável ou a um objeto
var myNum:Number = 7;
var birthday:Date = new Date();

//Atribuição estrita de tipo de dados de parâmetros


function welcome(firstName:String, age:Number) {
}

// Atribuição estrita de tipo de dados de parâmetro e valor de retorno


function square(myNum:Number):Number {
var squared:Number = myNum * myNum;
return squared;
}

Sobre tipos de dados 87


Você pode declarar o tipo de dados de objetos com base em classes internas (Button, Date
etc.), bem como em classes e interfaces criadas por você. No exemplo a seguir, se houver um
arquivo Student.as no qual define a classe Student, você poderá especificar que os objetos que
criar sejam do tipo Student:
var myStudent:Student = new Student();

Neste exemplo, suponha que você defina o seguinte código:


// no arquivo de classe Student.as
class Student {
public var status:Boolean; // propriedade dos objetos Student
}
// no arquivo FLA
var studentMaryLago:Student = new Student();
studentMaryLago.status = "enrolled"; /* Tipos incompatíveis em uma
instrução de atribuição: String encontrado onde Boolean é necessário. */

Quando o Flash compila esse script, um erro de tipos incompatíveis é gerado porque o
arquivo SWF espera um valor booleano.
Se criar uma função que não tenha um tipo de retorno, você poderá especificar o tipo de
retorno Void para essa função. Ou, se criar um atalho para uma função, você poderá atribuir o
tipo de dados Function à nova variável. Veja no exemplo a seguir como especificar o tipo
Function ou Void para objetos:
function sayHello(name_str:String):Void {
trace("Hello, " + name_str);
}
sayHello("world"); // Olá, mundo
var greeting:Function = sayHello;
greeting("Augustus"); // Olá, Augustus

Outra vantagem da atribuição estrita de tipos de dados é que o Flash exibe automaticamente
referências de código para objetos internos quando o tipo de dados é atribuído a eles
estritamente. Para obter mais informações, consulte “Sobre a atribuição de tipos de dados e a
atribuição estrita de tipos de dados” na página 85.
Como os arquivos publicados com o ActionScript 1.0 não respeitam as atribuições estritas de
tipos de dados durante a compilação, a atribuição do tipo incorreto de valor a uma variável à
qual um tipo foi atribuído estritamente não gera um erro do compilador.
var myNum:String = "abc";
myNum = 12;
/* Não há erro no ActionScript 1.0, mas há um erro de tipos incompatíveis no
ActionScript 2.0 */

88 Dados e tipos de dados


A razão disso é que, quando você publica um arquivo no ActionScript 1.0, o Flash interpreta
uma instrução, por exemplo, var myNum:String = "abc" como sintaxe de barra, e não
como atribuição estrita de tipo. (O ActionScript 2.0 não aceita sintaxe de barra.) Esse
comportamento pode resultar na atribuição de um objeto do tipo incorreto a uma variável,
fazendo com que o compilador permita chamadas de método ilegais e que referências a
propriedades não definidas sejam passadas sem serem relatadas.
Os arquivos publicados com o ActionScript 2.0 podem usar opcionalmente a atribuição de
tipos de dados. Portanto, se você implementar a atribuição estrita de tipos de dados em seu
código, defina suas configurações de publicação para o ActionScript 2.0. Você pode especificar
as configurações de publicação e definir em que versão do ActionScript deseja publicar seus
arquivos modificando essas configurações no menu principal, em File (Arquivo) > Publish
Settings (Configurações de publicação), ou clicando no botão Settings (Configurações) no
inspetor Properties (Propriedades) (certifique-se de que não haja instâncias selecionadas). Para
usar uma versão específica do ActionScript ou do Flash Player, selecione a guia Flash na caixa
de diálogo Publish Settings e escolha uma opção no menu pop-up de versões do ActionScript.
Para obter informações sobre verificação de tipo, consulte “Sobre a verificação de tipo”
na página 89.

Sobre a verificação de tipo


A verificação de tipo consiste em examinar se o tipo de uma variável e de uma expressão são
compatíveis. Portanto, o Flash verifica se o tipo especificado para uma variável corresponde
ao(s) valor(es) atribuído(s) a ela. Para obter mais informações sobre tipos estritos de dados e
atribuição de tipos de dados, consulte “Sobre a atribuição de tipos de dados e a atribuição
estrita de tipos de dados” na página 85 e “Atribuindo um tipo de dados” na página 87.
A verificação de tipo pode ocorrer durante a compilação ou a execução. Se você usar a
atribuição estrita de tipos de dados, a verificação de tipo ocorrerá durante a compilação.
Como o ActionScript é uma linguagem com atribuição dinâmica de tipos, o ActionScript
também pode realizar a verificação de tipo durante a execução.
Por exemplo, o código a seguir não especifica o tipo de dados do parâmetro xParam. Durante
a execução, você usa o parâmetro para armazenar um valor do tipo Number e outro do tipo
String. Em seguida, a função dynamicTest() usa o operador typeof para testar se o
parâmetro é do tipo String ou Number.
function dynamicTest(xParam) {
if (typeof(xParam) == "string") {
var myStr:String = xParam;
trace("String: " + myStr);
} else if (typeof(xParam) == "number") {
var myNum:Number = xParam;

Sobre tipos de dados 89


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

Não é necessário adicionar explicitamente informações de tipo de dados ao ActionScript. O


compilador do ActionScript permite que você use propriedades e chame métodos não
existentes durante a compilação. Dessa maneira, é possível criar propriedades ou atribuir
métodos dinamicamente durante a execução.
Um exemplo da flexibilidade oferecida pela verificação dinâmica de tipo envolve o uso de
propriedades e métodos não conhecidos durante a compilação. Como o código é menos
restritivo, isso poderá ser vantajoso em algumas situações de codificação. Por exemplo, o
código a seguir cria uma função chamada runtimeTest() que chama um método e retorna
uma propriedade, ambos desconhecidos para o compilador. O código não gerará um erro
durante a compilação, mas, se a propriedade ou o método não estiver acessível durante a
execução, ocorrerá um erro durante a execução.
function runtimeTest(myParam) {
myParam.someMethod();
return myParam.someProperty;
}

Sobre a determinação do tipo de dados


Ao testar e depurar seus programas, você pode detectar problemas que parecem estar
relacionados aos tipos de dados de itens diferentes. Ou, se você usar variáveis não associadas
explicitamente a um tipo de dados, talvez seja útil saber o tipo de dados de determinada
variável. Com o ActionScript, é possível determinar o tipo de dados de um item. Você pode
usar o operador typeof para retornar informações sobre os dados.
Use o operador typeof para obter os tipos de dados, mas lembre-se de que ele não retorna
informações sobre a classe à qual uma instância pertence.
O exemplo a seguir mostra como usar o operador typeof para retornar o tipo de objeto que
está sendo rastreado:
// Criar uma nova instância da classe LoadVars.
var my_lv:LoadVars = new LoadVars();

/* O operador typeof não especifica a classe, ele especifica apenas que


my_lv é um objeto*/
var typeResult:String = typeof(my_lv);
trace(typeResult); // objeto

90 Dados e tipos de dados


Neste exemplo, você cria uma nova variável String chamada myName e converte-a no tipo de
dados Number:
var myName:String = new String("17");
trace(myName instanceof String); // true
var myNumber:Number = new Number(myName);
trace(myNumber instanceof Number); // true

Para obter mais informações sobre esses operadores, consulte %{operador typeof}% e
%{operador instanceof}% em ActionScript 2.0 Language Reference. Para obter mais
informações sobre testes e depuração, consulte o Capítulo 18, “Depurando aplicativos”, na
página 745 Para obter mais informações sobre herança e interfaces, consulte o Capítulo 8,
“Herança”, na página 319. Para obter mais informações sobre classes, consulte o Capítulo 7,
“Classes”, na página 239.

Sobre variáveis
Uma variável é um recipiente que contém informações. O código a seguir mostra a aparência
de uma variável no ActionScript:
var myVariable:Number = 10;

Essa variável contém um valor numérico. O uso de :Number no código anterior atribui o tipo
de valor que a variável contém, denominado atribuição de tipos de dados. Para obter mais
informações sobre como atribuir tipos de dados, consulte “Sobre a atribuição de tipos de
dados e a atribuição estrita de tipos de dados” na página 85 e “Atribuindo um tipo de dados”
na página 87.
O recipiente (representado pelo nome da variável) é sempre o mesmo em todo o ActionScript,
mas o conteúdo (o valor) pode mudar. Você pode alterar o valor de uma variável em um script
quantas vezes desejar. Ao alterar o valor de uma variável durante a reprodução do arquivo
SWF, você poderá registrar e salvar informações sobre as atividades do usuário, gravar valores
que mudam à medida que o arquivo SWF é reproduzido ou avaliar se uma condição é true
ou false. Talvez a variável precise ser atualizada continuamente durante a reprodução do
arquivo SWF, como, por exemplo, quando o placar de um jogador muda em um jogo do
Flash. As variáveis são essenciais quando você cria e trata da interação com o usuário em um
arquivo SWF.

Sobre variáveis 91
É recomendável atribuir um valor a uma variável ao declará-la pela primeira vez. A atribuição
de um valor inicial é chamada inicialização da variável e ocorre geralmente no Frame 1
(Quadro 1) da Timeline (Linha de tempo) ou em uma classe carregada quando a reprodução
do arquivo SWF inicia. Há diversos tipos de variáveis, que são afetados pelo escopo. Para obter
mais informações sobre os diversos tipos de variáveis e escopo, consulte “Sobre variáveis e
escopo” na página 101.
D IC A

A inicialização de uma variável facilita o controle e a comparação de seu valor durante a


reprodução do arquivo SWF.
N OT A

O Flash Player 7 e versões posteriores avaliam as variáveis não inicializadas de maneira


diferente do Flash Player 6 e versões anteriores. Se tiver criado scripts para o Flash
Player 6 e planejar criar ou portar scripts para o Flash Player 7 ou versões posteriores,
você deverá compreender essas diferenças a fim de evitar um comportamento
inesperado.

As variáveis podem conter diversos tipos de dados; para obter mais informações, consulte
“Sobre tipos de dados” na página 76. O tipo de dados que uma variável contém afeta a forma
como o valor da variável é alterado quando atribuído em um script.
Os tipos mais comuns de informações que podem ser armazenados em uma variável são um
URL (tipo String), um nome de usuário (tipo String), o resultado de uma operação
matemática (tipo Number), o número de vezes que um evento ocorreu (tipo Number) ou se o
usuário clicou em determinado botão (tipo Boolean). Cada arquivo SWF e instância de um
objeto (como um clipe de filme) tem um conjunto de variáveis, sendo que cada variável possui
um valor, independentemente das variáveis de outros arquivos SWF ou clipes de filme.
Para exibir o valor de uma variável, use a instrução trace() a fim de enviar o valor para o
painel Output. Em seguida, o valor será exibido no painel Output quando você testar o
arquivo SWF no ambiente de teste. Por exemplo, trace(hoursWorked) envia o valor da
variável hoursWorked para o painel Output no ambiente de teste. Também é possível verificar
e definir os valores da variável no Debugger (Depurador), no ambiente de teste.
Para obter mais informações sobre variáveis, consulte os tópicos a seguir:
■ “Sobre a declaração de variáveis” na página 93
■ “Sobre a atribuição de valores” na página 93
■ “Sobre a atribuição de nomes a variáveis” na página 96
■ “Usando variáveis em um aplicativo” na página 97
■ “Sobre variáveis e escopo” na página 101
■ “Sobre valores padrão” na página 93
■ “Sobre operadores e variáveis” na página 96

92 Dados e tipos de dados


■ “Sobre o carregamento de variáveis” na página 106
■ “Usando variáveis em um projeto” na página 111

Sobre a declaração de variáveis


Você pode declarar variáveis em um quadro da timeline, diretamente em um objeto ou em um
arquivo de classe externo.
Para definir variáveis, use a palavra-chave var e siga as convenções de atribuição de nomes de
variáveis. Você pode declarar uma variável chamada firstName, como mostra o exemplo a
seguir:
var firstName:String;
Ao declarar uma variável, você atribui um tipo de dados a ela. Nesse caso, o tipo de dados
String é atribuído à variável firstName. Para obter mais informações sobre como atribuir
tipos de dados, consulte “Sobre a atribuição de tipos de dados e a atribuição estrita de tipos de
dados” na página 85.

Sobre valores padrão


Um valor padrão é o valor que uma variável contém antes de seu valor ser definido. A variável
é inicializada quando você define o seu valor pela primeira vez. Se você declarar uma variável,
mas não definir o seu valor, ela será considerada uma variável não inicializada. O valor padrão
de uma variável não inicializada é undefined. Para obter mais informações sobre como criar e
usar variáveis, consulte “Sobre variáveis” na página 91.

Sobre a atribuição de valores


Você pode definir um valor como o conteúdo atual de uma variável. O valor poderá consistir
em seqüências de caracteres, números, arrays, objetos, XML, datas ou até mesmo classes
personalizadas criadas por você. Lembre-se de que, no Flash, as variáveis são declaradas com a
palavra-chave var. Ao declarar a variável, você também atribui um tipo de dados a ela. Você
também pode atribuir um valor a uma variável, desde que ele corresponda ao tipo de dados
atribuído à variável.
O exemplo a seguir mostra como criar uma variável chamada catName:
var catName:String;

Sobre variáveis 93
Após declarar a variável, você poderá atribuir um valor a ela. Após a linha anterior do
ActionScript, insira esta linha:
catName = "Pirate Eye";
NO T A

Como Pirate Eye é uma seqüência de caracteres, o valor precisa estar entre aspas
retas.

Esse exemplo atribui o valor Pirate Eye à variável catName. Ao declarar uma variável, você
também pode atribuir um valor a ela, em vez de atribuí-lo posteriormente (como nos
exemplos anteriores). Você poderia definir a variável catName ao declará-la, como no seguinte
exemplo:
var catName:String = "Pirate Eye";

Se desejar exibir o valor da variável catName no ambiente de teste, você poderá usar a
instrução trace(). Essa instrução envia o valor para o painel Output. Você pode rastrear o
valor da variável catName e verificar que o valor real não inclui as aspas, usando o seguinte
ActionScript:
var catName:String = "Pirate Eye";
trace(catName); // Pirate Eye

Lembre-se de que o valor atribuído deve corresponder ao tipo de dados atribuído a ele (nesse
caso, String). Se você posteriormente tentar atribuir um número à variável catName, como
catName = 10, o seguinte erro será exibido no painel Output durante o teste do arquivo
SWF:
Type mismatch in assignment statement: found Number where String is
required.

Esse erro informa que você tentou definir o tipo incorreto de dados para uma variável
especificada.
Quando um valor numérico é atribuído a uma variável, as aspas não são necessárias, como
mostra o código a seguir:
var numWrinkles:Number = 55;

Se desejar alterar o valor de numWrinkles posteriormente no código, você poderá atribuir um


novo valor usando o seguinte ActionScript:
numWrinkles = 60;

Ao reatribuir um valor a uma variável existente, você não precisa usar a palavra-chave var ou
definir o tipo de dados da variável (nesse caso, :Number).
Se o valor for numérico ou booleano (true ou false), ele não usará aspas retas. Exemplos de
valores numéricos e booleanos são mostrados no trecho de código a seguir:

94 Dados e tipos de dados


var age:Number = 38;
var married:Boolean = true;
var hasChildren:Boolean = false;

No exemplo anterior, a variável age contém um valor inteiro (não-decimal), embora você
também possa usar um valor decimal ou de ponto flutuante, como 38,4. As variáveis
booleanas (como married ou hasChildren) têm somente dois valores possíveis, true ou
false.

Se você desejar criar um array e atribuir valores a ele, o formato será ligeiramente diferente,
como mostra o código a seguir:
var childrenArr:Array = new Array("Pylon", "Smithers", "Gil");

Há uma sintaxe alternativa (abreviada) para criar um array com os operadores de acesso de
array, que usam colchetes ([]). Você pode reescrever o exemplo anterior da seguinte maneira:
var childrenArr:Array = ["Pylon", "Smithers", "Gil"];

Para obter mais informações sobre como criar arrays e os operadores de acesso de array,
consulte “Sobre arrays” na página 172 e “Sobre uso da sintaxe de ponto para referenciar uma
instância” na página 125.
De maneira semelhante, você pode criar um novo objeto chamado myObj. Há dois métodos
para criar um novo objeto. O primeiro (e mais longo) método para codificar um array é
apresentado a seguir:
var myObj:Object = new Object();
myObj.firstName = "Steve";
myObj.age = 50;
myObj.childrenArr = new Array("Mike", "Robbie", "Chip");

O segundo e (mais curto) método para codificar o array myObj é o seguinte:


var myObj:Object = {firstName:"Steve", age:50, childrenArr:["Mike",
"Robbie", "Chip"]};

Como você pode observar nesse exemplo, o uso do método mais curto pode poupar muito
tempo e digitação, especialmente quando você define instâncias de objetos. É importante estar
familiarizado com essa sintaxe alternativa, pois você a encontrará se trabalhar em equipes ou
quando trabalhar com código ActionScript de terceiros encontrado, por exemplo, na Internet
ou em manuais.
N OT A

Nem todas as variáveis precisam ser definidas explicitamente. O Flash cria algumas
variáveis automaticamente. Por exemplo, para encontrar as dimensões do Stage, você
poderia usar os valores destas duas variáveis predefinidas: Stage.width e
Stage.height.

Sobre variáveis 95
Sobre operadores e variáveis
Talvez você não entenda os símbolos matemáticos contidos em seu código. Esses símbolos são
chamados operadores no ActionScript. Os operadores calculam um novo valor a partir de um
ou mais valores e são usados para atribuir um valor a uma variável no código. Use o operador
de igualdade (=) para atribuir um valor a uma variável:
var username:String = "Gus";

Outro exemplo é o operador de adição (+), que adiciona dois ou mais valores numéricos para
produzir um novo valor. Se você usar o operador + em dois ou mais valores de seqüência de
caracteres, as seqüências serão concatenadas. Os valores manipulados pelos operadores são
denominados operandos.
Ao atribuir um valor, use um operador a fim de definir um valor para uma variável. Por
exemplo, o script a seguir usa o operador de atribuição para atribuir o valor 7 à variável
numChildren:
var numChildren:Number = 7;

Se desejar alterar o valor da variável numChildren, use o seguinte código:


numChildren = 8;
NO TA

Não é necessário usar var, pois a variável foi definida anteriormente.

Para obter mais informações sobre como usar operadores no ActionScript, consulte “Sobre
operadores” na página 185.

Sobre a atribuição de nomes a variáveis


Tenha cautela ao nomear variáveis, pois, embora elas possam ter praticamente qualquer nome,
algumas regras devem ser observadas. O nome de uma variável deve seguir estas regras:
■ Uma variável deve ser um identificador.
N O TA

Um identificador é um nome de variável, propriedade, objeto, função ou método. O


primeiro caractere do identificador deve ser uma letra, um sublinhado (_) ou um
cifrão ($). Os caracteres subseqüentes podem ser uma letra, um número, um
sublinhado ou um cifrão.

■ Uma variável não pode ser uma palavra-chave nem um literal do ActionScript, como
true, false, null ou undefined. Para obter mais informações sobre literais, consulte
“Sobre literais” na página 138.
■ As variáveis devem ser exclusivas em seu escopo (consulte “Sobre variáveis e escopo”
na página 101).

96 Dados e tipos de dados


■ As variáveis não devem ser um elemento da linguagem ActionScript, como um nome de
classe.
Se você não seguir as regras ao atribuir um nome a uma variável, poderão ocorrer erros de
sintaxe ou resultados inesperados. No exemplo a seguir, se você atribuir o nome new a uma
variável e testar o seu documento, o Flash gerará um erro do compilador:
// Este código funciona como esperado.
var helloStr:String = new String();
trace(helloStr.length); // 0
// Mas, se você atribuir a uma variável o mesmo nome de uma classe
interna...
var new:String = "hello"; // erro: identificador esperado
var helloStr:String = new String();
trace(helloStr.length); // indefinido

O editor do ActionScript oferece suporte a referências de código para classes internas e


variáveis que tenham como base essas classes. Se desejar que o Flash forneça referências de
código para um tipo de objeto específico atribuído a uma variável, você poderá atribuir um
tipo estrito a ela. As referências de código fornecem uma sintaxe no estilo de dica de
ferramenta e um menu pop-up que o ajuda a criar o código rapidamente.
Por exemplo, digite o seguinte código:
var members:Array = new Array();
members.

Assim que você digita o ponto (.) no painel Actions (Ações), o Flash exibe uma lista de
métodos e propriedades disponíveis para objetos Array.
Para obter as convenções de codificação recomendadas para a atribuição de nomes a variáveis,
consulte “Atribuição de nome a variáveis” na página 772.

Usando variáveis em um aplicativo


Nesta seção, você usará variáveis em trechos curtos de código ActionScript. É necessário
declarar e inicializar uma variável em um script antes de usá-la em uma expressão. As
expressões são combinações de operandos e operadores que representam um valor. Por
exemplo, na expressão i+2, i e 2 são operandos, e + é um operador.
Se você não inicializar uma variável antes de usá-la em uma expressão, a variável não ficará
indefinida e poderá gerar resultados inesperados. Para obter mais informações sobre como
criar expressões, consulte o Capítulo 5, “Fundamentos da sintaxe e da linguagem”, na
página 119.
Se você usar uma variável indefinida, como no exemplo a seguir, o valor da variável no Flash
Player 7 e versões posteriores será NaN, e o script poderá produzir resultados indesejados:

Sobre variáveis 97
var squared:Number = myNum * myNum;
trace(squared); // NaN
var myNum:Number = 6;
No exemplo a seguir, a instrução que declara e inicializa a variável myNum vem em primeiro
lugar; portanto, squared pode ser substituído por um valor:
var myNum:Number = 6;
var squared:Number = myNum * myNum;
trace(squared); // 36

Um comportamento semelhante ocorre quando você passa uma variável não definida para um
método ou uma função, como mostrado a seguir.

Para comparar a passagem de variáveis indefinidas e definidas para uma


função:
1. Arraste um componente Button do painel Components (Componentes) até o Stage
(Palco).
2. Abra o inspetor Properties (Propriedades) e digite bad_button na caixa de texto Instance
Name (Nome da instância).
3. Digite o seguinte código no Frame 1 da Timeline.
// Não funciona
function badClickListener(evt:Object):Void {
getURL(targetUrl);
var targetUrl:String = "http://www.macromedia.com";
}
bad_button.addEventListener("click", badClickListener);

4. Selecione Control (Controlar) > Test Movie (Testar filme) e observe que o botão não
funciona (ele não abre a página da Web).
5. Arraste outro componente Button até o Stage. Selecione o botão.
6. Abra o inspetor Properties e digite good_button na caixa de texto Instance Name.
7. Adicione o seguinte ActionScript ao Frame 1 da Timeline (após o ActionScript adicionado
anteriormente):
// Funciona
function goodClickListener(evt:Object):Void {
var targetUrl:String = "http://www.macromedia.com";
getURL(targetUrl);
}
good_button.addEventListener("click", goodClickListener);

8. Selecione Control > Test Movie e clique no segundo botão adicionado ao Stage.
Esse botão abre a página da Web corretamente.

98 Dados e tipos de dados


O tipo de dados que uma variável contém afeta como e quando o seu valor será alterado. Os
tipos de dados primitivos, como Strings e Numbers, são passados por valor; isso significa que é
usado o valor atual da variável, em vez de uma referência a esse valor. Array e Object são
exemplos de tipos de dados complexos.
No exemplo a seguir, você definirá myNum como 15 e copiará o valor para otherNum. Quando
você altera myNum para 30 (na linha 3 do código), o valor de otherNum permanece igual a 15
porque otherNum não procura o seu valor em myNum. A variável otherNum contém o valor de
myNum recebido (na linha 2 do código).

Para usar variáveis no ActionScript:


1. Crie um novo documento do Flash e salve-o como var_example.fla.
2. Selecione o Frame 1 da Timeline e digite o código a seguir no painel Actions:
var myNum:Number = 15;
var otherNum:Number = myNum;
myNum = 30;
trace(myNum); // 30
trace(otherNum); // 15

Quando você altera myNum para 30 (na linha 3 do código), o valor de otherNum permanece
igual a 15 porque otherNum não procura o seu valor em myNum. A variável otherNum
contém o valor de myNum recebido (na linha 2 do código).
3. Selecione Control > Test Movie para que os valores sejam exibidos no painel Output.
4. Agora adicione o seguinte ActionScript após o código adicionado na etapa 2:
function sqr(myNum:Number):Number {
myNum *= myNum;
return myNum;
}
var inValue:Number = 3;
var outValue:Number = sqr(inValue);
trace(inValue); // 3
trace(outValue); // 9

Nesse código, a variável inValue contém um valor primitivo, 3; portanto, o valor é


passado para a função sqr(), e o valor retornado é 9. O valor da variável inValue não é
alterado, embora o valor de myNum seja alterado na função.
5. Selecione Control > Test Movie para que os valores sejam exibidos no painel Output.
O tipo de dados Object pode conter uma quantidade tão grande de informações complexas
que uma variável com esse tipo não armazenará o valor real, mas uma referência a esse valor.
Essa referência é semelhante a um alias que aponta para o conteúdo da variável. Quando a
variável precisa saber seu valor, a referência solicita o conteúdo e responde sem transferir o
valor para a variável.

Sobre variáveis 99
Para obter informações sobre como passar uma variável por referência, consulte “Passando
uma variável por referência” na página 100.

Passando uma variável por referência


Como os tipos de dados Array e Object armazenam uma referência a um valor, em vez de
conterem seu valor real, tenha cautela ao trabalhar com arrays e objetos.
O exemplo a seguir mostra como passar um objeto por referência. Ao criar uma cópia do
array, você cria, na verdade, apenas uma cópia da referência (ou alias) ao conteúdo do array.
Ao editar o conteúdo do segundo array, você modifica o conteúdo do primeiro e do segundo
arrays, pois ambos apontam para o mesmo valor.

Para passar um objeto por referência:


1. Selecione File (Arquivo) > New (Novo), escolha Flash Document (Documento do Flash)
para criar um novo arquivo FLA e salve-o como copybyref.fla.
2. Selecione o Frame 1 da Timeline e digite o código a seguir no painel Actions:
var myArray:Array = new Array("tom", "josie");
var newArray:Array = myArray;
myArray[1] = "jack";
trace(myArray); // tom,jack
trace(newArray); // tom,jack

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript.
Esse ActionScript cria um objeto Array chamado myArray com dois elementos. Crie a
variável newArray e passe uma referência para myArray. Quando você altera o segundo
elemento de myArray para jack, ele afeta todas as variáveis que contêm uma referência a
ele. A instrução trace() envia tom,jack para o painel Output.
N OT A

O Flash usa um índice que inicia em zero, ou seja, 0 é o primeiro item do array, 1 é o
segundo e assim por diante.

No exemplo a seguir, myArray contém um objeto Array, portanto, o array é passado para a
função zeroArray() por referência. A função zeroArray() aceita um objeto Array como
parâmetro e define todos os elementos desse array como 0. Ela pode modificar o array porque
ele é passado por referência.

Para passar um array por referência:


1. Selecione File > New, escolha Flash Document para criar um novo arquivo FLA e salve-o
como arraybyref.fla.

100 Dados e tipos de dados


2. Adicione o seguinte ActionScript ao Frame 1 da Timeline:
function zeroArray (theArr:Array):Void {
var i:Number;
for (i = 0; i < theArr.length; i++) {
theArr[i] = 0;
}
}

var myArr:Array = new Array();


myArr[0] = 1;
myArr[1] = 2;
myArr[2] = 3;
trace(myArr); // 1,2,3
zeroArray(myArr);
trace(myArr); // 0,0,0

3. Selecione Control > Test Movie para testar o ActionScript.


A primeira instrução trace() desse ActionScript exibe o conteúdo original do array
myArray (1,2,3). Depois que você chama a função zeroArray() e passa uma referência
ao array myArray, cada um dos valores do array é substituído e definido como zero. A
instrução trace() subseqüente exibe o novo conteúdo do array myArray (0,0,0). Como
o array é passado por referência, e não por valor, não é necessário retornar o seu conteúdo
atualizado a partir da função zeroArray().
Para obter mais informações sobre arrays, consulte “Sobre arrays” na página 172.

Sobre variáveis e escopo


O escopo de uma variável refere-se à área na qual a variável é conhecida (definida) e na qual
pode ser referenciada. A variável poderá ser conhecida em uma timeline ou em uma função
específica, ou poderá ser conhecida globalmente em todo o aplicativo. Para obter mais
informações sobre escopo, consulte “Sobre escopo e referência” na página 130.
A compreensão do escopo das variáveis é importante durante o desenvolvimento de aplicativos
Flash com o ActionScript. Além de indicar quando e onde é possível fazer referência a
variáveis, o escopo especifica por quanto tempo determinada variável existirá em um
aplicativo. Quando as variáveis são definidas no corpo de uma função, elas deixam de existir
assim que a função especificada é encerrada. Se tentar fazer referência a objetos no escopo
incorreto ou a variáveis expiradas, você receberá erros nos documentos do Flash, os quais
levarão a um comportamento inesperado ou à interrupção de uma funcionalidade.
Há três tipos de escopos de variável no ActionScript:
■ Variáveis globais e funções estão disponíveis para cada timeline e escopo do documento.
Portanto, uma variável global é definida em todas as áreas do código.

Sobre variáveis 101


■ Variáveis de Timeline estão disponíveis para qualquer script nessa timeline.
■ Variáveis locais estão disponíveis no corpo da função em que são declaradas (delineado por
chaves). Portanto, as variáveis locais são definidas somente em parte do código.
Para obter diretrizes sobre o uso de escopo e variáveis, consulte o Capítulo 5, “Sobre escopo e
referência”, na página 130.
N OT A

As classes do ActionScript 2.0 criadas por você oferecem suporte a escopos públicos,
privados e estáticos de variáveis. Para obter mais informações, consulte “Sobre
membros de classe” na página 265 e “Controlando o acesso de membros em classes”
na página 288.

Não é possível usar a atribuição estrita de dados para variáveis globais. Para obter informações
e uma solução alternativa, consulte “Variáveis globais” na página 102.

Variáveis globais
As variáveis globais e as funções estão visíveis para cada timeline e escopo do documento. Para
declarar (ou criar) uma variável com escopo global, use o identificador _global antes do
nome da variável e não use a sintaxe var =. Por exemplo, o código a seguir cria a variável
global myName:
var _global.myName = "George"; // Sintaxe incorreta para a variável global
_global.myName = "George"; // Sintaxe correta para a variável global

Entretanto, se inicializar uma variável local com o mesmo nome de uma variável global, você
não terá acesso à variável global enquanto estiver no escopo da variável local, como mostra o
exemplo a seguir:
_global.counter = 100; // Declara a variável global
trace(counter); // Acessa a variável global e exibe 100
function count():Void {
for (var counter:Number = 0; counter <= 2; counter++) { // Variável local
trace(counter); // Acessa a variável local e exibe de 0 a 2
}
}
count();
trace(counter); // Acessa a variável global e exibe 100

Esse exemplo mostra simplesmente que a variável global não é acessada no escopo da função
count(). Entretanto, você poderá acessar a variável de escopo global se adicionar a ela o
prefixo _global. Por exemplo, você poderia acessá-la se adicionasse o prefixo _global ao
contador, como no seguinte código:
trace(_global.counter);

102 Dados e tipos de dados


Você não poderá atribuir tipos de dados estritos às variáveis criadas no escopo _global, pois
precisará usar a palavra-chave var ao atribuir um tipo de dados. Por exemplo, isto não seria
possível:
_global.foo:String = "foo"; //erro de sintaxe
var _global.foo:String = "foo"; //erro de sintaxe

O recurso de segurança sandbox do Flash Player versão 7 e versões posteriores impõe restrições
ao acesso de variáveis globais em arquivos SWF carregados a partir de domínios de segurança
separados. Para obter mais informações, consulte Capítulo 17, “Noções básicas de segurança”,
na página 707.

Variáveis de Timeline
As variáveis de Timeline estão disponíveis para qualquer script nessa timeline. Para declarar
variáveis de timeline, use a instrução var e inicialize-as em qualquer quadro da timeline. A
variável está disponível para esse quadro e para todos os quadros subseqüentes, como no
exemplo apresentado a seguir.

Para usar variáveis de timeline em um documento:


1. Crie um novo documento do Flash e atribua o nome timelinevar.fla a ele.
2. Adicione o seguinte ActionScript ao Frame 1 da Timeline:
var myNum:Number = 15; /* inicializada no Frame 1 e, portanto, disponível
para todos os quadros */
3. Selecione o Frame 20 da Timeline.
4. Selecione Insert (Inserir) > Timeline > Blank Keyframe (Quadro-chave em branco).
5. Com o novo quadro-chave selecionado, digite o seguinte ActionScript no painel Actions:
trace(myNum);

6. Selecione Control > Test Movie para testar o novo documento.


O valor 15 é exibido no painel Output após aproximadamente um segundo. Como os
documentos do Flash executam um loop, por padrão, o valor 15 é exibido continuamente
no painel Output toda vez que a reprodução alcança o Frame 20 da Timeline. Para
interromper a ação de loop, adicione stop(); após a instrução trace().
É necessário declarar uma variável de timeline antes de tentar acessá-la em um script. Por
exemplo, se você colocar o código var myNum:Number = 15; em Frame 20, todos os scripts
anexados a um quadro anterior a esse não poderão acessar myNum e serão indefinidos em vez de
conterem o valor 15.

Sobre variáveis 103


Variáveis locais
Ao usar a instrução var em um bloco de função, você declara variáveis locais. Quando uma
variável local é declarada em um bloco de função (também chamado definição de função), ela é
definida no escopo desse bloco e expira no final dele. Portanto, a variável local existe somente
nessa função.
Por exemplo, se você declarar uma variável chamada myStr em uma função localScope, essa
variável não estará disponível fora da função.
function localScope():Void {
var myStr:String = "local";
}
localScope();
trace(myStr); // Indefinida, porque myStr não está definida globalmente

Se o nome usado para a variável local já estiver declarado como uma variável de timeline, a
definição local terá precedência sobre a definição da timeline enquanto a variável local estiver
no escopo. A variável de timeline ainda existirá for a da função. Por exemplo, o código a seguir
cria uma variável de seqüência de caracteres timeline chamada str1 e, em seguida, cria uma
variável local de mesmo nome na função scopeTest(). A instrução trace contida na função
gera a definição local da variável, mas a instrução trace fora da função gera a definição da
variável na timeline.
var str1:String = "Timeline";
function scopeTest():Void {
var str1:String = "Local";
trace(str1); // Local
}
scopeTest();
trace(str1); // Timeline

No próximo exemplo, observe que certas variáveis existem apenas enquanto determinada
função existir e poderão gerar erros se você tentar fazer referência a elas fora do escopo dessa
função.

Para usar variáveis locais em um aplicativo:


1. Crie um novo documento do Flash.
2. Abra o painel Actions (Window (Janela) > Actions (Ações)) e adicione o seguinte
ActionScript ao Frame 1 da Timeline:
function sayHello(nameStr:String):Void {
var greetingStr:String = "Hello, " + nameStr;
trace(greetingStr);
}
sayHello("world"); // Olá, mundo
trace(nameStr); // indefinido
trace(greetingStr); // indefinido

104 Dados e tipos de dados


3. Selecione Control > Test Movie para testar o documento.
O Flash exibe a seqüência de caracteres “Olá, mundo” no painel Output e indefinido
para os valores de nameStr e greetingStr porque as variáveis não estão mais disponíveis
no escopo atual. Somente é possível fazer referência a nameStr e greetingStr na
execução da função sayHello. Quando a função encerrar, as variáveis deixarão de existir.
As variáveis i e j são geralmente usadas como contadores de loop. No exemplo a seguir, i é
usada como uma variável local; ela só existe dentro da função initArray():
var myArr:Array = new Array();
function initArray(arrayLength:Number):Void {
var i:Number;
for(i = 0; i < arrayLength; i++) {
myArr[i] = i + 1;
}
}
trace(myArr); // <em branco>
initArray(3);
trace(myArr); // 1,2,3
trace(i); // indefinido
N OT A

A sintaxe a seguir também costuma ser usada para um loop for: for (var i:Number =
0; i < arrayLength; i++) {...}.

Esse exemplo exibe undefined no ambiente de teste do Flash porque a variável i não está
definida na timeline principal. Ela existe somente na função initArray().
Você pode usar variáveis locais para ajudar a evitar conflitos de nome, que podem gerar
resultados inesperados em seu aplicativo. Por exemplo, se usar age como uma variável local,
você poderá usá-la para armazenar a idade de uma pessoa em um contexto e a idade do filho
de uma pessoa em outro contexto. Nesse caso, não há conflito porque as variáveis são usadas
em escopos separados.
É recomendável usar variáveis locais no corpo de uma função para que a função possa atuar
como um código independente. Uma variável local só pode ser alterada em seu próprio bloco
de código. Se uma expressão em uma função usar uma variável global, um código ou eventos
externos à função poderão alterar seu valor, o que alteraria a função.
Você pode atribuir um tipo de dados a uma variável local ao declará-la. Isso ajuda a evitar a
atribuição do tipo de dados incorreto a uma variável existente. Para obter mais informações,
consulte “Sobre a atribuição de tipos de dados e a atribuição estrita de tipos de dados”
na página 85.

Sobre variáveis 105


Sobre o carregamento de variáveis
Nas seções a seguir, você carregará variáveis do servidor de diferentes maneiras ou em um
documento a partir de uma seqüência de caracteres de URL ou de FlashVars (você pode usar
FlashVars a fim de passar variáveis para o Flash) em seu código HTML. Essas práticas
demonstram que há várias maneiras de usar variáveis fora de um arquivo SWF.
Para obter mais informações sobre como carregar variáveis (como pares de nome/valor),
consulte o Capítulo 16, “Trabalhando com dados externos”, na página 663.
Você poderá usar variáveis de diferentes maneiras em um arquivo SWF, dependendo de suas
necessidades. Para obter mais informações, consulte os seguintes tópicos:
■ “Usando variáveis a partir do URL” na página 106
■ “Usando FlashVars em um aplicativo” na página 109
■ “Carregando variáveis a partir de um servidor” na página 110

Usando variáveis a partir do URL


Ao desenvolver um aplicativo ou um exemplo simples no Flash, você poderá passar valores de
uma página HTML para o documento do Flash. Os valores passados algumas vezes são
conhecidos como seqüência de caracteres de consulta ou variáveis codificadas em URL. As
variáveis de URL são úteis quando você deseja criar um menu no Flash, por exemplo. Você
pode inicializar o menu para mostrar a navegação correta por padrão. Você também pode criar
um visualizador de imagens no Flash e definir uma imagem padrão para exibição no site da
Web.

Para usar variáveis de URL em um documento:


1. Crie um documento do Flash e atribua o nome urlvariables.fla a ele.
2. Selecione File (Arquivo) > Save As (Salvar como) e salve o documento na área de trabalho.
3. Selecione o Frame 1 da Timeline e adicione o seguinte código ao painel Actions:
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
myTxt.text = _level0.myURL;

4. Selecione Control > Test Movie para testar o arquivo SWF no Flash Player.
O campo de texto exibe undefined. Para ter certeza de que as variáveis estão definidas
corretamente antes de continuar, verifique a existência das variáveis no Flash. Para isso,
verifique se elas estão indefinidas.

106 Dados e tipos de dados


5. Para verificar se a variável está definida, modifique o ActionScript adicionado ao painel
Actions na etapa 3 de acordo com o código a seguir. Adicione o código que aparece em
negrito:
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
if (_level0.myURL == undefined) {
myTxt.text = "myURL is not defined";
} else {
myTxt.text = _level0.myURL;
}

Quando você publica o documento do Flash, um documento HTML é criado por padrão
no mesmo diretório do arquivo SWF. Se um arquivo HTML não tiver sido criado,
selecione File (Arquivo) > Publish settings (Configurações de publicação) e, em seguida,
HTML na guia Formats (Formatos). Em seguida, publique o documento novamente.
O código a seguir demonstra o HTML do documento responsável por incorporar um
documento do Flash em uma página HTML. Examine esse HTML para entender como
as variáveis de URL funcionam na etapa a seguir (na qual você adicionará um código para
essas variáveis).
<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
codebase="http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/
swflash.cab#version=8,0,0,0" width="550" height="400"
id="urlvariables" align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="urlvariables.swf" />
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="urlvariables.swf" quality="high" bgcolor="#ffffff"
width="550" height="400" name="urlvariables" align="middle"
allowScriptAccess="sameDomain" type="application/x-shockwave-flash"
pluginspage="http://www.macromedia.com/go/getflashplayer" />
</object>
6. Para passar variáveis do documento HTML gerado para o documento do Flash, você pode
passá-las após o caminho e o nome do arquivo (urlvariables.swf). Adicione o texto em
negrito ao arquivo HTML gerado na área de trabalho.
<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
codebase="http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/
swflash.cab#version=8,0,0,0" width="550" height="400"
id="urlvariables" align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="urlvariables.swf?myURL=http://
weblogs.macromedia.com" />
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />

Sobre variáveis 107


<embed src="urlvariables.swf?myURL=http://weblogs.macromedia.com"
quality="high" bgcolor="#ffffff" width="550" height="400"
name="urlvariables" align="middle" allowScriptAccess="sameDomain"
type="application/x-shockwave-flash" pluginspage="http://
www.macromedia.com/go/getflashplayer" />
</object>
7. Se desejar passar diversas variáveis para o Flash, separe os pares de nome/valor com um E
comercial (&). Localize o seguinte código da etapa 6:
?myURL=http://weblogs.macromedia.com

Substitua-o por este texto:


?myURL=http://weblogs.macromedia.com&myTitle=Macromedia+News+Aggregator

Lembre-se de que é necessário efetuar as mesmas alterações nas marcas object e embed
para manter a consistência entre todos os navegadores. Observe que as palavras estão
separadas pelos sinais +. As palavras são separadas dessa maneira porque os valores são
codificados em URL e o sinal + representa um único espaço em branco.
N OT A

Para obter uma lista de caracteres especiais comuns codificados em URL, consulte
a Flash TechNote (Nota técnica do Flash), URL Encoding: Reading special
characters from a text file (Codificação de URL: Lendo caracteres especiais em um
arquivo de texto).

Como o E comercial (&) serve como delimitador para diversos pares de nome/valor, se os
valores passados contiverem esse caractere, poderão ocorrer resultados inesperados. Em
virtude da natureza dos pares de nome/valor e da análise, se os valores a seguir forem
passados para o Flash,
my.swf?name=Ben+&+Jerry&flavor=Half+Baked

ele criará as seguintes variáveis (e valores) no escopo raiz:


'name': 'Ben ' (note space at end of value)
' Jerry': '' (note space at beginning of variable name and an empty
value)
'flavor': 'Half Baked'

Para evitar isso, use o E comercial (&) como um caractere de escape no par de nome/valor
com seu equivalente codificado em URL (%26).
8. Abra o documento urlvariables.html e localize o seguinte código:
?myURL=http://weblogs.macromedia.com&myTitle=Macromedia+News+Aggregator

Substitua-o por este código:


?myURL=Ben+%26+Jerry&flavor=Half+Baked

108 Dados e tipos de dados


9. Salve o HTML revisado e teste o documento do Flash novamente.
Observe que o Flash criou os seguintes pares de nome/valor.
'name': 'Ben & Jerry'
'flavor': 'Half Baked'
NO T A

Todos os navegadores aceitarão seqüências de caracteres de até 64K (65535


bytes). FlashVars deve ser atribuída nas marcas object e embed para que funcione
em todos os navegadores.

Usando FlashVars em um aplicativo


Usar FlashVars para passar variáveis para o Flash é semelhante a usar o URL para passar
variáveis no código HTML. Com FlashVars, em vez de serem passadas após o nome do
arquivo, as variáveis são passadas em uma marca param separada, bem como na marca embed.

Para usar FlashVars em um documento:


1. Crie um novo documento do Flash e atribua o nome myflashvars.fla a ele.
2. Selecione File > Publish Settings, verifique se HTML está selecionado e clique em OK para
fechar a caixa de diálogo.
3. Adicione o seguinte ActionScript ao Frame 1 da Timeline principal:
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
if (_level0.myURL == undefined) {
myTxt.text = "myURL is not defined";
} else {
myTxt.text = _level0.myURL;
}
NO T A

Por padrão, o código HTML é publicado no mesmo local que myflashvars.fla.

4. Selecione File (Arquivo) > Publish (Publicar) para publicar os arquivos SWF e HTML.
5. Abra o diretório que contém os arquivos publicados (onde você salvou myflashvars.fla no
disco rígido) e abra o documento HTML (myflashvars.html, por padrão) em um editor
HTML, como o Dreamweaver ou o Bloco de Notas.
6. Adicione o código que aparece em negrito abaixo, para que o documento HTML
corresponda ao seguinte:
<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
codebase="http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/
swflash.cab#version=8,0,0,0" width="550" height="400" id="myflashvars"
align="middle">
<param name="allowScriptAccess" value="sameDomain" />

Sobre variáveis 109


<param name="movie" value="myflashvars.swf" />
<param name="FlashVars" value="myURL=http://weblogs.macromedia.com/">
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="myflashvars.swf" FlashVars="myURL=http://
weblogs.macromedia.com/" quality="high" bgcolor="#ffffff" width="550"
height="400" name="myflashvars" align="middle"
allowScriptAccess="sameDomain" type="application/x-shockwave-flash"
pluginspage="http://www.macromedia.com/go/getflashplayer" />
</object>

Esse código passa uma única variável chamada myURL, que contém a seqüência de
caracteres
http://weblogs.macromedia.com. Quando o arquivo SWF é carregado, uma
propriedade chamada myURL é criada no escopo _level0. Uma das vantagens de usar
FlashVars ou passar variáveis no URL é que elas ficam imediatamente disponíveis no Flash
quando o arquivo SWF é carregado. Isso significa que não é preciso criar funções para
verificar se o carregamento das variáveis foi concluído; esse procedimento seria necessário
se elas fossem carregadas com LoadVars ou XML.
7. Salve as alterações no documento HTML e feche-o.
8. Clique duas vezes em myflashvars.html para testar o aplicativo.
O texto http://weblogs.macromedia.com, uma variável do arquivo HTML, é exibido
no arquivo SWF.
N OT A

Todos os navegadores aceitarão seqüências de caracteres de até 64K (65.535


bytes). FlashVars deve ser atribuída nas marcas object e embed para que funcione
em todos os navegadores.

Carregando variáveis a partir de um servidor


Há várias maneiras de carregar variáveis no Flash a partir de origens externas (como arquivos
de texto, documentos XML etc.). Para obter mais informações sobre como carregar variáveis,
incluindo pares de nome/valor, consulte o Capítulo 16, “Trabalhando com dados externos”,
na página 663.
No Flash, é possível carregar facilmente variáveis usando a classe LoadVars, como mostra este
exemplo.

110 Dados e tipos de dados


Para carregar variáveis de um servidor:
1. Crie um novo documento do Flash.
2. Selecione o Frame 1 da Timeline e adicione o seguinte ActionScript ao painel Actions:
var my_lv:LoadVars = new LoadVars();
my_lv.onLoad = function(success:Boolean):Void {
if (success) {
trace(this.dayNames); // Domingo,Segunda-feira,Terça-feira,...
} else {
trace("Error");
}
}
my_lv.load("http://www.helpexamples.com/flash/params.txt");

Esse código carrega um arquivo de texto de um servidor remoto e analisa seus pares de
nome/valor.
DICA

Faça download ou exiba o arquivo de texto (http://www.helpexamples.com/flash/


params.txt) em um navegador se desejar saber como as variáveis são formatadas.

3. Selecione Control > Test Movie para testar o documento.


Se o arquivo for carregado com êxito, o evento complete será chamado e o painel Output
exibirá o valor de dayNames. Se não for possível fazer o download do arquivo de texto, o
argumento success será definido como false e o painel Output exibirá o texto Error.

Usando variáveis em um projeto


Quando você cria animações ou aplicativos com o Flash, em algumas situações não será
preciso usar nenhum tipo de variável em seu projeto. Por exemplo, se criar um sistema de
login, você talvez precise de variáveis para determinar se o nome de usuário e a senha são
válidos ou se foram preenchidos.
Para obter mais informações sobre como carregar variáveis (como pares de nome/valor),
consulte o Capítulo 16, “Trabalhando com dados externos”, na página 663.
No exemplo a seguir, você usará variáveis para armazenar o caminho de uma imagem que está
sendo carregada com a classe Loader, uma variável para a instância dessa classe e algumas
funções que são chamadas dependendo do carregamento bem ou não sucedido do arquivo.

Sobre variáveis 111


Para usar variáveis em um projeto:
1. Crie um novo documento do Flash e salve-o como imgloader.fla.
2. Selecione o Frame 1 da Timeline e adicione o seguinte ActionScript ao painel Actions:
/* Especifique a imagem padrão se um valor não tiver sido passado com
FlashVars. */
var imgUrl:String = "http://www.helpexamples.com/flash/images/
image1.jpg";
if (_level0.imgURL != undefined) {
// Se a imagem tiver sido especificada, substitua o valor padrão.
imgUrl = _level0.imgURL;
}

this.createEmptyMovieClip("img_mc", 10);
var mclListener:Object = new Object();
mclListener.onLoadInit = function(target_mc:MovieClip):Void {
target_mc._x = (Stage.width - target_mc._width) / 2;
target_mc._y = (Stage.height - target_mc._height) / 2;
}
mclListener.onLoadError = function(target_mc:MovieClip):Void {
target_mc.createTextField("error_txt", 1, 0, 0, 100, 20);
target_mc.error_txt.autoSize = "left";
target_mc.error_txt.text = "Error downloading specified image;\n\t" +
target_mc._url;
}
var myMCL:MovieClipLoader = new MovieClipLoader();
myMCL.addListener(mclListener);
myMCL.loadClip(imgUrl, img_mc);

A primeira linha do código especifica a imagem a ser carregada dinamicamente no


documento do Flash. Em seguida, verifique se um novo valor de imgURL foi especificado
usando FlashVars ou variáveis codificadas em URL. Se um novo valor tiver sido
especificado, o URL da imagem padrão será substituído pelo novo valor. Para obter
informações sobre como usar variáveis de URL, consulte “Usando variáveis a partir do
URL” na página 106. Para obter informações sobre FlashVars, consulte “Usando
FlashVars em um aplicativo” na página 109.
As linhas de código seguintes definem a instância MovieClip e um objeto ouvinte para a
instância MovieClipLoader futura. O objeto ouvinte de MovieClipLoader define dois
manipuladores de eventos, onLoadInit e onLoadError. Os manipuladores serão
chamados quando a imagem for carregada e inicializada com êxito no Stage ou se a
imagem não for carregada. Em seguida, crie a instância MovieClipLoader e usa o método
addListener() para adicionar o objeto ouvinte definido anteriormente para
MovieClipLoader. Finalmente, é feito o download da imagem que será ativada quando
você chamar o método MovieClipLoader.loadClip(), que especifica o arquivo de
imagem a ser carregado e o clipe de filme de destino no qual a imagem será carregada.

112 Dados e tipos de dados


3. Selecione Control > Test Movie para testar o documento.
Como você está testando o documento do Flash na ferramenta de criação, nenhum valor
de imgUrl será passado por FlashVars ou no URL e, portanto, a imagem padrão será
exibida.
4. Salve o documento do Flash e selecione File (Arquivo) > Publish (Publicar) para publicar
o arquivo como um documento SWF e HTML.
NO T A

Verifique se Flash e HTML estão selecionados na caixa de diálogo Publish Settings.


Selecione File > Publish Settings e clique na guia Formats. Em seguida, selecione as
duas opções.

5. Se testar o documento na ferramenta do Flash (selecione Control > Test Movie) ou em um


navegador local (File > Publish Preview (Visualizar publicação) > HTML), você verá que a
imagem é centralizada vertical e horizontalmente no Stage.
6. Edite o documento HTML gerado em um editor (como Dreamweaver ou Bloco de Notas)
e modifique o HTML padrão de acordo com o seguinte texto:
<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
codebase="http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/
swflash.cab#version=8,0,0,0" width="550" height="400"
id="urlvariables" align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="urlvariables.swf" />
<param name="FlashVars" value="imgURL=http://www.helpexamples.com/flash/
images/image2.jpg">
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="urlvariables.swf" quality="high" FlashVars="imgURL=http://
www.helpexamples.com/flash/images/image2.jpg" bgcolor="#ffffff"
width="550" height="400" name="urlvariables" align="middle"
allowScriptAccess="sameDomain" type="application/x-shockwave-flash"
pluginspage="http://www.macromedia.com/go/getflashplayer" />
</object>

7. Teste o documento HTML para ver as alterações. Uma imagem especificada no código
HTML é exibida no arquivo SWF.
Para modificar esse exemplo e usar suas próprias imagens, altere o valor de FlashVars (a
seqüência de caracteres entre aspas).

Sobre variáveis 113


Organizando dados em objetos
Você já deve estar familiarizado com os objetos que coloca no Stage. Por exemplo, pode existir
um objeto MovieClip no Stage, o qual contém outros clipes de filme. Os campos de texto, os
clipes de filme e os botões são geralmente chamados objetos quando colocados no Stage.
No ActionScript, os objetos são coleções de propriedades e métodos. Cada objeto tem seu
próprio nome e é uma instância de determinada classe. Os objetos internos pertencem a
classes predefinidas no ActionScript. Por exemplo, a classe interna Date fornece informações
do relógio do sistema no computador do usuário. A classe interna LoadVars pode ser usada
para carregar variáveis em um arquivo SWF.
Também é possível criar objetos e classes com o ActionScript. Você pode criar um objeto para
armazenar uma coleção de dados, como o nome, o endereço e o telefone de uma pessoa.
Também pode criar um objeto para armazenar informações sobre as cores de uma imagem. A
organização de dados em objetos pode ajudar a manter seus documentos do Flash mais
organizados. Para obter informações gerais sobre como criar uma classe personalizada para
armazenar uma coleção de métodos e propriedades, consulte “Criando arquivos de classes
personalizados” na página 249. Para obter informações detalhadas sobre classes internas e
personalizadas, consulte o Capítulo 7, “Classes”, na página 239.
Há várias maneiras de criar um objeto no ActionScript. O próximo exemplo cria objetos
simples de duas maneiras diferentes e, em seguida, executa um loop no conteúdo desses
objetos.

Para criar objetos simples no Flash:


1. Crie um novo documento do Flash e salve-o como simpleObjects.fla.
2. Selecione o Frame 1 da Timeline e digite o seguinte ActionScript no painel Actions:
// O primeiro método
var firstObj:Object = new Object();
firstObj.firstVar = "hello world";
firstObj.secondVar = 28;
firstObj.thirdVar = new Date(1980, 0, 1); // 1º de janeiro de 1980

Esse código, que é um dos métodos usados para criar um objeto simples, cria uma nova
instância do objeto e define algumas propriedades dele.
3. Agora digite o seguinte ActionScript após o código inserido na etapa 2.
// O segundo método
var secondObj:Object = {firstVar:"hello world", secondVar:28,
thirdVar:new Date(1980, 0, 1)};

114 Dados e tipos de dados


Este é outro método para criar um objeto. Os dois objetos são equivalentes. O código
acima cria um novo objeto e inicializa algumas propriedades usando a notação abreviada
do objeto.
4. Para executar um loop em cada um dos objetos anteriores e exibir o seu conteúdo, adicione
o seguinte ActionScript ao Frame 1 da Timeline (após o código já inserido):
var i:String;
for (i in firstObj) {
trace(i + ": " + firstObj[i]);
}
5. Selecione Control > Test Movie e o seguinte texto será exibido no painel Output:
firstVar: hello world
secondVar: 28
thirdVar: Tue Jan 1 00:00:00 GMT-0800 1980

Você também pode usar arrays para criar objetos. Em vez de ter uma série de variáveis como
firstname1, firstname2 e firstname3 para representar uma coleção de variáveis, é possível
criar um array de objetos para representar os mesmos dados. Essa técnica é demonstrada a
seguir.

Para usar um array para criar um objeto:


1. Crie um novo documento do Flash e salve-o como arrayObject.fla.
2. Selecione o Frame 1 da Timeline e digite o seguinte ActionScript no painel Actions:
var usersArr:Array = new Array();
usersArr.push({firstname:"George"});
usersArr.push({firstname:"John"});
usersArr.push({firstname:"Thomas"});

A vantagem de organizar variáveis em arrays e objetos é que é muito mais fácil executar um
loop nas variáveis e ver os valores, como mostra a etapa a seguir.
3. Digite o seguinte código após o ActionScript adicionado na etapa 2.
var i:Number;
for (i = 0; i < usersArr.length; i++) {
trace(usersArr[i].firstname); // George, John, Thomas
}

4. Selecione Control > Test Movie e o seguinte texto será exibido no painel Output:
George
John
Thomas

Organizando dados em objetos 115


O exemplo a seguir representa outro loop executado em objetos. Neste exemplo, é criado um
objeto e um loop é executado nele com for..in, e cada propriedade é exibida no painel
Output:
var myObj:Object = {var1:"One", var2:"Two", var3:18, var4:1987};
var i:String;
for (i in myObj) {
trace(i + ": " + myObj[i]);
}
//gera a seguinte saída:
/*
var1: One
var2: Two
var3: 18
var4: 1987
*/

Para obter informações sobre como criar loops, consulte o Capítulo 5, “Usando os loops for”,
na página 166. Para obter informações sobre loops for...in, consulte “Usando os loops for..in”
na página 167. Para obter mais informações sobre objetos, consulte o Capítulo 7, “Classes”,
na página 239.

Sobre a conversão
O ActionScript 2.0 permite que você converta um tipo de dados em outro. A conversão de
um objeto em um tipo diferente consiste em converter o valor armazenado no objeto ou na
variável em outro tipo.
Os resultados da conversão de tipos variam de acordo com os tipos de dados envolvidos. Para
converter um objeto em um tipo diferente, coloque o nome do objeto entre parênteses (()) e
preceda-o com o nome do novo tipo. Por exemplo, o código a seguir converte um valor
booleano em um inteiro.
var myBoolean:Boolean = true;
var myNumber:Number = Number(myBoolean);

Para obter mais informações sobre a conversão, consulte os seguintes tópicos:


■ “Sobre a conversão de objetos” na página 117

116 Dados e tipos de dados


Sobre a conversão de objetos
A sintaxe usada na conversão é type(item), onde você deseja que o compilador se comporte
como se o tipo de dados do item fosse type. A conversão é basicamente uma chamada de
função, que retornará null se a conversão falhar durante a execução (isso ocorre nos arquivos
publicados no Flash Player 7 ou versões posteriores; os arquivos publicados no Flash Player 6
não oferecem suporte a falhas de conversão durante a execução). Se a conversão for bem
sucedida, o retorno da chamada de função será o objeto original. Entretanto, o compilador
não é capaz de determinar se uma conversão falhará durante a execução e não gerará erros
durante a compilação nesses casos.
O código a seguir mostra um exemplo:
// Both the Cat and Dog classes are subclasses of the Animal class
function bark(myAnimal:Animal) {
var foo:Dog = Dog(myAnimal);
foo.bark();
}
var curAnimal:Animal = new Dog();
bark(curAnimal); // Funcionará
curAnimal = new Cat();
bark(curAnimal); // Não funcionará

Nesse exemplo, você declarou ao compilador que foo é um objeto Dog e, portanto, o
compilador pressupõe que foo.bark(); é uma instrução legal. Entretanto, o compilador não
sabe que a conversão falhará (ou seja, que você tentou converter um objeto Cat em um tipo
Animal), portanto, nenhum erro ocorrerá durante a compilação. Entretanto, se você incluir
uma verificação no script para garantir que a conversão tenha êxito, poderão ocorrer erros
durante a execução, como mostra este exemplo.
function bark(myAnimal:Animal) {
var foo:Dog = Dog(myAnimal);
if (foo) {
foo.bark();
}
}

Você pode converter uma expressão em uma interface. Se a expressão for um objeto que
implemente a interface ou tenha uma classe base que implemente a interface, a conversão terá
êxito. Caso contrário, ela falhará.
N O TA

A conversão em null ou undefined retornará undefined.

Sobre a conversão 117


Não é possível substituir tipos de dados primitivos que têm uma função de conversão global
correspondente por um operador de conversão de mesmo nome. Isso ocorre porque as funções
de conversão globais têm precedência sobre os operadores de conversão. Por exemplo, não é
possível converter em Array porque a função de conversão Array() tem precedência sobre o
operador de conversão.
Esse exemplo define duas variáveis de seqüência de caracteres (firstNum e secondNum), que
são adicionadas juntas. O resultado inicial é que os números são concatenados em vez de
serem adicionados, pois são do tipo de dados String. A segunda instrução trace converte os
dois números no tipo de dados Number antes de executar a adição que gera o resultado
adequado. A conversão de dados é importante ao trabalhar com dados carregados por meio de
XML ou FlashVars, como mostra o seguinte exemplo:
var firstNum:String = "17";
var secondNum:String = "29";
trace(firstNum + secondNum); // 1729
trace(Number(firstNum) + Number(secondNum)); // 46

Para obter mais informações sobre as funções de conversão de dados, consulte a entrada de
cada função de conversão em ActionScript 2.0 Language Reference: %{função Array}%,
%{função Boolean}%, %{função Number}%, %{função Object}% e %{função String}%.

118 Dados e tipos de dados


CAPÍTULO 5

Fundamentos da sintaxe e da
linguagem
5
A função da sintaxe e das instruções do ActionScript é semelhante à função das palavras nas
frases, que podem ser agrupadas para formar os parágrafos. O ActionScript pode ser tão
simples quanto isso. Por exemplo, na língua portuguesa, um ponto encerra uma frase. No
ActionScript, um ponto-e-vírgula encerra uma instrução. Na linguagem ActionScript, é
possível digitar uma ação stop() para interromper o loop da reprodução de uma instância de
clipe de filme ou de um arquivo SWF. É possível também escrever milhares de linhas de
código para potencializar uma aplicação bancária interativa. Como você pode ver, o
ActionScript pode realizar tarefas muito simples ou tarefas muito complexas.
O Capítulo 4, “Dados e tipos de dados,” explicou como a linguagem ActionScript usa os
dados e como é possível formatá-los no código. Este capítulo demonstrará como formar as
instruções no ActionScript usando a sintaxe. Ele contém pequenos trechos de código e alguns
exemplos para demonstrar os conceitos fundamentais da linguagem. Os próximos capítulos
apresentarão exemplos de código mais longos e cada vez mais complexos que complementarão
e facilitarão os fundamentos aprendidos neste capítulo.
As regras gerais descritas nesta seção aplicam-se a toda a linguagem ActionScript. A maioria
dos termos do ActionScript também tem requisitos individuais. Para obter as regras de um
termo específico, consulte a entrada correspondente em ActionScript 2.0 Language Reference
(Referência à linguagem ActionScript 2.0.
Aplicar os princípios básicos do ActionScript para criar programas sofisticados pode ser
desafiador para usuários novatos no ActionScript. Para obter mais informações sobre como
aplicar as regras descritas nesta seção, consulte Capítulo 19, “Melhores práticas e convenções
de codificação para ActionScript 2.0”, na página 767.
NO TA

Neste capítulo, você adicionará o ActionScript diretamente a um quadro da Timeline


(Linha de tempo). Nos capítulos posteriores, você usará as classes para separar o
ActionScript do arquivo FLA.

119
Para obter mais informações sobre como trabalhar com os fundamentos da sintaxe e da
linguagem do ActionScript, consulte os seguintes tópicos:
Sobre sintaxe, instruções e expressões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Sobre sintaxe de ponto e caminhos de destino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Sobre pontuadores de linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Sobre constantes e palavras-chave. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Sobre instruções. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Sobre arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Sobre operadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

Sobre sintaxe, instruções e expressões


A linguagem ActionScript é composta de classes internas. É necessário usar a sintaxe correta do
ActionScript para formar as instruções, a fim de que o código seja compilado e executado
corretamente no Flash. Nesse caso, a sintaxe seria a gramática e a ortografia de uma linguagem
de programação. O compilador não poderá compreender uma sintaxe incorreta e exibirá erros
ou avisos no painel Output (Saída) quando você tentar utilizar o documento no ambiente de
teste. Portanto, a sintaxe é um conjunto de regras e diretrizes que ajudam a compor a
linguagem ActionScript corretamente.
Uma instrução é uma diretriz fornecida ao arquivo FLA para fazer algo; por exemplo, executar
uma ação específica. Você pode, por exemplo, utilizar uma instrução condicional para
determinar se algo é verdadeiro ou existe. Em seguida, poderá executar ações especificadas,
como funções ou expressões, de acordo com o status da condição, se verdadeira ou não. A
instrução if é condicional e avalia uma condição para determinar a próxima ação a ser
executada no código.
// if statement
if (condition) {
// statements;
}

Para obter mais informações sobre as instruções, consulte “Sobre instruções” na página 149.
As expressões, diferentes das instruções, são combinações legais de símbolos do ActionScript
que representam um valor. As expressões têm valores, enquanto os valores e as propriedades
têm tipos. Uma expressão pode ser composta por operadores, operandos, valores, funções e
procedimentos. A expressão segue as regras de precedência e associação do ActionScript.
Geralmente, o Flash Player interpreta a expressão e retorna um valor que pode ser utilizado no
aplicativo.

120 Fundamentos da sintaxe e da linguagem


Por exemplo, o código a seguir é uma expressão:
x + 2

Na expressão anterior, x e 2 são operandos e + é um operador. Para obter mais informações


sobre os operadores e operandos, consulte “Sobre operadores” na página 185. Para obter mais
informações sobre os objetos e as propriedades, consulte “Tipo de dados Object”
na página 83.
A maneira como a linguagem ActionScript é formatada também determina até que ponto será
possível fazer a manutenção do código. Por exemplo, é difícil entender a lógica de um arquivo
FLA que não contenha recuos ou comentários, ou que tenha convenções de formatação e
nomeação inconsistentes. Quando você recua blocos do ActionScript (como loops e
instruções if ), a leitura e a depuração do código tornam-se mais fáceis caso ocorra algum
problema. Para obter mais informações sobre como formatar o ActionScript, consulte
“Formatando a sintaxe do ActionScript” na página 799. Você encontrará também a
formatação correta do ActionScript nessas seções.
Para obter mais informações sobre os fundamentos da sintaxe e da linguagem, consulte os
seguintes tópicos:
■ “Diferenças entre o ActionScript e o JavaScript”
■ “Sobre distinção entre maiúsculas e minúsculas”

Diferenças entre o ActionScript e o JavaScript


O ActionScript é semelhante à linguagem de programação JavaScript básica. Não é preciso
conhecer o JavaScript para utilizara o ActionScript. No entanto, se você conhecê-lo, o
ActionScript lhe parecerá familiar.
Este manual não tem como objetivo ensinar programação. Há vários recursos que fornecem
mais informações sobre os conceitos gerais de programação e sobre a linguagem JavaScript.
■ A especificação de linguagem ECMAScript (ECMA-262) Edition 3 deriva-se do
JavaScript e serve como padrão internacional para a linguagem JavaScript. O ActionScript
também baseia-se nessa especificação. Para obter mais informações, consulte www.ecma-
international.org/publications/standards/Ecma-262.htm.
■ O site da tecnologia Java contém tutoriais sobre a programação orientada a objetos (http:/
/java.sun.com/docs/books/tutorial/java/index.html) que destinam-se à linguagem Java,
mas são úteis para compreendermos os conceitos aplicados ao ActionScript.
Algumas diferenças entre o ActionScript e o JavaScript são descritos na lista a seguir:
■ O ActionScript não oferece suporte a objetos específicos de navegadores, como
Document, Window e Anchor.

Sobre sintaxe, instruções e expressões 121


■ O ActionScript não oferece suporte completo a todos os objetos internos do JavaScript.
■ O ActionScript não oferece suporte a algumas construções sintáticas do JavaScript, como
rótulos de instrução.
■ No ActionScript, a função eval() pode executar somente referências a variáveis.
■ O ActionScript 2.0 oferece suporte a vários recursos que não constam na especificação
ECMA-262, como as classes e a atribuição forte de tipos de dados. Muitos desses recursos
são modelados após a especificação de linguagem ECMAScript (ECMA-262) Edition 3
(consulte www.ecma-international.org/publications/standards/Ecma-262.htm).
■ O ActionScript não oferece suporte a expressões regulares que usam o objeto RegExp. No
entanto, a Macromedia Central não oferece suporte ao objeto RegExp. Para obter mais
informações sobre a Macromedia Central, consulte www.macromedia.com/software/
central.

Sobre distinção entre maiúsculas e minúsculas


Quando você escreve usando a linguagem ActionScript para Flash Player 7 e posterior, o
código faz distinção entre maiúsculas e minúsculas. Isso significa que as variáveis com uso de
maiúsculas e minúsculas um pouco diferente não são consideradas idênticas. O código do
ActionScript a seguir mostra isso:
// use mixed capitalization
var firstName:String = "Jimmy";
// use all lower case
trace(firstname); // undefined

Uma outra alternativa seria escrever o código da seguinte maneira:


// In file targeting Flash Player 8
// and either ActionScript 1.0 or ActionScript 2.0
//
// Sets properties of two different objects
cat.hilite = true;
CAT.hilite = true;

// Creates three different variables


var myVar:Number = 10;
var myvar:Number = 10;
var mYvAr:Number = 10;
N O TA

Não é recomendável diferenciar as variáveis ou qualquer identificador pelo uso de


maiúsculas e minúsculas. Para obter mais informações sobre como atribuir nomes a
variáveis, consulte Capítulo 19, “Melhores práticas e convenções de codificação para
ActionScript 2.0”, na página 767.

122 Fundamentos da sintaxe e da linguagem


Quando você publica usando versões do Flash Player (Flash Player 6 e anterior), o Flash
rastreia a seqüência de caracteres Jimmy no painel Output (Saída). Como o Flash Player 7 e as
versões posteriores fazem distinção entre maiúsculas e minúsculas, firstName e firstname
são consideradas duas variáveis separadas (no ActionScript 1.0 ou ActionScript 2.0). Esse é
um conceito importante. Se você criou arquivos FLA para Flash Player 6 ou anterior com
maiúsculas e minúsculas não correspondentes nas variáveis, a funcionalidade e os arquivos
podem ser interrompidos durante a conversão do arquivo ou aplicativo que referencia uma
versão mais recente do Flash Player.
Portanto, recomenda-se ser coerente na escolha das convenções de maiúsculas e minúsculas,
como foi feito neste manual. Assim, também será mais fácil diferenciar as variáveis, as classes e
os nomes de função. Não use maiúsculas e minúsculas para diferenciar dois identificadores.
Altere a instância, a variável ou o nome da classe, e não apenas as maiúsculas ou minúsculas.
Para obter mais informações sobre as convenções de codificação, consulte Capítulo 19,
“Melhores práticas e convenções de codificação para ActionScript 2.0”, na página 767.
A distinção entre maiúsculas e minúsculas tem um grande impacto quando se está
trabalhando com um serviço da Web que usa suas próprias regras de nomeação de variáveis e
quando as variáveis são incluídas ao retornarem do servidor para o arquivo SWF. Por exemplo,
se você usar o serviço da Web ColdFusion, os nomes de propriedade em uma estrutura ou
objeto poderão ter todas as letras maiúsculas; por exemplo, FIRSTNAME. Os resultados podem
ser inesperados se você não utilizar os nomes exatamente como fornecidos no Flash.
N OT A

A distinção entre maiúsculas e minúsculas também afeta as variáveis externas


carregadas em um arquivo SWF (as variáveis carregadas com LoadVars.load(), por
exemplo).

A distinção entre maiúsculas e minúsculas é implementada para scripts externos, como os


arquivos de classe do ActionScript 2.0, os scripts importados através do comando #include e
os scripts de um arquivo FLA. Se você encontrar erros durante a execução e estiver exportando
para mais de uma versão do Flash Player, analise os arquivos de script externos e os scripts dos
arquivos FLA para confirmar se o uso de maiúsculas e minúsculas está consistente.
A distinção entre maiúsculas e minúsculas é implementada em cada arquivo SWF. Se um
aplicativo Flash Player 8 estrito (que faz distinção entre maiúsculas e minúsculas) chamar um
arquivo SWF do Flash Player 6 não estrito, o ActionScript executado no arquivo SWF do
Player 6 será não estrito. Por exemplo, se você usar loadMovie() para carregar um arquivo
SWF do Flash Player 6 em um arquivo SWF do Flash Player 8, o SWF da versão 6 continuará
não fazendo distinção entre maiúsculas e minúsculas, embora o da versão 8 seja considerado
um arquivo que faz distinção entre maiúsculas e minúsculas.

Sobre sintaxe, instruções e expressões 123


Quando a sinalização da sintaxe por cores for ativada, os elementos de linguagem escritos com
as maiúsculas ou minúsculas corretas ficarão azuis, por padrão. Para obter mais informações,
consulte “Sobre palavras reservadas” na página 147.

Sobre sintaxe de ponto e caminhos de


destino
No ActionScript, você usa o operador de ponto (.) (sintaxe de ponto) para acessar as
propriedades ou os métodos que pertencem a um objeto ou a uma instância do Stage (Palco).
Além disso, esse operador é utilizado para identificar o caminho de destino de uma instância
(como um clipe de filme), variável, função ou objeto.
Uma expressão com sintaxe de ponto começa com o nome do objeto ou clipe de filme seguido
de um ponto e termina com o elemento a ser especificado. As seções a seguir demonstram
como escrever expressões com sintaxe de ponto.
Para controlar um clipe de filme, arquivo SWF carregado ou botão, é necessário especificar
um caminho de destino. Os caminhos de destino são endereços hierárquicos de nomes de
instâncias de clipes de filme, variáveis e objetos em um arquivo SWF. Para especificar um
caminho de destino de um clipe de filme ou botão, você deve atribuir um nome de instância
ao clipe de filme ou botão. Para atribuir um nome a uma instância de clipe de filme, selecione
a instância e digite o nome da instância no Property inspector (Inspetor de propriedades).
Uma outra alternativa é especificar o nome da instância com o código, caso ela tenha sido
criada através do ActionScript. Você pode usar um caminho de destino para atribuir uma ação
a um clipe de filme ou para obter ou definir o valor de uma variável ou propriedade.
Para obter mais informações sobre como atribuir um nome de instância e usar a sintaxe de
ponto para referenciar uma instância, consulte os seguinte tópicos:
■ “Sobre uso da sintaxe de ponto para referenciar uma instância” na página 125.
■ “Sobre escopo e referência” na página 130
■ “Usando o botão Target Path” na página 131
■ “Sobre sintaxe de barra” na página 131
Para obter mais informações sobre os objetos e as propriedades, consulte “Tipo de dados
Object” na página 83.

124 Fundamentos da sintaxe e da linguagem


Sobre uso da sintaxe de ponto para referenciar uma
instância
Para escrever a linguagem ActionScript que controla uma instância (por exemplo, um clipe de
filme) ou manipula ativos em um arquivo SWF carregado, especifique o nome e o endereço
dessa instância no código. Isso é denominado caminho de destino. Para referenciar (ou
endereçar) objetos em um arquivo SWF, use a sintaxe de ponto (também denominada notação
de ponto). Por exemplo, é necessário referenciar uma instância de clipe de filme ou de botão
antes de aplicar uma ação a ela. A sintaxe de ponto ajuda a criar um caminho para a instância-
alvo. O caminho da instância-alvo é, algumas vezes, denominado caminho de destino.
Um arquivo FLA tem uma hierarquia específica. É possível criar instâncias no Stage (Palco) ou
usar o ActionScript. É possível, até mesmo, criar instâncias dentro de outras ou deixá-las
aninhadas em várias outras instâncias. Qualquer instância pode ser manipulada, contanto que
ela tenha um nome.
Para atribuir um nome às instâncias, use um nome de instância, que você pode especificar de
duas formas (conforme demonstrado abaixo):
■ Manualmente, selecionando uma instância e digitando um nome de instância no Property
inspector (Inspetor de propriedades) (quando uma instância estiver no Stage).
■ Dinamicamente, usando o ActionScript. Para criar uma instância, use o ActionScript.
Atribua um nome a ela ao criá-la.
Para atribuir um nome à instância no Property inspector, digite um nome na caixa de texto
Instance Name (Nome da instância).
Também é possível atribuir um nome de instância a um objeto criado com o ActionScript.
Isso pode ser muito simples, como mostra o código a seguir:
this.createEmptyMovieClip("pic_mc", this.getNextHighestDepth());
pic_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");

Esse código cria um novo clipe de filme e atribui a ele o nome de instância pic_mc. Em
seguida, você pode manipular a instância pic_mc usando o código, como acontece ao carregar
uma imagem nele, conforme demonstrou o código anterior.
Para obter mais informações sobre como trabalhar com o escopo, consulte “Sobre escopo e
referência” na página 130 e “Sobre variáveis e escopo” na página 101.

Sobre sintaxe de ponto e caminhos de destino 125


Referenciando uma instância
Para que uma instância funcione no arquivo SWF, é necessário referenciá-la e instruí-la a
executar alguma tarefa, atribuindo uma ação a ela ou alterando suas propriedades.
Geralmente, é preciso definir o local do arquivo SWF em que essa instância está (por exemplo,
em que linha de tempo ela está ou em que instância ela está aninhada), criando o caminho de
destino. Lembre-se que você recebeu várias instâncias nos nomes de instância do arquivo FLA
e, depois, adicionou código ao arquivo FLA que usa esses nomes de instância. Ao fazer isso,
você referencia essa instância e a instrui a fazer algo (por exemplo, mover a reprodução ou
abrir uma página da Web). Para obter mais informações sobre os objetos e as propriedades,
consulte “Tipo de dados Object” na página 83.

Para referenciar uma instância:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash).
2. Selecione File > Save As (Salvar como) e atribua o nome target.fla ao arquivo.
3. Use a ferramenta Oval para desenhar uma forma no Stage (Palco). Desenhe uma forma oval
de qualquer tamanho e cor.
4. Use a ferramenta Selection (Seleção) para selecionar a forma oval no Stage.
DICA

Lembre-se de selecionar o traço e preenchê-lo se necessário.

5. Selecione Modify (Modificar) > Convert to Symbol (Converter em símbolo), selecione a


opção Movie Clip (Clipe de filme) e clique em OK para criar o símbolo.
6. Selecione o clipe de filme no Stage e atribua a ele o nome de instância myClip no Property
inspector (Inspetor de propriedades).
7. Insira uma nova camada e renomeie-a como actions.
8. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da camada actions:
myClip._xscale = 50;

Essa linha de código referencia a instância myClip no Stage. O ActionScript dimensiona a


instância para a metade de sua largura original. Como o ActionScript está na mesma linha
de tempo que o símbolo de clipe de filme, é necessário referenciar a instância usando
somente o nome da instância. Se a instância estiver em outra linha de tempo ou aninhada
em outra instância, será necessário modificar o caminho de destino apropriadamente.

126 Fundamentos da sintaxe e da linguagem


Referenciando uma instância aninhada
Também é possível referenciar as instâncias aninhadas dentro de outras instâncias. Talvez você
queira colocar uma segunda instância de clipe de filme dentro da instância myClip no
exercício de “Referenciando uma instância” na página 126. Você também pode referenciar
essa instância aninhada usando o ActionScript. Antes de passar para o próximo exercício, é
necessário concluir o exercício de “Referenciando uma instância” na página 126 e seguir estas
etapas para referenciar uma instância aninhada.

Para referenciar uma instância aninhada:


1. Abra target.fla conforme indicado no procedimento sobre como referenciar uma instância
e renomeie-a como target2.fla.
2. Clique duas vezes na instância myClip no Stage (Palco).
3. Selecione a ferramenta Oval e desenhe a forma oval dentro da instância myClip.
4. Selecione a nova forma e, em seguida, selecione Modify (Modificar)> Convert to Symbol
(Converter em símbolo).
5. Selecione a opção Movie Clip (Clipe de filme) e clique em OK.
6. Selecione a nova instância e digite myOtherClip na caixa de texto Instance Name (Nome
da instância) no inspetor Properties (Inspetor de propriedades).
7. Clique em Scene 1 (Cena 1) na barra de edição para retornar à Timeline (Linha de tempo)
principal.
8. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da camada actions:
myClip.myOtherClip._xscale = 50;

Esse ActionScript redimensiona a instância myOtherClip para metade de sua largura


atual. Como o arquivo target.fla modificou a propriedade _xscale das instâncias myClip
e myOtherClip é um símbolo aninhado, observe que myOtherClip terá 25% da largura
original.
Se você trabalhar com clipes de filme aninhados que tenham suas próprias linhas de tempo,
manipule a reprodução na linha de tempo de uma instância aninhada usando um código
similar ao trecho a seguir:
myClip.nestedClip.gotoAndPlay(15);
myClip.someOtherClip.gotoAndStop("tweenIn");

Observe que o clipe manipulado (nestedClip, por exemplo) aparece imediatamente antes da
ação. Você observará essa tendência nas próximas seções.

Sobre sintaxe de ponto e caminhos de destino 127


Você não está limitado a acessar métodos e propriedades de instâncias predefinidos no Stage,
conforme demonstrado nos exemplos anteriores. Também é possível definir uma variável em
um clipe de filme, conforme visto no código a seguir, que define uma variável no clipe de
filme starClip:
starClip.speed = 1.1;
starClip.gravity = 0.8;

Se as variáveis de velocidade ou gravidade já existissem na instância de clipe de filme starClip,


os valores anteriores seriam substituídos assim que os novos valores fossem definidos. É
possível adicionar novas propriedades ao clipe de filme starClip, pois a classe MovieClip foi
definida com a palavra-chave dynamic. A palavra-chave dynamic especifica que os objetos
baseados na classe especificada (nesse caso, MovieClip) podem adicionar e acessar
propriedades dinâmicas durante a execução. Para obter mais informações sobre a instrução
dinâmica, consulte %{dynamic statement}% em ActionScript 2.0 Language Reference
(Referência à linguagem ActionScript 2.0).

Referenciando instâncias dinâmicas e conteúdo carregado


Também é possível criar um objeto usando o ActionScript e referenciá-lo posteriormente
usando um caminho de destino. Por exemplo, você pode usar o ActionScript a seguir para
criar um clipe de filme. Depois, poderá alterar a rotação desse clipe de filme usando o
ActionScript, conforme mostrado neste exemplo:

Para referenciar uma instância de clipe de filme criada dinamicamente:


1. Crie um novo documento do Flash e salve o arquivo como targetClip.fla.
2. Insira uma nova camada e renomeie-a como actions.
3. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da camada actions:
this.createEmptyMovieClip("rotateClip", this.getNextHighestDepth());
trace(rotateClip);
rotateClip._rotation = 50;

4. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento.
Você pode informar que criou um clipe de filme devido à instrução trace, mas não
conseguirá ver nada no Stage (Palco). Mesmo que tenha adicionado um código que crie
uma instância de clipe de filme, nada aparecerá no Stage, a menos que tenha adicionado
algo ao clipe. Por exemplo, você poderia carregar uma imagem no clipe de filme.
5. Retorne ao ambiente de criação e abra o painel Actions (Ações).
6. Digite o seguinte ActionScript após o código adicionado na etapa 3:
rotateClip.loadMovie("http://www.helpexamples.com/flash/images/
image1.jpg");

128 Fundamentos da sintaxe e da linguagem


Esse código carregará uma imagem no clipe de filme rotateClip criado junto com o
código. Você está referenciando a instância rotateClip com o ActionScript.
7. Selecione Control > Test Movie para testar o documento.
Agora, aparecerá uma imagem no Stage que pode ser girada 50º no sentido horário.
Também é possível referenciar ou identificar partes dos arquivos SWF carregados em um
arquivo SWF base.

Para identificar um arquivo SWF carregado:


■ Use _levelX, onde X é o número de nível especificado na função loadMovie() que
carregou o arquivo SWF.
Por exemplo, um arquivo SWF carregado no nível 99 possui o caminho de destino
_level99. No exemplo a seguir, um arquivo SWF é carregado no nível 99 e define sua
visibilidade para false:
//Load the SWF onto level 99.
loadMovieNum("contents.swf", 99);
//Set the visibility of level 99 to false.
loaderClip.onEnterFrame = function(){
_level99._visible = false;
};
DICA

É recomendável evitar o uso de níveis caso seja possível carregar um conteúdo nos
clipes de filme em profundidades diferentes. O método
MovieClip.getNextHighestDepth() permite criar dinamicamente novas instâncias de
clipe de filme no Stage sem que seja necessário verificar se já existe alguma
instância em uma profundidade específica.

Definindo variáveis através de um caminho


É possível definir variáveis para instâncias aninhadas dentro de outras instâncias. Por exemplo,
se você quiser definir uma variável para uma forma que esteja dentro de outra forma, use o
código a seguir. A instância submitBtn está dentro de formClip na linha de tempo principal:
this.formClip.submitBtn.mouseOver = true;

Para expressar um método ou propriedade de um objeto específico (como um clipe de filme


ou um campo de texto), use esse padrão. Por exemplo, a propriedade de um objeto seria
myClip._alpha = 50;

Sobre sintaxe de ponto e caminhos de destino 129


Sobre escopo e referência
Quando você aninha instâncias, o clipe de filme que aninha um segundo clipe de filme é
denominado pai da instância aninhada. A instância aninhada chama-se instância filha. O
Stage (Palco) e a Timeline (Linha de tempo) principais são basicamente um clipe de filme e
podem, portanto, serem referenciados como tal. Para obter mais informações sobre o escopo,
consulte “Sobre variáveis e escopo” na página 101.
É possível referenciar instâncias pai e linhas de tempo pai usando o ActionScript. Para
referenciar a linha de tempo atual, use a palavra-chave this. Por exemplo, ao referenciar um
clipe de filme chamado myClip que esteja na linha de tempo atual, use
this.myClip.

Se desejar, elimine a palavra-chave this e use apenas


myClip

Você poderia adicionar a palavra-chave this para fins de legibilidade e consistência. Para
obter mais informações sobre as práticas de codificação recomendadas, consulte Capítulo 19,
“Melhores práticas e convenções de codificação para ActionScript 2.0”, na página 767.
Caso rastreie o clipe de filme, _level0.myClip aparecerá no painel Output (Saída) para cada
trecho de código acima. No entanto, se o ActionScript estiver dentro do clipe de filme
myClip, mas a linha de tempo principal tiver que ser referenciada, referencie o pai do clipe de
filme (que é o Stage principal). Clique duas vezes em um clipe de filme e coloque o seguinte
ActionScript na linha de tempo do clipe de filme:
trace("me: " + this);
trace("my parent: " + this._parent);

Teste o arquivo SWF e a seguinte mensagem aparecerá no painel Output:


me: _level0.myClip
my parent: _level0

Isso significa que você referenciou a linha de tempo principal. Use parent para criar um
caminho relativo para um objeto. Por exemplo, se o clipe de filme dogClip estiver aninhado
dentro do clipe de filme de animação animalClip, a seguinte instrução da instância dogClip
instruirá animalClip a interromper a animação:
this._parent.stop();

Se você estiver familiarizado com o Flash e o ActionScript, provavelmente já observou pessoas


usando o escopo _root. O escopo _root geralmente se refere à linha de tempo principal do
documento atual do Flash. Evite usar o escopo _root, a não ser que seja absolutamente
necessário. Use caminhos de destino relativos, em vez de _root.

130 Fundamentos da sintaxe e da linguagem


Caso utilize _root no código, possivelmente ocorrerão erros se o arquivo SWF for carregado
em outro documento do Flash. Quando o arquivo SWF é carregado em outro arquivo SWF, o
escopo _root do arquivo carregado pode apontar para o escopo raiz no qual ele é carregado,
em vez de referenciar sua própria raiz, conforme o desejado. Isso pode gerar resultados
imprevisíveis ou interromper a funcionalidade.

Usando o botão Target Path


Às vezes, demora um pouco para descobrir um caminho de destino específico ou qual
caminho de destino é necessário para um determinado código. Se você referenciar uma
instância existente no Stage (Palco), poderá usar o botão Target Path (Caminho de destino)
para determinar qual deve ser o caminho dessa instância.

Para usar o botão Target Path:


1. Abra o painel Actions (Ações) (Window (Janela) > Actions) e clique no botão Insert Target
Path (Inserir caminho de destino). Os clipes de filme do documento atual aparecem em
uma caixa de diálogo.
2. Selecione uma das instâncias na lista da caixa de diálogo.
3. Clique em OK.
4. O caminho de destino da instância selecionada aparece no painel Script.

Sobre sintaxe de barra


A sintaxe de barra foi usada no Flash 3 e 4 para indicar o caminho de destino de um clipe de
filme ou de uma variável. Essa sintaxe é suportada pelo ActionScript 1.0 no Flash Player 7 e
versões anteriores, mas não é suportada no ActionScript 2.0 e Flash Player 7 ou 8.
O uso da sintaxe de barra não é recomendável, a menos que não haja outra opção. Ela é
necessária, por exemplo, quando é preciso criar um conteúdo destinado especificamente ao
Flash Player 4 ou Flash Lite 1.1 (e versões anteriores), no qual a sintaxe de barra deve ser
utilizada. Para obter mais informações sobre o Flash Lite, consulte a página de produtos do
Flash Lite.

Sobre sintaxe de ponto e caminhos de destino 131


Sobre pontuadores de linguagem
Existem diversos pontuadores de linguagem no Flash. Os tipos de pontuadores mais comuns
são ponto-e-vírgula, (;), dois-pontos (:), parênteses [()] e chaves ({}). Cada um desses
pontuadores têm um significado especial na linguagem Flash e ajuda a definir tipos de dados,
encerrar instruções ou estruturar o ActionScript. As seções a seguir explicam como usar os
pontuadores no código.
Para obter mais informações sobre os pontuadores de linguagem, consulte os seguintes
tópicos:
■ “Ponto-e-vírgula e dois-pontos” na página 132
■ “Chaves” na página 133
■ “Parênteses” na página 137
■ “Sobre literais” na página 138
■ “Sobre comentários” na página 139
Para obter mais informações sobre o operador de ponto (.) e os operadores de acesso de array
([]), consulte “Usando operadores de ponto e de acesso de array” na página 194. Para obter
informações sobre espaço em branco e formatação de código, consulte “Formatando a sintaxe
do ActionScript” na página 799.

Ponto-e-vírgula e dois-pontos
As instruções do ActionScript são encerradas com um ponto-e-vírgula (;), conforme
demonstrado nas duas linhas de código a seguir:
var myNum:Number = 50;
myClip._alpha = myNum;

É possível omitir o ponto-e-vírgula. Nesse caso, o compilador do ActionScript assumirá que


cada linha de código representa uma única instrução. No entanto, é recomendável usar o
ponto-e-vírgula ao criar scripts, pois ele melhora a legibilidade do código. Quando você clica
no botão Auto Format (Formatação automática) do painel Actions (Ações) ou da janela
Script, os ponto-e-vírgulas precedentes são anexados ao final da instrução, por padrão.
N OT A

O uso de um ponto-e-vírgula para encerrar uma instrução permite inserir mais de uma
instrução em uma única linha, mas isso geralmente dificulta a leitura do código.

Um outro local em que se usa o ponto-e-vírgula é nos loops for. Ele é utilizado para separar
parâmetros, conforme mostrado no exemplo a seguir. O exemplo se repete de 0 a 9 e exibe
cada número no painel Output (Saída):

132 Fundamentos da sintaxe e da linguagem


var i:Number;
for (i = 0; i < 10; i++) {
trace(i); // 0,1,...,9
}

Os dois-pontos (:) são utilizados no código para atribuir tipos de dados às variáveis. Para
atribuir a um item um tipo de dados específico, defina seu tipo usando a palavra-chave var e a
sintaxe pós-dois-pontos, como no exemplo a seguir:
// strict typing of variable or object
var myNum:Number = 7;
var myDate:Date = new Date();
// strict typing of parameters
function welcome(firstName:String, myAge:Number) {
}
// strict typing of parameter and return value
function square(num:Number):Number {
var squared:Number = num * num;
return squared;
}

É possível declarar o tipo de dados de objetos com base em classes internas (Button, Date,
MovieClip etc.) e em classes e interfaces criadas por você. No trecho a seguir, você criará um
novo objeto, do tipo personalizado Student:
var firstStudent:Student = new Student();

Também é possível especificar se os objetos são do tipo de dados Function ou Void. Para obter
mais informações sobre como atribuir tipos de dados, consulte Capítulo 4, “Dados e tipos de
dados”, na página 75.

Chaves
Agrupe os eventos, as definições de classe e as funções do ActionScript em blocos usando as
chaves ({}). Coloque a chave de abertura na mesma linha da declaração.
N OT A

Também é possível colocar a chave de abertura na linha após a declaração. As


convenções de codificação recomendam colocar a chave de abertura na mesma linha
para fins de consistência. Para obter informações sobre as chaves e convenções de
codificação, consulte Capítulo 19, “Melhores práticas e convenções de codificação para
ActionScript 2.0”, na página 767.

Delimite cada instrução entre chaves quando ela fizer parte de uma estrutura de controle
if..else ou for), mesmo que ela contenha somente uma instrução. Essa prática ajudará a
evitar erros no ActionScript quando você esquecer de adicionar chaves ao código. O exemplo
a seguir mostra um código escrito de modo insatisfatório:

Sobre pontuadores de linguagem 133


var numUsers:Number;
if (numUsers == 0)
trace("no users found.");

Embora esse código seja válido, ele é considerado insatisfatório porque não tem chaves
delimitando as instruções.
DICA

As chaves serão adicionadas a essa instrução se você clicar no botão Check Syntax
(Verificar sintaxe).

Nesse caso, se você adicionar uma segunda instrução após a instrução trace, a segunda
instrução será executada, quer a variável numUsers seja igual a 0 ou não, o que poderá gerar
resultados inesperados. Por isso, adicione as chaves para que a saída do código seja semelhante
à mostrada neste exemplo:
var numUsers:Number;
if (numUsers == 0) {
trace("no users found");
}

O exemplo a seguir cria um objeto ouvinte de eventos e uma instância MovieClipLoader.


var imgUrl:String = "http://www.helpexamples.com/flash/images/image1.jpg";
this.createEmptyMovieClip("img_mc", 100);
var mclListener:Object = new Object();
mclListener.onLoadStart = function() {
trace("starting");
};
mclListener.onLoadInit = function(target_mc:MovieClip):Void {
trace("success");
};
mclListener.onLoadError = function(target_mc:MovieClip):Void {
trace("failure");
};
var myClipl:MovieClipLoader = new MovieClipLoader();
myClipl.addListener(mclListener);
myClipl.loadClip(imgUrl, img_mc);

O exemplo a seguir exibe um arquivo de classe simples que pode ser utilizado para criar um
objeto Student. Para obter mais informações sobre os arquivos de classe, consulte Capítulo 7,
“Classes”, na página 239.

Para usar chaves em um arquivo do ActionScript:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione ActionScript File (Arquivo
do ActionScript).
2. Selecione File > Save As (Salvar como) e salve o novo documento como Student.as.

134 Fundamentos da sintaxe e da linguagem


3. Adicione o seguinte ActionScript ao arquivo AS:
// Student.as
class Student {
private var _id:String;
private var _firstName:String;
private var _middleName:String;
private var _lastName:String;

public function Student(id:String, firstName:String,


middleName:String, lastName:String) {
this._id = id;
this._firstName = firstName;
this._middleName = middleName;
this._lastName = lastName;
}
public function get firstName():String {
return this._firstName;
}
public function set firstName(value:String):Void {
this._firstName = value;
}
// ...
}

4. Salve o arquivo de classe.


5. Selecione File > New e clique em Flash Document (Documento do Flash) para criar um
novo arquivo FLA.
6. Salve o novo arquivo FLA como student_test.fla.
7. Digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
// student_test.fla
import Student;
var firstStudent:Student = new Student("cst94121", "John", "H.", "Doe");
trace(firstStudent.firstName); // John
firstStudent.firstName = "Craig";
trace(firstStudent.firstName); // Craig

8. Selecione File > Save (Salvar) para salvar as alterações efetuadas em student_test.fla.
9. Selecione Control (Controlar) > Test Movie (Testar filme) para testar os arquivos FLA e
AS.
O exemplo a seguir demonstra como as chaves são utilizadas nas funções.

Para usar chaves nas funções:


1. Selecione File > New e, em seguida, selecione Flash Document para criar um novo arquivo
FLA.

Sobre pontuadores de linguagem 135


2. Selecione File > Save As e atribua o nome checkform.fla ao arquivo.
3. Arraste uma instância do componente Label do painel Components (Componentes) para
o Stage (Palco).
4. Abra o Property inspector (Inspetor de propriedades) (Window (Janela) > Properties
(Propriedades) > Properties) e, com a instância de componente Label selecionada, digite o
nome de instância status_lbl na caixa de texto Instance Name (Nome da instância).
5. Digite 200 na caixa de texto W (width) (L (largura)) para redimensionar o componente
para 200 pixels de largura.
6. Arraste uma instância do componente TextInput para o Stage e atribua a ela o nome
firstName_ti.
7. Arraste uma instância do componente Button para o Stage e atribua a ela o nome
submit_button.
8. Selecione o Frame 1 da Timeline e adicione o seguinte ActionScript ao painel Actions
(Ações):
function checkForm():Boolean {
status_lbl.text = "";
if (firstName_ti.text.length == 0) {
status_lbl.text = "Please enter a first name.";
return false;
}
return true;
}
function clickListener(evt_obj:Object):Void {
var success:Boolean = checkForm();
};
submit_button.addEventListener("click", clickListener);

9. Selecione File > Save para salvar o documento do Flash.


10. Selecione Control > Test Movie para testar o código no ambiente de criação.
No arquivo SWF, uma mensagem de erro será exibida se você clicar na instância Button do
Stage e não tiver o texto no componente TextInput firstName_ti. Esse erro aparecerá no
componente Label e informará aos usuários que eles precisam digitar um nome.
O próximo exemplo que utiliza chaves mostra como criar e definir propriedades em um
objeto. Neste exemplo, as propriedades são definidas no objeto através da especificação dos
nomes de variáveis entre chaves ({}):
var myObject:Object = {id:"cst94121", firstName:"John", middleName:"H.",
lastName:"Doe"};
var i:String;
for (i in myObject) {
trace(i + ": " + myObject[i]);
}

136 Fundamentos da sintaxe e da linguagem


/*
id: cst94121
firstName: John
middleName: H.
lastName: Doe
*/

Também é possível usar chaves vazias como atalho de sintaxe para a função new Object().
Por exemplo, o código a seguir cria uma instância Object vazia:
var myObject:Object = {};
DICA

Lembre-se de que cada chave de abertura deve ter uma chave de fechamento.

Parênteses
Ao definir uma função no ActionScript, você coloca os parâmetros entre parênteses [()],
conforme mostrado nas linhas de código a seguir:
function myFunction(myName:String, myAge:Number, happy:Boolean):Void {
// Your code goes here.
}

Ao chamar uma função, você também coloca qualquer parâmetro transmitido para a função
entre parênteses, conforme mostrado no exemplo a seguir:
myFunction("Carl", 78, true);

É possível usar parênteses para substituir a ordem de precedência do ActionScript ou para


facilitar a leitura das instruções do ActionScript. Isso significa que é possível alterar a ordem
em que os valores são computados delimitando certos valores entre colchetes, conforme
mostra o exemplo a seguir:
var computedValue:Number = (circleClip._x + 20) * 0.8;

Devido à ordem de precedência, se você não utilizou os parênteses ou usou duas instruções
separadas, a multiplicação será computada primeiro, o que significa que a primeira operação
será 20 * 0.8. O resultado, 16, será adicionado ao valor atual de circleClip._x e, por fim,
atribuído à variável computedValue.
Se você não usar parênteses, deverá adicionar uma instrução para avaliar a expressão, conforme
mostrado no exemplo a seguir:
var tempValue:Number = circleClip._x + 20;
var computedValue:Number = tempValue * 0.8;

Assim com os colchetes e as chaves, é necessário verificar se o parêntese de abertura tem um


parêntese de fechamento.

Sobre pontuadores de linguagem 137


Sobre literais
Um literal é um valor que aparece diretamente no código. Os literais são valores de constante
(invariáveis) dos documentos do Flash. Como exemplos de literal, pode-se citar true, false,
0, 1, 52 ou, até mesmo, a seqüência de caracteres “foo”.

Os exemplos a seguir são literais:


17
"hello"
-3
9.4
null
undefined
true
false

Os literais também podem ser agrupados para formar literais compostos. Os literais de array
são delimitados por colchetes ([]) e usam a vírgula (,) para separar elementos de array. Um
literal de array pode ser usado para inicializar um array. Os exemplos a seguir mostram dois
arrays que são inicializados através de literais de array. É possível usar a instrução new e
transmitir o literal composto como um parâmetro para o construtor da classe Array, mas
também é possível atribuir valores de literal diretamente ao instanciar qualquer classe interna
do ActionScript.
// using new statement
var myStrings:Array = new Array("alpha", "beta", "gamma");
var myNums:Array = new Array(1, 2, 3, 5, 8);

// assigning literal directly


var myStrings:Array = ["alpha", "beta", "gamma"];
var myNums:Array = [1, 2, 3, 5, 8];

Os literais também podem ser usados para inicializar um objeto genérico. Um objeto genérico
é uma instância da classe Object. Os literais de objeto são delimitados por chaves ({}) e usam
a vírgula (,) para separar as propriedades de objeto. Cada propriedade é declarada com dois-
pontos (:), pontuador que separa o nome da propriedade do valor da propriedade.
É possível criar um objeto genérico usando a instrução new e transmitir o literal de objeto
como um parâmetro para o construtor da classe Object. Uma outra alternativa é atribuir o
literal de objeto diretamente à instância que está sendo declarada. O exemplo a seguir cria um
novo objeto genérico e o inicializa com três propriedades, propA, propB e propC, cada uma
delas com valores definidos para 1, 2 e 3, respectivamente.
// using new statement
var myObject:Object = new Object({propA:1, propB:2, propC:3});

// assigning literal directly


var myObject:Object = {propA:1, propB:2, propC:3};

138 Fundamentos da sintaxe e da linguagem


Não confunda um literal de seqüência de caracteres com um objeto String. No exemplo a
seguir, a primeira linha de código cria o literal de seqüência de caracteres firstStr e a
segunda linha de código cria o objeto String secondStr:
var firstStr:String = "foo"
var secondStr:String = new String("foo")

Use literais de seqüência de caracteres, a menos que seja estritamente necessário usar um
objeto String para obter melhor desempenho. Para obter mais informações sobre as seqüências
de caracteres, consulte “Sobre seqüências de caracteres e a classe String” na página 477.

Sobre comentários
Os comentários são uma forma de fazer anotações no código com descrições em inglês sem
formatação que não serão avaliadas pelo compilador. É possível usar comentários no código
para descrever o que o código está fazendo ou quais dados serão retornados ao documento. O
uso dos comentários pode ajudar você a lembrar decisões de codificação importantes e pode
ser útil para qualquer outra pessoa que leia o código. Os comentários devem explicar
claramente a intenção do código, e não apenas traduzi-lo. Se algo não estiver muito óbvio no
código, adicione comentários.
É altamente recomendável o uso de comentários para adicionar observações aos scripts. Os
comentários documentam as decisões tomadas em relação ao código, respondendo a
perguntas "como" e "por quê". Eles facilitam a compreensão do ActionScript. Por exemplo,
você pode descrever uma solução alternativa nos comentários. Assim, você ou outro
desenvolvedor poderá localizar facilmente seções de código para atualizar ou corrigir. Se o
problema for corrigido ou amenizado em uma versão futura do Flash ou Flash Player, será
possível aperfeiçoar o ActionScript removendo a solução alternativa.
Evite usar comentários desordenados. Um exemplo de comentário desordenado é uma linha
de sinais de igual (=) ou asteriscos (*) utilizada para criar um bloco ou uma separação em
torno dos comentários. Em vez disso, use espaços em branco para separar os comentários do
ActionScript. Se você formatar o ActionScript usando o botão Auto Format (Formatação
automática) do painel Actions (Ações) ou da Janela Script, o espaço em branco será removido.
Lembre-se de adicionar novamente o espaço em branco no código ou use linhas de
comentário únicas (//) para manter o espaçamento. Será mais fácil remover essas linhas depois
que você formatar o código do que tentar encontrar o espaço em branco.

Sobre pontuadores de linguagem 139


Antes de implantar o projeto, remova quaisquer comentários supérfluos do código, como
“define the x and y variables” (definir variáveis x e y) ou outros comentários óbvios para outros
desenvolvedores. Caso ache que há muitos comentários extras no ActionScript, considere se
não é necessário reescrever alguns códigos. Se for necessário incluir vários comentários sobre o
funcionamento do código, isso geralmente será um indício de que o ActionScript não é
sofisticado nem intuitivo.
Quando a sinalização da sintaxe por cores for ativada, os comentários aparecerão em cinza, por
padrão. O tamanho dos comentários não afeta o tamanho do arquivo exportado e eles não
precisam seguir as regras de palavras-chave ou sintaxe do ActionScript.
NO TA

O uso de comentários no ActionScript é mais importante quando o objetivo é treinar o


público-alvo. Adicione comentários ao código se você estiver criando aplicativos de
exemplo destinados a demonstrar o Flash ou se estiver escrevendo artigos ou tutoriais
sobre o ActionScript.

Comentários de linha única


Use comentários de linha única para adicionar um comentário a uma única linha de código.
Você poderia criar uma única linha de código ou adicionar uma breve descrição sobre a função
de uma parte de um código. Para indicar que uma linha ou parte de uma linha é um
comentário, anteceda o comentário com duas barras (//), conforme mostrado no código a
seguir:
// The following sets a local variable for age.
var myAge:Number = 26;

Os comentários de linha única são geralmente utilizados para explicar um pequeno trecho de
código. É possível usar comentários de linha única para fazer qualquer comentário breve que
caiba em uma linha. O exemplo a seguir inclui um comentário de linha única:
while (condition) {
// handle condition with statements
}

Comentários de várias linhas


Use comentários de várias linhas (também denominados comentários em bloco) para fazer
comentários que ocupem diversas linhas. Os desenvolvedores geralmente usam comentários
de várias linhas para descrever arquivos, estruturas de dados e métodos. Eles são geralmente
inseridos no início de um arquivo e antes ou dentro de um método.

140 Fundamentos da sintaxe e da linguagem


Para criar um bloco de comentário, coloque /* no início das linhas comentadas e */ no final
do bloco de comentário. Essa técnica permite criar comentários extensos sem adicionar // no
início de cada linha. O uso de // em diversas linhas seqüenciais pode acarretar alguns
problemas quando os comentários são modificados.
O formato de um comentário de várias linhas é o seguinte:
/*
O ActionScript a seguir inicializa variáveis utilizadas nos sistemas
principais e de submenus. As variáveis são usadas para controlar as
opções escolhidas.
*/
D IC A

Se você inserir os caracteres de comentário (/* e */) em linhas separadas no início e no


final do comentário, poderá comentá-las facilmente antecedendo-as com caracteres de
barras duplas (//) (por exemplo, ///* e //*/). Isso permitirá inserir e retirar o comentário do
código com rapidez e facilidade.

Ao inserir uma grande quantidade de scripts em um bloco de comentários (que significa


comentar uma parte do script), você poderá testar partes específicas de um script. Por exemplo,
quando o script a seguir é executado, a parte do código contida no bloco não é executada:
// The following code runs.
var x:Number = 15;
var y:Number = 20;

// The following code is commented out and will not run.


/*
// create new Date object
var myDate:Date = new Date();
var currentMonth:Number = myDate.getMonth();
// convert month number to month name
var monthName:String = calcMonth(currentMonth);
var year:Number = myDate.getFullYear();
var currentDate:Number = myDate.getDate();
*/

// The code below runs.


var namePrefix:String = "My name is";
var age:Number = 20;
DICA

Recomenda-se inserir uma linha em branco antes de um comentário em bloco.

Sobre pontuadores de linguagem 141


Comentários finais
Use o recurso de comentário final para adicionar um comentário à mesma linha do código.
Esses comentários aparecem na mesma linha do código do ActionScript. Os desenvolvedores
geralmente usam comentários finais para indicar o que uma variável contém ou para descrever
o valor retornado em uma linha do of ActionScript. Os comentários finais devem ter o
seguinte formato:
var myAge:Number = 26; // variable for my age
trace(myAge); // 26

Recue os comentários para a direita, a fim de que os leitores possam distinguí-los do código.
Tente manter os comentários alinhados, se possível, conforme mostrado no código a seguir.
var myAge:Number = 28; // my age
var myCountry:String = "Canada"; // my country
var myCoffee:String = "Hortons"; // my coffee preference

Se você usar a formatação automática (clique no botão Auto Format (Formatação automática)
no painel Actions (Ações), os comentários finais se moverão para a próxima linha. Adicione
esses comentários depois que formatar o código. Do contrário, será necessário modificar a
posição dos comentários após o uso do botão Auto Format.

Comentários dentro das classes


Use comentários nas classes e interfaces para documentá-las e ajudar os desenvolvedores a
compreender o conteúdo da classe. Recomenda-se iniciar todos os arquivos de classe com um
comentário que forneça o nome da classe, seu número de versão, a data e o copyright. Por
exemplo, você poderia documentar a classe com um comentário semelhante a este:
/**
Pelican, class
version 1.2
10/10/2005
copyright Macromedia, Inc.
*/

Use comentários em bloco para descrever arquivos, estruturas de dados e métodos. Eles são
geralmente inseridos no início de um arquivo e antes ou dentro de um método.
Há dois tipos de comentários em uma classe ou arquivo de interface comum: comentários de
documentação e comentários de implementação. Os comentários de documentação são
usados para descrever as especificações do código e não descrevem a implementação. Use os
comentários de documentação para descrever interfaces, classes, métodos e construtores. Os
comentários de implementação são usados para fazer comentários sobre o código ou sobre a
implementação de seções específicas do código.

142 Fundamentos da sintaxe e da linguagem


Inclua um comentário de documentação para cada classe, interface ou membro e coloque-o
diretamente antes da declaração. Se houver informações adicionais a serem documentadas que
não se ajustem aos comentários de documentação, use comentários de implementação (em
blocos de comentários ou em comentários de linha única). Os comentários de implementação
devem vir logo após a declaração.
Os dois tipos de comentários usam delimitadores um pouco diferentes. Os comentários de
documentação são delimitados por /** e */, enquanto os de implementação são delimitados
por /* e */.
DICA

Não inclua comentários que não estejam diretamente relacionados à classe que está
sendo lida. Por exemplo, não inclua comentários que descrevam o pacote
correspondente.

Também é possível usar comentários de linha única, comentários em bloco e comentários


finais nos arquivos de classe. Para obter mais informações sobre esses tipos de comentários,
consulte as seguintes seções:
■ “Comentários de linha única” na página 140
■ “Comentários de várias linhas” na página 140
■ “Comentários finais” na página 142

Sobre constantes e palavras-chave


As constantes e as palavras-chave são os componentes básicos da sintaxe do ActionScript. As
constantes são propriedades com um valor fixo que não podem ser alteradas. Portanto, elas são
valores que não se alteram em todo o aplicativo.
O Flash possui diversas constantes predefinidas, que podem ajudar a simplificar o
desenvolvimento de um aplicativo. A classe Key possui um exemplo de constantes. Além
disso, ela contém várias propriedades, como Key.ENTER ou Key.PGDN. Se você utilizar as
constantes, nunca precisará memorizar que os valores de código das teclas Enter e Page Down
são 13 e 34. Os valores de constante não facilitam apenas o desenvolvimento e a depuração,
mas também a leitura do código pelos outros desenvolvedores.
As palavras-chave no ActionScript são usadas para executar tipos específicos de ações. Por isso,
elas também são palavras reservadas, que não podem ser usadas como identificadores (como os
nomes de variável, função ou rótulo). Como exemplos de palavras reservadas, pode-se citar if,
else, this, function e return.

Sobre constantes e palavras-chave 143


Para obter mais informações sobre as constantes e palavras-chave, consulte os seguintes
tópicos:
■ “Usando constantes” na página 144
■ “Sobre palavras-chave” na página 146
■ “Sobre palavras reservadas” na página 147
Para obter mais informações sobre os objetos e as propriedades, consulte “Tipo de dados
Object” na página 83. Para obter uma lista das constantes da linguagem (como false e NaN),
consulte ActionScript Language Elements (Elementos da linguagem ActionScript) > categoria
Constants (Constantes) em ActionScript 2.0 Language Reference (Referência à linguagem
ActionScript 2.0).

Usando constantes
As constantes são propriedades com um valor fixo que não podem ser alteradas. Portanto, elas
são valores que não se alteram em todo o aplicativo. A linguagem ActionScript contém várias
constantes predefinidas. Por exemplo, as constantes BACKSPACE, ENTER, SPACE e TAB são
propriedades da classe Key e se referem às teclas do teclado. A constante Key.TAB sempre tem
o mesmo significado: ela indica a tecla Tab em um teclado. As constantes são úteis quando se
quer comparar valores e usar valores fixos no aplicativo.
Para testar se o usuário está pressionando a tecla Enter, use a seguinte instrução:
var keyListener:Object = new Object();
keyListener.onKeyDown = function() {
if (Key.getCode() == Key.ENTER) {
trace("Are you ready to play?");
}
};
Key.addListener(keyListener);

Para que o ActionScript anterior funcione, talvez seja necessário desativar os atalhos de teclado
no ambiente de criação. Selecione Control (Controlar) > Test Movie (Testar filme) no menu
principal. Depois, enquanto visualiza o arquivo SWF no player, selecione Control > Disable
Keyboard Shortcuts (Desativar atalhos de teclado) na janela de visualização do arquivo SWF.
No Flash, não há como criar seus próprios valores de constante, a não ser quando você cria
suas próprias classes personalizadas com variáveis de membro privadas. Não é possível criar
uma variável “somente leitura” no Flash.
As variáveis devem conter letras minúsculas ou letras minúsculas e maiúsculas. No entanto, as
constantes (variáveis que não se alteram) devem conter letras maiúsculas. Separe as palavras
com caracteres de sublinhado, conforme mostrado no ActionScript a seguir:

144 Fundamentos da sintaxe e da linguagem


var BASE_URL:String = "http://www.macromedia.com"; //constant
var MAX_WIDTH:Number = 10; //constant

Escreva as constantes estáticas em maiúsculas e separe as palavras com um sublinhado. Não


codifique diretamente constantes numéricas, a menos que a constante seja 1, 0 ou -1, que você
pode usar em um loop for como um valor de contador.
É possível usar constantes em situações nas quais é necessário fazer referência a uma
propriedade cujo valor nunca é alterado. Isso ajudará a detectar erros de digitação no código
que provavelmente não serão encontrados se você usar literais, além de permitir a alteração do
valor em um único local. Para obter mais informações sobre os literais, consulte “Sobre
literais” na página 138.
Por exemplo, a definição de classe no exemplo a seguir cria três constantes que seguem a
convenção de nomeação utilizada pelo ActionScript 2.0.

Para usar constantes em um aplicativo:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione ActionScript File (Arquivo
do ActionScript) para criar um arquivo AS.
2. Atribua o nome ConstExample.as ao novo arquivo.
3. Digite o seguinte código na janela Script:
class ConstExample {
public static var EXAMPLE_STATIC:String = "Global access";
public var EXAMPLE_PUBLIC:String = "Public access";
private var EXAMPLE_PRIVATE:String = "Class access";
}

A propriedade EXAMPLE_STATIC é estática, o que significa que ela se aplica à classe como
um todo, e não a uma determinada instância da classe. Você deve acessar a propriedade
estática de uma classe usando o nome da classe, e não o nome de uma instância. Não é
possível acessar uma propriedade estática através de uma instância de classe.
4. Crie um novo documento do Flash e salve-o como const.fla.
5. Abra o painel Actions (Ações) e digite o código a seguir no Frame 1 (Quadro 1) da Timeline
(Linha de tempo):
trace(ConstExample.EXAMPLE_STATIC); // output: Global access

Ao declarar a propriedade EXAMPLE_STATIC como estática, você usa esse código para
acessar o valor da propriedade.
6. Selecione Control > Test Movie para testar o documento.
Global access será exibido no painel Output (Saída).
7. No painel Actions, digite esse código após o código adicionado na etapa 5.

Sobre constantes e palavras-chave 145


trace(ConstExample.EXAMPLE_PUBLIC); // error
trace(ConstExample.EXAMPLE_PRIVATE); // error

8. Selecione Control > Test Movie para testar o documento.


As propriedades EXAMPLE_PUBLIC e EXAMPLE_PRIVATE não são estáticas. Quando você
tenta acessar os valores através da classe, recebe a seguinte mensagem de erro:
The property being referenced does not have the static attribute.

Para acessar uma propriedade não estática, acesse o valor através de uma instância da
classe. Como a propriedade EXAMPLE_PUBLIC é pública, ela está disponível para ser
codificada fora da definição da classe.
9. No painel Actions, exclua as instruções trace adicionadas nas etapas 5 e 7.
10. Insira o seguinte código no painel Actions:
var myExample:ConstExample = new ConstExample();
trace(myExample.EXAMPLE_PUBLIC); // output: Public access

Esse código cria a instância myExample e acessa a propriedade EXAMPLE_PUBLIC.


11. Selecione Control > Test Movie para testar o documento.
Public access será exibido no painel Output.
12. No painel Actions, exclua a instrução trace adicionada na etapa 10.
13. Insira o seguinte código no painel Actions:
trace(myExample.EXAMPLE_PRIVATE); // error

A propriedade EXAMPLE_PRIVATE é privada e, portanto, está disponível somente na


definição da classe.
14. Selecione Control > Test Movie para testar o documento.
A mensagem The member is private and cannot be accessed (O membro é privado
e não pode ser acessado) será exibida no painel Output.
Para obter mais informações sobre as classes internas e sobre como criar classes
personalizadas, consulte Capítulo 7, “Classes”, na página 239.

Sobre palavras-chave
As palavras-chave são palavras do ActionScript que têm uma função específica. Por exemplo,
use a palavra-chave var para declarar uma variável. A palavra-chave var é mostrada na linha
de código a seguir:
var myAge:Number = 26;

146 Fundamentos da sintaxe e da linguagem


Uma palavra-chave é uma palavra reservada que tem um significado específico: por exemplo,
use a palavra-chave class para definir uma nova classe do ActionScript e a palavra-chave var
para declarar variáveis locais. Estes são outros exemplos de palavras-chave reservadas: if, else,
this, function e return.

As palavras-chave não podem ser usadas como identificadores (como nomes de variável,
função ou rótulo) e você não deve usá-las em nenhum outro local dos arquivos FLA para
outros fins (como nomes de instância). Você já utilizou bastante a palavra-chave var,
principalmente se leu o Capítulo 4, “Dados e tipos de dados”, na página 75. O ActionScript
reserva palavras da linguagem para fins específicos. Portanto, não é possível usar palavras-
chave como identificadores (como nomes de variável, função ou rótulo). Essas palavras-chave
estão listadas em “Sobre palavras reservadas” na página 147.

Sobre palavras reservadas


As palavras reservadas são palavras que não podem ser utilizadas como identificadores no
código, pois elas estão reservadas para serem usadas pelo ActionScript. As palavras reservadas
são palavras-chave, que, por sua vez, são instruções e palavras do ActionScript reservadas para
uso futuro. Isso significa que você não deve usá-las para atribuir nomes a variáveis, instâncias,
classes personalizadas etc., pois isso pode acarretar problemas técnicos no seu trabalho.
A tabela a seguir lista as palavras-chave do Flash que ocasionam erros nos scripts:

add and break case


catch class continue default

delete do dynamic else

eq extends finally for


function ge get gt

if ifFrameLoaded implements import

in instanceof interface intrinsic

le lt ne new

not on onClipEvent or

private public return set


static switch tellTarget this

throw try typeof var

void while with

Sobre constantes e palavras-chave 147


A tabela a seguir lista palavras-chave que são reservadas para uso futuro no ActionScript ou
pela especificação preliminar ECMAScript (ECMA-262) Edition 4. Evite também usar estas
palavras-chave no código:

abstract enum export short

byte long synchronized char

debugger protected double volatile


float throws transient goto

Todos os nomes de classe interna, classe de componente e interface são palavras reservadas e
não devem ser usados como identificadores no código:

Accessibility Accordion Alert Array

Binding Boolean Button Camera

CellRenderer CheckBox Collection Color


ComboBox ComponentMixins ContextMenu ContextMenuItem

CustomActions CustomFormatter CustomValidator DataGrid

DataHolder DataProvider DataSet DataType

Date DateChooser DateField Delta

DeltaItem DeltaPacket DepthManager EndPoint

Error FocusManager Form Function


Iterator Key Label List

Loader LoadVars LocalConnection Log

Math Media Menu MenuBar


Microphone Mouse MovieClip MovieClipLoader

NetConnection NetStream Number NumericStepper

Object PendingCall PopUpManager PrintJob

ProgressBar RadioButton RDBMSResolver Screen

ScrollPane Selection SharedObject Slide

SOAPCall Sound Stage String

StyleManager System TextArea TextField

TextFormat TextInput TextSnapshot TransferObject

Tree TreeDataProvider TypedValue UIComponent

UIEventDispatcher UIObject Video WebService

148 Fundamentos da sintaxe e da linguagem


WebServiceConnector Window XML XMLConnector

XUpdateResolver

Diversas palavras, embora não sejam palavras reservadas, não devem ser usadas como
identificadores (como nomes de variável ou instância) no código do ActionScript. Essas
palavras são usadas pelas classes internas que compõem a linguagem ActionScript. Portanto,
não use nomes de propriedades, métodos, classes, interfaces, nomes de classe de componente e
valores como nomes no código (como acontece quando você atribui nomes a variáveis, classes
ou instâncias).
Para entender o que são esses nomes, consulte ActionScript 2.0 Language Reference (Referência
à linguagem ActionScript 2.0) e pesquise o painel Help (Ajuda) para obter instruções
adicionais e as seções de uso deste manual (Introdução ao ActionScript 2.0 no Flash).

Sobre instruções
Uma instrução é uma diretriz fornecida ao arquivo FLA para fazer algo; por exemplo, executar
uma ação específica. Você pode, por exemplo, utilizar uma instrução condicional para
determinar se algo é verdadeiro ou existe. Em seguida, o código poderá executar ações
especificadas, como funções ou expressões, de acordo com o status da condição, se verdadeira
ou não.
Por exemplo, a instrução if é condicional e avalia uma condição para determinar a próxima
ação a ser executada no código.
// if statement
if (condition) {
// statements;
}

Um outro exemplo é a instrução return, que retorna um resultado como valor da função em
que ela é executada.
Existem diversas maneiras de formatar ou escrever o ActionScript. A escrita do ActionScript
pode ser diferenciada através do modo como você forma a sintaxe; por exemplo, através da
maneira como você espaça as instruções ou do local em que insere as chaves ({}) no código.
Mesmo que haja diferentes formas de compor instruções sem interromper o código, existem
algumas diretrizes gerais que você pode seguir para escrever um ActionScript válido.
Coloque apenas uma instrução em uma linha para aumentar a legibilidade do
ActionScript. O exemplo a seguir mostra o uso recomendado e não recomendado das
instruções:

Sobre instruções 149


theNum++; // recommended
theOtherNum++; // recommended
aNum++; anOtherNum++; // not recommended

Atribua variáveis como instruções separadas. Considere o seguinte exemplo do


ActionScript:
var myNum:Number = (a = b + c) + d;

Esse ActionScript incorpora uma atribuição no código, o que dificulta a leitura. Se você
atribuir variáveis como instruções separadas, isso melhorará a legibilidade, como mostra o
exemplo a seguir:
var a:Number = b + c;
var myNum:Number = a + d;

As seções a seguir mostram como compor instruções específicas no ActionScript. Para obter
informações sobre como escrever e formatar eventos, consulte Capítulo 10, “Manipulando
eventos”, na página 347.
Para obter mais informações sobre cada instrução, consulte os seguintes tópicos:
■ “Sobre instruções compostas” na página 150
■ “Sobre condições” na página 151
■ “Repetindo ações através de loops” na página 162

Sobre instruções compostas


Uma instrução composta contém diversas instruções delimitadas por chaves ({}). As
instruções dentro de uma instrução composta podem ser qualquer tipo de instrução do
ActionScript. Uma instrução composta típica é mostrada a seguir.
As instruções dentro de chaves são recuadas na instrução composta, como mostra o
ActionScript a seguir:
var a:Number = 10;
var b:Number = 10;
if (a == b) {
// This code is indented.
trace("a == b");
trace(a);
trace(b);
}

Essa instrução composta contém várias instruções, mas atua como se fosse uma instrução
única no código do ActionScript. A chave de abertura é colocada no final da instrução
composta. A chave de fechamento começa com uma linha e se alinha ao início da instrução
composta.

150 Fundamentos da sintaxe e da linguagem


Para obter mais informações sobre como usar as chaves, consulte “Chaves” na página 133.

Sobre condições
Você usa as condições para determinar se algo é verdadeiro ou existe. Em seguida, se desejar,
pode repetir uma ação (usando loops) ou executar ações especificadas, como funções ou
expressões, com base no status da condição, se verdadeira ou não. Por exemplo, é possível
determinar se uma determinada variável é definida ou tem um valor específico e executar um
bloco de código com base no resultado. Além disso, é possível alterar os gráficos no
documento do Flash com base na hora do relógio do sistema do usuário ou nas condições
climáticas do local em que o usuário está no momento.
Para executar uma ação que dependa da existência de uma condição ou para repetir uma ação
(criar instruções de loop), use as instruções if, else, else if, for, while, do while,
for..in ou switch.

Para obter mais informações sobre quais condições você pode usar e sobre como escrevê-las,
consulte os seguintes tópicos:
■ “Sobre condições de escrita” na página 151
■ “Usando a instrução if ” na página 152
■ “Usando a instrução if..else” na página 153
■ “Usando a instrução if..else if ” na página 154
■ “Usando uma instrução switch” na página 156
■ “Usando as instruções try..catch e try..catch..finally” na página 158
■ “Sobre o operador condicional e a sintaxe alternativa” na página 160

Sobre condições de escrita


As instruções que verificam se uma condição é verdadeira ou falsa começam com o termo if.
Se a condição retornar true, o ActionScript executará a próxima instrução. Se a condição
retornar false, o ActionScript passará para a próxima instrução fora do bloco de código.
DICA

Para otimizar o desempenho do código, verifique as condições mais prováveis primeiro.

Sobre instruções 151


As instruções a seguir testam três condições. O termo else if especifica testes alternativos
que poderão ser executados se as condições anteriores forem falsas.
if ((passwordTxt.text.length == 0) || (emailTxt.text.length == 0)) {
gotoAndStop("invalidLogin");
} else if (passwordTxt.text == userID){
gotoAndPlay("startProgram");
}

Nesse trecho de código, se o tamanho dos campos de texto passwordTxt ou emailTxt for 0
(por exemplo, o usuário não digitou um valor), o documento do Flash será redirecionado para
o rótulo de quadro invalidLogin. Se os campos passwordTxt e emailTxt contiverem valores
e o conteúdo do campo de texto passwordTxt corresponder à variável userID, o arquivo SWF
será redirecionado para o rótulo de quadro startProgram.
Para procurar uma das diversas condições, use a instrução switch, em vez de várias instruções
else if. Para obter mais informações sobre as instruções switch, consulte “Usando uma
instrução switch” na página 156.
Consulte as seções a seguir para obter informações sobre como escrever diferentes tipos de
condições nos aplicativos ActionScript.

Usando a instrução if
Use a instrução if quando quiser executar uma série de instruções com base no status true de
uma determinada condição.
// if statement
if (condition) {
// statements;
}

Você terá diversas oportunidades de usar as instruções if enquanto estiver trabalhando em um


projeto do Flash. Por exemplo, se você estiver criando um site do Flash que exija que os
usuários façam login antes de acessar determinadas seções do site, use uma instrução if para
confirmar que o usuário digitará algum texto nos campos de nome de usuário e senha.
Caso seja necessário validar nomes de usuário e senhas usando um banco de dados externo,
provavelmente será preciso verificar se a combinação nome de usuário/senha utilizada por um
usuário corresponde a um registro no banco de dados. Também será necessário verificar se o
usuário tem permissão para acessar a parte especificada do site.
Se você criar scripts de animações no Flash, provavelmente usará a instrução if para testar se
uma instância no Stage (Palco) ainda está dentro dos limites do Stage. Por exemplo, se uma
bola se mover para baixo no eixo y, provavelmente será necessário detectar quando a bola
colidirá com a borda final do Stage, para que seja possível alterar a direção e a bola possa subir.

152 Fundamentos da sintaxe e da linguagem


Para usar uma instrução if:
1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash).
2. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte
ActionScript no painel Actions (Ações):
// create a string to hold AM and PM
var amPm:String = "AM";
// no parameters pass to Date, so returns current date/time
var current_date:Date = new Date();
// if current hour is greater than/equal to 12, sets amPm string to "PM".
if (current_date.getHours() >= 12) {
amPm = "PM";
}
trace(amPm);

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript.
Nesse código, você cria uma seqüência de caracteres que exibirá AM ou PM com base na
hora do dia. Se a hora atual for maior ou igual a 12, a seqüência de caracteres amPM será
definida para PM. Por fim, você rastreia a seqüência de caracteres amPm e, se a hora for
maior ou igual a 12, a sigla PM será exibida. Do contrário, a sigla AM será exibida.

Usando a instrução if..else


A instrução condicional if..else permitirá testar uma condição e, em seguida, executar um
bloco de código se a condição existir ou executar um bloco de código alternativo se a condição
não existir.
Por exemplo, o código a seguir testa se o valor x é maior que 20, gera uma instrução trace()
se o valor for maior que 20 ou gera uma instrução trace() diferente se valor não for maior
que 20:
if (x > 20) {
trace("x is > 20");
} else {
trace("x is <= 20");
}

Para executar um bloco de código alternativo, use a instrução if sem a instrução else.

Sobre instruções 153


A instrução if..else do Flash é semelhante à instrução if. Por exemplo, se você usar a
instrução if para confirmar se o nome de usuário e a senha fornecidos por um usuário
corresponde a um valor armazenado em um banco de dados, provavelmente será necessário
redirecionar o usuário com base na validade do nome de usuário e da senha. Se o login for
válido, redirecione o usuário para uma página de boas-vindas usando o bloco if. No entanto,
se o login for válido, redirecione o usuário para o formulário de login e exiba uma mensagem
de erro usando o bloco else.

Para usar a instrução if..else em um documento:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash) para criar um novo arquivo FLA.
2. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte
ActionScript no painel Actions (Ações):
// create a string that holds AM/PM based on the time of day.
var amPm:String;
// no parameters pass to Date, so returns current date/time.
var current_date:Date = new Date();
// if current hour is greater than/equal to 12, sets amPm string to "PM".
if (current_date.getHours() >= 12) {
amPm = "PM";
} else {
amPm = "AM";
}
trace(amPm);

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript.
Nesse código, você cria uma seqüência de caracteres que retém a sigla AM ou PM de acordo
com a hora do dia. Se a hora atual for maior ou igual a 12, a seqüência de caracteres amPM
será definida para PM. Por fim, você rastreia a seqüência de caracteres amPm e, se a hora for
maior ou igual a 12, a sigla PM será exibida. Do contrário, você verá a sigla AM no painel
Output (Saída).

Usando a instrução if..else if


É possível testar mais de uma condição usando a instrução condicional if..else if. A
seguinte sintaxe é utilizada em uma instrução if..else if:
// else-if statement
if (condition) {
// statements;
} else if (condition) {
// statements;
} else {

154 Fundamentos da sintaxe e da linguagem


// statements;
}

Um bloco if..else if é utilizado nos projetos do Flash quando é necessário verificar uma
série de condições. Por exemplo, se você quiser exibir uma imagem diferente na tela com base
na hora do dia em que o usuário está acessando, crie uma série de instruções if que
determinarão se é de manhã cedo, de tarde, início da noite ou final da noite. Em seguida,
exiba um gráfico apropriado.
O código a seguir não somente testa se o valor x é maior que 20, mas também se o valor x é
negativo:
if (x > 20) {
trace("x is > 20");
} else if (x < 0) {
trace("x is negative");
}

Para usar uma instrução if..else if em um documento:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash).
2. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte
ActionScript no painel Actions (Ações):
var now_date:Date = new Date();
var currentHour:Number = now_date.getHours();
// if the current hour is less than 11AM...
if (currentHour < 11) {
trace("Good morning");
// else..if the current hour is less than 3PM...
} else if (currentHour < 15) {
trace("Good afternoon");
// else..if the current hour is less than 8PM...
} else if (currentHour < 20) {
trace("Good evening");
// else the current hour is between 8PM and 11:59PM
} else {
trace("Good night");
}

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript.
Nesse código, você cria uma seqüência de caracteres chamada currentHour que retém o
número da hora atual (por exemplo, se a hora for 18:19, currentHour reterá o número
18). Use o método getHours() da classe Date para obter a hora atual. Em seguida, use a
instrução if..else if para rastrear informações no painel Output (Saída), com base no
número retornado. Para obter mais informações, consulte os comentários no trecho de
código anterior.

Sobre instruções 155


Usando uma instrução switch
A instrução switch cria uma estrutura ramificada para as instruções do ActionScript. Assim
como a instrução if, a instrução switch testará uma condição e executará instruções se a
condição retornar um valor true.
Quando a instrução switch é utilizada, a instrução break solicita ao Flash que ignore o
restante das instruções do bloco case e passe para a primeira instrução após a instrução switch
delimitada. Se um bloco case não contiver uma instrução break, uma condição chamada “fall
through” será emitida. Nesse caso, a instrução case a seguir também será executada até que
uma instrução break seja encontrada ou que a instrução switch seja encerrada. Esse
comportamento é demonstrado no exemplo a seguir, onde a primeira instrução case não
contém uma instrução break e, portanto, os dois blocos de códigos dos dois primeiros casos (A
e B) são executados.
Todas as instruções switch devem incluir um caso default. O caso default deve sempre ser
o último em uma instrução switch e incluir uma instrução break para impedir que um erro
de anulação ocorra se outro caso for adicionado. Por exemplo, se a condição do exemplo a
seguir retornar A, as duas instruções dos casos A e B serão executadas, pois o caso A não possui
uma instrução break. Quando um caso é anulado, ele não possui uma instrução break, mas
inclui um comentário no local da instrução break (consulte o exemplo a seguir após o caso
A). Use o seguinte formato ao escrever instruções switch:
switch (condition) {
case A :
// statements
// falls through
case B :
// statements
break;
case Z :
// statements
break;
default :
// statements
break;
}

Para usar uma instrução switch em um documento:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash).

156 Fundamentos da sintaxe e da linguagem


2. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte
ActionScript no painel Actions (Ações):
var listenerObj:Object = new Object();
listenerObj.onKeyDown = function() {
// Use the String.fromCharCode() method to return a string.
switch (String.fromCharCode(Key.getAscii())) {
case "A" :
trace("you pressed A");
break;
case "a" :
trace("you pressed a");
break;
case "E" :
case "e" :
/* E doesn't have a break statement, so this block executes if you
press e or E. */
trace("you pressed E or e");
break;
case "I" :
case "i" :
trace("you pressed I or i");
break;
default :
/* If the key pressed isn’t caught by any of the above cases,
execute the default case here. */
trace("you pressed some other key");
}
};
Key.addListener(listenerObj);

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript.
Digite letras usando o teclado, incluindo as teclas a, e ou i. Ao digitar essas três teclas, você
verá as instruções trace no ActionScript anterior. A linha de código cria um novo objeto
que será utilizado como ouvinte da classe Key. Use esse objeto para informar ao evento
onKeyDown() que o usuário pressionou uma tecla. O método Key.getAscii() retorna o
código ASCII da última tecla que o usuário pressionou ou liberou; portanto, é necessário
usar o método String.fromCharCode() para retornar uma seqüência de caracteres que
contém os caracteres representados pelos valores ASCII dos parâmetros. Como “E” não
possui uma instrução break, o bloco será executado se o usuário pressionar a tecla e ou E.
Se o usuário pressionar uma tecla que não seja abordada por nenhum dos três primeiros
casos, o caso padrão será executado.

Sobre instruções 157


Usando as instruções try..catch e try..catch..finally
Os blocos try..catch..finally permitem adicionar uma manipulação de erros aos
aplicativos do Flash. As palavras-chave try..catch..finally permitem delimitar o bloco de
códigos onde um erro pode ocorrer e responder a esse erro. Se algum código do bloco de
códigos try gerar um erro (através da instrução throw), o controle passará para o bloco
catch, se houver algum. Depois, o controle passará para o bloco de códigos finally, se
houver algum. O bloco finally opcional sempre é executado, independentemente da
geração de um erro.
Se o código do bloco try não gerar um erro (ou seja, se o bloco try for concluído
normalmente), ainda assim, o código do bloco finally será executado.
NO TA

O bloco finally será executado mesmo que o bloco try seja encerrado por uma instrução
return.

Escreva as instruções try..catch e try..catch..finally no seguinte formato:


// try-catch
try {
// statements
} catch (myError) {
// statements
}

// try-catch-finally
try {
// statements
} catch (myError) {
// statements
} finally {
// statements
}

Sempre que o código gerar um erro, você poderá escrever manipuladores personalizados para
lidar com esse erros e executar as ações apropriadas. Talvez seja necessário carregar dados
externos de um serviço da Web ou de um arquivo de texto ou exibir uma mensagem de erro
para o usuário final. Você pode, até mesmo, usar o bloco catch para tentar se conectar a um
serviço da Web que informe um administrador sobre um determinado erro, a fim de que ele
possa verificar o funcionamento do aplicativo.

Para usar o bloco try..catch..finally para validação de dados antes de dividir


alguns números:
1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash).

158 Fundamentos da sintaxe e da linguagem


2. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte
ActionScript no painel Actions (Ações):
var n1:Number = 7;
var n2:Number = 0;
try {
if (n2 == 0) {
throw new Error("Unable to divide by zero");
}
trace(n1/n2);
} catch (err:Error) {
trace("ERROR! " + err.toString());
} finally {
delete n1;
delete n2;
}

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento.
4. O painel Output (Saída) exibirá a mensagem Unable to divide by zero (Não é possível
dividir por zero).
5. Retorne ao ambiente de criação e altere a seguinte linha de código:
var n2:Number = 0;
to
var n2:Number = 2;
6. Selecione Control > Enter (Entrar) para testar o documento novamente.
Se o valor n2 for igual a zero, ocorrerá um erro, que será detectado pelo bloco catch e
resultará na exibição de uma mensagem no painel Output. Se o valor y não for igual a
zero, o painel Output exibirá o resultado de n1 dividido por n2. O bloco finally será
executado, independentemente da geração de um erro, e excluirá os valores das variáveis
n1 e n2 do documento do Flash.

Você não está limitado a gerar novas instâncias da classe Error quando ocorrer um erro. Você
poderá também estender a classe Error para criar erros personalizados, conforme demonstrado
no exemplo a seguir.

Para criar um erro personalizado:


1. Selecione File > New e crie um novo arquivo do ActionScript.
2. Selecione File > Save As (Salvar como) e atribua o nome DivideByZeroException.as ao
arquivo.
3. Digite o seguinte ActionScript no painel Script:
// In DivideByZeroException.as:
class DivideByZeroException extends Error {

Sobre instruções 159


var message:String = "Divide By Zero error";
}

4. Salve o arquivo do ActionScript.


5. Crie um novo documento do Flash chamado exception_test.fla no mesmo diretório do
arquivo do ActionScript e salve o arquivo.
6. Digite o seguinte ActionScript no painel Actions do Frame 1 da Timeline principal:
var n1:Number = 7;
var n2:Number = 0;
try {
if (n2 == 0) {
throw new DivideByZeroException();
} else if (n2 < 0) {
throw new Error("n2 cannot be less than zero");
} else {
trace(n1/n2);
}
} catch (err:DivideByZeroException) {
trace(err.toString());
} catch (err:Error) {
trace("An unknown error occurred; " + err.toString());
}

7. Salve o documento do Flash e selecione Control > Test Movie para testar o arquivo no
ambiente de teste.
Como o valor de n2 é igual a 0, o Flash gera uma classe de erro personalizada
DivideByZeroException e exibe o erro Divide By Zero no painel Output. Se você
alterar o valor de n2 na segunda linha de 0 para -1 e testar novamente o documento do
Flash, verá a mensagem An unknown error occurred; n2 cannot be less than
zero (Erro desconhecido; n2 não pode ser menor que zero) no painel Output. A definição
do valor de n2 para qualquer número maior que 0 fará com que o resultado da divisão
apareça no painel Output. Para obter mais informações sobre como criar classes
personalizadas, consulte o Capítulo 7, “Classes”, na página 239.

Sobre o operador condicional e a sintaxe alternativa


Se quiser usar atalhos, poderá utilizar o operador condicional (?:), conhecido também como
expressões condicionais. O operador condicional permite converter instruções if..else
simples em uma única linha de código. O operador ajuda a diminuir o valor do código escrito
enquanto realiza a mesma tarefa, mas ele também tende a dificultar mais a leitura do
ActionScript.
A condição a seguir é escrita na forma extensa, verifica se a variável numTwo é maior que zero e
retorna o resultado numOne/numTwo ou a seqüência de caracteres carrot:

160 Fundamentos da sintaxe e da linguagem


var numOne:Number = 8;
var numTwo:Number = 5;
if (numTwo > 0) {
trace(numOne / numTwo); // 1.6
} else {
trace("carrot");
}

Usando uma expressão condicional, você escreverá o mesmo código usando o seguinte
formato:
var numOne:Number = 8;
var numTwo:Number = 0;
trace((numTwo > 0) ? numOne/numTwo : "carrot");

Como pode ver, a sintaxe reduzida prejudica a legibilidade e, portanto, não é preferencial.
Caso precise usar operadores condicionais, coloque a condição inicial (antes do ponto de
interrogação [?]) entre parênteses. Isso ajudará a melhorar a legibilidade do ActionScript. O
código a seguir é um exemplo de ActionScript com melhor legibilidade:
var numOne:Number;
(numOne >= 5) ? numOne : -numOne;

É possível escrever uma instrução condicional que retorne um valor booleano, como mostra o
exemplo a seguir:
if (cartArr.length > 0) {
return true;
} else {
return false;
}

No entanto, se comparado ao código anterior, o ActionScript do exemplo a seguir será


preferencial:
return (cartArr.length > 0);

O segundo trecho é mais curto e tem menos expressões para avaliação, além de ser mais fácil
de ler e entender.
Ao escrever condições complexas, recomenda-se usar parênteses [()] para agrupar as
condições. Caso não use parênteses, você (ou outras pessoas que estejam usando o
ActionScript) poderá encontrar erros de precedência de operador. Para obter mais informações
sobre precedência de operador, consulte “Sobre associatividade e precedência de operadores”
na página 188.
Por exemplo, o código a seguir não usa parênteses ao redor da condição:
if (fruit == "apple" && veggie == "leek") {}

O código a seguir usa um formato adequado, delimitando as instruções entre parênteses:


if ((fruit == "apple") && (veggie == "leek")) {}

Sobre instruções 161


Repetindo ações através de loops
O ActionScript pode repetir uma ação um número especificado de vezes ou enquanto uma
condição específica existir. Os loops permitem repetir uma série de instruções quando uma
condição específica é true. Existem quatro tipos de loops no ActionScript: for, for..in,
while e do..while. Cada tipo de loop se comporta de um jeito e tem uma função diferente.

A maioria dos loops usa algum tipo de contador para controlar o número de execuções. Cada
execução de um loop é denominada iteração. Você pode declarar uma variável e escrever uma
instrução que aumente ou diminua a variável sempre que o loop for executado. Na ação for,
o contador e a instrução que aumenta a contagem fazem parte da ação.

Loop Descrição
for Repete uma ação usando um contador interno.

for..in Itera os filhos de um clipe de filme ou objeto.

while Repete uma ação enquanto uma condição existir.

do..while É semelhante aos loops; a única diferença é que a expressão é avaliada


na parte inferior do bloco de códigos, para que o loop sempre seja
executado pelo menos uma vez.

O tipo de loop mais comum é o for, que é repetido em um bloco de códigos um número
predefinido de vezes. Por exemplo, se você tiver um array de itens e quiser executar uma série
de instruções em cada item do array, use um loop for e execute-o de 0 até o número de itens
do array. Um outro tipo de loop é o for..in, que pode ser muito útil quando é necessário
repetir cada combinação nome/valor de um objeto e executar algum tipo de ação. Isso poderá
ser útil quando você estiver depurando projetos do Flash e quiser exibir os valores carregados
de fontes externas, como serviços da Web ou arquivos de texto/XML externos. Os dois
últimos tipos de loops (while e do..while) são úteis quando é necessário executar uma
repetição em uma série de instruções mas você não sabe necessariamente quantas vezes precisa
fazer isso. Nesse caso, é possível usar um loop while que execute a repetição desde que uma
determinada condição seja verdadeira.
O ActionScript pode repetir uma ação um número especificado de vezes ou enquanto uma
condição específica existir. Use as ações while, do..while, for e for..in para criar loops.
Esta seção contém informações gerais sobre esses loops. Consulte os procedimentos a seguir
para obter mais informações sobre cada um desses loops.

Para repetir uma ação enquanto uma condição existir:


■ Use a instrução while.

162 Fundamentos da sintaxe e da linguagem


Um loop while avaliará uma expressão e executará o código em seu corpo se a expressão
for true. Depois que cada instrução do corpo for executada, a expressão será avaliada
novamente. No exemplo a seguir, o loop é executado quatro vezes:
var i:Number = 4;
while (i > 0) {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
i--;
}

Você pode usar a instrução do...while para criar o mesmo tipo de loop que while. Em
um loop do..while, a expressão é avaliada na parte inferior do bloco de códigos, a fim de
que o loop sempre seja executado pelo menos uma vez.
Isso é mostrado no exemplo a seguir:
var i:Number = 4;
do {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
i--;
} while (i > 0);

Para obter mais informações sobre a instrução while, consulte “Usando os loops while”
na página 169.

Para repetir uma ação usando um contador interno:


■ Use a instrução for.
A maioria dos loops usa algum tipo de contador para controlar o número de execuções.
Cada execução de um loop é denominada iteração. Você pode declarar uma variável e
escrever uma instrução que aumente ou diminua a variável sempre que o loop for
executado. Na ação for, o contador e a instrução que aumenta a contagem fazem parte da
ação.
No exemplo a seguir, a primeira expressão (var i:Number = 4) é a expressão inicial que é
avaliada antes da primeira iteração. A segunda expressão ( i > 0) é a condição que é
verificada sempre antes da execução do loop. A terceira expressão (i--) é denominada
expressão final e é avaliada sempre após a execução do loop.
for (var i:Number = 4; i > 0; i--) {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
}
Para obter mais informações sobre a instrução for, consulte “Usando os loops for”
na página 166.

Sobre instruções 163


Para executar uma repetição nos filhos de um clipe de filme ou objeto:
■ Use a instrução for..in.
Os filhos são outros clipes de filme, funções, objetos e variáveis. O exemplo a seguir usa a
instrução trace para imprimir seus resultados no painel Output (Saída):
var myObject:Object = {name:'Joe', age:25, city:'San Francisco'};
var propertyName:String;
for (propertyName in myObject) {
trace("myObject has the property: " + propertyName + ", with the
value: " + myObject[propertyName]);
}

Este exemplo produz os seguintes resultados no painel Output:


myObject has the property: name, with the value: Joe
myObject has the property: age, with the value: 25
myObject has the property: city, with the value: San Francisco

Talvez seja necessário que o script itere um determinado tipo de filho; por exemplo, apenas
filhos de clipes de filme. Você pode fazer isso usando for..in com o operador typeof.
No exemplo a seguir, uma instância de clipe de filme filho (chamada instance2) está
dentro de um clipe de filme no Stage (Palco). Adicione o seguinte ActionScript ao Frame 1
(Quadro 1) da Timeline (Linha de tempo):
for (var myName in this) {
if (typeof (this[myName]) == "movieclip") {
trace("I have a movie clip child named " + myName);
}
}

Para obter mais informações sobre a instrução for..in, consulte “Usando os loops for..in”
na página 167.
A VI S O

As iterações do Flash são executadas rapidamente no Flash Player, mas os loops


dependem muito do processador. Quanto mais iterações um loop tem e quanto mais
instruções são executadas em cada bloco, mais recursos do processador são
consumidos. Loops escritos de modo insatisfatório podem ocasionar problemas de
desempenho e de estabilidade.

Para obter mais informações sobre cada instrução, consulte as seções individuais que
acompanham este capítulo, como “Usando os loops while” na página 169 e suas respectivas
entradas em ActionScript 2.0 Language Reference (Referência à linguagem ActionScript 2.0).

164 Fundamentos da sintaxe e da linguagem


Sobre criação e término de loops
O exemplo a seguir mostra um array simples de nomes de meses. Um loop for é iterado de 0
até o número de itens do array e exibe cada item no painel Output.
var monthArr:Array = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
var i:Number;
for (i = 0; i < monthArr.length; i++) {
trace(monthArr[i]);
}

Quando se trabalha com arrays, quer eles sejam simples ou complexos, é necessário conhecer
uma condição chamada loop infinito. O loop infinito, como o próprio nome já diz, é um loop
sem condição de término. Isso gera problemas, pois ocasiona falha no aplicativo Flash, faz
com que o documento do Flash pare de responder a um navegador da Web ou gera um
comportamento muito inconsistente do documento do Flash. O código a seguir é um
exemplo de loop infinito:
// BAD CODE- creates an infinite loop
// USE AT OWN RISK!
var i:Number;
for (i = 0; i < 10; i--) {
trace(i);
}

O valor de i é inicializado para 0 e a condição de término é atendida quando i é maior ou


igual a 10 e depois que cada iteração do valor de i é decrementada. É provável que o erro fique
imediatamente óbvio: se o valor de i diminuir após cada iteração do loop e a condição de
término nunca for atendida. Os resultados variam de acordo com o computador em que a
condição é executada. Além disso, a velocidade em que o código apresenta falha depende da
velocidade da CPU e de outros fatores. Por exemplo, o loop é executado aproximadamente
142.620 vezes antes de exibir uma mensagem de erro em um determinado computador.
A mensagem de erro a seguir é exibida em uma caixa de diálogo:
A script in this movie is causing Flash Player to run slowly. If it
continues to run, your computer may become unresponsive. Do you want to
abort the script?

Quando se trabalha com um loop (especialmente com os loops while e do..while), sempre
verifique se é possível encerrá-lo adequadamente (ou seja, se ele não é encerrado com um loop
infinito).
Para obter mais informações sobre como controlar loops, consulte “Usando uma instrução
switch” na página 156.

Sobre instruções 165


Usando os loops for
O loop for permite iterar uma variável de um intervalo específico de valores. O loop for é
útil quando você sabe exatamente quantas vezes precisa repetir uma série de instruções do
ActionScript. Isso será útil se for necessário duplicar um clipe de filme no Stage (Palco) um
determinado número de vezes ou repetir um array e executar uma tarefa em cada item desse
array. O loop for repete uma ação usando um contador interno. Em uma instrução for, o
contador e a instrução que incrementa o contador fazem parte da instrução for. Escreva a
instrução for usando o seguinte formato básico:
for (init; condition; update) {
// statements;
}

Você deve fornecer três expressões a uma instrução for: uma variável que é definida com um
valor inicial, uma instrução condicional que determina quando o loop terminará e uma
expressão que altera o valor da variável com cada loop. Por exemplo, o código a seguir se
repete cinco vezes. O valor da variável i começa em 0 e termina em 4. A saída da variável são
os números de 0 a 4, cada um na sua própria linha.
var i:Number;
for (i = 0; i < 5; i++) {
trace(i);
}

No exemplo a seguir, a primeira expressão (i = 0) é a expressão inicial que é avaliada antes da


primeira iteração. A segunda expressão (i < 5) é a condição que é verificada sempre antes da
execução do loop. A terceira expressão (i++) é denominada expressão final e é avaliada sempre
após a execução do loop.

Para criar um loop for:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash).
2. Crie um clipe de filme no Stage.
3. Clique com o botão direito do mouse no símbolo de clipe de filme do painel Library
(Biblioteca) e selecione Linkage (Vinculação) no menu contextual.
4. Marque a caixa de seleção Export for ActionScript (Exportar para ActionScript) e digite
libraryLinkageClassName na caixa de entrada de texto Class (Classe). Clique em OK.
5. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte
ActionScript no painel Actions (Ações):
var i:Number;
for (i = 0; i < 5; i++) {

166 Fundamentos da sintaxe e da linguagem


this.attachMovie("libraryLinkageClassName", "clip" + i + "_mc", i,
{_x:(i * 100)});
}

6. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código no Flash
Player.
Observe como cinco clipes de filme se duplicaram na parte superior do Stage. Esse
ActionScript duplica o símbolo de clipe de filme na biblioteca e reposiciona os clipes no
Stage nas coordenadas x de 0, 100, 200, 300 e 400 pixels. O loop é executado cinco vezes,
com a variável i definida com um valor de 0 a 4. Na última iteração do loop, o valor de i
é incrementado para 4 e a segunda expressão (i < 5) não é mais verdadeira, o que fará
com o loop seja encerrado.
Lembre-se de incluir um espaço após cada expressão em uma instrução for. Para obter mais
informações, consulte %{for statement}% em ActionScript 2.0 Language Reference
(Referência à linguagem ActionScript 2.0).

Usando os loops for..in


Use a instrução for..in para repetir (ou iterar) os filhos de um clipe de filme, as propriedades
de um objeto ou os elementos de um array. Os filhos, já mencionados anteriormente, são
outros clipes de filme, funções, objetos e variáveis. As funções comuns do loop for..in
incluem a repetição de instâncias em uma linha de tempo ou a repetição das combinações
chave/valor em um objeto. A repetição de objetos pode ser uma maneira eficaz de depurar
aplicativos, pois ela permite ver quais dados são retornados pelos serviços da Web ou
documentos externos, como arquivos de texto ou XML.
Por exemplo, é possível usar um loop for...in para iterar as propriedades de um objeto
genérico (as propriedades de objeto não são mantidas em nenhuma ordem específica; elas são
exibidas em uma ordem aleatória):
var myObj:Object = {x:20, y:30};
for (var i:String in myObj) {
trace(i + ": " + myObj[i]);
}

Esse código exibe o seguinte no painel Output (Saída):


x: 20
y: 30

É possível também iterar os elementos de um array:


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

Sobre instruções 167


Esse código exibe o seguinte no painel Output:
three
two
one

Para obter mais informações sobre os objetos e as propriedades, consulte “Tipo de dados
Object” na página 83.
NO T A

Não será possível iterar as propriedades de um objeto se ele for um instância de uma
classe personalizada, a menos que a classe seja dinâmica. Mesmo com instâncias de
classes dinâmicas, você pode iterar somente as propriedades adicionadas
dinamicamente.
NO TA

As chaves ({}) usadas para delimitar o bloco de instruções a ser executado pela
instrução for..in não serão necessárias se apenas uma instrução for executada.

O exemplo a seguir usa for..in para iterar as propriedades de um objeto:

Para criar um loop:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash).
2. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte
ActionScript no painel Actions (Ações):
var myObj:Object = {name:"Tara", age:27, city:"San Francisco"};
var i:String;
for (i in myObj) {
trace("myObj." + i + " = " + myObj[i]);
}

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código no Flash
Player.
Ao testar o arquivo SWF, você verá o seguinte texto no painel Output:
myObj.name = Tara
myObj.age = 27
myObj.city = San Francisco

Se você escrever um loop for..in em um arquivo de classe (um arquivo externo do


ActionScript), os membros de instância não estarão disponíveis no loop, mas os membros
estáticos estarão. No entanto, se você escrever um loop for..in em um arquivo FLA de uma
instância de classe, os membros de instância estarão disponíveis, mas os membros estáticos
não. Para obter mais informações sobre como escrever arquivos de classe, consulte Capítulo 7,
“Classes”, na página 239. Para obter mais informações, consulte %{for..in statement}% em
ActionScript 2.0 Language Reference (Referência à linguagem ActionScript 2.0)

168 Fundamentos da sintaxe e da linguagem


Usando os loops while
Use a instrução while para repetir uma ação enquanto existir uma condição; ela é semelhante
à instrução if, que se repete contanto que a condição seja true.
Um loop while avaliará uma expressão e executará o código em seu corpo se a expressão for
true. Se a condição retornar true, uma instrução ou uma série de instruções será executada
antes que o loop reverso avalie a condição novamente. Quando a condição retornar false, a
instrução ou a série de instruções será ignorada e o loop terminará. O uso do loop while pode
ser útil quando você não tem certeza de quantas vezes precisará repetir um bloco de códigos.
Por exemplo, o código a seguir rastreia os números no painel Output (Saída):
var i:Number = 0;
while (i < 5) {
trace(i);
i++;
}

Você verá os seguintes números rastreados no painel Output:


0
1
2
3
4

Uma desvantagem do uso de um loop while, em vez de um loop for, é que os loops infinitos
são mais fáceis de serem gerados com os loops while. O código de exemplo do loop for não
será compilado se você omitir a expressão que incrementa a variável do contador, mas o
exemplo do loop while é compilado mesmo que essa etapa seja omitida. Sem a expressão que
incrementa i, o loop se torna um loop infinito.
Para criar e usar um loop while em um arquivo FLA, siga este exemplo.

Para criar um loop while:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash).
2. Abra o painel Components (Componentes) e arraste um componente DataSet para o Stage
(Palco).
3. Abra o Property inspector (Inspetor de propriedades) (Window (Janela) > Properties
(Propriedades) > Properties) e digite o nome de instância users_ds.
4. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte
ActionScript no painel Actions (Ações):
var users_ds:mx.data.components.DataSet;
//
users_ds.addItem({name:"Irving", age:34});

Sobre instruções 169


users_ds.addItem({name:"Christopher", age:48});
users_ds.addItem({name:"Walter", age:23});
//
users_ds.first();
while (users_ds.hasNext()) {
trace("name:" + users_ds.currentItem["name"] + ", age:" +
users_ds.currentItem["age"]);
users_ds.next();
}

5. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento.
As seguintes informações são exibidas no painel Output:
name:Irving, age:34
name:Christopher, age:48
name:Walter, age:23

Para obter mais informações, consulte %{while statement}% em ActionScript 2.0 Language
Reference (Referência à linguagem ActionScript 2.0).

Sobre loops do..while


Você pode usar a instrução do...while para criar o mesmo tipo de loop que while. No
entanto, a expressão é avaliada na parte inferior do bloco de códigos em um loop do..while
(ele é verificado depois que o bloco de códigos é executado), para que o loop sempre seja
executado pelo menos uma vez. As instruções são executadas apenas se a condição retornar
true.
O código a seguir mostra um exemplo simples de loop do..while que gera a saída mesmo
que a condição não seja atendida.
var i:Number = 5;
do {
trace(i);
i++;
} while (i < 5);
// Output: 5
Ao usar loops, é necessário evitar a criação de loops infinitos. Se a condição em um loop
do..while retornar continuamente true, um loop infinito será gerado e exibirá um aviso ou
travará o Flash Player. Use o loop for em vez disso, caso você sabia quantas vezes deseja
executar a repetição. Para obter mais informações sobre isso e exemplos de %{do..while
statement}%, consulte ActionScript 2.0 Language Reference (Referência à linguagem
ActionScript 2.0).

170 Fundamentos da sintaxe e da linguagem


Usando loops aninhados no ActionScript
O exemplo a seguir demonstra como criar um array de objetos e exibir cada um dos valores na
estrutura aninhada. Este exemplo mostra como usar o loop for para repetir cada item do array
e como usar o loop for..in para iterar cada combinação chave/valor nos objetos aninhados.

Aninhando um loop dentro de outro loop:


1. Crie um novo documento do Flash.
2. Selecione File (Arquivo) > Save As (Salvar como) e atribua o nome loops.fla ao documento.
3. Adicione o seguinte código ao Frame 1 (Quadro 1) da Timeline (Linha de tempo):
var myArr:Array = new Array();
myArr[0] = {name:"One", value:1};
myArr[1] = {name:"Two", value:2};
//
var i:Number;
var item:String;
for (i = 0; i < myArr.length; i++) {
trace(i);
for (item in myArr[i]) {
trace(item + ": " + myArr[i][item]);
}
trace("");
}

4. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código.
O seguinte será exibido no painel Output (Saída):
0
name: One
value: 1

1
name: Two
value: 2

Você sabe quantos itens há no array; portanto, pode repetir cada item usando um loop for
simples. Como cada objeto do array pode ter diferentes combinações nome/valor, é
possível usar um loop for..in para iterar cada valor e exibir os resultados no painel
Output.

Sobre instruções 171


Sobre arrays
Um array é um objeto cujas propriedades são identificadas por números que representam suas
posições dentro da estrutura. Basicamente, um array é uma lista de itens. É importante
lembrar que cada elemento de um array não precisa ter o mesmo tipo de dados. É possível
misturar números, datas, seqüências de caracteres e objetos, e até mesmo adicionar um array
aninhado em cada índice de arrays.
O exemplo a seguir é um array simples de nomes de meses.
var myArr:Array = new Array();
myArr[0] = "January";
myArr[1] = "February";
myArr[2] = "March";
myArr[3] = "April";

O array anterior de nomes de meses também pode ser reescrito da seguinte maneira:
var myArr:Array = new Array("January", "February", "March", "April");

Uma outra alternativa é usar a sintaxe abreviada conforme mostrado a seguir:


var myArr:Array = ["January", "February", "March", "April"];

Um array é como uma estrutura de dados. É como um edifício comercial, onde cada andar
contém um tipo de dados diferente (como contabilidade no terceiro andar e engenharia no
quinto). Assim, é possível armazenar diferentes tipos de dados em um único array, incluindo
outros arrays. Cada andar desse prédio pode conter vários tipos de conteúdo (o executivo e a
contabilidade poderiam compartilhar o terceiro andar).
Um array contém elementos, que são equivalentes a cada andar do prédio. Cada elemento tem
uma posição numérica (o índice), que é como você indica a posição de cada elemento no array.
É semelhante ao número dos andares de um prédio. Cada elemento pode conter uma parte
dos dados (que pode ser um número, uma seqüência de caracteres, um valor booleano ou, até
mesmo, um array ou objeto) ou ficar vazio.
É possível também controlar e modificar o próprio array. Por exemplo, talvez seja necessário
mover o departamento de engenharia para o térreo do prédio. Os arrays permitem que você
mova os valores e altere o tamanho do array (digamos que ele permite renovar o prédio e
adicionar ou remover andares). Assim, é possível adicionar ou remover elementos e mover
valores para vários elementos.
Portanto, o prédio (o array) contém andares (os elementos), que são numerados (o índice), e
cada andar contém um ou mais departamentos (os valores).

172 Fundamentos da sintaxe e da linguagem


Para obter mais informações sobre como modificar arrays, consulte “Sobre modificação de
arrays” na página 175. Para obter informações sobre como usar arrays e sobre os índices,
consulte “Usando arrays” na página 173. Para obter informações sobre como adicionar e
remover elementos, consulte “Sobre adição e remoção de elementos” na página 177. Para
obter informações sobre o operador de acesso de array, consulte “Usando operadores de ponto
e de acesso de array” na página 194.
Na pasta Samples do disco rígido, há um arquivo de exemplo de origem chamado array.fla.
Esse exemplo ilustra a manipulação de arrays usando o ActionScript. O código do exemplo
cria um array e classifica, adiciona e remove itens de dois componentes List. Localize o arquivo
de exemplo nos diretórios a seguir:
■ No Windows, vá para a unidade de inicialização\Program Files\Macromedia\Flash
8\Samples e Tutorials\Samples\ActionScript\Arrays.
■ No Macintosh, vá para Macintosh HD/Applications/Macromedia Flash 8/Samples e
Tutorials/Samples/ActionScript/Arrays.

Usando arrays
Existem diversas maneiras de usar os arrays. Utilize-os para armazenar listas de objetos, como
um grupo de itens retornados. Se você carregar dados dos servidores Web remotos, é provável
que receba até mesmo dados como um array de objetos aninhados. Geralmente, os arrays
contêm dados em um formato similar. Por exemplo, se você criar um aplicativo de áudio no
Flash, provavelmente terá a lista de reprodução de um usuário armazenada como um array de
informações de música, armazenada nos objetos. Cada objeto contém o nome da música, o
nome do artista, a duração da música, o local de um arquivo de som (como um MP3) ou
quaisquer outras informações que precisem ser associadas a um determinado arquivo.
O local de um item em um array chama-se índice. Todos os arrays começam com zero, o que
significa que o seu primeiro elemento é [0], o segundo é [1] e assim sucessivamente.
Existem diferentes tipos de arrays, que você descobrirá nas seções a seguir. Os arrays mais
comuns usam um índice numérico para pesquisar um determinado item em um array
indexado. O segundo tipo de array chama-se array associativo e usa um índice de texto, em vez
de um índice numérico, para pesquisar informações. Para obter mais informações sobre os
arrays comuns, consulte “Sobre arrays” na página 172. Para obter mais informações sobre os
arrays associativos, consulte “Criando arrays associativos” na página 181. Para obter mais
informações sobre as matrizes, consulte “Criando matrizes” na página 178. Para obter
informações sobre o operador de acesso de array, consulte “Usando operadores de ponto e de
acesso de array” na página 194.

Sobre arrays 173


A classe Array interna permite acessar e manipular arrays. Para criar um objeto Array, use o
construtor new Array() ou o operador de acesso de array ([]). Para acessar os elementos de
um array, use também o operador de acesso de array ([]). O exemplo a seguir usa um array
indexado.

Para usar arrays no código:


1. Crie um novo documento do Flash e salve-o como basicArrays.fla.
2. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo):
// define a new array
var myArr:Array = new Array();
// define values at two indexes
myArr[1] = "value1";
myArr[0] = "value0";
// iterate over the items in the array
var i:String;
for (i in myArr) {
// trace the key/value pairs
trace("key: " + i + ", value: " + myArr[i]);
}

Na primeira linha do ActionScript, defina um novo array para reter os valores. Em


seguida, defina dados (value0 e value1) nos dois índices do array. Use um loop for..in
para iterar cada um dos itens desse array e exibir as combinações chave/valor no painel
Output (Saída) usando uma instrução trace.
3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código.
O seguinte texto será exibido no painel Output:
key: 0, value: value0
key: 1, value: value1

Para obter mais informações sobre os loops for..in, consulte “Usando os loops for..in”
na página 167.
Para obter informações sobre como criar diferentes tipos de arrays, consulte as seguintes
seções:
■ “Criando arrays indexados” na página 178
■ “Criando matrizes” na página 178
■ “Criando arrays associativos” na página 181
Na pasta Samples do disco rígido, há um arquivo de exemplo de origem chamado array.fla.
Esse exemplo ilustra a manipulação de arrays usando o ActionScript. O código do exemplo
cria um array e classifica, adiciona e remove itens de dois componentes List. Localize o arquivo
de exemplo nos diretórios a seguir:

174 Fundamentos da sintaxe e da linguagem


■ No Windows, vá para a unidade de inicialização\Program Files\Macromedia\Flash
8\Samples e Tutorials\Samples\ActionScript\Arrays.
■ No Macintosh, vá para Macintosh HD/Applications/Macromedia Flash 8/Samples e
Tutorials/Samples/ActionScript/Arrays.

Sobre modificação de arrays


É possível também controlar e modificar o array usando o ActionScript. Você pode mover
valores em torno de um array ou alterar o tamanho do array. Por exemplo, se você quiser
trocar dados nos dois índices de um array, use o código a seguir:
var buildingArr:Array = new Array();
buildingArr[2] = "Accounting";
buildingArr[4] = "Engineering";
trace(buildingArr); // undefined,undefined,Accounting,undefined,Engineering

var temp_item:String = buildingArr[2];


buildingArr[2] = buildingArr[4];
buildingArr[4] = temp_item;
trace(buildingArr); // undefined,undefined,Engineering,undefined,Accounting

Talvez seja necessário saber porque é preciso criar uma variável temporária no exemplo
anterior. Se você copiou o conteúdo do índice de array 4 no índice de array 2 e vice-versa, o
conteúdo original do índice de array 2 se perderá. Ao copiar o valor de um dos índices de array
em uma variável temporária, é possível salvar o valor e copiá-lo com segurança de volta para o
código posteriormente. Por exemplo, se você usar o código a seguir, verá que o valor do índice
de array 2 (Accounting) se perdeu. Agora, você tem duas equipes de engenharia, mas
nenhuma de contabilidade.
// wrong way (no temporary variable)
buildingArr[2] = buildingArr[4];
buildingArr[4] = buildingArr[2];
trace(buildingArr); //
undefined,undefined,Engineering,undefined,Engineering

Na pasta Samples do disco rígido, há um arquivo de exemplo de origem chamado array.fla.


Esse exemplo ilustra a manipulação de arrays usando o ActionScript. O código do exemplo
cria um array e classifica, adiciona e remove itens de dois componentes List. Localize o arquivo
de exemplo nos diretórios a seguir:
■ No Windows, vá para a unidade de inicialização\Program Files\Macromedia\Flash
8\Samples e Tutorials\Samples\ActionScript\Arrays.
■ No Macintosh, vá para Macintosh HD/Applications/Macromedia Flash 8/Samples e
Tutorials/Samples/ActionScript/Arrays.

Sobre arrays 175


Sobre referência e localização de tamanho
Quando você trabalha com arrays, geralmente precisa saber quantos itens existem no array.
Isso pode ser muito útil durante a criação de loops for que iteram cada elemento do array e
executam uma série de instruções. Veja um exemplo no trecho a seguir:
var monthArr:Array = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
trace(monthArr); // Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec
trace(monthArr.length); // 12
var i:Number;
for (i = 0; i < monthArr.length; i++) {
monthArr[i] = monthArr[i].toUpperCase();
}
trace(monthArr); // JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC

No exemplo anterior, você cria um array e o preenche com nomes de meses. O conteúdo e o
tamanho do array é exibido. O loop for itera cada item do array e converte o valor em
maiúsculas. Depois, o conteúdo do array é exibido novamente.
No ActionScript a seguir, se você criar um elemento no índice de array 5, o tamanho do array
retornará 6 (já que o array começa sempre com zero), em vez do número real de itens do array,
conforme seria o esperado:
var myArr:Array = new Array();
myArr[5] = "five";
trace(myArr.length); // 6
trace(myArr); // undefined,undefined,undefined,undefined,undefined,five

Para obter mais informações sobre os loops for, consulte “Usando os loops for”
na página 166. Para obter informações sobre o operador de acesso de array, consulte “Usando
operadores de ponto e de acesso de array” na página 194.
Na pasta Samples do disco rígido, há um arquivo de exemplo de origem chamado array.fla.
Esse exemplo ilustra a manipulação de arrays usando o ActionScript. O código do exemplo
cria um array e classifica, adiciona e remove itens de dois componentes List. Localize o arquivo
de exemplo nos diretórios a seguir:
■ No Windows, vá para a unidade de inicialização\Program Files\Macromedia\Flash
8\Samples e Tutorials\Samples\ActionScript\Arrays.
■ No Macintosh, vá para Macintosh HD/Applications/Macromedia Flash 8/Samples e
Tutorials/Samples/ActionScript/Arrays.

176 Fundamentos da sintaxe e da linguagem


Sobre adição e remoção de elementos
Um array contém elementos e cada elemento tem uma posição numérica (o índice), que é a
maneira utilizada para indicar a posição de cada elemento no array. Cada elemento pode reter
uma parte dos dados ou ficar vazio. Um elemento pode reter os seguintes dados: um número,
uma seqüência de caracteres ou, até mesmo, um array ou objeto.
Ao criar elementos em um array, crie os índices seqüencialmente sempre que possível. Isso será
útil na depuração dos aplicativos. Em “Sobre referência e localização de tamanho”
na página 176, você viu que, se atribuir um único valor em um array no índice 5, o tamanho
do array será retornado como 6. Isso fará com que cinco valores indefinidos sejam inseridos no
array.
O exemplo a seguir demonstra como criar um novo array, excluir um item em um
determinado índice, e adicionar e substituir dados em um índice do array:
var monthArr:Array = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
delete monthArr[5];
trace(monthArr); // Jan,Feb,Mar,Apr,May,undefined,Jul,Aug,Sep,Oct,Nov,Dec
trace(monthArr.length); // 12
monthArr[5] = "JUN";
trace(monthArr); // Jan,Feb,Mar,Apr,May,JUN,Jul,Aug,Sep,Oct,Nov,Dec

Mesmo que você tenha excluído o item no índice de array 5, o tamanho do array ainda será 12
e o item no índice de array 5 será alterado para uma seqüência de caracteres em branco, em vez
de desaparecer completamente.
Na pasta Samples do disco rígido, há um arquivo de exemplo de origem chamado array.fla.
Esse exemplo ilustra a manipulação de arrays usando o ActionScript. O código do exemplo
cria um array e classifica, adiciona e remove itens de dois componentes List. Localize o arquivo
de exemplo nos diretórios a seguir:
■ No Windows, vá para a unidade de inicialização\Program Files\Macromedia\Flash
8\Samples e Tutorials\Samples\ActionScript\Arrays.
■ No Macintosh, vá para Macintosh HD/Applications/Macromedia Flash 8/Samples e
Tutorials/Samples/ActionScript/Arrays.

Sobre arrays 177


Criando arrays indexados
Os arrays indexados armazenam uma série de um ou mais valores. É possível pesquisar os itens
por sua posição no array, que é o que você poderia ter feito nas seções anteriores. O primeiro
índice é sempre o número 0. Ele é incrementado em um em cada elemento subseqüente que
você adiciona ao array. É possível criar um array indexado chamando o construtor de classe
Array ou inicializando o array com um literal de array. Crie arrays usando o construtor Array e
um literal de array no próximo exemplo.

Para criar um array indexado:


1. Crie um novo documento do Flash e salve-o como indexArray.fla.
2. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo):
var myArray:Array = new Array();
myArray.push("one");
myArray.push("two");
myArray.push("three");
trace(myArray); // one,two,three

Na primeira linha do ActionScript, defina um novo array para reter os valores.


3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código.
O seguinte texto será exibido no painel Output (Saída):
one,two,three

4. Retorne à ferramenta de criação e exclua o código do painel Actions (Ações).


5. Adicione o seguinte ActionScript ao Frame 1 da Timeline:
var myArray:Array = ["one", "two", "three"];
trace(myArray); // one,two,three

Nesse código, você usará o literal de array para definir um novo array para o código. Esse
código equivale ao ActionScript escrito na etapa 2. Durante o teste do código, a mesma
saída aparece no painel Output.

Criando matrizes
No ActionScript, é possível implementar arrays como arrays aninhados, que são basicamente
arrays de arrays. Os arrays aninhados, também conhecidos como matrizes, podem ser
considerados grades. Portanto, durante a programação, você provavelmente usará matrizes
para modelar esses tipos de estruturas. Por exemplo, um tabuleiro de xadrez é uma grade de
oito colunas e linhas. Você pode modelar esse tabuleiro como um array com oito elementos,
cada um deles contendo também um array com oito elementos.

178 Fundamentos da sintaxe e da linguagem


Por exemplo, considere uma lista de tarefas armazenadas como um array indexado de
seqüências de caracteres:
var tasks:Array = ["wash dishes", "take out trash"];

Para armazenar uma lista separada de tarefas para cada dia da semana, crie um matriz com um
elemento para cada dia da semana. Cada elemento contém um array indexado que armazena a
lista de tarefas.
A T E NÇ ÃO

Quando você usa o operador de acesso de array, o compilador do ActionScript não


pode verificar se o elemento acessado é uma propriedade válida do objeto.

Para criar uma matriz básica e recuperar elementos no array:


1. Crie um novo documento do Flash e salve-o como multiArray1.fla.
2. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo):
var twoDArray:Array = new Array(new Array("one","two"), new
Array("three", "four"));
trace(twoDArray);

Esse array, o twoDArray, consiste em dois elementos de array. Esses elementos são arrays
compostos por dois elementos. Nesse caso, twoDArray é o array principal que contém dois
arrays aninhados.
3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código. O seguinte
será exibido no painel Output (Saída):
one,two,three,four

4. Retorne ao ambiente de criação e abra o painel Actions (Ações). Insira um comentário na


instrução trace, conforme mostrado a seguir:
// trace(twoDArray);

5. Adicione o seguinte ActionScript ao final do código no Frame 1 da Timeline:


trace(twoDArray[0][0]); // one
trace(twoDArray[1][1]); // four

Para recuperar elementos de uma matriz, use vários operadores de acesso de array ([]) após
o nome do array de nível superior. O primeiro [] refere-se ao índice do array de nível
superior. Os operadores de acesso de array subseqüentes referem-se aos elementos dos
arrays aninhados.
6. Selecione Control > Test Movie para testar o código. O seguinte será exibido no painel
Output:
one
four

Sobre arrays 179


É possível usar loops for aninhados para criar matrizes. O exemplo a seguir mostrará como
fazer isso.

Para criar uma matriz usando um loop for:


1. Crie um novo documento do Flash e salve-o como multiArray2.fla.
2. Adicione o seguinte ActionScript ao Frame 1 da Timeline:
var gridSize:Number = 3;
var mainArr:Array = new Array(gridSize);
var i:Number;
var j:Number;
for (i = 0; i < gridSize; i++) {
mainArr[i] = new Array(gridSize);
for (j = 0; j < gridSize; j++) {
mainArr[i][j] = "[" + i + "][" + j + "]";
}
}
trace(mainArr);

Esse ActionScript cria um array 3 x 3 e define o valor de cada nó de array com seu índice.
Em seguida, você rastreia o array (mainArr).
3. Selecione Control > Test Movie para testar o código.
O seguinte será exibido no painel Output:
[0][0],[0][1],[0][2],[1][0],[1][1],[1][2],[2][0],[2][1],[2][2]

Também é possível usar loops for aninhados para iterar os elementos de uma matriz,
conforme mostrado no exemplo a seguir.

Para usar um loop for para iterar uma matriz:


1. Crie um novo documento do Flash e salve-o como multiArray3.fla.
2. Adicione o seguinte ActionScript ao Frame 1 da Timeline:
// from previous example
var gridSize:Number = 3;
var mainArr:Array = new Array(gridSize);
var i:Number;
var j:Number;
for (i = 0; i < gridSize; i++) {
mainArr[i] = new Array(gridSize);
for (j = 0; j < gridSize; j++) {
mainArr[i][j] = "[" + i + "][" + j + "]";
}
}

Nesse código, conforme mostrado no exemplo anterior, o loop externo itera cada elemento
de mainArray. O loop interno itera cada array aninhado e retorna cada nó de array.

180 Fundamentos da sintaxe e da linguagem


3. Adicione o seguinte ActionScript ao Frame 1 da Timeline, seguindo o código digitado na
etapa 2:
// iterate through elements
var outerArrayLength:Number = mainArr.length;
for (i = 0; i < outerArrayLength; i++) {
var innerArrayLength:Number = mainArr[i].length;
for (j = 0; j < innerArrayLength; j++) {
trace(mainArr[i][j]);
}
}

Esse ActionScript itera os elementos do array. Use a propriedade length de cada array
como condição do loop.
4. Selecione Control > Test Movie para exibir os elementos mostrados no painel Output. O
seguinte será exibido no painel Output:
[0][0]
[0][1]
[0][2]
[1][0]
[1][1]
[1][2]
[2][0]
[2][1]
[2][2]

Para obter informações sobre como usar os arrays, consulte o “Usando arrays” na página 173.
Para obter informações sobre os elementos do array, consulte “Sobre adição e remoção de
elementos” na página 177. Para obter informações sobre o operador de acesso de array,
consulte “Usando operadores de ponto e de acesso de array” na página 194.

Criando arrays associativos


Um array associativo, que é como um objeto, é composto de chaves e valores fora de ordem. Os
arrays associativos usam chaves, em vez de um índice numérico, para organizar os valores
armazenados. Cada chave é uma seqüência exclusiva. Ela é associada a um valor e usada para
acessá-lo. Esse valor pode ser um tipo de dados, como Number, Array, Object etc. Ao criar um
código para localizar um valor associado a uma chave, você está indexando ou executando
uma pesquisa. É por isso que você usará arrays associativos na maioria das vezes.

Sobre arrays 181


A associação entre uma chave e um valor é geralmente chamada de vinculação. A chave e o
valor são mapeados entre si. Por exemplo, um livro de contatos poderia ser considerado um
array associativo, onde os nomes são as chaves e os endereços de e-mail são os valores.
NO TA

Os arrays associativos são coleções de combinações chave/valor dispostas fora de


ordem. O código não deve esperar que as chaves de um array associativo sejam
exibidas em uma ordem específica.

Ao usar arrays associativos, você pode chamar o elemento de array necessário usando uma
seqüência de caracteres em vez de um número, que é geralmente mais fácil de memorizar. A
desvantagem é que esses arrays não são tão úteis em um loop porque não utilizam números
como valor de índice. Eles são úteis quando é necessário realizar freqüentemente a pesquisa
por valores de chave. Por exemplo, se você tivesse um array de nomes e idades que precisasse
utilizar com muita freqüência, seria recomendável usar um array associativo.
O exemplo a seguir demonstra como criar um objeto e definir uma série de propriedades em
um array associativo.

Para criar um array associativo simples:


1. Crie um novo documento do Flash.
2. Digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo):
// Define the object to use as an associative array.
var someObj:Object = new Object();
// Define a series of properties.
someObj.myShape = "Rectangle";
someObj.myW = 480;
someObj.myH = 360;
someObj.myX = 100;
someObj.myY = 200;
someObj.myAlpha = 72;
someObj.myColor = 0xDFDFDF;
// Display a property using dot operator and array access syntax.
trace(someObj.myAlpha); // 72
trace(someObj["myAlpha"]); // 72

A primeira linha do ActionScript define um novo objeto (someObj) que é utilizado como
array associativo. Depois disso, você define uma série de propriedades em someObj. Por
fim, você exibe uma propriedade selecionada através do operador de ponto e da sintaxe de
acesso de array.
N O TA

É possível acessar variáveis em um array associativo usando dois métodos diferentes:


sintaxe de ponto (someObj.myColor) e sintaxe de array (someObj[‘myColor’]).

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript.

182 Fundamentos da sintaxe e da linguagem


O painel Output (Saída) exibe o número 72 duas vezes, que representa os dois níveis alfa
rastreados.
Existem duas maneiras de criar arrays associativos no ActionScript 2.0:
■ Usando um construtor Object
■ Usando um construtor Array
Essas duas maneiras são demonstradas nos exemplos a seguir.
NO T A

O exemplo anterior utilizou um construtor Object para criar um array associativo.

Se você usar o construtor Object para criar um array associativo, poderá tirar proveito da
inicialização do array com um literal de objeto. Uma instância da classe Object, também
chamada de objeto genérico, é funcionalmente idêntica a um array associativo. Na verdade, as
instâncias Object são basicamente arrays associativos. Recomenda-se usar arrays associativos
nas funcionalidades semelhantes a dicionário, nas quais é mais conveniente ter chaves de
seqüência de strings em vez de índices numéricos. Cada nome de propriedade do objeto
genérico atua como a chave que fornece acesso a um valor armazenado. Para obter mais
informações sobre os literais, consulte “Sobre literais” na página 138. Para obter mais
informações sobre as classes, consulte Capítulo 7, “Classes”, na página 239.

Para criar um array associativo usando um construtor Object:


1. Crie um novo documento do Flash e salve-o como assocArray.fla.
2. Adicione o seguinte ActionScript ao Frame 1 da Timeline:
var monitorInfo:Object = {type:"Flat Panel", resolution:"1600 x 1200"};
trace(monitorInfo["type"] + ", " + monitorInfo["resolution"]);

Esse código cria um array associativo chamado monitorInfo e usa um literal de objeto
para inicializar o array com duas combinações chave/valor.
N OT A

Se não for necessário inicializar o array no momento da declaração, use o construtor


Object para criar o array:

var monitorInfo:Object = new Object();

3. Selecione Control > Test Movie.


O painel Output exibirá o seguinte:
Flat Panel, 1600 x 1200

Sobre arrays 183


4. Adicione o seguinte ActionScript ao Frame 1 da Timeline (após o código digitado
anteriormente):
monitorInfo["aspectRatio"] = "16:10";
monitorInfo.colors = "16.7 million";
trace(monitorInfo["aspectRatio"] + ", " + monitorInfo.colors);

Depois que você usar um literal de objeto ou o construtor de classe Object para criar o
array, será possível adicionar novos valores ao array usando o operador de colchetes ([]) ou
o operador de ponto (.), conforme demonstrado nesse código. O código que você acabou
de digitar adiciona dois novos valores ao array monitorInfo.
5. Selecione Control > Test Movie.
O painel Output exibirá o seguinte texto:
16:10, 16.7 million

Observe que uma chave pode conter um caractere de espaço. Isso é possível com o
operador de colchetes, mas gerará um erro se você tentar isso com o operador de ponto. O
uso de espaços nos nomes de chave não é recomendado. Para obter mais informações sobre
os operadores de colchetes e operadores de ponto, consulte “Sobre operadores”
na página 185. Para obter mais informações sobre o código formatado corretamente,
consulte “Formatando a sintaxe do ActionScript” na página 799.
A segunda maneira de criar um array associativo é usar o construtor Array e o operador de
colchetes ([]) ou o operador de ponto (.) para adicionar as combinações chave/valor ao array.
Se você declarar o array associativo para ser do tipo Array, não é possível usar um literal de
objeto para inicializar o array.
NO T A

Não há nenhuma vantagem em usar o construtor Array para criar um array associativo.
O construtor Array é melhor para criar arrays indexados.

O próximo exemplo demonstra como usar o construtor Array para criar um array associativo.

Para criar um array associativo usando um construtor Array:


1. Crie um novo documento do Flash e salve-o como assocArray2.fla.
2. Adicione o seguinte ActionScript ao Frame 1 da Timeline:
var monitorInfo:Array = new Array();
monitorInfo["type"] = "Flat Panel";
monitorInfo["resolution"] = "1600 x 1200";
trace(monitorInfo["type"] + ", " + monitorInfo["resolution"]);

Esse código cria um array associativo chamado monitorInfo usando o construtor Array e
adiciona uma chave chamada type e outra denominada resolution, junto com seus
respectivos valores.

184 Fundamentos da sintaxe e da linguagem


3. Selecione Control > Test Movie.
O painel Output exibirá o seguinte texto:
Flat Panel, 1600 x 1200
N OT A

Não há nenhuma vantagem em usar o construtor Array para criar um array


associativo. O construtor Array é melhor para criar arrays indexados.

Os arrays associativos são basicamente instâncias da classe Object e não existe nenhuma
vantagem em criar arrays associativos com o construtor Array. Mesmo que você crie um array
associativo com o construtor new Array(), não poderá usar nenhum método e propriedade
da classe Array (como sort() ou length) ao utilizar um array associativo. Para usar
combinações chave/valor em vez de índice numérico, use a classe Object em vez de um array
associativo.

Sobre operadores
Esta seção descreve regras gerais sobre tipos comuns, precedência e associatividade de
operadores.
Os operadores são caracteres que especificam como combinar, comparar ou alterar valores em
uma expressão. Uma expressão é qualquer instrução que o Flash possa avaliar e que retorne
um valor. Você pode criar uma expressão combinando operadores e valores ou chamando uma
função. Para obter mais informações sobre as expressões, consulte “Sobre sintaxe, instruções e
expressões” na página 120.
Por exemplo, uma expressão matemática usa operadores numéricos para manipular os valores
utilizados. Como exemplos de caracteres de operador, pode-se citar +, <, * e =. Uma expressão
consiste em operadores e operandos, os quais são qualquer combinação legal de símbolos do
ActionScript que representam um valor. Um operando é a parte do código na qual o operador
executa ações. Por exemplo, na expressão x + 2, x e 2 são operandos e + é um operador.
As expressões e os operadores são utilizados com freqüência no código. É possível combinar
operadores e valores para criar uma expressão e, ainda, chamar uma função.
N O TA

Esta seção descreve como usar cada tipo de operador. No entanto, não haverá tempo
de discutir cada um deles. Para obter informações sobre cada operador, incluindo os
operadores especiais que não se enquadram nas categorias a seguir, consulte
ActionScript 2.0 Language Reference (Referência à linguagem ActionScript 2.0).

Sobre operadores 185


As partes do código em que o operador executa ações são chamadas de operandos. Por
exemplo, você pode usar o operador de adição (+) para somar valores de um literal numérico.
Você pode fazer isso para somar o valor de uma variável chamada myNum.
myNum + 3;

Neste exemplo, myNum e 3 são operandos.


Esta seção descreve regras gerais sobre tipos comuns, precedência e associatividade de
operadores:
■ “Usando operadores para manipular valores” na página 187
■ “Sobre associatividade e precedência de operadores” na página 188
■ “Sobre uso de operadores com seqüências de caracteres” na página 192
■ “Usando operadores de ponto e de acesso de array” na página 194
■ “Sobre operadores pós-fixados” na página 196
■ “Sobre operadores unários” na página 197
■ “Sobre operadores multiplicativos” na página 197
■ “Sobre operadores aditivos” na página 198
■ “Usando operadores numéricos” na página 198
■ “Sobre operadores relacionais” na página 200
■ “Sobre operadores de igualdade” na página 200
■ “Usando operadores relacionais e de igualdade” na página 200
■ “Sobre operadores de atribuição” na página 204
■ “Usando operadores de atribuição” na página 204
■ “Sobre operadores lógicos” na página 205
■ “Usando operadores lógicos” na página 206
■ “Sobre operadores de deslocamento bit a bit” na página 207
■ “Sobre operadores lógicos bit a bit” na página 208
■ “Usando operadores bit a bit” na página 208
■ “Sobre o operador condicional” na página 210
■ “Usando operadores em um documento” na página 210
Para obter informações sobre os operadores que não se enquadram nessas categorias, consulte
ActionScript 2.0 Language Reference (Referência à linguagem ActionScript 2.0), que contém
informações sobre todos os operadores que podem ser utilizados.
As seções a seguir mostram algumas funções comuns dos operadores. Para obter mais
informações sobre como usar vários operadores em um único exemplo de código, consulte
“Usando operadores em um documento” na página 210.

186 Fundamentos da sintaxe e da linguagem


Usando operadores para manipular valores
Os operadores são geralmente utilizados para manipular valores no Flash. Por exemplo, você
poderia criar um jogo no Flash onde o placar mudasse de acordo com a interação do usuário
com as instâncias no Stage (Palco). Use uma variável para reter o valor e os operadores para
manipular o valor da variável.
Por exemplo, você poderia aumentar o valor de uma variável chamada myScore. O exemplo a
seguir demonstra como usar os operadores + (adição) e += (atribuição de adição) para somar e
incrementar valores no código.

Para manipular valores usando os operadores:


1. Crie um novo documento do Flash.
2. Abra o painel Actions (Ações) (Window (Janela) > Actions) e digite o código a seguir no
painel Script:
// example one
var myScore:Number = 0;
myScore = myScore + 1;
trace("Example one: " + myScore); // 1

// example two
var secondScore:Number = 1;
secondScore += 3;
trace("Example two: " + secondScore); // 4

3. Selecione Control (Controlar) > Test Movie (Testar filme).


O painel Output (Saída) exibirá o seguinte texto:
Example one: 1
Example two: 4

O operador de adição é fácil de compreender, pois soma dois valores. No primeiro


exemplo de código, ele soma o valor atual de myScore com o número 1. Depois, armazena
o resultado na variável myScore.
O segundo exemplo de código usa o operador de atribuição de adição para somar e atribuir
um novo valor em uma única etapa. É possível reescrever a linha myScore = myScore + 1
(no exercício anterior) como myScore++ ou, até mesmo, myScore += 1. O operador de
incremento (++) é um modo simplificado de dizer myScore = myScore + 1, pois ele
manipula um incremento e uma atribuição simultaneamente. Veja um exemplo do operador
de incremento no ActionScript a seguir:
var myNum:Number = 0;
myNum++;
trace(myNum); // 1
myNum++;
trace(myNum); // 2

Sobre operadores 187


Observe que o trecho de código anterior não tem operadores de atribuição. Em vez disso, ele
se baseia no operador de incremento.
É possível manipular o valor de uma variável usando operadores quando uma condição é
true. Por exemplo, você poderá usar o operador de incremento (++) para incrementar a
variável i enquanto a condição for true. No código a seguir, a condição será true enquanto i
for menor que 10. Enquanto a condição for true, você incrementará i em um número mais
alto usando i++.
var i:Number;
for (i = 1; i < 10; i++) {
trace(i);
}

O painel Output exibirá os números de 1 a 9, que é a incrementação da variável i até chegar à


condição de término (i é igual a 10), e parará. O último valor exibido é 9. Portanto, o valor de
i será 1 quando o arquivo SWF começar a ser executado e 9 depois que o rastreamento for
concluído.
Para obter mais informações sobre as condições e os loops, consulte “Sobre instruções”
na página 149.

Sobre associatividade e precedência de operadores


Quando dois ou mais operadores são utilizados em uma instrução, alguns deles têm
precedência sobre outros. A precedência e associatividade de operador determinam a ordem
em que os operadores são processados. O ActionScript tem uma hierarquia que determina
quais operadores serão executados primeiro. No final desta seção, há uma tabela que descreve
essa hierarquia.
Embora possa parecer natural para os usuários familiarizados com a aritmética ou a
programação básica que o compilador processe o operador de multiplicação (*) antes do
operador de adição (+), o compilador precisa de instruções explícitas sobre quais operadores
devem ser processados primeiro. Essas instruções são conhecidas como precedência de operador.
Você verá um exemplo de precedência de operador quando estiver trabalhando com os
operadores de multiplicação e adição:
var mySum:Number;
mySum = 2 + 4 * 3;
trace(mySum); // 14

Observe que a saída dessa instrução é 14, pois a multiplicação tem uma precedência de
operador mais alta. Portanto, 4 * 3 e avaliado primeiro e o resultado é somado com o número
2.

188 Fundamentos da sintaxe e da linguagem


É possível determinar o que acontecerá delimitando as expressões entre parênteses. O
ActionScript define uma precedência de operador padrão que pode ser alterada através dos
parênteses (()). Quando uma expressão de adição é colocada entre parênteses, o ActionScript
executa a adição primeiro:
var mySum:Number;
mySum = (2 + 4) * 3;
trace(mySum); // 18

Agora, a saída dessa instrução será 18.


Os operadores também podem ter a mesma precedência. Nesse caso, a associatividade
determinará a ordem em que os operadores serão executados. A associatividade pode ser da
esquerda para a direita ou da direita para a esquerda.
Observe o operador de multiplicação novamente. Ele tem uma associatividade da esquerda
para a direita; portanto, as duas instruções a seguir são idênticas.
var mySum:Number;
var myOtherSum:Number;
mySum = 2 * 4 * 3;
myOtherSum = (2 * 4) * 3;
trace(mySum); // 24
trace(myOtherSum); // 24

Dois ou mais operadores de mesma precedência podem aparecer na mesma expressão. Nesses
casos, o compilador usa as regras de associatividade para determinar qual operador deve ser
processado primeiro. Todos os operadores binários, exceto os de atribuição, possuem a
associatividade da esquerda para direita, o que significa que os operadores da esquerda são
processados antes dos operadores da direita. Os operadores de atribuição e o operador
condicional (?:) possuem a associatividade da direita para a esquerda, o que significa que os
operadores da direita são processados antes dos operadores da esquerda. Para obter mais
informações sobre os operadores de atribuição, consulte “Usando operadores de atribuição”
na página 204. Para obter mais informações sobre o operador condicional (?:), consulte
“Sobre o operador condicional” na página 210.
Por exemplo, considere os operadores de sinal de menor (<) e sinal de maior (>), que possuem
a mesma precedência. Se esses dois operadores forem utilizados na mesma expressão, o
operador da esquerda será processado primeiro porque ambos possuem a associatividade da
esquerda para direita. Isso significa que as duas instruções a seguir produzem a mesma saída:
trace(3 > 2 < 1); // false
trace((3 > 2) < 1); // false

Sobre operadores 189


O operador maior que (>) é processado primeiro, o que resultará em um valor true porque o
operando 3 é maior que o operando 2. Em seguida, o valor true é passado para o operador
menor que (<), junto com o operando 1. O operador menor que (<) converte o valor true no
valor numérico 1 e compara esse valor numérico com o segundo operando 1 para retornar o
valor false (o valor 1 não é menor que 1).
Considere a ordem dos operandos no ActionScript, particularmente quando você estiver
configurando condições complexas e souber a freqüência em que uma dessas condições se
apresenta como true. Por exemplo, se você souber que i será maior que 50 na sua condição,
será necessário escrever i<50 primeiro. Portanto, isso será verificado primeiro, para que a
segunda condição a ser escrita não precise ser verificada com tanta freqüência.
A tabela a seguir lista todos os operadores do ActionScript e sua associatividade, da
precedência mais alta para a mais baixa. Para obter mais informações e diretrizes sobre como
usar os operadores e os parênteses, consulte Capítulo 19, “Formatando a sintaxe do
ActionScript”, na página 799.

Operador Descrição Associatividade


Precedência mais alta
x++ Pós-incremento Esquerda para
direita
x-- Pós-decremento Esquerda para
direita
. Acesso de propriedade de objeto Esquerda para
direita
[ ] Elemento de array Esquerda para
direita
( ) Parênteses Esquerda para
direita
function ( ) Chamada de função Esquerda para
direita
++x Pré-incremento Direita para
esquerda
--x Pré-decremento Direita para
esquerda
- Negação unária, como x = -1 Esquerda para
direita
~ NOT bit a bit Direita para
esquerda

190 Fundamentos da sintaxe e da linguagem


Operador Descrição Associatividade
! NOT lógico Direita para
esquerda
new Alocar objeto Direita para
esquerda
delete Desalocar objeto Direita para
esquerda
typeof Tipo de objeto Direita para
esquerda
void Retorna um valor indefinido Direita para
esquerda
* Multiplicar Esquerda para
direita
/ Dividir Esquerda para
direita
% Módulo Esquerda para
direita
+ Mais unário Direita para
esquerda
- Menos unário Direita para
esquerda
<< Deslocamento para esquerda bit a bit Esquerda para
direita
>> Deslocamento para direita bit a bit Esquerda para
direita
>>> Deslocamento para direita bit a bit (sem sinal) Esquerda para
direita
instanceof Instância de (localiza a classe da qual o objeto é Esquerda para
uma instância) direita
Requer Flash Player 6 ou posterior
< Menor que Esquerda para
direita
<= Menor ou igual a Esquerda para
direita
> Maior que Esquerda para
direita

Sobre operadores 191


Operador Descrição Associatividade
>= Maior ou igual a Esquerda para
direita
== Igual a Esquerda para
direita
!= Diferente de Esquerda para
direita
& AND bit a bit Esquerda para
direita
^ XOR bit a bit Esquerda para
direita
| OR bit a bit Esquerda para
direita
&& AND lógico Esquerda para
direita
|| OR lógico Esquerda para
direita
?: Condicional Direita para
esquerda
= Atribuição Direita para
esquerda
*=, /=, %=, +=, - Atribuição composta Direita para
=, &=, |=, ^=,
esquerda
<<=, >>=, >>>=

, Vírgula Esquerda para


direita

Precedência mais baixa

Sobre uso de operadores com seqüências de


caracteres
Os operadores de comparação só compararão seqüências de caracteres se os dois operandos
forem seqüências de caracteres. Uma exceção a essa regra é o operador de igualdade estrita
(===). Se apenas um operando for uma seqüência de caracteres, o ActionScript converterá
ambos os operandos em números e executará uma comparação numérica. Para obter mais
informações sobre os operadores numéricos, consulte “Usando operadores numéricos”
na página 198.

192 Fundamentos da sintaxe e da linguagem


Com exceção do operador de igualdade (==), os operadores de comparação (>, >=, < e <=)
afetam seqüências de caracteres de maneira diferente quando operam em outros valores.
Os operadores de comparação comparam seqüências de caracteres para determinar qual virá
primeiro pela ordem alfabética. As seqüências de caracteres em maiúsculas têm precedência
sobre as seqüências de caracteres em minúsculas. Isso significa que o "Egg" vem antes de
"chicken".
var c:String = "chicken";
var e:String = "Egg";
trace(c < e); // false
var riddleArr:Array = new Array(c, e);
trace(riddleArr); // chicken,Egg
trace(riddleArr.sort()); // Egg,chicken

Nesse ActionScript, o método sort() da classe Array reordena o conteúdo do array em ordem
alfabética. Observe que o valor “Egg” vem antes de “chicken” porque o E maiúsculo vem antes
do c minúsculo. Para comparar as seqüências de caracteres independentemente do uso de
maiúsculas e minúsculas, é necessário converter as seqüências de caracteres em maiúsculas ou
minúsculas antes de compará-las. Para obter mais informações sobre os operadores de
comparação, consulte “Sobre operadores de igualdade” na página 200 e “Usando operadores
relacionais e de igualdade” na página 200.
É possível usar os métodos toLowerCase() ou toUpperCase() para converter as seqüências
de caracteres e deixá-las com o mesmo uso de maiúsculas e minúsculas antes que elas sejam
comparadas. No exemplo a seguir, as duas seqüências de caracteres são convertidas em
minúsculas e comparadas. Agora, "chicken" virá antes de "egg":
var c:String = "chicken";
var e:String = "Egg";
trace(c.toLowerCase() < e.toLowerCase()); // true
NO T A

Os operadores de comparação comparam apenas duas seqüências de caracteres. Por


exemplo, os operadores não compararão os valores se um operando for um valor
numérico. Se apenas um dos operandos for uma seqüência de caracteres, o
ActionScript converterá ambos os operandos em números e executará uma
comparação numérica.

É possível usar operadores para manipular seqüências de caracteres. Use o operador de adição
(+) para concatenar operandos de seqüências de caracteres. Talvez você já tenha usado o
operador de adição para concatenar seqüências de caracteres ao escrever instruções trace. Por
exemplo, você poderia escrever o seguinte:
var myNum:Number = 10;
trace("The variable is " + myNum + ".");

Sobre operadores 193


Após o teste do código, o painel Output (Saída) exibirá o seguinte:
The variable is 10.

No exemplo a seguir, a instrução trace usa o operador + para concatenar, e não para somar.
Quando você está trabalhando com seqüências de caracteres e números, o Flash, algumas
vezes, concatena em vez de somar numericamente.
Por exemplo, é possível concatenar duas seqüências de caracteres de diferentes variáveis em um
único campo de texto. No código ActionScript a seguir, a variável myNum é concatenada com
uma seqüência de caracteres, que, por sua vez, é exibida no campo de texto myTxt do Stage
(Palco).
this.createTextField("myTxt", 11, 0, 0, 100, 20);
myTxt.autoSize = "left";
var myNum:Number = 10;
myTxt.text = "One carrot. " + myNum + " large eggplants.";
myTxt.text += " Lots of vegetable broth.";

Esse código retorna o seguinte em um campo de texto com o nome de instância myTxt:
One carrot. 10 large eggplants. Lots of vegetable broth.

O exemplo anterior mostrou como é possível usar os operadores de adição (+) e atribuição de
adição (+=) para concatenar seqüências de caracteres. Observe como a terceira linha do código
usa o operador de adição para concatenar o valor da variável myNum no campo de texto e como
a quarta linha do código usa o operador de atribuição de adição para concatenar uma
seqüência de caracteres no valor existente do campo de texto.
Se apenas um dos operandos de seqüência de texto for uma seqüência de caracteres, o Flash
converterá o outro operando em seqüência de caracteres. Portanto, o valor de myNum será
convertido em seqüência de caracteres no exemplo anterior.
NO T A

O ActionScript trata os espaços no começo ou final de uma seqüência de caracteres


como uma parte literal dessa seqüência.

Usando operadores de ponto e de acesso de array


É possível usar o operador de ponto (.) e o operador de acesso de array ([]) para acessar
propriedades internas ou personalizadas do ActionScript. Use os operadores de ponto para
referenciar determinados índices em um objeto. Por exemplo, se um objeto contiver alguma
informação do usuário, especifique um determinado nome de chave no operador de acesso de
array para recuperar o nome de um usuário, conforme demonstrado no ActionScript a seguir:
var someUser:Object = {name:"Hal", id:2001};
trace("User's name is: " + someUser["name"]); // User's name is: Hal
trace("User's id is: " + someUser["id"]); // User's id is: 2001

194 Fundamentos da sintaxe e da linguagem


Por exemplo, o ActionScript a seguir usa o operador de ponto para definir determinadas
propriedades dentro dos objetos:
myTextField.border = true;
year.month.day = 9;
myTextField.text = "My text";

Os operadores de ponto e de acesso de array são muito parecidos. O operador de ponto utiliza
um identificador como propriedade, mas o operador de acesso de array retorna o conteúdo
como nome e acessa o valor desse nome de propriedade. O operador de acesso de array
permite definir e recuperar dinamicamente nomes de instância e variáveis.
O operador de acesso de array será útil ser você não souber exatamente quais chaves estão em
um objeto. Quando isso ocorrer, use o loop for..in para iterar um objeto ou clipe de filme e
exibir seu conteúdo.

Para usar os operadores de ponto e de acesso de array:


1. Em um novo documento do Flash, crie um clipe de filme na Timeline (Linha de tempo)
principal.
2. Selecione o clipe de filme e abra o Property inspector (Inspetor de propriedades).
3. Digite o nome de instância myClip.
4. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline:
myClip.spam = 5;
trace(myClip.spam); // 5

Para definir um valor na instância myClip da linha de tempo atual, use os operadores de
ponto ou de acesso de array, conforme demonstrado nesse ActionScript. Se você escrever
uma expressão dentro do operador de acesso de array, ele a avaliará primeiro e usará o
resultado como nome da variável.
5. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento.
O painel Output (Saída) exibirá o número 5.
6. Retorne ao ambiente de criação e substitua a primeira linha do ActionScript pelo seguinte:
myClip["spam"] = 10;

7. Selecione Control > Test Movie para testar o documento.


O painel Output exibirá o número 10.
8. Retorne ao ambiente de criação e clique duas vezes na instância myClip.
9. Adicione quatro novas instâncias a myClip.
10. Use o Property inspector para adicionar os seguintes nomes de instância a cada uma das
quatro instâncias: nestedClip1, nestedClip2, nestedClip3, nestedClip4.

Sobre operadores 195


11. Adicione o seguinte código ao Frame 1 da Timeline principal:
var i:Number;
for (i = 1; i <= 4; i++) {
myClip["nestedClip" + i]._visible = false;
}

Esse ActionScript alternará a visibilidade de cada clipe de filme aninhado.


12. Selecione Control > Test Movie para testar o ActionScript recém-adicionado.
Agora as quatro instâncias aninhadas não estão mais visíveis. Você está usando o operador
de acesso de array para iterar cada clipe de filme aninhado na instância myClip e definir
sua propriedade visível dinamicamente. Isso economizará tempo porque não é necessário
referenciar especificamente cada instância.
Também é possível usar o operador de acesso de array que fica no lado esquerdo de uma
atribuição, o que permitirá definir dinamicamente a instância, a variável e os nomes de objeto:
myNum[i] = 10;
No ActionScript 2.0, é possível usar o operador de colchetes para acessar propriedades em um
objeto criado dinamicamente, caso a definição de classe desse objeto não receba o atributo
dynamic. Também é possível criar matrizes através desse operador. Para obter mais
informações sobre como criar matrizes com operadores de acesso de array, consulte “Criando
matrizes” na página 178.

Sobre operadores pós-fixados


Os operadores pós-fixados utilizam um operador e incrementam ou decrementam o valor
desse operador. Embora esses operadores sejam unários, eles não são classificados junto com os
demais operadores unários, pois têm uma precedência mais alta e um comportamento
especial. Para obter informações sobre os operadores unários, consulte “Sobre operadores
unários” na página 197.
Quando um operador pós-fixado é utilizado como parte de uma expressão maior, o valor da
expressão é retornado antes do processamento do operador pós-fixado. Por exemplo, o código
a seguir mostra como o valor da expressão xNum++ é retornado antes que ele seja
incrementado.
var xNum:Number = 0;
trace(xNum++); // 0
trace(xNum); // 1

Quando esse código é rastreado, o texto exibido no painel Output (Saída) é o seguinte:
0
1

196 Fundamentos da sintaxe e da linguagem


Os operadores desta tabela possuem a mesma precedência:

Operador Operação executada


++ Incremento (pós-fixado)
-- Decremento (pós-fixado)

Sobre operadores unários


Os operadores unários utilizam um operando. Os operadores de incremento (++) e
decremento (--) desse grupo são operadores pré-fixados; isso significa que eles aparecerão antes
do operando em uma expressão. Eles também podem aparecer depois do operando; nesse
caso, eles serão operadores pós-fixados. Para obter informações sobre os operadores pós-fixados,
consulte “Sobre operadores pós-fixados” na página 196.
Os operadores pré-fixados diferem dos pós-fixados porque o operador de incremento ou
decremento é concluído antes que o valor da expressão geral seja retornado. Por exemplo, o
código a seguir mostra como o valor da expressão xNum++ é retornado depois que ele é
incrementado.
var xNum:Number = 0;
trace(++xNum); // 1
trace(xNum); // 1

Todos os operadores desta tabela possuem a mesma precedência:

Operador Operação executada


++ Incremento (pré-fixado)
-- Decremento (pré-fixado)
+ + unário
! - unário (negação)
typeof Retorna informações de tipo
void Retorna um valor indefinido

Sobre operadores multiplicativos


Os operadores multiplicativos usam dois operandos e executam cálculos de multiplicação,
divisão ou módulo. Outros operadores numéricos incluem operadores aditivos. Para obter
informações sobre os operadores aditivos, consulte “Sobre operadores aditivos” na página 198.

Sobre operadores 197


Todos os operadores desta tabela possuem a mesma precedência:

Operador Operação executada


* Multiplicação
/ Divisão
% Módulo

Para obter informações sobre como usar os operadores multiplicativos, consulte “Usando
operadores numéricos” na página 198.

Sobre operadores aditivos


Os operadores aditivos utilizam dois operandos e executam cálculos de adição ou subtração.
Outros operadores numéricos incluem operadores multiplicativos. Para obter informações
sobre os operadores multiplicativos, consulte “Sobre operadores multiplicativos”
na página 197.
Os operadores desta tabela possuem a mesma precedência:

Operador Operação executada


+ Adição
- Subtração

Para obter informações sobre como usar operadores aditivos, consulte “Usando operadores
numéricos” na página 198.

Usando operadores numéricos


Use operadores numéricos para adicionar, subtrair, dividir e multiplicar valores no
ActionScript. É possível executar vários tipos de operações aritméticas. Um dos operadores
mais comuns é o operador de incremento, geralmente formado como i++. Esse operador tem
outras funções. Para obter mais informações sobre o operador de incremento, consulte
“Usando operadores para manipular valores” na página 187.
É possível adicionar o incremento antes (pré-incremento) ou depois (pós-incremento) de um
operando.

198 Fundamentos da sintaxe e da linguagem


Para compreender os operadores numéricos no ActionScript:
1. Crie um novo documento do Flash.
2. Digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo):
// example one
var firstScore:Number = 29;
if (++firstScore >= 30) {
// should trace
trace("Success! ++firstScore is >= 30");
}
// example two
var secondScore:Number = 29;
if (secondScore++ >= 30) {
// shouldn't trace
trace("Success! secondScore++ is >= 30");
}

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript.
O bloco de códigos “Example one” rastreia, mas o bloco de códigos “Example two” não. O
primeiro exemplo usa um pré-incremento (++firstScore) para incrementar e calcular
firstScore antes que ele seja testado em relação ao número 30. Portanto, firstScore é
incrementado em 30 e, em seguida, testado em relação a esse número.
Entretanto, Example two usa um pós-incremento (secondScore++), que é avaliado após a
execução do teste. Portanto, 29 é comparado com 30 e incrementado em 30 após a
avaliação.
Para obter mais informações sobre a precedência de operador, consulte “Sobre associatividade
e precedência de operadores” na página 188.
Ao carregar dados de fontes externas (como arquivos XML, FlashVars, serviços da Web etc.), é
preciso ter cuidado ao trabalhar com operadores numéricos. Às vezes, o Flash trata os números
como seqüências de caracteres, pois o arquivo SWF não conhece o tipo de dados do número.
Nesse caso, você pode adicionar 3 e 7 para obter o resultado 37, pois os dois números são
concatenados como seqüências de caracteres, em vez de serem somados numericamente. Nesse
caso, é necessário converter manualmente os dados das seqüências de caracteres em números
através da função Number().

Sobre operadores 199


Sobre operadores relacionais
Os operadores relacionais utilizam dois operandos, comparam seus valores e retornam um
valor booleano. Todos os operadores desta tabela possuem a mesma precedência:

Operador Operação executada


< Menor que
> Maior que
<= Menor ou igual a
>= Maior ou igual a
instanceof Verifica a cadeia de protótipos
in Procura propriedades de objeto

Para obter informações sobre como usar os operadores relacionais, consulte “Usando
operadores relacionais e de igualdade” na página 200.

Sobre operadores de igualdade


Os operadores de igualdade utilizam dois operandos, comparam seus valores e retornam um
valor booleano. Todos os operadores desta tabela possuem a mesma precedência:

Operador Operação executada


== Igualdade
!= Diferença
=== Igualdade estrita
!== Diferença estrita

Para obter informações sobre como usar operadores de igualdade, consulte “Usando
operadores relacionais e de igualdade” na página 200.

Usando operadores relacionais e de igualdade


Os operadores relacionais e de igualdade, também chamados de operadores de comparação,
comparam os valores das expressões e retornam true ou false (um valor booleano).
Geralmente, os operadores de comparação são utilizados em loops e instruções condicionais
para especificar a condição aplicável no momento em que o loop deve parar.

200 Fundamentos da sintaxe e da linguagem


Use o operador de igualdade (==) para determinar se os valores ou as referências dos dois
operandos são iguais e se essa comparação retornará um valor booleano. Os operandos de
seqüência de caracteres, números ou valores booleanos são comparados através de um valor.
Os operandos de objeto e array são comparados através de uma referência.
Neste exemplo, veja como usar o operador de igualdade para testar o tamanho do array e
exibir uma mensagem no painel Output (Saída) caso não haja itens no array.
var myArr:Array = new Array();
if (myArr.length == 0) {
trace("the array is empty.");
}

Quando você seleciona Control (Controlar) > Test Movie (Testar filme), a seqüência de
caracteres the array is empty aparece no painel Output.
É possível usar o operador de igualdade para comparar valores, mas não para definir valores.
Tente usar o operador de atribuição (=) para verificar a igualdade.

Para usar os operadores relacionais e de igualdade no código:


1. Crie um novo documento do Flash.
2. Digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo):
var myNum:Number = 2;
if (myNum == 2) {
// do something
trace("It equals 2");
}

Nesse ActionScript, use o operador de igualdade (==) para verificar a igualdade. Verifique
se a variável myNum é igual a 2.
3. Selecione Control > Test Movie.
A seqüência de caracteres It equals 2 aparece no painel Output.
4. Retorne ao ambiente de criação e altere:
var myNum:Number = 2;

para:
var myNum:Number = 4;

5. Selecione Control > Test Movie novamente.


A seqüência de caracteres It equals 2 não aparece no painel Output.
6. Retorne ao ambiente de criação e altere:
if (myNum == 2) {

para
if (myNum = 2) {

Sobre operadores 201


7. Selecione Control > Test Movie novamente.
A seqüência de caracteres It equals 2 aparece no painel Output novamente.
Na etapa 6, você atribui o valor 2 a myNum, em vez de comparar myNum com 2. Nesse caso,
a instrução if é executada independente do valor anterior de myNum, o que pode gerar
resultados inesperados durante o teste do documento do Flash.
Para obter mais informações sobre como utilizar corretamente o operador de atribuição,
consulte “Usando operadores de atribuição” na página 204.
O operador de igualdade estrita (===) é similar ao operador de igualdade; a única diferença é
que ele não realiza a conversão de tipo. Se dois operandos forem de tipos diferentes, o
operador de igualdade retornará false. O operador de diferença estrita (!==) retorna o
resultado oposto ao do operador de igualdade estrita.
O ActionScript a seguir demonstra a diferença-chave entre o operador de igualdade (==) e o
operador de igualdade estrita (===):
var num1:Number = 32;
var num2:String = new String("32");
trace(num1 == num2); // true
trace(num1 === num2); // false

Primeiro, você define as variáveis numéricas: num1 enum2. Se você comparar as variáveis
usando o operador de igualdade, o Flash tentará converter os valores no mesmo tipo de dados
e, em seguida, comparará esses valores para constatar se são iguais. Quando o operador de
igualdade estrita (===) é utilizado, o Flash não tenta realizar nenhuma conversão de tipo de
dados antes de comparar os valores. Conseqüentemente, o Flash considera as variáveis como
dois valores separados.
No exemplo a seguir, você usará o operador de maior ou igual a (>=) para comparar valores e
executar o código com base no valor digitado por um usuário em um campo de texto.

Para usar o operador de maior ou igual a no código:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash) para criar um arquivo FLA.
2. Adicione o seguinte código ao Frame 1 da Timeline principal:
this.createTextField("myTxt", 20, 0, 0, 100, 20);
myTxt.type = "input";
myTxt.border = true;
myTxt.restrict = "0-9";

this.createEmptyMovieClip("submit_mc", 30);
submit_mc.beginFill(0xFF0000);
submit_mc.moveTo(0, 0);
submit_mc.lineTo(100, 0);
submit_mc.lineTo(100, 20);

202 Fundamentos da sintaxe e da linguagem


submit_mc.lineTo(0, 20);
submit_mc.lineTo(0, 0);
submit_mc.endFill();
submit_mc._x = 110;

submit_mc.onRelease = function(evt_obj:Object):Void {
var myNum:Number = Number(myTxt.text);
if (isNaN(myNum)) {
trace("Please enter a number");
return;
}
if (myNum >= 10) {
trace("Your number is greater than or equal to 10");
} else {
trace("Your number is less than 10");
}
};

3. Selecione Control > Test Movie para testar o ActionScript.


Também é possível verificar se determinadas condições são verdadeiras e executar um
bloco alternativa se a condição não for verdadeira.
4. Altere a condição no ActionScript da seguinte maneira.
if (myNum == 10) {
trace("Your number is 10");
} else {
trace("Your number is not 10");
}

5. Selecione Control > Test Movie para testar o ActionScript novamente.


Com exceção do operador de igualdade estrita (===), os operadores de comparação
compararão seqüências de caracteres somente se os operandos forem seqüências de caracteres.
Se apenas um dos operandos for uma seqüência de caracteres, os dois operandos serão
convertidos em números e executarão uma comparação numérica. Para obter mais
informações sobre as seqüências de caracteres e os operadores, consulte “Sobre uso de
operadores com seqüências de caracteres” na página 192. Para obter informações sobre como a
ordem e a precedência de operador afetam o ActionScript, consulte “Sobre associatividade e
precedência de operadores” na página 188.

Sobre operadores 203


Sobre operadores de atribuição
Os operadores de atribuição utilizam dois operandos e atribuem um valor a um operando com
base no valor do outro operando. Todos os operadores desta tabela possuem a mesma
precedência:

Operador Operação executada


= Atribuição
*= Atribuição de multiplicação
/= Atribuição de divisão
%= Atribuição de módulo
+= Atribuição de adição
-= Atribuição de subtração
<<= Atribuição de deslocamento para esquerda bit a bit
>>= Atribuição de deslocamento para direita bit a bit
>>>= Atribuição de deslocamento para direita bit a bit (sem sinal)
&= Atribuição AND bit a bit
^= Atribuição XOR bit a bit
|= Atribuição OR bit a bit

Para obter informações sobre como usar operadores de atribuição, consulte “Usando
operadores de atribuição” na página 204.

Usando operadores de atribuição


Use o operador de atribuição (=) para atribuir um determinado valor a uma variável. Para
atribuir uma seqüência de caracteres a uma variável, faça o seguinte:
var myText:String = "ScratchyCat";

Também é possível usar o operador de atribuição para atribuir diversas variáveis na mesma
expressão. Na instrução a seguir, o valor 10 é atribuído às variáveis numOne, numTwo e
numThree.
var numOne:Number;
var numTwo:Number;
var numThree:Number;
numOne = numTwo = numThree = 10;

204 Fundamentos da sintaxe e da linguagem


Também é possível usar operadores de atribuição composta para combinar operações. Esses
operadores são executados nos dois operandos e, depois, atribuem o novo valor ao primeiro
operando. Por exemplo, essas duas instruções desempenham a mesma função:
var myNum:Number = 0;
myNum += 15;
myNum = myNum + 15;

Ao trabalhar com o operador de atribuição, você poderá ter problemas se tentar somar os
valores de uma expressão, conforme mostrado no exemplo a seguir:
trace("the sum of 5 + 2 is: " + 5 + 2); // the sum of 5 + 2 is: 52

O Flash concatena os valores 5 e 2, em vez de somá-los. Para resolver isso, coloque a expressão
5+2 entre parênteses, conforme mostrado no código a seguir:
trace("the sum of 5 + 2 is: " + (5 + 2)); // the sum of 5 + 2 is: 7

Sobre operadores lógicos


Use operadores lógicos para comparar valores booleanos (true e false) e, em seguida, retorne
um valor booleano com base nessa comparação. Por exemplo, se dois operandos forem
avaliados como true, o operador AND lógico (&&) retornará true. Se um ou ambos os
operandos forem avaliados como true, o operador OR lógico (||) retornará true.
Os operadores lógicos utilizam dois operandos e retornam um resultado booleano. Estes
operadores não têm a mesma precedência e são listados na tabela a seguir por ordem
decrescente de precedência:

Operador Operação executada


&& AND lógico
|| OR lógico

Para obter informações sobre como usar os operadores lógicos, consulte “Usando operadores
lógicos” na página 206.

Sobre operadores 205


Usando operadores lógicos
Os operadores lógicos são freqüentemente usados com os operadores de comparação para
determinar a condição de uma instrução if. Isso é demonstrado pelo exemplo a seguir.

Para usar operadores lógicos no código:


1. Selecione File (Arquivo) > New (Novo) e crie um novo documento do Flash.
2. Abra o painel Actions (Ações) e digite o seguinte ActionScript no Frame 1 (Quadro 1) da
Timeline (Linha de tempo):
this.createTextField("myTxt", 20, 0, 0, 100, 20);
myTxt.type = "input";
myTxt.border = true;
myTxt.restrict = "0-9";

this.createEmptyMovieClip("submit_mc", 30);
submit_mc.beginFill(0xFF0000);
submit_mc.moveTo(0, 0);
submit_mc.lineTo(100, 0);
submit_mc.lineTo(100, 20);
submit_mc.lineTo(0, 20);
submit_mc.lineTo(0, 0);
submit_mc.endFill();
submit_mc._x = 110;

submit_mc.onRelease = function():Void {
var myNum:Number = Number(myTxt.text);
if (isNaN(myNum)) {
trace("Please enter a number");
return;
}
if ((myNum > 10) && (myNum < 20)) {
trace("Your number is between 10 and 20");
} else {
trace("Your number is NOT between 10 and 20");
}
};

Nesse ActionScript, você cria um campo de texto durante a execução. Se você digitar um
número no campo de texto e clicar no botão do Stage (Palco), o Flash usará o operador
lógico para exibir uma mensagem no painel Output (Saída). A mensagem dependerá do
número digitado no campo de texto.

206 Fundamentos da sintaxe e da linguagem


Ao usar operandos, é necessário ter cuidado com a ordem; principalmente quando você estiver
utilizando condições complexas. No trecho a seguir, observe como o operador AND lógico é
utilizado para verificar se um número está entre 10 e 20. De acordo com o resultado, uma
mensagem apropriada será exibida. Se o número for menor que 10 ou maior que 20, uma
mensagem alternativa será exibida no painel Output.
submit_mc.onRelease = function():Void {
var myNum:Number = Number(myTxt.text);
if (isNaN(myNum)) {
trace("Please enter a number");
return;
}
if ((myNum > 10) && (myNum < 20)) {
trace("Your number is between 10 and 20");
} else {
trace("Your number is NOT between 10 and 20");
}
};

Sobre operadores de deslocamento bit a bit


Os operadores de deslocamento bit a bit utilizam dois operandos e deslocam os bits do
primeiro operando até o ponto especificado pelo segundo operando. Todos os operadores
desta tabela possuem a mesma precedência:

Operador Operação executada


<< Deslocamento para esquerda bit a bit
>> Deslocamento para direita bit a bit
>>> Deslocamento para direita bit a bit (sem sinal)

Para obter informações sobre como usar operadores bit a bit, consulte “Usando operadores bit
a bit” na página 208. Para obter informações específicas sobre cada operador bit a bit, consulta
a entrada correspondente em ActionScript 2.0 Language Reference (Referência à Linguagem
ActionScript 2.0).

Sobre operadores 207


Sobre operadores lógicos bit a bit
Os operadores lógicos bit a bit utilizam dois operandos e executam operações lógicas em nível
de bit. Estes operadores não têm a mesma precedência e são listados na tabela a seguir por
ordem decrescente de precedência:

Operador Operação executada


& AND bit a bit
^ XOR bit a bit
| OR bit a bit

Para obter informações sobre como usar operadores bit a bit, consulte “Usando operadores bit
a bit” na página 208. Para obter mais informações sobre cada operador bit a bit, consulte a
entrada correspondente em ActionScript 2.0 Language Reference (Referência à linguagem
ActionScript 2.0).

Usando operadores bit a bit


Os operadores bit a bit manipulam internamente números de ponto flutuante para
transformá-los em números inteiros de 32 bits. A operação exata realizada depende do
operador, mas todas as operações bit a bit avaliam cada dígito binário (bit) do número inteiro
de 32 bits individualmente para computar um novo valor. Para obter uma lista de operadores
de deslocamento bit a bit, consulte “Sobre operadores de deslocamento bit a bit”
na página 207. Para obter uma lista de operadores lógicos bit a bit, consulte “Sobre operadores
lógicos bit a bit” na página 208.
Usar os operadores bit a bit no Flash não é muito comum, mas pode ser útil em algumas
circunstâncias. Por exemplo, talvez seja necessário criar uma matriz de permissões para um
projeto do Flash, mas sem criar variáveis separadas para cada tipo de permissão. Nesse caso,
você poderia usar operadores bit a bit.
O exemplo a seguir mostra como usar o operador OR bit a bit com o método Array.sort()
para especificar opções de classificação.

Para usar o operador OR bit a bit:


1. Selecione File (Arquivo) > New (New) e crie um novo documento do Flash.

208 Fundamentos da sintaxe e da linguagem


2. Digite o seguinte ActionScript no painel Actions (Ações):
var myArr:Array = new Array("Bob", "Dan", "doug", "bill", "Hank",
"tom");
trace(myArr); // Bob,Dan,doug,bill,Hank,tom
myArr.sort(Array.CASEINSENSITIVE | Array.DESCENDING);
trace(myArr); // tom,Hank,doug,Dan,Bob,bill

A primeira linha define um array de nomes aleatórios e os rastreia no painel Output


(Saída). Depois, você chama o método Array.sort() e especifica duas opções de
classificação usando os valores constantes Array.CASEINSENSITIVE e
Array.DESCENDING. O resultado do método de classificação faz com que os itens no array
sejam classificados na ordem inversa (de 'z' a 'a'). A pesquisa não faz distinção entre
maiúsculas e minúsculas; ou seja, a e A são considerados idênticos, diferente da pesquisa
que faz distinção entre maiúsculas e minúsculas, onde o Z teria precedência sobre o a.
3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript. O
seguinte texto será exibido no painel Output (Saída):
Bob,Dan,doug,bill,Hank,tom
tom,Hank,doug,Dan,Bob,bill

Existem cinco opções disponíveis no método de classificação:


■ 1 ou Array.CASEINSENSITIVE (binary = 1)
■ 2 ou Array.DESCENDING (binary = 10)
■ 4 ou Array.UNIQUESORT (binary = 100)
■ 8 ou Array.RETURNINDEXEDARRAY (binary = 1000)
■ 16 ou Array.NUMERIC (binary = 10000)
Existem três maneiras diferentes de definir as opções de classificação de um array:
my_array.sort(Array.CASEINSENSITIVE | Array.DESCENDING); // constants
my_array.sort(1 | 2); // numbers
my_array.sort(3); // adding the numbers

Embora isso provavelmente não seja óbvio, os valores numéricos das opções de classificação
são, na verdade, dígitos bit a bit (binários ou de base 2). O valor de constante
Array.CASEINSENSITIVE equivale ao valor numérico 1, que também é o valor binário 1. O
valor de constante Array.DECENDING tem um valor numérico 2 ou um valor binário 10.
Trabalhar com números binários pode ser confuso. O valor binário tem apenas dois valores
possíveis, 1 ou 0. É por isso que o valor 1 é representado como 10. Para exibir o número 3
como valor binário, ele seria 11 (1+10). O número 4 representado em binário é 100, o
número 5 em binário é 101, e assim sucessivamente.

Sobre operadores 209


O ActionScript a seguir demonstra como classificar um array de valores numéricos em ordem
decrescente usando o operador AND bit a bit para adicionar as constantes
Array.DESCENDING e Array.NUMERIC juntas.
var scores:Array = new Array(100,40,20,202,1,198);
trace(scores); // 100,40,20,202,1,198
trace(scores.sort()); // 1,100,198,20,202,40
var flags:Number = Array.NUMERIC|Array.DESCENDING;
trace(flags); // 18 (base 10)
trace(flags.toString(2)); // 10010 (binary -- base2)
trace(scores.sort(flags)); // 202,198,100,40,20,1

Sobre o operador condicional


O operador condicional é ternário, o que significa que ele utiliza três operandos. Ele é um
método abreviado de aplicação da instrução condicional if..else:

Operador Operação executada


?: Condicional

Para obter informações sobre como usar o operador condicional e um exemplo, consulte
“Sobre o operador condicional e a sintaxe alternativa” na página 160.

Usando operadores em um documento


No exemplo a seguir, o método Math.round() é utilizado para arredondar os cálculos para
um número arbitrário de casas decimais. Esse método arredonda o valor do parâmetro x para
cima ou para baixo até chegar ao inteiro mais próximo e retorna esse valor. Após modificar um
pouco o ActionScript, você pode fazer com que o Flash arredonde os números para um
determinado número de casas decimais.
No exemplo a seguir, os operadores de divisão e multiplicação também são utilizados para
calcular os pontos de um usuário com base no número de respostas corretas dividido pelo
número total de perguntas. Os pontos do usuário podem ser multiplicados por um número e
exibidos para que se obtenha pontos entre 0% e 100%. Em seguida, use o operador de adição
para concatenar os pontos do usuário em uma seqüência de caracteres exibida no painel
Output (Saída).

210 Fundamentos da sintaxe e da linguagem


Para usar os operadores no ActionScript:
1. Crie um novo documento do Flash.
2. Digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
var correctAnswers:Number = 11;
var totalQuestions:Number = 13;
//round to the nearest integer
//var score:Number = Math.round(correctAnswers / totalQuestions * 100);
//round to two decimal places
var score:Number = Math.round(correctAnswers / totalQuestions * 100 *
100) / 100;
trace("You got " + correctAnswers + " out of " + totalQuestions + "
answers correct, for a score of " + score + "%.");

3. Selecione Control (Controlar) > Test Movie (Testar filme).


O painel Output exibirá o seguinte texto:
You got 11 out of 13 answers correct, for a score of 84.62%.

Quando você chamar Math.round() nesse exemplo, os pontos serão arredondados para o
número inteiro mais próximo (85) e exibidos no painel Output. Se você multiplicar o
número por 100, antes de chamar Math.round() e dividi-lo por 100, faça com que o
Flash arredonde o número para 2 casas decimais. Esse procedimento retornará uma
pontuação mais precisa.
4. Tente alterar a variável correctAnswers para 3 e selecione Control > Test Movie para
testar o arquivo SWF novamente.
Caso esteja desenvolvendo um aplicativo de teste, talvez seja necessário criar uma série de
perguntas verdadeiro/falso ou de múltipla escolha usando os componentes RadioButton e
Label. Depois que os usuários terminarem de responder cada pergunta e clicar no botão
Submit (Enviar), compare as respostas com um gabarito e calcule os pontos dos usuários.

Sobre operadores 211


212 Fundamentos da sintaxe e da linguagem
CAPÍTULO 6

Funções e métodos 6
Entender funções é importante quando se está escrevendo ActionScript, criando classes e
usando métodos. Há diversos tipos de funções com os quais você irá trabalhar. Nesse capítulo,
você aprenderá sobre funções e métodos: como usá-los nos aplicativos quando se usa classes
internas e como criá-los. No Capítulo 7, “Classes,”, você criará classes personalizadas para as
quais escreverá funções regularmente. Você também aprenderá a criar funções em arquivos de
classe do ActionScript.
Você pode usar funções no seu código para adicionar interatividade, animações e outros
efeitos aos aplicativos. Esse capítulo aborda os tipos de função que você pode criar nos
aplicativos Flash. Para obter informações sobre quais são essas funções e esses métodos, assim
como exercícios nos quais você poderá criar e usar funções e métodos no Flash, consulte os
tópicos a seguir:
Sobre funções e métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Noções básicas sobre métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .235

Sobre funções e métodos


Os métodos e as funções são blocos de código ActionScript que podem ser reutilizados em
qualquer lugar de um arquivo SWF. Você pode criar suas funções no arquivo FLA ou em um
arquivo externo do ActionScript e chamá-las em qualquer local de seus documentos. Métodos
são meramente funções que estão localizadas dentro de uma definição de classe do
ActionScript. Você pode definir funções para executar uma série de instruções sobre valores
passados. As funções também podem retornar valores. Depois que uma função for definida,
ela poderá ser chamada de qualquer Timeline, incluindo aquela de um arquivo SWF
carregado.

213
Se você passar valores como parâmetros para uma função, esta poderá executar cálculos
usando os valores fornecidos. Cada função tem suas próprias características e algumas delas
exigem que você passe determinados tipos ou números de valores. Se você passar mais
parâmetros do que o necessário para a função, ela ignorará os valores extras. Se algum
parâmetro obrigatório não for passado, a função atribuirá o tipo de dados undefined aos
parâmetros vazios. o que poderá gerar erros durante a execução. Uma função também pode
retornar valores (consulte “Retornando valores de funções” na página 233).
N OT A

Para chamar uma função, a definição dessa função deve estar em um quadro que já
tenha sido reproduzido.

Uma função bem escrita pode ser considerada uma “caixa-preta”. Se ela tiver comentários
cuidadosamente inseridos a respeito de sua entrada, saída e objetivo, um usuário da função
não precisará compreender exatamente como ela funciona internamente.
A sintaxe básica para uma função com nome simples é:
function traceMe() {
trace("sua mensagem");
}
traceMe();

Para obter informações sobre a criação de funções com nome, consulte “Criando funções com
nome” na página 219.
A sintaxe básica de uma função com nome simples que é criada no exemplo anterior passando
um parâmetro, yourMessage, é:
function traceMe(yourMessage:String) {
trace(yourMessage);
}
traceMe("Como vai você?");

Como alternativa, se você quiser passar diversos parâmetros, você poderia usar o seguinte
código:
var yourName:String = "Ester";
var yourAge:String = "65";
var favSoftware:String = "Flash";
function traceMe(favSoftware:String, yourName:String, yourAge:String) {
trace("I'm " + yourName + ", I like " + favSoftware + ", and I'm " +
yourAge + ".");
}
traceMe(favSoftware,yourName,yourAge);

Para obter mais informações sobre como passar parâmetros, consulte “Passando parâmetros
para uma função” na página 231.

214 Funções e métodos


Há diversos tipos de função que você pode criar. Para obter mais informações sobre criação de
funções, assim como links para seções sobre criação de tipos específicos de função, consulte
“Sobre tipos de métodos e funções” na página 215. Para ver um exemplo de comparação entre
métodos e funções, consulte “Noções básicas sobre métodos” na página 235.
N OT A

Para obter informações sobre criação de código usando Script Assist, consulte
“Criando ActionScript com o Script Assist” na página 368, “Criando um evento
startDrag/stopDrag com o Script Assist” na página 372 e o tutorial ActionScript:Use
Script Assist Mode (que começa com “Open the starter document” on page 211).

Para obter mais informações sobre funções e métodos, consulte os tópicos a seguir:
■ “Sobre tipos de métodos e funções” na página 215

Sobre tipos de métodos e funções


As funções pertencentes a uma classe são denominadas de métodos dessa classe. Há diversos
tipos de funções que você pode usar nos aplicativos, incluindo funções internas, com nome e
definidas pelo usuário, anônimas, de retorno, construtoras e literais de função. As seções a
seguir contêm informações sobre como definir essas funções.
Você também pode criar funções em um arquivo de classe do ActionScript. Essas funções são
usadas como métodos nos scripts. No exemplo a seguir, a classe Person exibe um método
construtor, métodos de classe, métodos de instância e métodos de acesso (getters e setters): Os
comentários no código de exemplo mostram em que parte do código esses métodos ocorrem.
N OT A

Para obter informações sobre criação de arquivos de classe, tais como o seguinte,
consulte o Capítulo 7, “Classes”, na página 239.

class Person {
public static var numPeople:Number = 0;

// membros de instância
private var _speed:Number;

// construtor
public function Person(speed:Number) {
Person.numPeople++;
this._speed = speed;
}

// métodos estáticos
public static function getPeople():Number {
return Person.numPeople;
}

Sobre funções e métodos 215


// métodos de instância
public function walk(speed:Number):Void {
this._speed = speed;
}
public function run():Void {
this._speed *= 2;
}
public function rest():Void {
this._speed = 0;
}

// getters/setters (métodos de acesso)


public function get speed():Number {
return this._speed;
}
}

Para obter uma demonstração completa de como criar métodos como os do código de
exemplo anterior, consulte o Capítulo 7, “Classes”, na página 239. Os métodos usados no
código devem pertencer a uma classe que seja interna à linguagem ActionScript. MovieClip e
Math são exemplos de classes de nível superior que podem ser usadas em um aplicativo.
Quando são usados no código métodos dessas classes, isso significa que eles são funções
criadas na classe interna (semelhantes ao código de exemplo anterior). Opcionalmente, você
poderia usar métodos de uma classe personalizada que tivesse criado.
As funções não pertencentes a uma classe são chamadas de funções de nível superior (às vezes
chamadas de pré-definidas ou funções internas), significando que você pode chamá-las sem um
construtor. Exemplos de funções que são internas ao nível superior da linguagem ActionScript
são trace() e setInterval().
Para adicionar uma chamada de função de nível superior ao código, basta adicionar uma única
linha de código no painel Script do painel Actions (Ações). Por exemplo, digite o seguinte:
trace("minha mensagem");

Quando o arquivo SWF é testado com essa única linha de código, a função de nível superior
trace() é chamada e o texto é exibido no painel Output (Saída).
Quando desejar atribuir um método a uma propriedade, lembre-se de que é necessário omitir
os parênteses após o nome do método porque você está passando uma referência à função:
my_mc.myMethod = aFunction;

216 Funções e métodos


Entretanto, para chamar um método em seu código, você precisará incluir os parênteses após
o nome do método:
my_mc.myMethod();
NO T A

Para obter mais informações sobre funções de nível superior, consulte “Sobre funções
internas e de nível superior” na página 217.

Também há várias outras maneiras de se definir funções. Para obter mais informações sobre
cada tipo de função, consulte as seguintes seções:
■ “Sobre funções internas e de nível superior” na página 217
■ “Criando funções com nome” na página 219
■ “Criando funções anônimas e de retorno de chamada” na página 220
■ “Sobre literais de função” na página 222
■ “Especificando e chamando funções definidas pelo usuário” na página 225
■ “Sobre funções construtoras” na página 223
Para obter informações sobre a criação e o uso de funções e métodos, consulte as seguintes
seções relacionadas. Para obter informações sobre o uso de funções, consulte “Usando funções
no Flash” na página 227. Para obter informações sobre o uso de métodos, consulte “Noções
básicas sobre métodos” na página 235.
N OT A

Para obter informações sobre criação de código usando Script Assist, consulte
“Criando ActionScript com o Script Assist” na página 368, “Criando um evento
startDrag/stopDrag com o Script Assist” na página 372 e o tutorial ActionScript:Use
Script Assist Mode (que começa com “Open the starter document” on page 211).

Sobre funções internas e de nível superior


Como já foi discutido em “Sobre funções e métodos” na página 213, uma função é um bloco
de código ActionScript que pode ser reutilizado em qualquer lugar de um arquivo SWF. Se
você passar valores como parâmetros para uma função, a função operará com esses valores.
Uma função também pode retornar valores.
Você pode usar funções que são internas à linguagem ActionScript. Elas podem ser funções de
nível superior, como descrito em “Sobre tipos de métodos e funções” na página 215, ou estar
contidas em uma classe interna, como Math ou MovieClip, que podem ser usadas como
métodos no aplicativo.

Sobre funções e métodos 217


No ActionScript, funções internas são utilizadas para realizar determinadas tarefas e acessar
informações. Por exemplo, para obter o número de milissegundos de reprodução do arquivo
SWF, você pode usar getTimer(). Também é possível obter o número da versão do Flash
Player que hospeda o arquivo usando getVersion(). As funções que pertencem a um objeto
são denominadas métodos. As funções que não pertencem a um objeto são denominadas
funções de nível superior e são encontradas em subcategorias da categoria Global Functions
(Funções globais) do painel Actions (Ações).
Algumas funções internas exigem que se passe determinados valores. Se forem passados mais
parâmetros do que o exigido pela função, os valores extras serão ignorados. Se algum
parâmetro obrigatório não for passado, o tipo de dados undefined será atribuído aos
parâmetros vazios, o que poderá gerar erros durante a execução.
NO T A

Para chamar uma função, a definição dessa função deve estar em um quadro que já
tenha sido reproduzido.

As funções de nível superior são fáceis de usar. Para chamar uma função, basta usar o nome da
função e passar os parâmetros necessários: (Para obter informações sobre parâmetros
necessários, consulte a entrada para a função em ActionScript 2.0 Language Reference,
Referência da linguagem ActionScript). Por exemplo, adicione o seguinte ActionScript ao Frame
1 (Quadro 1) da Timeline (Linha de tempo):
trace("minha mensagem");

Ao testar o arquivo SWF, minha mensagem é exibida no painel Output (Saída). Dois outros
exemplos de funções de nível superior são setInterval() e getTimer(). O próximo
exemplo mostra como usar essas duas funções em conjunto. Adicione o seguinte código ao
Frame 1 (Quadro 1) da Timeline (Linha de tempo):
function myTimer():Void {
trace(getTimer());
}
var intervalID:Number = setInterval(myTimer, 100);

Esse código cria um temporizador simples usando getTimer() e usa as funções de nível
superior setInterval() e trace() para exibir o número de milissegundos desde que o
arquivo SWF começou a ser reproduzido no Flash Player.
Chamar uma função de nível superior é como chamar uma função definida pelo usuário. Para
obter mais informações, consulte “Especificando e chamando funções definidas pelo usuário”
na página 225. Para obter informações sobre cada função, consulte a entrada correspondente
em ActionScript 2.0 Language Reference (Referência da linguagem ActionScript).

218 Funções e métodos


Criando funções com nome
Uma função com nome é um tipo de função que você geralmente cria no código ActionScript
para executar todos os tipos de ação. Quando você cria um arquivo SWF, as funções com
nome são compiladas primeiro, o que significa que você pode fazer referência à função em
qualquer parte do código, contanto que a função tenha sido definida no quadro atual ou
anterior. Por exemplo, se uma função for definida no Frame 2 de uma timeline, você não
poderá acessar essa função no Frame 1 da timeline.
O formato padrão das funções com nome é o seguinte:
function functionName(parameters) {
// bloco de função
}

Esse código contém as seguintes partes:


■ nomeFunção é o nome exclusivo da função. Todos os nomes de funções em um
documento devem ser exclusivos.
■ paramêtros contém um ou mais parâmetros que são passados para a função. Os
parâmetros são às vezes chamados argumentos. Para obter mais informações sobre
parâmetros, consulte “Passando parâmetros para uma função” na página 231.
■ // bloco de função contém todo o código ActionScript executado pela função. Essa
parte contém as instruções que executam várias ações. Você pode colocar o código que
deseja executar aqui. O comentário // bloco de função é um espaço reservado onde o
código referente ao bloco de função deve ser inserido.

Para usar uma função com nome:


1. Crie um novo documento chamado namedFunc.fla.
2. Importe um arquivo de som curto para a biblioteca selecionando File (Arquivo) > Import
(Importar) > Import to Library (Importar para a biblioteca) e selecionando um arquivo de
som.
3. Clique com o botão direito do mouse no arquivo de som e selecione Linkage (Vinculação).
4. Digite mySoundID na caixa de texto Identifier (Identificador).
5. Selecione o Frame 1 da Timeline e adicione o seguinte código ao painel Actions:
function myMessage() {
trace("mySoundID completed");
}
var my_sound:Sound = new Sound();
my_sound.attachSound("mySoundID");
my_sound.onSoundComplete = myMessage;
my_sound.start();

Sobre funções e métodos 219


Nesse código, você cria uma função com nome chamada myMessage, que pode ser usada
posteriormente no script para chamar uma função trace().
6. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o arquivo SWF.
Use a instrução function para criar sua própria função no ActionScript. Lembre-se de que os
parâmetros são opcionais; entretanto, se não houver parâmetros, ainda será necessário incluir
os colchetes. O conteúdo entre as chaves ({}) é chamado bloco de função.
Você pode criar funções na timeline principal ou em arquivos externos do ActionScript,
incluindo arquivos de classes.
Também é possível criar funções construtoras em arquivos de classes usando esse formato
(entretanto, o nome da função corresponde à classe). Para obter mais informações sobre
funções construtoras, consulte “Criando a função construtora” na página 283. Consulte
também o Capítulo 7, “Classes”, na página 239 para obter exemplos e informações sobre a
criação de funções em classes.

Criando funções anônimas e de retorno de chamada


Uma função com nome é uma função a que você se refere no script antes ou depois de defini-
la, enquanto que uma função anônima é uma função sem nome que faz referência a si mesma;
você faz referência à função anônima ao criá-la. Ao criar código ActionScript, você cria muitas
funções anônimas.
As funções anônimas são normalmente usadas quando se trabalha com manipuladores de
eventos. Para criar uma função anônima, você pode armazenar um literal de função em uma
variável. Portanto, é possível fazer referência à função posteriormente no código. O próximo
exemplo mostra como criar uma função anônima.

Para criar uma função anônima:


1. Crie um clipe de filme no Stage (Palco) e selecione o clipe.
2. Abra o inspetor Properties e digite my_mc na caixa de texto Instance Name (Nome de
instância).
3. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte código
no painel Actions (Ações):
var myWidth = function () {
trace(my_mc._width);
};
//posteriormente no código você pode adicionar
myWidth();

4. Selecione Control > Test Movie.


A largura do clipe de filme é exibida no painel Output (Saída).

220 Funções e métodos


Também é possível criar uma função em um objeto, como uma instância LoadVars ou XML.
Você pode associar uma função anônima a um determinado evento para criar uma função de
retorno de chamada. Uma função chama uma função de retorno de chamada quando ocorre
um evento específico, como, por exemplo, após um carregamento (onLoad()) ou uma
animação (onMotionFinished()).
Por exemplo, às vezes é necessário criar um código ActionScript para manipular os dados
carregados em um arquivo SWF a partir do servidor. Depois que os dados são carregados no
arquivo, é possível acessá-los nesse local. É importante usar o ActionScript para verificar se os
dados foram totalmente carregados. As funções de retorno de chamada podem ser usadas para
enviar um sinal indicando que os dados foram carregados no documento.
Na função de retorno de chamada a seguir, na qual você carrega um documento XML remoto,
uma função anônima é associada ao evento onLoad(). Você usa XML.load() e a função de
retorno de chamada, como mostra o exemplo a seguir. Digite o seguinte código no Frame 1
(Quadro 1) da Timeline (Linha de tempo):
var my_xml:XML = new XML();
my_xml.onLoad = function(success:Boolean):Void {
trace(success);
};
my_xml.load("http://www.helpexamples.com/crossdomain.xml");

No trecho de código anterior, observe que o manipulador de eventos onLoad() usa uma
função anônima para manipular o evento onLoad().
Para obter mais informações sobre funções de retorno de chamada, consulte o Capítulo 10,
“Manipulando eventos”, na página 347.
Você também pode usar funções anônimas com a função setInterval(), conforme
mostrado no código a seguir, que usa setInterval() para chamar a função anônima
aproximadamente a cada 1000 milissegundos (1 segundo):
setInterval(function() {trace("intervalo");}, 1000);

Você pode usar funções com nome em vez de funções anônimas. Funções com nome são
geralmente mais fáceis de ler e entender (exceto em algumas circunstâncias, tais como funções
de retorno de chamada). Também é possível fazer referência antecipada a uma função com
nome; isso significa que ela é referenciada antes de existir em uma Timeline.
Você não pode referenciar uma função anônima em nenhuma parte do código (a menos que
atribua a função a uma variável), da mesma maneira que pode ser feito com funções com
nome. Por exemplo, suponha que você tenha funções anônimas no Frame 5 do arquivo FLA,
como as seguintes:
//com um clipe de filme chamado my_mc que estende uma timeline
stop();
var myWidth = function () {

Sobre funções e métodos 221


trace(my_mc._width);
};

Se você colocar o código a seguir no Frame 1, ele não referenciará a função:


myWidth();

Da mesma maneira, o código a seguir, colocado em qualquer quadro, não funciona:


myWidth();
var myWidth:Function = function () {
trace(my_mc._width);
};

No entanto, este código funciona corretamente:


var myWidth:Function = function () {
trace(my_mc._width);
};
myWidth();
N OT A

Você também pode colocar myWidth() em qualquer quadro após o quadro que contém a
função myWidth.

Ao definir uma função com nome, chamá-la em um script de quadro funciona, embora o
código equivalente com uma função anônima não funcione:
// o código a seguir funciona porque você está chamando uma função com nome:
myWidth();
function myWidth() {
trace("foo");
}
// o código a seguir não funciona porque você está chamando uma função
anônima:
myWidth();
var myWidth:Function = function () {
trace("foo");
};

Para obter mais informações, consulte “Criando funções com nome” na página 219.
N OT A

Para obter informações sobre criação de código usando Script Assist, consulte
“Criando ActionScript com o Script Assist” na página 368, “Criando um evento
startDrag/stopDrag com o Script Assist” na página 372 e o tutorial ActionScript:Use
Script Assist Mode (que começa com “Open the starter document” on page 211).

Sobre literais de função


Um literal de função é uma função sem nome declarada em uma expressão em vez de em uma
instrução. Os literais são úteis quando é necessário usar uma função temporariamente ou usar
uma função no código no lugar de uma expressão. Esta é a sintaxe de um literal de função:

222 Funções e métodos


function (param1, param2, etc) {
// instruções
};

Por exemplo, o código a seguir usa um literal de função como expressão:


var yourName:String = "Ester";
setInterval(function() {trace(yourName);}, 200);
N OT A

Quando você redefine um literal de função, a definição da nova função substitui a antiga.

Você pode armazenar um literal de função em uma variável para acessá-lo posteriormente em
seu código. Para fazer isso, use uma função anônima. Para obter mais informações, consulte
“Criando funções anônimas e de retorno de chamada” na página 220.

Sobre funções construtoras


Um construtor de classe é uma função especial chamada automaticamente quando você cria
uma instância de uma classe usando a palavra-chave new (por exemplo, var my_xml:XML =
new XML();). A função construtora tem o mesmo nome da classe que a contém. Por exemplo,
uma classe personalizada Person criada conteria a seguinte função construtora:
public function Person(speed:Number) {
Person.numPeople++;
this._speed = speed;
}

Em seguida, você poderia criar uma nova instância usando:


var myPerson:Person = new Person();
NO T A

Se nenhuma função construtora for explicitamente declarada, ou seja, se você não criar
uma função cujo nome corresponda ao da classe, o compilador automaticamente criará
uma função construtora vazia.

Uma classe pode conter apenas uma função construtora; funções construtoras sobrecarregadas
não são permitidas no ActionScript 2.0. Além disso, uma função construtora não pode ter um
tipo de retorno. Para obter mais informações sobre a criação de funções construtoras em
arquivos de classe, consulte “Criando a função construtora” na página 283.

Sobre funções e métodos 223


Definindo funções globais e de timeline
Em “Sobre funções e métodos” na página 213, você explorou os diversos tipos de funções
disponíveis no Flash. Assim como as variáveis, as funções são anexadas à Timeline do clipe de
filme que as define, e você deve usar um caminho de destino para chamá-las. Como ocorre
com as variáveis, você pode usar o identificador _global se desejar declarar uma função global
disponível para todas as timelines e escopos sem usar um caminho de destino. Para definir
uma função global, preceda o nome da função com o identificador _global, como no
seguinte exemplo:
_global.myFunction = function(myNum:Number):Number {
return (myNum * 2) + 3;
};
trace(myFunction(5)) // 13

Para obter informações sobre _global e escopo, consulte “Sobre variáveis e escopo”
na página 101.
Para definir uma função de timeline, use a instrução function seguida do nome da função,
dos parâmetros a serem passados para a função e das instruções do ActionScript que indicam o
que ela faz.
O exemplo a seguir é uma função denominada areaOfCircle com o parâmetro radius:
function areaOfCircle(radius:Number):Number {
return (Math.PI * radius * radius);
}
trace (areaOfCircle(8));

Também há várias outras maneiras de se definir funções. Para obter mais informações sobre
cada tipo de função, consulte as seguintes seções:
■ “Sobre funções internas e de nível superior” na página 217
■ “Criando funções com nome” na página 219
■ “Criando funções anônimas e de retorno de chamada” na página 220
■ “Sobre literais de função” na página 222
■ “Sobre funções construtoras” na página 223
■ “Especificando e chamando funções definidas pelo usuário” na página 225

224 Funções e métodos


Para obter informações sobre a atribuição de nomes a funções, consulte “Atribuindo nomes a
funções” na página 226. Para obter um exemplo detalhado do uso de funções em um arquivo
de classe externo, consulte “Usando funções no Flash” na página 227 e o Capítulo 7,
“Classes”, na página 239
N OT A

Para obter informações sobre criação de código usando Script Assist, consulte
“Criando ActionScript com o Script Assist” na página 368, “Criando um evento
startDrag/stopDrag com o Script Assist” na página 372 e o tutorial ActionScript:Use
Script Assist Mode (que começa com “Open the starter document” on page 211).

Especificando e chamando funções definidas pelo


usuário
As funções definidas pelo usuário são aquelas criadas para serem usadas em aplicativos, em
contraposição às funções de classes internas que executam funções predefinidas. Você mesmo
atribui um nome às funções e adiciona instruções ao bloco de função. As seções anteriores
abordam a criação de funções com nome, sem nome e de retorno de chamada. Para obter
informações sobre a atribuição de nomes a funções, consulte “Atribuindo nomes a funções”
na página 226 e, para obter informações sobre o uso de funções, consulte “Usando funções no
Flash” na página 227.
Você pode usar um caminho de destino para chamar uma função em qualquer timeline a
partir de qualquer outra timeline, inclusive daquela de um arquivo SWF carregado. Para
chamar uma função, digite o caminho de destino para o nome da função, se for preciso, e
passe os parâmetros necessários entre parênteses. Há vários tipos de sintaxe para as funções
definidas pelo usuário. O código a seguir usa um caminho para chamar a função
initialize(), que foi definida na timeline atual e não requer parâmetro algum:
this.initialize();

O exemplo a seguir usa um caminho relativo para chamar a função list() definida no clipe
de filme functionsClip:
this._parent.functionsClip.list(6);

Para obter informações sobre a criação de funções com nome, consulte “Criando funções com
nome” na página 219. Para obter mais informações sobre parâmetros, consulte “Passando
parâmetros para uma função” na página 231.
Você também pode definir suas próprias funções com nome. Por exemplo, a seguinte função
com nome helloWorld() é definida pelo usuário:
function helloWorld() {
trace("Olá mundo!");
};

Sobre funções e métodos 225


O exemplo a seguir mostra como usar uma função definida pelo usuário em um arquivo FLA.

Para criar e chamar uma função simples definida pelo usuário:


1. Crie um novo documento do Flash e salve-o como udf.fla.
2. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
function traceHello(name:String):Void {
trace("hello, " + name + "!");
}
traceHello("world"); // hello, world!

O código anterior cria uma função definida pelo usuário chamada traceHello() que
utiliza um argumento, name, e apresenta uma mensagem de saudação. Para chamar uma
função definida pelo usuário, você pode chamar traceHello a partir da mesma timeline
que a definição da função e passar um único valor de seqüência de caracteres.
3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
Para obter mais informações sobre funções com nome, consulte “Criando funções com nome”
na página 219. As classes contêm várias funções definidas pelo usuário. Para obter
informações sobre a criação de funções em arquivos de classes, consulte “Usando funções no
Flash” na página 227. Consulte também as seguintes seções do Capítulo 7, “Classes”: “Usando
métodos e propriedades de um arquivo de classe” na página 260, “Sobre propriedades
(membros) e métodos públicos, privados e estáticos” na página 262 e “Sobre membros de
classe” na página 265.

Atribuindo nomes a funções


Os nomes de funções devem iniciar em letra minúscula e descrever o valor retornado por elas,
se for o caso. Por exemplo, se a função estiver retornando o nome de uma música, você deverá
atribuir à função o nome getCurrentSong().
Estabeleça um padrão para agrupar funções semelhantes (funções relacionadas entre si com
base na funcionalidade) porque o ActionScript não permite sobrecarga. No contexto da
programação orientada a objeto, a sobrecarga refere-se à capacidade de fazer com que as
funções se comportem de maneira diferente, dependendo dos tipos de dados que são passados
para elas.
Assim como as variáveis, você não pode usar caracteres especiais e o nome do método não
pode começar com número. Para obter mais informações, consulte “Convenções de atribuição
de nome” na página 769. Para obter informações sobre a atribuição de nomes a métodos,
consulte “Atribuindo nomes a métodos” na página 237.

226 Funções e métodos


Usando funções no Flash
Essa seção mostra como usar funções em um aplicativo. Alguns dos exemplos de código a
seguir usam o ActionScript que reside no arquivo FLA, enquanto outros colocam funções em
um arquivo de classe para comparação. Para obter mais informações e exemplos sobre o uso de
funções em um arquivo de classe ,consulte o Capítulo 7, “Classes”, na página 239. Para obter
informações e instruções detalhadas sobre como criar funções para um arquivo de classe,
consulte “Exemplo: Criando classes personalizadas” na página 278.
Para reduzir o volume de trabalho necessário, bem como o tamanho do arquivo SWF, tente
reutilizar os blocos de código sempre que possível. Uma das maneiras de reutilizar o código é
chamando uma função várias vezes, em vez de criar um código diferente a cada vez. As funções
podem ser códigos genéricos; é possível usar os mesmos blocos de código para finalidades
ligeiramente diferentes em um arquivo SWF. A reutilização do código permite criar aplicativos
eficientes e minimiza o código ActionScript que precisa ser criado, reduzindo o tempo de
desenvolvimento.
Você pode criar funções em um arquivo FLA ou em um arquivo de classe; também pode criar
o código ActionScript residente em um componente baseado em código. Os exemplos a seguir
mostram como criar funções na timeline e em um arquivo de classe.
DICA

Empacotando o código em arquivos de classes ou em componentes baseados em


código, é possível compartilhar, distribuir ou reutilizar facilmente blocos de código.
Usuários podem instalar o componente, arrastá-lo para o Stage e usar o código
armazenado no arquivo, como, por exemplo, o fluxo de trabalho para componentes
baseados em código disponíveis no Flash (Window - Janela> Common Libraries -
Bibliotecas comuns > Classes).

O exemplo a seguir mostra como criar e chamar uma função em um arquivo FLA.

Para criar e chamar uma função em um arquivo FLA:


1. Crie um novo documento do Flash e salve-o como basicFunction.fla.
2. Selecione Window > Actions (Ações) para abrir o painel Library (Biblioteca).
3. Digite o seguinte código ActionScript no painel Script:
function helloWorld(){
// as instruções entram aqui
trace("Olá mundo!");
};

Esse ActionScript define a função (com nome e definida pelo usuário) chamada
helloWorld(). Se você testar o arquivo SWF desta vez, nada acontecerá. Por exemplo,
você não verá a instrução trace no painel Output (Saída). Para ver essa instrução, é
necessário chamar a função helloWorld().

Sobre funções e métodos 227


4. Digite a seguinte linha de código ActionScript após a função:
helloWorld();

Esse código chama a função helloWorld().


5. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o arquivo FLA.
O seguinte texto é exibido no painel Output: Olá mundo!
Para obter informações sobre como passar valores (parâmetros) para uma função, consulte
“Passando parâmetros para uma função” na página 231.
Há diversas maneiras de criar funções na Timeline principal. A principal delas é usar funções
com nome e funções anônimas. Por exemplo, você pode usar a seguinte sintaxe ao criar
funções:
function myCircle(radius:Number):Number {
return (Math.PI * radius * radius);
}
trace(myCircle(5));

Em geral, as funções anônimas são de mais difícil leitura. Compare o código apresentado a
seguir com o anterior.
var myCircle:Function = function(radius:Number):Number {
// insira o bloco de função aqui
return (Math.PI * radius * radius);
};
trace(myCircle(5));

Também é possível colocar funções em arquivos de classes ao usar o ActionScript 2.0, como
mostra este exemplo:
class Circle {
public function area(radius:Number):Number {
return (Math.PI * Math.pow(radius, 2));
}
public function perimeter(radius:Number):Number {
return (2 * Math.PI * radius);
}
public function diameter(radius:Number):Number {
return (radius * 2);
}
}

Para obter mais informações sobre a criação de funções em um arquivo de classe, consulte o
Capítulo 7, “Classes”, na página 239.

228 Funções e métodos


Como você pode ver no código de exemplo anterior, você não precisa colocar funções em uma
timeline. O exemplo a seguir também coloca funções em um arquivo de classe. Essa prática é
recomendada quando você cria aplicativos grandes com o ActionScript 2.0, pois ela permite a
reutilização do código em diversos aplicativos. Para reutilizar as funções em outros aplicativos,
você pode importar a classe existente em vez de reescrever o código desde o início. Também é
possível duplicar as funções no novo aplicativo.

Para criar funções em um arquivo de classe:


1. Crie um novo documento do ActionScript e salve-o como Utils.as.
2. Digite o seguinte ActionScript no painel Script:
class Utils {
public static function randomRange(min:Number, max:Number):Number {
if (min > max) {
var temp:Number = min;
min = max;
max = temp;
}
return (Math.floor(Math.random() * (max - min + 1)) + min);
}
public static function arrayMin(num_array:Array):Number {
if (num_array.length == 0) {
return Number.NaN;
}
num_array.sort(Array.NUMERIC | Array.DESCENDING);
var min:Number = Number(num_array.pop());
return min;
}
public static function arrayMax(num_array:Array):Number {
if (num_array.length == 0) {
return undefined;
}
num_array.sort(Array.NUMERIC);
var max:Number = Number(num_array.pop());
return max;
}
}

3. Selecione File (Arquivo) > Save (Salvar) para salvar o arquivo do ActionScript.
4. Crie um novo documento do Flash e salve-o como classFunctions.fla no mesmo diretório
que Utils.as.
5. Selecione Window > Actions (Ações) para abrir o painel Library (Biblioteca).
6. Digite o seguinte ActionScript no painel Script:
var randomMonth:Number = Utils.randomRange(0, 11);
var min:Number = Utils.arrayMin([3, 3, 5, 34, 2, 1, 1, -3]);
var max:Number = Utils.arrayMax([3, 3, 5, 34, 2, 1, 1, -3]);

Sobre funções e métodos 229


trace("month: " + randomMonth);
trace("min: " + min); // -3
trace("max: " + max); // 34

7. Selecione Control (Controlar) > Test Movie (Testar filme) para testar os documentos. O
seguinte texto é exibido no painel Output:
month: 7
min -3
max 34
NO TA

Para obter informações sobre criação de código usando Script Assist, consulte
“Criando ActionScript com o Script Assist” na página 368, “Criando um evento
startDrag/stopDrag com o Script Assist” na página 372 e o tutorial ActionScript:Use
Script Assist Mode (que começa com “Open the starter document” on page 211).

Usando variáveis em funções


As variáveis locais são ferramentas valiosas para organizar códigos e facilitar sua compreensão.
Quando uma função usa variáveis locais, ela pode ocultar suas variáveis de todos os outros
scripts no arquivo SWF; as variáveis locais são chamadas no escopo do corpo da função e
deixam de existir quando a função é encerrada. O Flash também trata todos os parâmetros
passados para uma função como variáveis locais.
NO TA

Também é possível usar variáveis comuns em uma função. No entanto, se essas


variáveis forem modificadas, é recomendável usar comentários de script para
documentar essas modificações.

Para usar variáveis em funções:


1. Crie um novo documento do Flash e salve-o como flashvariables.fla.
2. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
var myName:String = "Ester";
var myAge:String = "65";
var myFavSoftware:String = "Flash";
function traceMe(yourFavSoftware:String, yourName:String,
yourAge:String) {
trace("I'm " + yourName + ", I like " + yourFavSoftware + ", and I'm "
+ yourAge + ".");
}
traceMe(myFavSoftware, myName, myAge);

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.

230 Funções e métodos


Para obter mais informações sobre parâmetros, consulte “Passando parâmetros para uma
função” na página 231. Para obter mais informações sobre variáveis e dados, leia o Capítulo 4,
“Dados e tipos de dados”, na página 75.

Passando parâmetros para uma função


Os parâmetros, também chamados argumentos, são os elementos com base nos quais as
funções executam seu código. (Neste manual, os termos parâmetro e argumento são
equivalentes.) Você pode passar parâmetros (valores) para uma função e, depois, usar esses
parâmetros para processar a função. Use os valores contidos no bloco da função (instruções da
função).
Algumas vezes, os parâmetros são obrigatórios e, outras, opcionais. Poderão até mesmo existir
alguns parâmetros obrigatórios e alguns opcionais na mesma função. Se você não passar
parâmetros suficientes para uma função, o Flash define os valores dos parâmetros ausentes
como undefined, o que pode gerar resultados inesperados no arquivo SWF.
A função a seguir chamada myFunc() utiliza o parâmetro someText:
function myFunc(someText:String):Void {
trace(someText);
}

Após passar o parâmetro, você poderá passar um valor para a função ao chamá-la. Esse valor é
exibido no painel Output (Saída), da seguinte maneira:
myFunc("Isso é o que é mostrado");

Ao chamar a função, você deve sempre passar o número especificado de parâmetros, a menos
que a sua função verifique se há valores indefinidos e defina valores padrão de acordo. A
função substitui os valores passados para os parâmetros na definição da função; se algum
parâmetro estiver faltando, o Flash define o valor como undefined. Você passa parâmetros
regularmente para funções ao criar o código ActionScript.
Também é possível passar vários parâmetros para uma função, o que poderá ser tão simples
como mostrado a seguir:
var birthday:Date = new Date(1901, 2, 3);
trace(birthday);

Cada parâmetro é separado por uma vírgula. Várias funções internas da linguagem
ActionScript têm vários parâmetros. Por exemplo, o método startDrag() da classe
MovieClip utiliza cinco parâmetros, lockCenter, left, top, right e bottom:
startDrag(lockCenter:Boolean, left:Number, top:Number, right:Number,
bottom:Number):Void

Sobre funções e métodos 231


Para passar um parâmetro para uma função:
1. Crie um novo documento do Flash e salve-o como parameters.fla.
2. Adicione o seguinte código ao Frame 1 (Quadro 1) da Timeline (Linha de tempo):
function traceMe(yourMessage:String):Void {
trace(yourMessage);
}
traceMe("Como vai você?");

As primeiras linhas de código criam uma função definida pelo usuário chamada
traceMe(), que utiliza um único parâmetro, yourMessage. A última linha de código
chama a função traceMe() e passa o valor da seqüência de caracteres “Como vai você?”.
3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
O próximo exemplo demonstra como passar vários parâmetros para uma função.

Para passar vários parâmetros para uma função:


1. Crie um novo documento do Flash e salve-o como functionTest.fla.
2. Adicione o seguinte código ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
function getArea(width:Number, height:Number):Number {
return width * height;
}

A função getArea() utiliza dois parâmetros, width e height.


3. Digite o seguinte código após a função:
var area:Number = getArea(10, 12);
trace(area); // 120

A chamada da função getArea() atribui os valores 10 e 12 à largura e à altura,


respectivamente, e o valor de retorno é salvo na instância area. Em seguida, rastreie os
valores salvos na instância area.
4. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o arquivo SWF.
Você verá 120 no painel Output.
Os parâmetros da função getArea() assemelham-se aos valores de uma variável local; eles
existem enquanto a função é chamada e deixam de existir quando ela é encerrada.
No próximo exemplo, o ActionScript retorna o valor NaN (Not a Number, não é número) se
você não passar parâmetros suficientes para a função addNumbers().

Para passar um número variável de parâmetros para uma função:


1. Crie um novo documento do Flash e salve-o como functionTest2.fla.

232 Funções e métodos


2. Adicione o seguinte código ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
function addNumbers(a:Number, b:Number, c:Number):Number {
return (a + b + c);
}
trace(addNumbers(1, 4, 6)); // 11
trace(addNumbers(1, 4)); // NaN (Not a Number), c igual a undefined
trace(addNumbers(1, 4, 6, 8)); // 11

Se você não passar parâmetros suficientes para a função addNumbers, os argumentos


ausentes recebem o valor padrão de undefined. Se você passar parâmetros demais, o
excesso de parâmetros será ignorado.
3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
O Flash exibe os seguintes valores: 11, NaN, 11.

Retornando valores de funções


Use a instrução return para retornar valores de funções. A instrução return especifica o valor
retornado por uma função. A instrução return retorna o resultado de uma avaliação como o
valor da função na qual a expressão é executada. A instrução return retorna os resultados
imediatamente ao código de chamada.
Para obter mais informações, consulte %{return statement}% em ActionScript 2.0 Language
Reference (Referência da linguagem ActionScript).
As regras a seguir regem o uso da instrução return em funções:
■ Se um tipo de retorno diferente de Void for especificado para uma função, será necessário
incluir uma instrução return seguida do valor retornado na função.
■ Se você especificar o tipo de retorno Void, não precisará incluir uma instrução return; no
entanto, se fizer isso, não insira nenhum valor após a instrução.
■ Independentemente do tipo de retorno, você poderá usar uma instrução return para sair
de uma função antes de ela terminar.
■ Se você não especificar um tipo de retorno, a inclusão de uma instrução return será
opcional.
Por exemplo, a função a seguir retorna o quadrado do parâmetro myNum e especifica que o
valor retornado deve ser um tipo de dados Number:
function sqr(myNum:Number):Number {
return myNum * myNum;
}

Sobre funções e métodos 233


Algumas funções executam uma série de tarefas sem retornar um valor. O próximo exemplo
retorna o valor processado. Você capturará o valor em uma variável, a qual poderá ser usada
em seu aplicativo.

Para retornar um valor e capturá-lo em uma variável:


1. Crie um novo documento do Flash e salve-o como return.fla.
2. Adicione o seguinte código ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
function getArea(width:Number, height:Number):Number {
return width * height;
}

A função getArea() utiliza dois parâmetros, width e height.


3. Digite o seguinte código após a função:
var area:Number = getArea(10, 12);
trace(area); // 120

A chamada da função getArea() atribui os valores 10 e 12 à largura e à altura,


respectivamente, e o valor de retorno é salvo na instância area. Em seguida, rastreie os
valores salvos na instância area.
4. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o arquivo SWF.
Você verá 120 no painel Output.
Os parâmetros da função getArea() assemelham-se aos valores de uma variável local; eles
existem enquanto a função é chamada e deixam de existir quando ela é encerrada.

Sobre funções aninhadas


É possível chamar uma função a partir de outra. Isso permite aninhar funções para que
executem tarefas específicas no Flash.
Por exemplo, você pode aninhar funções na timeline para executar tarefas específicas em uma
seqüência de caracteres. Digite o seguinte código no Frame 1 (Quadro 1) da Timeline (Linha
de tempo):
var myStr:String = "My marshmallow chicken is yellow.";
trace("Original string: " + myStr);
function formatText():Void {
changeString("Put chicken in microwave.");
trace("Changed string: " + myStr);
}
function changeString(newtext:String):Void {
myStr = newtext;
}

234 Funções e métodos


// Chame a função.
formatText();

Selecione Control (Controlar) > Test Movie (Testar filme) para testar a função aninhada. As
funções formatText() e changeString() são aplicadas à seqüência de caracteres quando a
função formatText() é chamada.

Noções básicas sobre métodos


Métodos são funções associadas a uma classe, a qual pode ser uma classe personalizada ou
classes internas que fazem parte da linguagem ActionScript. Para obter informações sobre
comparação de métodos e funções, consulte “Sobre funções e métodos” na página 213 e
“Sobre tipos de métodos e funções” na página 215.
Por exemplo, sortOn() é um método interno associado à classe Array (sortOn é uma função
da classe Array pré-definida interna no Flash).

Para usar o método sortOn() em um arquivo FLA:


1. Crie um novo documento do Flash e salve-o como methods.fla.
2. Adicione o seguinte código ao Frame 1 (Quadro 1) da Timeline (Linha de tempo):
var userArr:Array = new Array();
userArr.push({firstname:"George", age:39});
userArr.push({firstname:"Dan", age:43});
userArr.push({firstname:"Socks", age:2});
userArr.sortOn("firstname");
var userArrayLenth:Number = userArr.length;
var i:Number;
for (i = 0; i < userArrayLenth; i++) {
trace(userArr[i].firstname);
}

O método sortOn() da classe Array é usado para criar um novo objeto Array chamado
userArr. O array é preenchido com três objetos que contêm um nome e uma idade; em
seguida, ele é classificado com base no valor da propriedade firstname de cada objeto.
Finalmente, você executará uma repetição em cada item do array e exibirá o nome no
painel Output (Saída); depois, classificará os nomes em ordem alfabética pela letra inicial.
3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o arquivo SWF.
O código a seguir é exibido no painel Output:
Dan
George
Socks

Noções básicas sobre métodos 235


Conforme demonstrado em “Criando funções com nome” na página 219, quando você cria o
código a seguir no Frame 1 (Quadro 1) da Timeline, o código ActionScript define uma função
chamada eatCabbage().
function eatCabbage() {
trace("tastes bad");
}
eatCabbage();
No entanto, se você criar a função eatCabbage() dentro de um arquivo de classe e, por
exemplo, chamar eatCabbage() no arquivo FLA, então eatCabbage() será considerado um
método.
Os próximos exemplos mostram como criar métodos dentro de uma classe.

Para comparar métodos e funções:


1. Crie um novo arquivo do ActionScript, selecione File (Arquivo) > Save As (Salvar como) e
salve-o como EatingHabits.as.
2. Digite o seguinte código ActionScript na janela Script :
class EatingHabits {
public function eatCabbage():Void {
trace("tastes bad");
}
}

3. Salve as alterações feitas a EatingHabits.as.


4. Crie um novo documento Flash, selecione File > Save As, atribua o nome methodTest.fla
e salve o arquivo no mesmo diretório que EatingHabits.as.
5. Digite o seguinte código ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de
tempo):
var myHabits:EatingHabits = new EatingHabits();
myHabits.eatCabbage();

Ao usar esse ActionScript, você chamará o método eatCabbage() da classe EatingHabits.


N O TA

Ao usar métodos de uma classe interna (além da classe personalizada criada


anteriormente neste procedimento), você usará um método da Timeline.

6. Após a linha anterior do ActionScript, adicione o seguinte código:


function eatCarrots():Void {
trace("tastes good");
}
eatCarrots();

Nesse código, você irá criar e chamar a função eatCarrots().


7. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o arquivo SWF.

236 Funções e métodos


Atribuindo nomes a métodos
Você deve usar verbos para nomear métodos e palavras com letras maiúsculas e minúsculas
para palavras concatenadas, sendo que a inicial deve estar em letra minúscula. Por exemplo,
você poderia nomear métodos das seguintes maneiras:
sing();
boogie();
singLoud();
danceFast();

Utilize verbos para a maioria dos métodos, pois eles executam uma operação em um objeto.
Assim como as variáveis, você não pode usar caracteres especiais e o nome do método não
pode começar com número. Para obter mais informações, consulte “Convenções de atribuição
de nome” na página 769.

Noções básicas sobre métodos 237


238 Funções e métodos
CAPÍTULO 7

Classes 7
Este capítulo mostra como usar e criar classes com o ActionScript 2.0. As classes são o
componente básico do ActionScript 2.0 e desempenham um papel mais importante do que
nas versões anteriores do Macromedia Flash. Neste capítulo, você aprenderá sobre a
importância das classes no Flash.
O capítulo inicia com uma explicação da terminologia fundamental e de sua relação com as
classes e a OOP (Object-Oriented Programming, Programação orientada a objeto). Em
seguida, você examina um arquivo de classe de exemplo para compreender como cada seção
do arquivo funciona e como a classe está organizada. O restante do capítulo mostra como criar
suas próprias classes personalizadas e usá-las nos documentos do Flash. Você aprenderá sobre o
caminho de classe do Flash e como uma classe deve ser documentada para que outras pessoas
possam compreender facilmente o seu código e o objetivo geral da classe ao lerem ou usarem o
código.
Esta seção contém exemplos de códigos para familiarizá-lo com a criação de classes no
ActionScript 2.0. Ao concluir este capítulo, você deverá ser capaz de criar um arquivo de classe
típico, compreender e reconhecer as classes do Flash, e ler arquivos de classes de outros
usuários.
Se não estiver familiarizado com os scripts do ActionScript 2.0, consulte o Capítulo 5,
“Fundamentos da sintaxe e da linguagem”, na página 119 e o Capítulo 19, “Melhores práticas
e convenções de codificação para ActionScript 2.0”, na página 767.

239
Para obter mais informações sobre como trabalhar com classes personalizadas e internas,
consulte os seguintes tópicos:
Sobre a programação orientada a objeto e o Flash . . . . . . . . . . . . . . . . . . . . . . . . . 240
Criando arquivos de classes personalizados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Sobre como trabalhar com classes personalizadas em um aplicativo . . . . . . . . . .252
Exemplo: Criando classes personalizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Exemplo: Usando arquivos de classes personalizados no Flash. . . . . . . . . . . . . . . 291
Atribuindo uma classe a símbolos no Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Compilando e exportando classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .296
Noções básicas sobre classes e escopo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Sobre classes de nível superior e internas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
Sobre como trabalhar com classes internas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312

Sobre a programação orientada a objeto


e o Flash
O ActionScript 2.0 é uma linguagem orientada a objeto. Assim como o ActionScript, as
linguagens OOP baseiam-se no conceito de classes e instâncias. Uma classe define todas as
propriedades que distinguem uma série de objetos. Por exemplo, a classe User representa um
grupo de usuários que utilizam o seu aplicativo. Em seguida, você tem um instanciamento da
classe, que, para a classe User, é um dos usuários individuais, ou seja, um de seus membros. O
instanciamento produz uma instância da classe User e essa instância possui todas as
propriedades da classe User.
As classes também são consideradas como tipos de dados ou modelos que podem ser criados
para definir um novo tipo de objeto. Por exemplo, se precisar do tipo de dados Lettuce em seu
aplicativo, você poderá criar a classe Lettuce. Isso definirá o objeto Lettuce, ao qual você
poderá atribuir métodos (wash()) e propriedades (leafy ou bugs). Para definir uma classe,
use a palavra-chave class em um arquivo de script externo. Você pode criar esse arquivo na
ferramenta de criação do Flash selecionando File (Arquivo) > New (Novo) e, em seguida,
selecionando ActionScript File (Arquivo do ActionScript).

240 Classes
O Flash Player 8, disponível no Flash Basic 8 e no Flash Professional 8, adiciona vários novos
recursos à linguagem ActionScript, como efeitos de filtro, upload e download de arquivos, e a
API (Application Programming Interface, Interface de programação de aplicativos) externa.
Como sempre, o ActionScript 2.0 fornece várias palavras-chave e conceitos avançados e
familiares de OOP (como classe, interface e pacote) encontrados em outras linguagens
de programação, como Java. A linguagem de programação permite criar estruturas de
programa reutilizáveis, dimensionáveis, resistentes e fáceis de manter. Ela também diminui o
tempo de desenvolvimento fornecendo aos usuários assistência completa sobre codificação e
informações de depuração. Você pode usar o ActionScript 2.0 para criar objetos e estabelecer
herança, bem como para criar classes personalizadas e estender as classes de nível superior e
internas do Flash. Neste capítulo, você aprenderá a criar classes e a usar classes personalizadas.
O Flash Basic 8 e o Flash Professional 8 contêm aproximadamente 65 classes de nível superior
e internas que fornecem desde tipos de dados básicos, ou “primitivos” (Array, Boolean, Date e
assim por diante), a erros e eventos personalizados, além de várias maneiras de carregar
conteúdo externo (XML, imagens, dados binários brutos e muito mais). Você também pode
criar suas próprias classes personalizadas e integrá-las aos documentos do Flash ou, até mesmo,
estender as classes de nível superior e adicionar sua própria funcionalidade ou modificar a
funcionalidade existente. Por exemplo, este capítulo mostra como criar uma classe Person
personalizada em “Sobre membros de classe” na página 265, que contém propriedades
personalizadas relativas ao nome e à idade de uma pessoa. Depois, você pode tratar essa classe
personalizada como um novo tipo de dados em seus documentos e criar uma nova instância
da classe usando o operador new.
Para obter mais informações sobre como trabalhar com programação orientada a objeto,
consulte os seguintes tópicos:
■ “As vantagens de usar classes” na página 241
■ “Sobre pacotes” na página 242
■ “Sobre valores e tipos de dados” na página 245
■ “Princípios da programação orientada a objeto” na página 246

As vantagens de usar classes


Na OOP, uma classe define uma categoria de objeto. Uma classe descreve as propriedades
(dados) e o método (comportamentos) de um objeto, da mesma maneira que uma planta
arquitetônica descreve as características de uma construção. As classes personalizadas são
criadas em um arquivo externo do ActionScript (AS), e você pode importá-las para o seu
aplicativo ao compilar o arquivo FLA.

Sobre a programação orientada a objeto e o Flash 241


As classes podem ser muito úteis quando você cria aplicativos Flash maiores, pois grande parte
da complexidade do aplicativo pode ser organizada em arquivos de classes externos. Ao mover
grande parte da lógica para uma classe personalizada, você não só facilita a reutilização do
código, como também pode “ocultar” alguns dos métodos e das propriedades de outras partes
do código ActionScript. Isso ajuda a impedir que outras pessoas acessem informações
confidenciais ou alterem dados que não devem ser alterados.
Ao usar uma classe, você também pode estender as classes existentes e adicionar nova
funcionalidade ou modificar a funcionalidade existente. Por exemplo, se você criar três classes
muito semelhantes, poderá criar uma classe base e, em seguida, duas outras que estendam essa
classe. Essas duas classes podem adicionar outros métodos e propriedades, de modo que você
não precise criar três arquivos de classe que dupliquem o mesmo código e a mesma lógica.
Outra vantagem de usar classes é a capacidade de reutilizar o código. Por exemplo, se você
criar uma classe personalizada que crie uma barra de progresso personalizada usando a
interface de programação de aplicativos (API) Drawing, poderá salvar a classe de barra de
progresso em seu caminho de classe e reutilizar o mesmo código em todos os documentos do
Flash importando a classe personalizada. Para obter mais informações sobre como definir o
caminho de classe, consulte “Sobre a importação de arquivos de classes” na página 254 e
“Sobre a definição e a modificação do caminho de classe” na página 255.

Sobre pacotes
Ao criar classes, organize seus arquivos de classes do ActionScript em pacotes. Um pacote é um
diretório que contém um ou mais arquivos de classes e reside em um diretório determinado do
caminho de classe (consulte “Sobre a importação de arquivos de classes” na página 254 e
“Sobre a definição e a modificação do caminho de classe” na página 255). Um pacote pode,
por sua vez, conter outros pacotes, chamados subpacotes, cada um com seus próprios arquivos
de classes.
Assim como as variáveis, os nomes de pacotes podem ser identificadores; ou seja, o primeiro
caractere pode ser uma letra, sublinhado (_) ou cifrão ($) e os caracteres seguintes podem ser
uma letra, número, sublinhado ou cifrão. Existem maneiras mais usadas de atribuir nomes a
pacotes, por exemplo, a recomendação de evitar usar caracteres sublinhados ou de cifrão. Para
obter mais informações sobre atribuição de nome a pacotes, consulte “Atribuindo nomes a
pacotes” na página 777.
Os pacotes normalmente são usados para organizar classes relacionadas. Por exemplo, você
pode ter três classes relacionadas, Square, Circle e Triangle, que são definidas em Square.as,
Circle.as e Triangle.as. Suponha que você tenha salvo os arquivos ActionScript em um
diretório especificado do caminho de classe, como mostra o seguinte exemplo:

242 Classes
// Em Square.as:
class Square {}

// Em Circle.as:
class Circle {}

// Em Triangle.as:
class Triangle {}

Como esses três arquivos de classes estão relacionados, você pode decidir colocá-los em um
pacote (diretório) chamado Shapes. Nesse caso, o nome de classe totalmente qualificado
conterá o caminho do pacote e o nome de classe simples. Os caminhos de pacotes são
denotados com a sintaxe de ponto (.), na qual cada ponto indica um subdiretório.
Por exemplo, se você tivesse colocado no diretório Shapes cada arquivo ActionScript que
define uma forma, seria necessário alterar o nome de cada arquivo de classe para refletir o novo
local, da seguinte maneira:
// Em Shapes/Square.as:
class Shapes.Square {}

// Em Shapes/Circle.as:
class Shapes.Circle {}

// Em Shapes/Triangle.as:
class Shapes.Triangle {}

Para fazer referência a uma classe que se encontra em um diretório de pacote, você poderá
especificar seu nome de classe totalmente qualificado ou importar o pacote usando a instrução
import. Para obter mais informações, consulte “Trabalhando com pacotes” na página 244.

Comparação de classes e pacotes


Na OOP, uma classe define uma categoria de objeto. As classes são essencialmente tipos de
dados que você poderá criar se desejar definir um novo tipo de objeto em seu aplicativo. Uma
classe descreve as propriedades (dados) e os comportamentos (métodos) de um objeto, da mesma
maneira que uma planta arquitetônica descreve as características de uma construção. As
propriedades (variáveis definidas em uma classe) e os métodos da classe são designados
coletivamente como os membros da classe. Para usar as propriedades e os métodos definidos
por uma classe, geralmente você cria primeiro uma instância dessa classe (exceto no caso de
classes com membros estáticos, consulte “Sobre os membros de classe (estáticos)”
na página 315, como a classe Math de nível superior e “Propriedades e métodos estáticos”
na página 264). A relação entre uma instância e sua classe é semelhante à existente entre uma
casa e sua planta arquitetônica.

Sobre a programação orientada a objeto e o Flash 243


No Flash, os pacotes são diretórios que contêm um ou mais arquivos de classes e residem em
um caminho de arquivo designado. É possível colocar arquivos de classes personalizados
relacionados em um mesmo diretório. Por exemplo, você pode ter três classes relacionadas
chamadas SteelWidget, PlasticWidget e WoodWidget que são definidas em SteelWidget.as,
PlasticWidget.as e WoodWidget.as. Essas classes seriam organizadas no pacote Widget. Para
obter mais informações sobre pacotes, consulte “Trabalhando com pacotes” na página 244 e
“Criando e empacotando arquivos de classes” na página 281.

Trabalhando com pacotes


Pacotes são diretórios que contêm um ou mais arquivos de classes e residem em um diretório
específico do caminho da classe. Por exemplo, o pacote flash.filters é um diretório no disco
rígido que contém diversos arquivos de classe para cada tipo de filtro (tais como BevelFilter,
BlurFilter, DropShadowFilter e assim por diante) no Flash 8.
N OT A

Para usar a instrução import, é necessário especificar ActionScript 2.0 e Flash Player 6
ou uma versão posterior na guia Flash da caixa de diálogo Publish Settings
(Configurações de publicação) do arquivo FLA.

A instrução import permite acessar classes sem especificar os nomes totalmente qualificados.
Por exemplo, se você quiser usar a classe BlurFilter em um script, você deve referir-se a ela pelo
nome totalmente qualificado (flash.filters.BlurFilter) ou importá-la; se você a importar,
poderá então fazer referência a ela pelo nome da classe (BlurFilter). O código ActionScript a
seguir demonstra as diferenças entre usar a instrução import e usar nomes de classe
totalmente qualificados.
Se você não importar a classe BlurFilter, o seu código precisa usar o nome de classe totalmente
qualificado (nome do pacote seguido do nome da classe) a fim de usar o filtro:
// sem importação
var myBlur:flash.filters.BlurFilter = new flash.filters.BlurFilter(10, 10,
3);

O mesmo código, escrito com uma instrução import, permite acessar o BlurFilter usando
somente o nome da classe em vez de sempre ter que usar o nome totalmente qualificado. Isso
pode representar menos tempo de digitação e reduzir a possibilidade de erros:
// com importação
import flash.filters.BlurFilter;
var myBlur:BlurFilter = new BlurFilter(10, 10, 3);

Se você estiver importando diversas classes em um pacote (tais como BlurFilter,


DropShadowFilter e GlowFilter) você pode usar um dos métodos de importar cada classe. O
primeiro método de importação de diversas classes é importar cada classe usando uma
instrução import separada, conforme observado no trecho a seguir:

244 Classes
import flash.filters.BlurFilter;
import flash.filters.DropShadowFilter;
import flash.filters.GlowFilter;

Usando instruções import individuais para cada classe em um pacote pode tornar-se muito
desgastante e pode levar a erros de digitação. O segundo método de importação de classes em
um pacote é usar um caractere curinga que importa todas as classes dentro de um determinado
nível de um pacote. O ActionScript a seguir mostra um exemplo de importação com caractere
curinga:
import flash.filters.*; // importa cada classe dentro de um pacote
flash.filters

A instrução import aplica-se apenas ao script atual (quadro ou objeto) no qual ela é chamada.
Por exemplo, suponha que você importe todas as classes do pacote macr.util no Frame 1
(Quadro 1) de um documento do Flash. Nesse quadro, você pode fazer referência às classes
desse pacote por seus nomes de classe em vez de usar os nomes totalmente qualificados. Se
você quisesse usar o nome de classe em outro script de quadro, no entanto, você deveria
referenciar classes naquele pacote pelos nomes totalmente qualificados ou adicionar uma
instrução import ao outro quadro que importa as classes naquele pacote.
Ao usar instruções import, também é importante observar que classes são importadas
somente para o nível especificado. Por exemplo, se você importou todas as classes no pacote
mx.transitions, somente as classes no diretório /transitions/ serão importadas, e não todas as
classes dentro dos subdiretórios (tais como as classes no pacote mx.transitions.easing).
DICA

Se você importar uma classe, mas não a usar no script, a classe não será exportada
como parte do arquivo SWF. Isso significa que você pode importar pacotes grandes
sem se preocupar com o tamanho do arquivo SWF. O bytecode associado a uma classe
será incluído em um arquivo SWF somente se a classe for realmente usada.

Sobre valores e tipos de dados


Dados, valores e tipos são conceitos importantes quando você começa a criar classes e a usá-
las. Você aprendeu sobre dados e tipos em Capítulo 4, “Dados e tipos de dados”, na
página 75. Ao trabalhar com classes, lembre-se de que os tipos de dados descrevem o tipo de
informação que uma variável ou um elemento do ActionScript pode conter, como Boolean,
Number e String. “Sobre tipos de dados” na página 76Para obter mais informações, consulte .
As expressões têm valores, enquanto os valores e as propriedades têm tipos. Os valores que
podem ser definidos, bem como fornecidos e obtidos de uma propriedade de uma classe,
devem ser compatíveis com essa propriedade. A compatibilidade indica que o tipo de um valor
é compatível com o tipo em uso, como no seguinte exemplo:
var myNum:Number = 10;

Sobre a programação orientada a objeto e o Flash 245


Para obter mais informações sobre como atribuir tipos de dados estritos, consulte “Sobre a
atribuição de tipos de dados e a atribuição estrita de tipos de dados” na página 85.

Princípios da programação orientada a objeto


Nas seções a seguir, você examinará a terminologia usada neste capítulo antes de começar a
criar o código ActionScript. Esta breve introdução aos princípios envolvidos no
desenvolvimento de programas orientados a objeto o ajudará a acompanhar as seções e os
exemplos apresentados neste capítulo e no restante deste manual. Esses princípios são
descritos mais profundamente no restante deste capítulo, junto com os detalhes sobre como
eles são implementados no Flash 8.
As seções a seguir usam a analogia de um gato para demonstrar a semelhança entre gatos e os
conceitos de programação orientada a objeto (OOP).

Objetos
Considere um objeto do mundo real, como, por exemplo, um gato. Pode-se dizer que os gatos
têm propriedades (ou estados) como nome, idade e cor; eles também têm comportamentos,
como dormir, comer e ronronar. Na OOP, os objetos também têm propriedades e
comportamentos. Com as técnicas orientadas a objeto, é possível modelar um objeto do
mundo real (como um gato) ou um objeto mais abstrato (como um processo químico).
N OT A

A palavra comportamentos é usada genericamente aqui e não se refere ao painel


Behaviors (Comportamentos) do ambiente de criação do Flash.

Para obter mais informações sobre objetos, consulte “Tipo de dados Object” na página 83.

Instâncias e membros de classe


Continuando com a analogia do mundo real, considere que há gatos de cores, idades e nomes
diferentes, com maneiras diferentes de comer e ronronar. Porém, apesar de suas diferenças
individuais, todos os gatos são membros da mesma categoria, ou em termos da OOP, da
mesma classe: a classe de gatos. Na terminologia da OOP, cada gato é considerado como uma
instância da classe Cat.
Da mesma maneira, na OOP, uma classe define a estrutura de um tipo de objeto. As
características e os comportamentos pertencentes a uma classe são tratadas, em conjunto,
como membros dessa classe. As características (nome, idade e cor, no exemplo do gato) são
chamadas propriedades da classe e são representadas como variáveis; os comportamentos
(brincar, dormir) são chamados métodos da classe e são representados como funções.

246 Classes
Para obter mais informações sobre instâncias e membros de classe, consulte “Sobre membros
de classe” na página 265 e “Usando membros de classe” na página 269.

Herança
Uma das principais vantagens da OOP é a capacidade de criar subclasses de (ou estender) uma
classe; a subclasse herda todas as propriedades e métodos da classe. A subclasse normalmente
define métodos e propriedades adicionais ou sobrescreve métodos ou propriedades definidas
na superclasse. As subclasses também substituem (fornecem suas próprias definições para) os
métodos definidos em uma superclasse.
Uma das principais vantagens de usar uma estrutura de superclasse/subclasse é que é mais fácil
reutilizar código semelhante entre diversas classes. Por exemplo, você poderia criar uma
superclasse chamada Animal, que contém as características e os comportamentos comuns de
todos os animais. Em seguida, você poderia criar várias subclasses que herdam as
características da superclasse Animal e adicionar características específicas a esse tipo de
animal.
Você poderia criar uma classe Cat que herda características de outra classe. Por exemplo, você
pode criar uma classe Mamifero, que define certas propriedades e comportamentos comuns a
todos os mamíferos. em seguida, criar uma classe Cat que estenda essa classe. Outra subclasse,
como a classe Siamese, poderia estender a classe Cat (ou criar uma subclasse dela) e assim por
diante.
Criar subclasses permite reutilizar o código. Em vez de recriar todos os códigos comuns às
duas classes, você pode simplesmente estender uma classe existente.
DICA

Em um aplicativo complexo, determinar como estruturar a hierarquia das classes é uma


parte importante do projeto. Certifique-se de determinar essa hierarquia antes iniciar a
programação.

Para obter mais informações sobre herança e subclasses, consulte o Capítulo 8, “Herança”, na
página 319.

Interfaces
Na OOP, as interfaces podem ser descritas como modelos de definições de classes, e as classes
que implementam interfaces precisam implementar esse modelo de métodos. Usando a
analogia do gato, uma interface é semelhante à planta arquitetônica de um gato: a planta
informa de que partes você precisa, mas não necessariamente como essas partes são montadas,
ou como as partes funcionam.

Sobre a programação orientada a objeto e o Flash 247


Você pode usar interfaces para adicionar estrutura e facilitar a manutenção dos aplicativos.
Como o ActionScript 2.0 oferece suporte somente à extensão de uma única superclasse, as
interfaces podem ser usadas como uma forma de herança múltipla limitada.
Uma interface também pode ser considerada como um “contrato de programação” que pode
ser usado para impor os relacionamentos entre classes não relacionadas de outra maneira. Por
exemplo, suponha que você esteja trabalhando com uma equipe de programadores, cada um
responsável por uma parte diferente (classe) do mesmo aplicativo. Ao projetar o aplicativo,
você estabelece um conjunto de métodos que as diferentes classes usam para se comunicarem.
Portanto, você cria uma interface que declara esses métodos, seus parâmetros e tipos de
retorno. Qualquer classe que implemente essa interface deve fornecer definições para esses
métodos; caso contrário, ocorrerá um erro do compilador.
Para obter mais informações sobre herança, consulte Capítulo 8, “Herança”, na página 319.
Para obter mais informações sobre interfaces, consulte o Capítulo 9, “Interfaces”, na
página 331.

Encapsulamento
Em um projeto orientado a objeto bem elaborado, os objetos são considerados como “caixas-
pretas” que contêm ou encapsulam funcionalidade. O programador deve ser capaz de interagir
com um objeto conhecendo somente suas propriedades, métodos e eventos (sua interface de
programação), sem conhecer os detalhes de sua implementação. Essa abordagem permite que
os programadores utilizem níveis mais elevados de abstração e fornece uma estrutura de
organização para a criação de sistemas complexos.
O encapsulamento é o motivo pelo qual o ActionScript 2.0 inclui, por exemplo, controle de
acesso a membros, permitindo que os detalhes da implementação permaneçam privados e
invisíveis para o código externo aos objetos. O código externo ao objeto é forçado a interagir
com a interface de programação do objeto em vez de com os detalhes da implementação (o
que pode ser oculto em métodos e propriedades privados. Essa abordagem oferece algumas
vantagens importantes; por exemplo, ela permite que o criador do objeto altere a sua
implementação sem a necessidade de alterar o código externo ao objeto, ou seja, desde que a
interface de programação não seja alterada.
Para obter mais informações sobre encapsulamento, consulte “Sobre o uso de
encapsulamento” na página 276.

248 Classes
Polimorfismo
A OOP permite expressar as diferenças entre classes individuais usando uma técnica chamada
polimorfismo, pela qual as classes podem substituir os métodos de suas superclasses e definir
implementações especializadas desses métodos. No Flash, as subclasses podem definir
implementações especializadas de métodos herdados da superclasse, mas não podem acessar a
implementação da superclasse como em outras linguagens de programação.
Por exemplo, você pode criar inicialmente uma classe chamada Mammal com os métodos
play() e sleep() e, em seguida, criar as subclasses Cat, Monkey e Dog para estender essa
classe. As subclasses substituem o método play() da classe Mammal para refletir os hábitos
desses tipos específicos de animais. Monkey implementa o método play() para pendurar-se
nos galhos de árvores; Cat implementa o método play() para avançar em um novelo de lã;
Dog implementa o método play() para apanhar uma bola. Como a funcionalidade sleep()
é semelhante entre os animais, você usaria a implementação de superclasse.
Para obter mais informações sobre polimorfismo, consulte o Capítulo 8, “Herança”, na
página 319 e “Usando o polimorfismo em um aplicativo” na página 327.

Criando arquivos de classes


personalizados
O exemplo a seguir examina as partes de um arquivo de classe. Você aprenderá a criar uma
classe e a modificá-la para que possa usá-la de várias maneiras com o Flash. Você também
aprenderá sobre as partes de uma classe, como importá-las e como trabalhar com arquivos de
classes personalizados no Flash.
Em primeiro lugar, você examinará uma classe muito simples. O exemplo a seguir mostra a
organização de uma classe simples chamada UserClass.
Para definir uma classe, use a palavra-chave class em um arquivo de script externo, e não em
um script criado no painel Actions (Ações). A estrutura de classes também é relevante para os
arquivos de interface. Essa estrutura é ilustrada a seguir e, depois da ilustração, você criará uma
classe.
■ O arquivo de classe inicia com comentários de documentação que incluem uma descrição
geral do código, bem como informações sobre autor e versão.
■ Adicione suas instruções import (se aplicável).
■ Crie uma instrução de pacote, uma declaração de classe ou uma declaração de interface, da
seguinte maneira:
class UserClass {...}

Criando arquivos de classes personalizados 249


■ Inclua os comentários necessários sobre a implementação de classe ou interface. Nesses
comentários, adicione informações pertinentes à toda classe ou interface.
■ Adicione todas as variáveis estáticas. Escreva as variáveis de classe pública primeiro,
seguidas de variáveis de classe privada.
■ Adicione variáveis de instância. Escreva primeiro as variáveis membro públicas, seguidas
das variáveis membro privadas.
■ Adicione a instrução construtora, como a do exemplo abaixo:
public function UserClass(username:String, password:String) {...}

■ Escreva os métodos. Agrupe-os por funcionalidade, e não por acessibilidade ou escopo. A


organização dos métodos dessa maneira aumenta a legibilidade e a clareza do código.
■ Escreva os métodos getter/setter no arquivo de classe.
O exemplo a seguir examina uma classe simples do ActionScript chamada User.

Para criar arquivos de classes:


1. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
2. Selecione File > Save As (Salvar como) e atribua o nome User.as ao novo arquivo.
3. Digite o seguinte código ActionScript na janela Script:
/**
Classe de usuário
author: John Doe
version: 0.8
modified: 08/21/2005
copyright: Macromedia, Inc.

Esse código define uma classe User personalizada que permite criar
novos usuários e especificar as informações de login dos usuários.
*/

class User {
// variáveis de instância privadas
private var __username:String;
private var __password:String;

// instrução construtora
public function User(p_username:String, p_password:String) {
this.__username = p_username;
this.__password = p_password;
}

public function get username():String {


return this.__username;
}

250 Classes
public function set username(value:String):Void {
this.__username = value;
}

public function get password():String {


return this.__password;
}
public function set password(value:String):Void {
this.__password = value;
}
}

4. Salve as alterações no arquivo de classe.


O trecho de código anterior inicia com um comentário de documentação padronizado, que
especifica o nome da classe, o autor, a versão, a data da última modificação, informações
de copyright e uma breve descrição do que a classe faz.
A instrução construtora da classe User utiliza dois parâmetros: p_username e p_password,
que são copiados para as variáveis de instância privadas __username e __password da
classe. O restante do código da classe define as propriedades getter e setter das variáveis de
instância privadas. Para criar uma propriedade somente leitura, você definiria uma função
getter, mas não uma função setter. Por exemplo, para garantir que um nome de usuário
não seja alterado após ser definido, você excluiria a função setter username do arquivo de
classe User.
5. Selecione File > New e, em seguida, selecione Flash Document (Documento Flash).
6. Selecione File > Save As e atribua o nome user_test.fla ao arquivo. Salve o arquivo no
mesmo diretório que User.as.
7. Digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo):
import User;
var user1:User = new User("un1", "pw1");
trace("Before:");
trace("\t username = " + user1.username); // un1
trace("\t password = " + user1.password); // pw1
user1.username = "1nu";
user1.password = "1wp";
trace("After:");
trace("\t username = " + user1.username); // 1nu
trace("\t password = " + user1.password); // 1wp

Como a classe User criada anteriormente é muito básica, o ActionScript contido no


documento do Flash também é muito simples. A primeira linha do código importa a
classe User personalizada para o documento do Flash. A importação dessa classe permite
usá-la como um tipo de dados personalizado.

Criando arquivos de classes personalizados 251


Uma única instância da classe User é definida e atribuída a uma variável chamada user1.
Você atribui um valor ao objeto User user1 e define username como un1 e password
como pw1. As duas instruções trace apresentadas a seguir exibem o valor atual de
user1.username e user1.password utilizando as funções getter da classe User, que
retornam seqüências de caracteres. A duas próximas linhas usam as funções setter da classe
User a fim de definir novos valores para as variáveis username e password. Finalmente,
você exibe os valores de username e password no painel Output (Saída). As instruções
trace exibem os valores modificados definidos com as funções setter.
8. Salve o arquivo FLA e selecione Control (Controlar) > Test Movie (Testar filme) para testar
os arquivos.
Você verá os resultados das instruções trace no painel Output. Nos próximos exemplos,
você usará esses arquivos em um aplicativo.
Um arquivo de exemplo no disco rígido demonstra como criar um menu dinâmico com dados
XML e um arquivo de classe personalizado. O exemplo chama o construtor XmlMenu() do
ActionScript e passa dois parâmetros: o caminho para o arquivo de menu XML e uma
referência à timeline atual. O resto da funcionalidade reside em um arquivo de classe
personalizado, XmlMenu.as.
Você pode encontrar o arquivo de origem de exemplo, xmlmenu.fla, na pasta Samples
(Exemplos) no disco rígido.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\XML_Menu.
■ No Macintosh, navegue até Macintosh HD/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/XML_Menu.

Sobre como trabalhar com classes


personalizadas em um aplicativo
Em “Criando arquivos de classes personalizados” na página 249, você criou um arquivo de
classe personalizado. Nas seções a seguir, você usará esse arquivo em um aplicativo. O fluxo de
trabalho para a criação de classes envolve, no mínimo, as seguintes etapas:
1. Definir uma classe em um arquivo de classe externo do ActionScript. Para obter
informações sobre como definir e criar um arquivo de classe, consulte “Criando arquivos
de classes personalizados” na página 249.

252 Classes
2. Salvar o arquivo de classe no diretório de caminho de classe designado (o local em que o
Flash procura as classes) ou no mesmo diretório que o arquivo FLA do aplicativo. Para
obter mais informações sobre como definir o caminho de classe, consulte “Sobre a definição
e a modificação do caminho de classe” na página 255. Para ver uma comparação e obter
mais informações sobre a importação de arquivos de classes, consulte “Sobre a importação
de arquivos de classes” na página 254.
3. Criar uma instância da classe em outro script, em um documento FLA ou em um arquivo
de script externo, ou criando uma subclasse com base na classe original. Para obter mais
informações sobre a criação de instâncias de uma classe, consulte “Criando instâncias de
classes em um exemplo” na página 294.
As seções subseqüentes deste capítulo contêm exemplos de código que você poderá usar para
se familiarizar com a criação de classes no ActionScript 2.0. Se não estiver familiarizado com o
ActionScript 2.0, leia o Capítulo 4, “Dados e tipos de dados”, na página 75 e o Capítulo 5,
“Fundamentos da sintaxe e da linguagem”, na página 119
Para obter mais informações sobre como trabalhar com classes personalizadas, consulte os
seguintes tópicos:
■ “Sobre a importação de arquivos de classes” na página 254
■ “Usando um arquivo de classe no Flash” na página 259
■ “Usando métodos e propriedades de um arquivo de classe” na página 260
■ “Sobre membros de classe” na página 265
■ “Sobre os métodos getter e setter” na página 270
■ “Como o compilador resolve as referências de classes” na página 258
■ “Sobre classes dinâmicas” na página 273
■ “Sobre o uso de encapsulamento” na página 276
■ “Sobre o uso da palavra-chave this em classes” na página 277
Um arquivo de exemplo no disco rígido demonstra como criar um menu dinâmico com dados
XML e um arquivo de classe personalizado. O exemplo chama o construtor XmlMenu() do
ActionScript e passa dois parâmetros: o caminho para o arquivo de menu XML e uma
referência à timeline atual. O resto da funcionalidade reside em um arquivo de classe
personalizado, XmlMenu.as.
Você pode encontrar o arquivo de origem de exemplo, xmlmenu.fla, na pasta Samples
(Exemplos) no disco rígido.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\XML_Menu.
■ No Macintosh, navegue até Macintosh HD/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/XML_Menu.

Sobre como trabalhar com classes personalizadas em um aplicativo 253


Sobre a importação de arquivos de classes
Para usar uma classe ou uma interface definida, o Flash deve localizar os arquivos externos do
ActionScript que contêm a definição da classe ou da interface de modo que possa importar o
arquivo. A lista de diretórios na qual o Flash procura as definições de classes, interfaces,
funções e variáveis é denominada caminho de classe. O Flash possui duas configurações de
caminho de classe, um caminho de classe global e um em nível de documento:
■ Caminho de classe global é um caminho de classe compartilhado por todos os
documentos do Flash e Você deve configurá-lo na caixa de diálogo Preferences
(Preferências) (Edit (Editar) > Preferences (Windows) ou Flash > Preferences (Macintosh),
clique em ActionScript na lista Category (Categoria) e, em seguida, clique em
ActionScript 2.0 Settings (Configurações do ActionScript 2.0)).
■ Caminho de classe em nível de documento é um caminho de classe definido
especificamente para um único documento do Flash, Ele é configurado na caixa de diálogo
Publish Settings (Configurações de publicação) (File > Publish Settings, selecione a guia
Flash e, em seguida, clique no botão Settings, Configurações).
As seguintes regras se aplicam à importação de arquivos de classes:
■ As instruções import podem existir nos seguintes locais:
■ Qualquer local antes da definição de classe nos arquivos de classe
■ Qualquer local nos scripts de quadro ou de objetos
■ Qualquer local nos arquivos ActionScript que você incluir em um aplicativo (usando a
instrução #include).
■ Para importar definições empacotadas individuais, use esta sintaxe:
import flash.display.BitmapData;

■ Você pode importar pacotes inteiros com a sintaxe de caracteres curingas:


import flash.display.*;

Você também pode incluir código ActionScript em um arquivo de documento do Flash (FLA)
usando uma instrução include. As seguintes regras se aplicam à instrução include:
■ Essencialmente, as instruções include copiam e colam o conteúdo no arquivo incluído do
ActionScript.
■ As instruções include dentro dos arquivos de classe do ActionScript são relativas ao
subdiretório que contém o arquivo.

254 Classes
■ Em um arquivo do Flash (FLA), as instruções include só podem inserir código válido em
arquivos FLA, e a mesma regra se aplica aos outros locais em que as instruções include
podem residir. Por exemplo, se uma definição de classe contiver uma instrução include,
somente definições de propriedades e de métodos poderão existir no arquivo incluído do
ActionScript:
// Foo.as
class Foo {
#include "FooDef.as"
}
// FooDef.as:
var fooProp;
function fooMethod() {}
trace("Foo"); // Essa instrução não é permitida na definição de classe.

Para obter mais informações sobre a instrução include, consulte %{#include directive}% em
ActionScript 2.0 Language Reference (Referência da linguagem ActionScript). Para obter mais
informações sobre caminhos de classes, consulte “Sobre a definição e a modificação do
caminho de classe” na página 255.

Sobre a definição e a modificação do caminho de classe


Para usar uma classe ou uma interface definida, o Flash deve localizar os arquivos ActionScript
externos que contêm a definição da classe ou da interface. A lista de diretórios na qual o Flash
procura as definições de classes e interfaces é denominada caminho de classe.
Depois de criar um arquivo de classe do ActionScript, você precisa salvar o arquivo em um dos
diretórios especificados no caminho de classe ou em um subdiretório desse caminho. (Você
pode modificar o caminho de classe para incluir o caminho de diretório desejado). Caso
contrário, o Flash não poderá resolver, ou seja, localizar a classe ou a interface especificada no
script. Os subdiretórios criados em um diretório do caminho de classe chamam-se pacotes e
permitem a você organizar as suas classes. (Para obter mais informações sobre pacotes,
consulte “Criando e empacotando arquivos de classes” na página 281.)
O Flash tem duas configurações de caminho de classe: um caminho de classe global e um
caminho de classe em nível de documento. O caminho de classe global é compartilhado por
todos os documentos do Flash. O caminho de classe em nível de documento é definido
especificamente para um único documento do Flash.

Sobre como trabalhar com classes personalizadas em um aplicativo 255


O caminho de classe global aplica-se aos arquivos ActionScript e FLA externos, e é definido na
caixa de diálogo Preferences (Preferências) (Windows: Edit (Editar) > Preferences (Windows)
ou Flash > Preferences (Macintosh), selecione ActionScript da lista Category (Categoria) e, em
seguida, clique em ActionScript 2.0 Settings (Configurações do ActionScript)). Você pode
definir o caminho de classe em nível de documento na caixa de diálogo Publish Settings
(Configurações de publicação) do documento do Flash (File (Arquivo) > Publish Settings,
selecione a guia Flash e, em seguida, clique no botão Settings (Configurações).
N OT A

Quando você clica no botão Check Syntax (Verificar sintaxe) acima do painel Script ao
editar um arquivo do ActionScript, o compilador examina somente o caminho de classe
global. Os arquivos do ActionScript não são associados a arquivos FLA no modo de
edição e não possuem o seu próprio caminho de classe.

Usando um caminho de classe global


O caminho de classe global é compartilhado por todos os documentos do Flash.
Você pode modificar o caminho de classe global usando a caixa de diálogo Preferences. Para
modificar a configuração do caminho de classe em nível de documento, use a caixa de diálogo
Publish Settings para o arquivo FLA. Nos dois casos, você pode adicionar caminhos de
diretório absolutos (por exemplo, C:/my_classes) e caminhos de diretório relativos (por
exemplo, ../my_classes ou “.”). A ordem dos diretórios na caixa de diálogo reflete a ordem
em que eles são pesquisados.
Por padrão, o caminho de classe global contém um caminho absoluto e outro relativo. O
caminho absoluto é denotado por $(LocalData)/Classes na caixa de diálogo Preferences. O
local do caminho absoluto é mostrado aqui:
■ Windows: Hard Disk\Documents and Settings\user\Local Settings\Application
Data\Macromedia\Flash 8\idioma\Configuration\Classes.
■ Macintosh: Hard Disk/Users/usuário/Library/Application Support/Macromedia/Flash 8/
idioma/Configuration/Classes.
NO T A

Não exclua o caminho de classe global absoluto. O Flash utiliza esse caminho de
classe para acessar as classes internas. Se você acidentalmente excluir esse
caminho de classe, restabeleça-o adicionando $(LocalData)/Classes como um
novo caminho de classe.

A parte do caminho de classe global referente ao caminho relativo é denotada por um ponto
(.) e aponta para o diretório de documentos atual. Saiba que os caminhos de classe relativos
podem apontar para diretórios diferentes, dependendo do local do documento que está sendo
compilado ou publicado.
Para adicionar um caminho de classe global ou editar um caminho de classe existente, siga
estas etapas.

256 Classes
Para modificar o caminho de classe global:
1. Selecione Edit (Editar) > Preferences (Preferências) (Windows) ou Flash > Preferences
(Macintosh) para abrir a caixa de diálogo Preferences.
2. Clique no ActionScript na coluna esquerda e, em seguida, clique no botão ActionScript 2.0
Settings (Configurações do ActionScript 2.0).
3. Clique no botão Browse to Path (Navegar até caminho) para navegar até o diretório que
deseja adicionar.
4. Navegue até o caminho desejado e clique em OK.

Para excluir um diretório do caminho de classe:


1. Selecione o caminho na lista Classpath (Caminho de classe).
2. Clique no botão Remove from Path (Remover do caminho).
NO T A

Não exclua o caminho de classe global absoluto. O Flash utiliza esse caminho de
classe para acessar as classes internas. Se você acidentalmente excluir esse
caminho de classe, restabeleça-o adicionando $(LocalData)/Classes como um
novo caminho de classe.

Para obter informações sobre a importação de pacotes, consulte “Trabalhando com pacotes”
na página 244.

Usando um caminho de classe em nível de documento


O caminho de classe em nível de documento se aplica somente a arquivos FLA. Para defini-lo,
use a caixa de diálogo Publish Settings (Configurações de publicação) referente a um arquivo
FLA, em File (Arquivo) > Publish Settings, clique na guia Flash e, em seguida, clique em
ActionScript 2.0 Settings (Configurações do ActionScript 2.0). O padrão é que o caminho de
classe em nível de documento fique vazio. Quando você cria e salva um arquivo FLA em um
diretório, esse diretório torna-se um diretório de caminho de classe designado.
Ao criar classes, é possível que, algumas vezes, você deseje armazená-las em um diretório que
será adicionado posteriormente à lista de diretórios de caminho de classe global nas seguintes
situações:
■ Se você tiver um conjunto de classes utilitárias que sejam usadas em todos os seus projetos
■ Se você desejar verificar a sintaxe do seu código (clique no botão Check Syntax (Verificar
sintaxe)) dentro do arquivo ActionScript externo
A criação de um diretório evita a perda de classes personalizadas se você desinstalar e reinstalar
o Flash, especialmente se o diretório de caminho de classe global padrão for excluído e
substituído, porque todas as classes armazenadas nesse diretório seriam perdidas.

Sobre como trabalhar com classes personalizadas em um aplicativo 257


Por exemplo, você pode criar para suas classes personalizadas um diretório como o
apresentado a seguir:
■ Windows: Hard Disk\Documents and Settings\usuário\custom classes.
■ Macintosh: Hard Disk/Users/usuário/custom classes.
Em seguida, você adicionaria esse caminho à lista de caminhos de classe global (consulte
“Usando um caminho de classe global” na página 256).
Quando o Flash tenta resolver as referências de classes em um script FLA, ele pesquisa
primeiro o caminho de classe em nível de documento especificado para esse arquivo FLA. Se
ele não encontrar a classe nesse caminho ou se o caminho estiver vazio, ele pesquisará o
caminho de classe global. Se ele não encontrar a classe nesse caminho, ocorrerá um erro do
compilador.

Para modificar o caminho de classe no nível do documento:


1. Selecione File > Publish Settings para abrir a caixa de diálogo Publish Settings.
2. Clique na guia Flash.
3. Clique no botão Settings perto do menu pop-up ActionScript Version (Versão do
ActionScript).
4. Você pode digitar manualmente um caminho de arquivo ou clicar no botão Browse to Path
(Navegar até caminho) para navegar até o diretório que deseja adicionar ao caminho de
classe.
NO T A

Para editar um diretório de caminho de classe existente, selecione o caminho na lista


Classpath (Caminho de classe), clique no botão Browse to Path, navegue até o
diretório que deseja adicionar e clique em OK.
N OT A

Para excluir um diretório do caminho de classe, selecione o caminho na lista


Classpath e clique no botão Remove Selected Path (-) (Remover o caminho
selecionado).

Para obter mais informações sobre pacotes, consulte “Sobre pacotes” na página 242.

Como o compilador resolve as referências de classes


Quando o Flash tenta resolver as referências de classes em um script FLA, ele pesquisa
primeiro o caminho de classe em nível de documento especificado para esse arquivo FLA. Se a
classe não for encontrada nesse caminho ou se o caminho estiver vazio, o Flash pesquisará o
caminho de classe global. Se a classe não for encontrada nesse caminho, ocorrerá um erro do
compilador.

258 Classes
No Flash Professional, quando você clica no botão Check Syntax (Verificar sintaxe) ao editar
um arquivo ActionScript, o compilador examina somente o caminho de classe global; os
arquivos ActionScript não são associados a arquivos FLA no modo de edição nem possuem o
seu próprio caminho de classe.

Usando um arquivo de classe no Flash


Para criar uma instância de uma classe do ActionScript, use o operador new para chamar a
função construtora da classe. A função construtora sempre tem o mesmo nome da classe e
retorna uma instância da classe, que você normalmente atribui a uma variável. Por exemplo, se
estivesse usando a classe User criada em “Criando arquivos de classes personalizados”
na página 249, você escreveria o seguinte código para criar um objeto User:
var firstUser:User = new User();
N OT A

Em alguns casos, não é necessário criar uma instância de uma classe para usar suas
propriedades e métodos. Para obter mais informações sobre membros (estáticos) de
classes, consulte “Sobre os membros de classe (estáticos)” na página 315 e
“Propriedades e métodos estáticos” na página 264.

Use o operador ponto (.) para acessar o valor de uma propriedade em uma instância. Digite o
nome da instância à esquerda do ponto e o nome da propriedade à direita. Por exemplo, na
instrução a seguir, firstUser é a instância e username é a propriedade:
firstUser.username

Você também pode usar em um documento do Flash as classes de nível superior ou internas
da linguagem ActionScript. Por exemplo, o código a seguir cria um novo objeto Array e,
depois, mostra sua propriedade length:
var myArray:Array = new Array("apples", "oranges", "bananas");
trace(myArray.length); // 3

Para obter mais informações sobre o uso de classes personalizadas no Flash, consulte o
“Exemplo: Usando arquivos de classes personalizados no Flash” na página 291. Para obter
informações sobre a função construtora, consulte “Criando a função construtora”
na página 283.

Sobre como trabalhar com classes personalizadas em um aplicativo 259


Usando métodos e propriedades de um arquivo de
classe
Na OOP, os membros (propriedades ou métodos) de uma classe podem ser membros de
instância ou membros de classe. Os membros de instância são criados para cada instância da
classe; eles são definidos para o protótipo da classe quando são inicializados na definição de
classe. Os membros de classe, por outro lado, são criados uma vez por classe. (Os membros da
classe também são conhecidos como membros estáticos.)
Propriedades são atributos que definem um objeto. Por exemplo, length é uma propriedade
de todos os arrays que especifica o número de elementos do array. Métodos são funções
associadas a uma classe. Para obter mais informações sobre funções e métodos, consulte o
Capítulo 6, “Funções e métodos”, na página 213.
O exemplo a seguir mostra como criar um método em um arquivo de classe:
class Sample {
public function myMethod():Void {
trace("myMethod");
}
}

Depois, você poderia chamar esse método em seu documento. Para chamar um método de
instância ou acessar uma propriedade de instância, você faz referência a uma instância da
classe. No exemplo a seguir, picture01, uma instância da classe personalizada Picture
(disponível no exercício a seguir), chama o método showInfo():
var img1:Picture = new Picture("http://www.helpexamples.com/flash/images/
image1.jpg");
// Chame o método showInfo().
img1.showInfo();

O próximo exemplo demonstra como criar uma classe personalizada Picture para armazenar
várias informações sobre uma foto.

Para usar as classes Picture e PictureClass em um arquivo FLA:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione ActionScript File (Arquivo
ActionScript). Salve o documento como Picture.as e, em seguida, clique em OK.
Crie sua classe Picture personalizada nesse documento.
2. Digite o seguinte código ActionScript na janela Script:
/**
Picture class
author: John Doe
version: 0.53
modified: 6/24/2005
copyright: Macromedia, Inc.

260 Classes
A classe Picture é usada como um recipiente para uma imagem e seu URL.
*/

class Picture {
private var __infoObj:Object;

public function Picture(src:String) {


this.__infoObj = new Object();
this.__infoObj.src = src;
}

public function showInfo():Void {


trace(this.toString());
}
private function toString():String {
return "[Picture src=" + this.__infoObj.src + "]";
}

public function get src():String {


return this.__infoObj.src;
}
public function set src(value:String):Void {
this.__infoObj.src = value;
}
}

3. Salve o arquivo do ActionScript.


4. Selecione File > New Flash Document (Documento do Flash) para criar um arquivo FLA.
Salve-o como picture_test.fla no mesmo diretório em que salvou o arquivo de classe
Picture.
5. Digite o seguinte código ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de
tempo):
var picture1:Picture = new Picture("http://www.helpexamples.com/flash/
images/image1.jpg");
picture1.showInfo();
this.createEmptyMovieClip("img_mc", 9);
img_mc.loadMovie(picture1.src);

6. Salve o documento do Flash.


7. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento.
O seguinte texto é exibido no painel Output:
[Picture src=http://www.helpexamples.com/flash/images/image1.jpg]

Sobre como trabalhar com classes personalizadas em um aplicativo 261


Um arquivo de exemplo no disco rígido demonstra como criar um menu dinâmico com dados
XML e um arquivo de classe personalizado. O exemplo chama o construtor XmlMenu() do
ActionScript e passa dois parâmetros: o caminho para o arquivo de menu XML e uma
referência à timeline atual. O resto da funcionalidade reside em um arquivo de classe
personalizado, XmlMenu.as.
Você pode encontrar o arquivo de origem de exemplo, xmlmenu.fla, na pasta Samples
(Exemplos) no disco rígido.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\XML_Menu.
■ No Macintosh, navegue até Macintosh HD/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/XML_Menu.

Sobre propriedades (membros) e métodos públicos, privados


e estáticos
Ao criar arquivos de classes do ActionScript em um arquivo de script externo, você poderá
criar quatro tipos de métodos e propriedades: métodos públicos e propriedades, métodos
privados e propriedades, métodos estáticos públicos e propriedades e métodos estáticos
privados e propriedades. Esses métodos e propriedades definem como o Flash pode acessar
variáveis e permitem especificar quais partes do código podem acessar determinados métodos
ou propriedades.
Ao criar aplicativos pequenos ou grandes baseados em classes, é importante considerar se um
método ou propriedade deve ser privado ou público. Isso garantirá a segurança máxima do
código. Por exemplo, se você criar uma classe User, talvez não deseje que os usuários dessa
classe sejam capazes de alterar a ID de outros usuários. Definindo a propriedade da classe (às
vezes chamada membro de instância) como privada, você poderá limitar ao código da classe
ou das subclasses dessa classe o acesso à propriedade, o que significa que nenhum usuário
poderá alterar essa propriedade diretamente.

Propriedades e métodos públicos


A palavra-chave public especifica que uma variável ou função está disponível para qualquer
chamador. Como as variáveis e as funções são públicas por padrão, a palavra-chave this é
usada principalmente por razões estilísticas e de legibilidade, indicando que a variável existe
no escopo atual. Por exemplo, você pode usá-la para manter a consistência em um bloco de
código que também contém variáveis privadas ou estáticas. Ela pode ser usada como palavra-
chave pública ou privada.

262 Classes
A classe Sample a seguir já contém um método público chamado myMethod():
class Sample {
private var ID:Number;
public function myMethod():Void {
this.ID = 15;
trace(this.ID); // 15
trace("myMethod");
}
}

Se desejar adicionar uma propriedade pública, use a palavra “public” em vez de “private”,
como mostra o seguinte código de exemplo:
class Sample {
private var ID:Number;
public var email:String;
public function myMethod():Void {
trace("myMethod");
}
}

Como a propriedade email é pública, você pode alterá-la na classe Sample ou diretamente em
um FLA.

Propriedades e métodos privados


A palavra-chave private determina que uma variável ou função está disponível apenas para a
classe que a declara ou a define ou para subclasses dessa classe. Por padrão, uma variável ou
função é pública e está disponível para qualquer chamador. Use a palavra-chave this se
desejar restringir o acesso a uma variável ou função, como mostra o seguinte exemplo:
class Sample {
private var ID:Number;
public function myMethod():Void {
this.ID = 15;
trace(this.ID); // 15
trace("myMethod");
}
}

Para adicionar uma propriedade privada à classe anterior, você deve usar simplesmente a
palavra-chave private antes da palavra-chave var.
Se você tentar acessar a propriedade ID privada fora da classe Sample, você receberá um erro
de compilador e uma mensagem no painel Output (Saída). A mensagem indica que o
membro é privado e não pode ser acessado.

Sobre como trabalhar com classes personalizadas em um aplicativo 263


Propriedades e métodos estáticos
A palavra-chave static determina que uma variável ou função seja criada somente uma vez
por classe, em vez de em todos os objetos baseados nessa classe. Você pode acessar um membro
de classe estático sem criar uma instância da classe. As propriedades e os métodos estáticos
podem ser definidos no escopo público ou privado.
Os membros estáticos, também chamados membros de classe, são atribuídos à classe, e não a
uma instância da classe. Para chamar um método ou acessar uma propriedade da classe, você
faz referência ao nome da classe, em vez de a uma instância específica dela, como mostra o
seguinte código:
trace(Math.PI / 8); // 0.392699081698724

Se você digitar essa linha de código no painel de script do painel Actions (Ações), será exibido
um resultado no painel Output (Saída).
Por exemplo, no exemplo da classe Sample anterior, você poderia criar uma variável estática
para controlar quantas instâncias da classe foram criadas, como demonstrado no seguinte
código:
class Sample {
public static var count:Number = 0;
private var ID:Number;
public var email:String;
public function Sample() {
Sample.count++;
trace("count updated: " + Sample.count);
}
public function myMethod():Void {
trace("myMethod");
}
}

Toda vez que uma nova instância da classe Sample é criada, o método construtor apresenta o
número total de instâncias de classe Sample definidas até o momento.
Algumas das classes de nível superior do ActionScript têm membros de classe (ou membros
estáticos), como você viu anteriormente nesta seção ao chamar a propriedade Math.PI. Os
membros de classe (propriedades e métodos) são acessados ou chamados no nome da classe, e
não em uma instância dela. Portanto, você não cria uma instância da classe para usar essas
propriedades e métodos.
Por exemplo, a classe Math de nível superior consiste apenas em métodos e propriedades
estáticos. Para chamar qualquer um dos seus métodos, você não cria uma instância dessa
classe. Em vez disso, basta chamar os métodos na própria classe Math. O código a seguir
chama o método sqrt() da classe Math:

264 Classes
var squareRoot:Number = Math.sqrt(4);
trace(squareRoot); // 2

O código a seguir chama o método max() da classe Math, que determina o maior de dois
números:
var largerNumber:Number = Math.max(10, 20);
trace(largerNumber); // 20

Para obter mais informações sobre a criação de membros de classe, consulte “Sobre membros
de classe” na página 265 e “Usando membros de classe” na página 269.
Um arquivo de exemplo no disco rígido demonstra como criar um menu dinâmico com dados
XML e um arquivo de classe personalizado. O exemplo chama o construtor XmlMenu() do
ActionScript e passa dois parâmetros: o caminho para o arquivo de menu XML e uma
referência à timeline atual. O resto da funcionalidade reside em um arquivo de classe
personalizado, XmlMenu.as.
Você pode encontrar o arquivo de origem de exemplo, xmlmenu.fla, na pasta Samples
(Exemplos) no disco rígido.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\XML_Menu.
■ No Macintosh, navegue até Macintosh HD/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/XML_Menu.

Sobre membros de classe


A maioria dos membros (métodos e propriedades) abordados até agora neste capítulo são de
um tipo denominado membros de instância. Para cada membro de instância, há uma cópia
exclusiva desse membro em cada instância da classe. Por exemplo, a variável de membro email
da classe Sample tem um membro de instância, pois cada pessoa tem um endereço eletrônico
diferente.
Outro tipo de membro é o membro de classe. Há somente uma cópia de um membro de classe,
e ela é usada para a classe inteira. Qualquer variável declarada em uma classe, mas fora de uma
função, é uma propriedade da classe. No exemplo a seguir, a classe Person tem duas
propriedades, age e name, de tipo Number e String, respectivamente.
class Person {
public var age:Number;
public var username:String;
}

Igualmente, qualquer função declarada em uma classe é considerada um método da classe. No


exemplo da classe Person, você pode criar um método chamado getInfo().

Sobre como trabalhar com classes personalizadas em um aplicativo 265


class Person {
public var age:Number;
public var username:String;
public function getInfo():String {
// definição do método getInfo()
}
}

No trecho de código anterior, o método getInfo() da classe Person, bem como as


propriedades age e username, são membros de instância públicos. A propriedade age não
poderia ser considerada com um membro de classe, pois cada pessoa tem uma idade diferente.
Somente as propriedades e os métodos compartilhados por todos os indivíduos da classe
devem ser membros de classe.
Suponha que toda classe deva ter uma variável species que indique o nome em latim da
espécie que a classe representa. Para cada objeto Person, a espécie é Homo sapiens. Como não
valeria a pena armazenar uma cópia exclusiva da seqüência de caracteres "Homo sapiens"
para cada instância da classe, esse membro deve ser um membro de classe.
Os membros de classe são declarados com a palavra-chave static. Por exemplo, você poderia
declarar o membro de classe species com o seguinte código:
class Person {
public static var species:String = "Homo sapiens";
// ...
}

Você também pode declarar os métodos de uma classe como estáticos, como no seguinte
código:
public static function getSpecies():String {
return Person.species;
}

Os métodos estáticos podem acessar somente propriedades estáticas, e não propriedades de


instância. Por exemplo, o código a seguir resultará em um erro do compilador, porque o
método getAge() da classe faz referência à variável de instância age.
class Person {
public var age:Number = 15;
// ...
public static function getAge():Number {
return age; /* **Error**: Não é possível acessar variáveis de instância
em funções estáticas. */
}
}

Para resolver esse problema, você pode transformar o método em um método de instância ou
transformar a variável em uma variável de classe.

266 Classes
Para obter mais informações sobre membros de classe (também chamados propriedades
estáticas), consulte “Propriedades e métodos estáticos” na página 264.
Um arquivo de exemplo no disco rígido demonstra como criar um menu dinâmico com dados
XML e um arquivo de classe personalizado. O exemplo chama o construtor XmlMenu() do
ActionScript e passa dois parâmetros: o caminho para o arquivo de menu XML e uma
referência à timeline atual. O resto da funcionalidade reside em um arquivo de classe
personalizado, XmlMenu.as.
Você pode encontrar o arquivo de origem de exemplo, xmlmenu.fla, na pasta Samples
(Exemplos) no disco rígido.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\XML_Menu.
■ No Macintosh, navegue até Macintosh HD/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/XML_Menu.

Usando o padrão de design Singleton


Uma forma comum de usar membros de classe é com o padrão de design Singleton. Um
padrão de design define uma abordagem formal para estruturar o código. Geralmente, você
estrutura um padrão de design como uma solução para um problema comum de
programação. Há vários padrões de design estabelecidos, como o Singleton. Esse padrão
garante que uma classe tenha apenas uma instância e permite acessar globalmente a instância.
Para obter informações detalhadas sobre o padrão de design Singleton, consulte
www.macromedia.com/devnet/mx/coldfusion/articles/design_patterns.html.
Freqüentemente, há situações em que é necessário ter exatamente um objeto de determinado
tipo em um sistema. Por exemplo, em um jogo de xadrez, há somente um tabuleiro; da mesma
maneira, em cada país, há somente uma capital. Embora exista apenas um objeto, você deve
encapsular a funcionalidade desse objeto em uma classe. Entretanto, talvez você precise
gerenciar e acessar a instância única desse objeto. Uma das maneiras de fazer isso é usar uma
variável global; contudo, as variáveis globais não são desejáveis para a maioria dos objetos.
Uma abordagem melhor é fazer com que a classe gerencie a instância única do objeto usando
membros de classe. O exemplo a seguir mostra um uso padrão típico do design Singleton, em
que a instância Singleton é criada apenas uma vez.

Para usar o padrão de design Singleton:


1. Selecione File (Arquivo) > New (Novo) e, em seguida, selecione ActionScript File (Arquivo
ActionScript). Salve o documento como Singleton.as.

Sobre como trabalhar com classes personalizadas em um aplicativo 267


2. Digite o seguinte código ActionScript na janela Script:
/**
Singleton class
author: John Doe
version: 0.53
modified: 6/24/2008
copyright: Macromedia, Inc.
*/

class Singleton {
private static var instance:Singleton = null;
public function trackChanges():Void {
trace("tracking changes.");
}
public static function getInstance():Singleton {
if (Singleton.instance == null) {
trace("creating new Singleton.");
Singleton.instance = new Singleton();
}
return Singleton.instance;
}
}

3. Salve o documento Singleton.as.


4. Selecione File > New e, em seguida, selecione Flash Document (Documento do Flash) para
criar um arquivo FLA, e salve-o como singleton_test.fla no mesmo diretório em que foi
salvo o arquivo de classe Singleton.
5. Digite o seguinte código ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de
tempo):
Singleton.getInstance().trackChanges(); // controlando alterações.

var s:Singleton = Singleton.getInstance(); // controlando alterações.


s.trackChanges();

6. Salve o documento do Flash.


7. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento.
O objeto Singleton só será criado quando for necessário; ou seja, quando outro código
solicitá-lo chamando o método getInstance(). Esse procedimento é geralmente chamado
criação lenta e pode ajudar a tornar o seu código mais eficiente em várias circunstâncias.

268 Classes
Lembre-se de não usar nem classes de menos nem demais para o aplicativo, porque isso pode
levar a arquivos de classe malfeitos, o que pode prejudicar o desempenho do aplicativo ou do
seu fluxo de trabalho. Você deve sempre tentar usar arquivos de classe em vez de colocar
código em outros lugares (por exemplo, timelines); no entanto, evite criar muitas classes que
tenham uma pequena quantidade de funcionalidade ou algumas classes que realizem muitas
funcionalidades. Essas duas situações podem indicar design inadequado.

Usando membros de classe


É possível usar os membros de classe para manter as informações de estado de uma classe e
suas instâncias. Por exemplo, para acompanhar o número de instâncias que foram criadas de
uma determinada classe. Uma maneira fácil de fazer isso é usar uma propriedade da classe que
é incrementada sempre que uma nova instância é criada.
No exemplo a seguir, você criará uma classe Widget que define um contador de instância
simples e estático chamado widgetCount. Sempre que uma nova instância da classe é criada, o
valor de widgetCount é incrementado em 1, e o valor atual de widgetCount é exibido no
painel Output (Saída).

Para criar um contador de instância usando uma variável de classe:


1. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
2. Digite o seguinte código na janela Script:
class Widget {
//Inicialize a variável de classe
public static var widgetCount:Number = 0;
public function Widget() {
Widget.widgetCount++;
trace("Creating widget #" + Widget.widgetCount);
}
}

A variável widgetCount é declarada como estática, portanto, é inicializada como 0


somente uma vez. Sempre que a instrução construtora da classe Widget é chamada, ela
adiciona 1 a widgetCount e exibe o número da instância atual que está sendo criada.
3. Salve o arquivo como Widget.as.
4. Selecione File > New Flash document (Documento do Flash) para criar um arquivo FLA e
salve-o como widget_test.fla no mesmo diretório que Widget.as.
5. Em widget_test.fla, digite o seguinte código no Frame 1 (Quadro 1) da Timeline (Linha de
tempo):
// Antes que você crie qualquer instância da classe,
// Widget.widgetCount é igual a zero (0).

Sobre como trabalhar com classes personalizadas em um aplicativo 269


trace("Widget count at start: " + Widget.widgetCount); // 0
var widget1:Widget = new Widget(); // 1
var widget2:Widget = new Widget(); // 2
var widget3:Widget = new Widget(); // 3
trace("Widget count at end: " + Widget.widgetCount); // 3

6. Salve as alterações em widget_test.fla.


7. Selecione Control > Test Movie para testar o arquivo.
O Flash exibe as seguintes informações no painel Output (Saída):
Widget count at start: 0
Creating widget # 1
Creating widget # 2
Creating widget # 3
Widget count at end: 3

Sobre os métodos getter e setter


Getter e setter são métodos de acesso, ou seja, eles são geralmente uma interface pública para
alterar os membros privados de uma classe. Esses métodos são usados para definir uma
propriedade. Você acessa esses métodos como propriedades fora da classe, embora defina-os na
classe como métodos. As propriedades externas à classe podem ter um nome diferente do
nome da propriedade na classe.
O uso dos métodos getter e setter oferece algumas vantagens, como a capacidade de criar, com
uma funcionalidade sofisticada, membros que podem ser acessados como propriedades. Eles
também permitem criar propriedades somente leitura e somente gravação.
Embora os métodos getter e setter sejam úteis, evite uso excessivo porque, entre outros
problemas, eles podem dificultar a manutenção do código em determinadas situações. Além
disso, eles permitem o acesso à sua implementação de classes, como membros públicos. A
prática de OOP não recomenda o acesso direto às propriedades em uma classe.
Ao criar classes, procure sempre tornar o maior número possível de suas variáveis de instância
privadas e adicionar métodos getter e setter conforme adequado. Isso é recomendável porque,
muitas vezes, você não desejará permitir que os usuários alterem determinadas variáveis de
suas classes. Por exemplo, se tiver um método estático privado que controle o número de
instâncias criadas para uma classe específica, você não desejará que os usuários modifiquem
esse contador usando o código. Somente a instrução construtora deverá incrementar essa
variável quando for chamada. Nesse caso, você pode criar uma variável de instância privada e
permitir um método getter somente para a variável de contador; dessa maneira, os usuários só
poderão recuperar o valor atual usando o método getter e não poderão definir novos valores
com o método setter. A criação de um método getter sem um setter é uma forma simples de
tornar somente leitura determinadas variáveis de sua classe.

270 Classes
Usando métodos getter e setter
A sintaxe dos métodos getter e setter é a seguinte:
■ O método getter não usa parâmetros e sempre retorna um valor.
■ O método setter sempre usa um parâmetro e nunca retorna um valor.
As classes normalmente definem métodos getter que fornecem acesso de leitura e métodos
setter que fornecem acesso de gravação a uma propriedade específica. Por exemplo, imagine
uma classe que contenha uma propriedade userName:
private var userName:String;

Em vez de permitir que instâncias da classe acessem diretamente essa propriedade


(user.userName = "Buster", por exemplo), a classe pode ter dois métodos, getUserName()
e setUserName(), que serão implementados como mostra o seguinte exemplo:

Para usar métodos getter e setter:


1. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
2. Digite o seguinte código na janela Script:
class Login {
private var __username:String;
public function Login(username:String) {
this.__username = username;
}
public function getUserName():String {
return this.__username;
}
public function setUserName(value:String):Void {
this.__username = value;
}
}

3. Salve o documento do ActionScript como Login.as.


Como você pode observar, getUserName retorna o valor atual de userName, e
setUserName() define o valor de userName como o parâmetro de seqüência de caracteres
passado para o método.
4. Selecione File > New Flash document (Documento do Flash) para criar um arquivo FLA e
salve-o como login_test.fla no mesmo diretório que Login.as.
5. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
var user:Login = new Login("RickyM");

// chamando o método getUserName()

Sobre como trabalhar com classes personalizadas em um aplicativo 271


var userName:String = user.getUserName();
trace(userName); // RickyM

// chamando o método setUserName()


user.setUserName("EnriqueI");
trace(user.getUserName()); // EnriqueI

6. Selecione Control > Test Movie para testar o arquivo.


O Flash exibe as seguintes informações no painel Output (Saída):
RickyM
EnriqueI

Entretanto, se desejar uma sintaxe mais concisa, use os métodos getter e setter implícitos.
Esses métodos permitem acessar as propriedades da classe de maneira direta e, ao mesmo
tempo, seguir as práticas recomendadas de OOP.
Para definir esses métodos, use os atributos de método get e set. Crie métodos que
obtenham ou definam o valor de uma propriedade e adicione a palavra-chave get ou set
antes do nome do método, como mostra o próximo exemplo:
N OT A

Os métodos getter/setter implícitos são abreviações sintáticas do método


Object.addProperty() encontrado no ActionScript 1.0.

Para usar métodos getter e setter implícitos:


1. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
2. Digite o seguinte código na janela Script:
class Login2 {
private var __username:String;
public function Login2(username:String) {
this.__username = username;
}
public function get userName():String {
return this.__username;
}
public function set userName(value:String):Void {
this.__username = value;
}
}

3. Salve o documento do ActionScript como Login2.as.

272 Classes
Lembre-se de que os métodos getter não utilizam parâmetros. Os métodos setter devem
ter exatamente um parâmetro obrigatório. Um método setter pode ter o mesmo nome de
um método getter no mesmo escopo. Os métodos getter e setter não podem ter o mesmo
nome de outras propriedades. Por exemplo, no código anterior em que você definiu
métodos getter e setter chamados userName, não poderia existir também uma propriedade
chamada userName na mesma classe.
4. Selecione File > New Flash document (Documento do Flash) para criar um arquivo FLA e
salve-o como login2_test.fla no mesmo diretório que Login2.as.
5. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
var user:Login2 = new Login2("RickyM");

// chamando o método "get"


var userNameStr:String = user.userName;
trace(userNameStr); // RickyM

// chamando o método "set"


user.userName = "EnriqueI";
trace(user.userName); // EnriqueI

Diferentemente dos métodos comuns, os métodos getter e setter são chamados sem
parênteses ou argumentos. Os métodos getter e setter são chamados da mesma maneira
que uma propriedade de mesmo nome.
6. Salve o documento do Flash e selecione Control (Controlar) > Test Movie (Testar filme)
para testar o arquivo.
O Flash exibe as seguintes informações no painel Output (Saída):
RickyM
EnriqueI
N OT A

Não é possível usar atributos de métodos getter e setter em declarações de método


de interface.

Sobre classes dinâmicas


Ao adicionar a palavra-chave dynamic a uma definição de classe, você especifica que os objetos
com base nessa classe podem adicionar e acessar propriedades dinâmicas durante a execução.
Você deve criar classes dinâmicas somente se precisar especificamente dessa funcionalidade.
A verificação de tipo em classes dinâmicas é menos estrita que em classes não-dinâmicas, pois
os membros acessados na definição de classe e em instâncias da classe não são comparados
com aqueles definidos no escopo da classe. No entanto, ainda é possível realizar a verificação
de tipo das funções de membros de classes para detectar tipos de retorno e tipos de parâmetro.

Sobre como trabalhar com classes personalizadas em um aplicativo 273


Para obter informações sobre a criação de classes dinâmicas, consulte “Criando classes
dinâmicas” na página 274.

Criando classes dinâmicas


O padrão é que as propriedades e os métodos de uma classe sejam fixos. Ou seja, uma
instância de uma classe não pode criar ou acessar as propriedades ou os métodos que não
foram originalmente declarados ou definidos pela classe. Por exemplo, considere uma classe
Person que define duas propriedades, userName e age.

Para criar uma classe que não seja dinâmica:


1. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
2. Digite o seguinte ActionScript na janela Script:
class Person {
public var userName:String;
public var age:Number;
}

Se, em outro script, você criar uma instância da classe Person e tentar acessar uma
propriedade da classe que não existe, o compilador gerará um erro.
3. Salve o arquivo no disco rígido como Person.as.
4. Selecione File > New Flash Document (Documento do Flash) para criar um arquivo FLA
e clique em OK.
5. Selecione File > Save As (Salvar como), atribua um nome ao arquivo person_test.fla e salve
o arquivo no mesmo diretório que a classe Person criada anteriormente.
6. Adicione o código a seguir para criar uma nova instância da classe Person (firstPerson)
e tente atribuir um valor a uma propriedade chamada hairColor (que não existe na classe
Person):
var firstPerson:Person = new Person();
firstPerson.hairColor = "blue"; // Erro. Não existe uma propriedade com o
nome 'hairColor'.

7. Salve o documento do Flash.


8. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código.
Esse código gera um erro do compilador porque a classe Person não declara uma
propriedade chamada hairColor. Na maioria dos casos, é exatamente isso que você deseja
que aconteça. Embora os erros do compilador não sejam desejáveis, eles são muito úteis
para os programadores: mensagens de erro adequadas o ajudam a criar o código correto
apontando os erros no início do processo de codificação.

274 Classes
Entretanto, em alguns casos, você poderá adicionar e acessar, durante a execução,
propriedades ou métodos de uma classe que não foram definidos na classe original. O
modificador de classe dynamic permite que você faça exatamente isso.

Para criar uma classe dinâmica:


1. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
2. Selecione File > Save As (Salvar como) e atribua o nome Person2.as ao arquivo. Salve o
arquivo no disco rígido.
3. Digite o seguinte código na janela Script:
dynamic class Person2 {
public var userName:String;
public var age:Number;
}

Esse ActionScript adiciona a palavra-chave dynamic à classe Person no exemplo anterior.


As instâncias da classe Person2 podem adicionar e acessar as propriedades e os métodos
não definidos nessa classe.
4. Salve as alterações no arquivo do ActionScript.
5. Selecione File > New Flash Document (Documento do Flash) para criar um arquivo FLA
e clique em OK.
6. Selecione File > Save As (Salvar como) e atribua o nome person2_test.fla ao novo arquivo.
Salve-o no mesmo diretório que Person2.as.
7. Digite o código a seguir para criar uma nova instância da classe Person2 (firstPerson) e
atribua um valor a uma propriedade chamada hairColor (que não existe na classe
Person2).
var firstPerson:Person2 = new Person2();
firstPerson.hairColor = "blue";
trace(firstPerson.hairColor); // azul

8. Salve as alterações no arquivo person2_test.fla.


9. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código.
Como a classe personalizada do Flash é dinâmica, é possível adicionar métodos e
propriedades a ela durante a execução (quando o arquivo SWF é reproduzido). Quando
você testar o código, o texto azul deverá ser exibido no painel Output (Saída).

Sobre como trabalhar com classes personalizadas em um aplicativo 275


Ao desenvolver aplicativos, não convém tornar as classes dinâmicas, a menos que isso seja
necessário. Um dos motivos disso é que a verificação de tipo em classes dinâmicas é menos
estrita do que em classes não-dinâmicas, pois os membros acessados na definição e nas
instâncias da classe não são comparados com os definidos no escopo da classe. No entanto,
ainda é possível realizar a verificação de tipo das funções de membros de classes para detectar
tipos de retorno e tipos de parâmetro.
As subclasses de classes dinâmicas também são dinâmicas, com uma exceção. As subclasses da
classe MovieClip não são dinâmicas por padrão, embora a classe MovieClip seja dinâmica.
Essa implementação permite maior controle sobre as subclasses da classe MovieClip, pois você
tem a opção de torná-las dinâmicas ou não:
class A extends MovieClip {} // A não é dinâmico
dynamic class B extends A {} // B é dinâmico
class C extends B {} // C é dinâmico
class D extends A {} // D não é dinâmico
dynamic class E extends MovieClip{} // E é dinâmico

Para obter informações sobre subclasses, consulte Capítulo 8, “Herança”, na página 319.

Sobre o uso de encapsulamento


Em um projeto orientado a objeto bem elaborado, os objetos são considerados como “caixas-
pretas” que contêm ou encapsulam funcionalidade. O programador deve ser capaz de interagir
com um objeto conhecendo somente suas propriedades, métodos e eventos (sua interface de
programação), sem conhecer os detalhes de sua implementação. Essa abordagem permite que
os programadores utilizem níveis mais elevados de abstração e fornece uma estrutura de
organização para a criação de sistemas complexos.
O encapsulamento é o motivo pelo qual o ActionScript 2.0 inclui, por exemplo, controle de
acesso a membros, de modo que os detalhes da implementação possam permanecer privados e
invisíveis para o código externo aos objetos. O código externo ao objeto é forçado a interagir
com a interface de programação do objeto em vez de com os detalhes da implementação. Essa
abordagem oferece algumas vantagens importantes; por exemplo, ela permite que o criador do
objeto altere a sua implementação sem a necessidade de alterar o código externo ao objeto,
desde que a interface de programação não seja alterada.
Um exemplo de encapsulamento no Flash seria definir todas as variáveis de membro e de
classe como privadas e forçar as pessoas que implementam suas classes a acessar essas variáveis
com os métodos getter e setter. Essa forma de encapsulamento garante que, se houver
necessidade de alterar a estrutura das variáveis no futuro, você precisará alterar somente o
comportamento das funções getter e setter, em vez de forçar todos os desenvolvedores a
alterarem o modo como acessam as variáveis da classe.

276 Classes
O código a seguir mostra como você poderia modificar a classe Person dos exemplos
anteriores, definir seus membros de instância como privados e definir métodos getter e setter
para esses membros:
class Person {
private var __userName:String;
private var __age:Number;
public function get userName():String {
return this.__userName;
}
public function set userName(value:String):Void {
this.__userName = value;
}
public function get age():Number {
return this.__age;
}
public function set age(value:Number):Void {
this.__age = value;
}
}

Sobre o uso da palavra-chave this em classes


Use a palavra-chave this como prefixo nas suas classes para métodos e variáveis membro.
Embora não seja necessária, a palavra-chave this permite identificar facilmente se uma
propriedade ou um método pertence a uma classe quando tem um prefixo; sem a palavra-
chave, não é possível saber se a propriedade ou o método pertence à superclasse.
Você também pode usar um prefixo de nome de classe para variáveis e métodos, mesmo
dentro de uma classe. Isso ajuda a qualificar as referências que você faz, tornando o código
legível. Dependendo do ambiente de codificação usado, a adição de prefixos também poderá
ativar referências de código.
N OT A

Não é necessário adicionar esses prefixos, e alguns desenvolvedores consideram isso


desnecessário. A Macromedia recomenda a adição da palavra-chave this como um
prefixo, pois ela pode melhorar a legibilidade e o ajuda a criar um código claro
fornecendo contexto para seus métodos e variáveis.

Sobre como trabalhar com classes personalizadas em um aplicativo 277


Exemplo: Criando classes personalizadas
Depois de explorar os conceitos básicos de arquivos de classes e os tipos de elementos que eles
contêm, é hora de aprender algumas diretrizes gerais para a criação desses arquivos. O
primeiro exemplo deste capítulo mostra como criar classes e empacotá-las. O segundo
exemplo mostra como usar os arquivos de classes com um arquivo FLA.
A T E NÇ ÃO

O código do ActionScript em arquivos externos é compilado em um arquivo SWF


quando você publica, exporta, testa ou depura um arquivo FLA. Portanto, se você fizer
qualquer alteração em um arquivo externo, será preciso salvá-lo e recompilar os
arquivos FLA que o utilizam.

Como vimos em “Criando arquivos de classes personalizados” na página 249, uma classe
consiste em duas partes principais: a declaração e o corpo. A declaração da classe consiste pelo
menos na instrução class, seguida do identificador do nome da classe e de chaves ({}). Tudo o
que estiver dentro das chaves é o corpo da classe, como mostra o seguinte exemplo:
class className {
// corpo da classe
}

Quando desejar, você pode definir classes somente em arquivos ActionScript externos. Por
exemplo, não é possível definir uma classe em um script de quadro no arquivo FLA. Portanto,
você criará um novo arquivo para este exemplo.
Na sua forma mais básica, uma classe declaration consiste na palavra-chave class, seguida
pelo nome da classe (Person, neste caso) e chaves ({}). Tudo entre as chaves chama-se corpo da
classe e é onde as propriedades e os métodos da classe são definidos.
No final deste exemplo, a organização básica de seus arquivos de classes será a seguinte:
■ Comentários de documentação
■ Declaração da classe
■ Função construtora
■ Corpo da classe
Você não cria subclasses neste capítulo. Para obter mais informações sobre herança e
subclasses, consulte o Capítulo 8, “Herança”, na página 319.
Este exemplo contém os seguintes tópicos:
■ “Sobre as diretrizes gerais para criação de classes” na página 279
■ “Criando e empacotando arquivos de classes” na página 281
■ “Criando a função construtora” na página 283
■ “Adicionando métodos e propriedades” na página 285

278 Classes
■ “Controlando o acesso de membros em classes” na página 288
■ “Documentando as classes” na página 290
Um arquivo de exemplo no disco rígido demonstra como criar um menu dinâmico com dados
XML e um arquivo de classe personalizado. O exemplo chama o construtor XmlMenu() do
ActionScript e passa dois parâmetros: o caminho para o arquivo de menu XML e uma
referência à timeline atual. O resto da funcionalidade reside em um arquivo de classe
personalizado, XmlMenu.as.
Você pode encontrar o arquivo de origem de exemplo, xmlmenu.fla, na pasta Samples
(Exemplos) no disco rígido.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\XML_Menu.
■ No Macintosh, navegue até Macintosh HD/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/XML_Menu.

Sobre as diretrizes gerais para criação de classes


Você deve usar as diretrizes a seguir ao criar arquivos de classes personalizados. Elas o ajudarão
a criar classes corretas e bem estruturadas. Você praticará essas diretrizes nos próximos
exemplos.
■ Em geral, coloque apenas uma declaração por linha e não coloque o mesmo tipo ou tipos
diferentes de declarações na mesma linha. Formate as declarações como no seguinte
exemplo:
private var SKU:Number; // número SKU do produto (identificação)
private var quantity:Number; // quantidade do produto

■ Inicialize as variáveis locais ao declará-las, a menos que o valor inicial seja determinado por
um cálculo. Para obter informações sobre a inicialização de variáveis, consulte
“Adicionando métodos e propriedades” na página 285.
■ Declare as variáveis antes de usá-las (incluindo repetições). Por exemplo, o código a seguir
predeclara a variável de iterador de repetição (i) antes de usá-la para a repetição for:
var my_array:Array = new Array("one", "two", "three");
var i:Number;
for (i = 0 ; i < my_array.length; i++) {
trace(i + " = " + my_array[i]);
}

■ Evite usar declarações locais que ocultem declarações de nível superior. Por exemplo, não
declare uma variável duas vezes, como mostra o seguinte exemplo:

Exemplo: Criando classes personalizadas 279


// código incorreto
var counter:Number = 0;
function myMethod() {
var counter:Number;
for (counter = 0; counter <= 4; counter++) {
// instruções;
}
}

Esse código declara a mesma variável dentro de um bloco interno.


■ Não atribua diversas variáveis a um único valor em uma instrução, pois isso dificulta a
leitura, como você pode observar nos seguintes exemplos de código ActionScript:
// formulário incorreto
xPos = yPos = 15;

ou
// formulário incorreto
class User {
private var m_username:String, m_password:String;
}

■ Só crie variáveis de instância públicas ou variáveis de membro ou de classe estáticas


públicas se houver um bom motivo para isso. Verifique se essas variáveis são
explicitamente públicas antes de criá-las dessa maneira.
■ Defina a maioria das variáveis de membro como privadas a menos que haja um bom
motivo para torná-las públicas. Do ponto de vista do design, é preferível tornar as variáveis
de membro privadas e permitir o acesso a essas variáveis somente por meio de um pequeno
grupo de funções getter e setter.

Sobre a atribuição de nomes a arquivos de classes


Os nomes de classes devem ser identificadores; ou seja, o primeiro caractere deve ser uma letra,
sublinhado (_) ou cifrão ($), e os caracteres subseqüentes devem ser uma letra, número,
sublinhado ou cifrão. Como prática recomendada, tente usar somente letras em nomes de
classes.
O nome da classe deve corresponder exatamente ao do arquivo ActionScript que o contém,
incluindo o uso de maiúsculas e minúsculas. No exemplo a seguir, se você criar uma classe
chamada Rock, o arquivo ActionScript que contém a definição da classe deverá se chamar
Rock.as:
// No arquivo Rock.as
class Rock {
// Corpo da classe Rock
}

280 Classes
Você irá nomear e criar uma definição de classe na seção a seguir. Consulte a seção “Criando e
empacotando arquivos de classes” na página 281 para criar, nomear e empacotar os arquivos
de classes. Para obter mais informações sobre nomeação de arquivos de classe, consulte
“Nomeando classes e objetos” na página 776.

Criando e empacotando arquivos de classes


Nesta seção, você irá criar, nomear e empacotar os arquivos de classe usados neste exemplo
(“Exemplo: Criando classes personalizadas” na página 278). As seções subseqüentes mostram
como criar arquivos de classes completos (embora simples). Para obter informações detalhadas
sobre pacotes, consulte “Sobre pacotes” na página 242, “Comparação de classes e pacotes”
na página 243 e “Trabalhando com pacotes” na página 244.
Ao criar um arquivo de classe, decida onde deseja armazená-lo. Nas etapas a seguir, você
salvará o arquivo de classe e o arquivo FLA de aplicativo que usa esse arquivo no mesmo
diretório para fins de simplicidade. Entretanto, se desejar verificar a sintaxe, também será
necessário informar ao Flash como ele poderá encontrar o arquivo. Normalmente, ao criar um
aplicativo, você adiciona ao caminho de classe do Flash o diretório onde deseja armazenar o
aplicativo e os arquivos de classes. Para obter informações sobre caminhos de classe, consulte
“Sobre a definição e a modificação do caminho de classe” na página 255.
Os arquivos de classes também são denominados arquivos do ActionScript (AS). Os arquivos
AS são criados com a ferramenta de criação do Flash ou com um editor externo. Vários
editores externos, como o Macromedia Dreamweaver e o Macromedia Flex Builder, podem
criar esses arquivos.
N OT A

O nome da classe (Person) deve corresponder exatamente ao nome do arquivo AS que


a contém (ClassA.as). Isso é muito importante; se esses dois nomes forem diferentes,
incluindo o uso de maiúsculas e minúsculas, a classe não será compilada.

Para criar um arquivo de classe e uma declaração de classe:


1. Selecione File (Arquivo) > New (Novo) Flash Document (Documento do Flash) para criar
um documento FLA e clique em OK.
2. Selecione File > Save as (Salvar como) e atribua o nome package_test.fla ao novo arquivo;
em seguida, salve o documento do Flash no diretório atual.
Você adicionará conteúdo a esse documento do Flash em uma etapa posterior.
3. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
4. Selecione File > Save As e crie um novo subdiretório chamado com e, em seguida, faça o
seguinte:

Exemplo: Criando classes personalizadas 281


a. No subdiretório com, crie um novo subdiretório chamado macromedia.
b. No subdiretório macromedia, crie um novo subdiretório chamado utils.
c. Salve o documento atual do ActionScript no diretório utils e atribua o nome ClassA.as
ao arquivo.
5. Digite o seguinte código na janela Script:
class com.macromedia.utils.ClassA {
}

O código anterior cria uma nova classe chamada ClassA no pacote com.macromedia.utils.
6. Salve o documento do ActionScript ClassA.as.
7. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
8. Selecione File > Save As, atribua o nome ClassB.as ao novo arquivo e salve-o no mesmo
diretório que o arquivo ClassA.as criado em uma etapa anterior.
9. Digite o seguinte código na janela Script:
class com.macromedia.utils.ClassB {
}

O código anterior cria uma nova classe chamada ClassB no pacote com.macromedia.utils.
10. Salve as alterações nos arquivos de classes ClassA.as e ClassB.as.
Os arquivos de classes usados em um arquivo FLA são importados para um arquivo SWF
quando compilados. O código criado em um arquivo de classe deve ter determinada
metodologia e organização, as quais são abordadas nas seções subseqüentes.
Se estiver criando várias classes personalizadas, use pacotes para organizar seus arquivos de
classes. Um pacote é um diretório que contém um ou mais arquivos de classes e reside em um
diretório de caminho de classe designado. Os nomes das classes devem ser totalmente
qualificados no arquivo em que forem declarados; ou seja, eles devem refletir o diretório
(pacote) em que estão armazenados. Para obter mais informações sobre caminhos de classes,
consulte “Sobre a definição e a modificação do caminho de classe” na página 255.
Por exemplo, uma classe chamada com.macromedia.docs.YourClass é armazenada no
diretório com/macromedia/docs. A declaração da classe no arquivo YourClass.as deve ser
semelhante à seguinte:
class com.macromedia.docs.YourClass {
// sua classe
}
N O TA

Você criará a declaração de classe que reflete o diretório de pacotes na seção a seguir,
“Exemplo: Criando classes personalizadas” na página 278.

282 Classes
Por essa razão, é recomendável planejar a sua estrutura de pacotes antes de começar a criar as
classes. De outra forma, se você decidir mover os arquivos das classes depois de criá-los, será
necessário modificar as instruções de declaração dessas classes para refletir sua nova
localização.

Para empacotar os arquivos de classes:


1. Escolha o nome de pacote que deseja usar.
Os nomes de pacotes devem ser intuitivos e facilmente identificáveis pelos
desenvolvedores. Lembre-se de que o nome do pacote também corresponde à estrutura de
diretório determinada. Por exemplo, todas as classes do pacote com.macromedia.utils
precisarão ser colocadas na pasta com/macromedia/utils de seu disco rígido.
2. Crie a estrutura de diretório necessária após escolher o nome do pacote.
Por exemplo, se tiver atribuído o nome com.macromedia.utils ao pacote, você precisará
criar a estrutura de diretório com/macromedia/utils e colocar suas classes na pasta utils.
3. Use o prefixo com.macromedia.utils para todas as classes criadas nesse pacote.
Por exemplo, se o nome da classe for ClassA, o nome completo da classe precisará ser
com.macromedia.utils.ClassA no arquivo de classe com/macromedia/utils/
ClassA.as.
4. Se a estrutura do pacote for alterada no futuro, lembre-se de modificar não só a estrutura
de diretório como também o nome do pacote em cada arquivo de classe; além disso, todas
as instruções de importação ou referências a uma classe desse pacote precisarão ser
modificadas.
Para continuar a criar os arquivos de classes, consulte “Criando a função construtora”
na página 283.

Criando a função construtora


Você já aprendeu a criar a declaração da classe em “Criando e empacotando arquivos de
classes” na página 281. Nesta parte do capítulo, você criará o que chamamos de função
construtora do arquivo de classe.
N O TA

Você aprenderá a criar comentários, instruções e declarações em seções posteriores.

Exemplo: Criando classes personalizadas 283


Construtores são funções usadas para inicializar (definir) as propriedades e os métodos de uma
classe. Por definição, construtores são funções em uma definição de classe que têm o mesmo
nome da classe. Por exemplo, o código a seguir define uma classe Person e implementa uma
função construtora. Na OOP, a função construtora inicializa cada nova instância de uma
classe.
Uma função construtora de classe é uma função especial chamada automaticamente quando
você cria uma instância de uma classe usando o operador new. A função construtora tem o
mesmo nome da classe que a contém. Por exemplo, a classe Person criada anteriormente
continha a seguinte função construtora:
// Função construtora da classe Person
public function Person (uname:String, age:Number) {
this.__name = uname;
this.__age = age;
}

Considere os seguintes pontos ao criar funções construtoras:


■ Se nenhuma função construtora for explicitamente declarada, ou seja, se você não criar
uma função cujo nome corresponda ao da classe, o compilador automaticamente criará
uma função construtora vazia.
■ Uma classe pode conter apenas uma função construtora; funções construtoras
sobrecarregadas não são permitidas no ActionScript 2.0.
■ Uma função construtora não deve ter nenhum tipo de retorno.
O termo construtor também é normalmente usado quando você cria (instancia) um objeto
com base em uma classe específica. As instruções a seguir são chamadas das funções
construtoras relativas à classe Array de nível superior e à classe Person personalizada:
var day_array:Array = new Array("Sun", "Mon", "Tue", "Wed", "Thu", "Fri",
"Sat");
var somePerson:Person = new Person("Tom", 30);

Em seguida, você adicionará uma função especial denominada função construtora.


NO T A

Este exercício faz parte do “Exemplo: Criando classes personalizadas” na página 278.
Se você não desejar avançar no exemplo, faça o download dos arquivos de classe em
www.helpexamples.com/flash/learnas/classes/.

Para adicionar funções construtoras aos arquivos de classes:


1. Abra o arquivo de classe ClassA.as na ferramenta de criação do Flash.
2. Modifique o arquivo de classe existente de acordo com o seguinte código (as alterações a
serem feitas estão em negrito):

284 Classes
class com.macromedia.utils.ClassA {
function ClassA() {
trace("ClassA constructor");
}
}

O código anterior define um método construtor para a classe ClassA. Esse construtor
envia uma seqüência de caracteres simples para o painel Output (Saída) que informa
quando uma nova instância da classe foi criada.
3. Abra o arquivo de classe ClassB.as na ferramenta de criação do Flash.
4. Modifique o arquivo de classe de acordo com o seguinte código (as alterações a serem feitas
estão em negrito):
class com.macromedia.utils.ClassB {
function ClassB() {
trace("ClassB constructor");
}
}

5. Salve os dois arquivos do ActionScript antes de continuar.


Para continuar a criar o arquivo de classe, consulte “Adicionando métodos e propriedades”
na página 285.

Adicionando métodos e propriedades


Para criar as propriedades das classes ClassA e ClassB, use a palavra-chave var para definir
variáveis.
N OT A

Os três exercícios a seguir fazem parte do “Exemplo: Criando classes personalizadas”


na página 278. Se você não desejar avançar no exemplo, faça o download dos arquivos
de classe em www.helpexamples.com/flash/learnas/classes/.

Para adicionar propriedades às classes ClassA e ClassB:


1. Abra ClassA.as e ClassB.as na ferramenta de criação do Flash.
2. Modifique o arquivo ActionScript ClassA.as de acordo com o seguinte código (as alterações
a serem feitas estão em negrito):
class com.macromedia.utils.ClassA {
static var _className:String;
function ClassA() {
trace("ClassA constructor");
}
}

O bloco de código anterior adiciona uma nova variável estática, _className, que contém
o nome da classe atual.

Exemplo: Criando classes personalizadas 285


3. Modifique a classe ClassB e adicione a variável estática para tornar essa classe semelhante
ao código anterior.
4. Salve os dois arquivos do ActionScript antes de continuar.
D IC A

Por convenção, as propriedades da classe são definidas na parte superior do corpo


da classe. A sua definição nesse local facilita a compreensão do código, mas não é
obrigatória.

A sintaxe pós-dois-pontos (por exemplo, var username:String e var age:Number) é usada


nas declarações de variáveis. Esse é um exemplo de atribuição estrita de tipos de dados.
Quando você atribui um tipo a uma variável usando o formato var
variableName:variableType, o compilador ActionScript verifica se os valores atribuídos a
essa variável correspondem ao tipo especificado. Se o tipo de dados correto não for usado no
arquivo FLA que importa essa classe, o compilador gerará um erro. Para obter mais
informações sobre como atribuir tipos de dados estritos, consulte “Sobre a atribuição de tipos
de dados e a atribuição estrita de tipos de dados” na página 85.
Os membros de uma classe consistem em propriedades (declarações de variáveis) e métodos
(definições de funções). Você deve declarar e definir todas as propriedades e métodos no corpo
da classe (entre as chaves [{}]); caso contrário, ocorrerá um erro durante a compilação. Para
obter informações sobre membros, consulte “Sobre propriedades (membros) e métodos
públicos, privados e estáticos” na página 262.

Para adicionar métodos às classes ClassA e ClassB:


1. Abra ClassA.as e ClassB.as na ferramenta de criação do Flash.
2. Modifique o arquivo de classe ClassA de acordo com o seguinte código (as alterações a
serem feitas estão em negrito):
class com.macromedia.utils.ClassA {
static var _className:String;

function ClassA() {
trace("ClassA constructor");
}
function doSomething():Void {
trace("ClassA - doSomething()");
}
}

O bloco de código em negrito cria um novo método na classe que envia uma seqüência de
caracteres para o painel Output (Saída).

286 Classes
3. Em ClassA.as, selecione Tools (Ferramentas) > Check Syntax (Verificar sintaxe) para
verificar a sintaxe do arquivo do ActionScript.
Se algum erro for informado no painel Output, compare o ActionScript do script com o
código completo criado na etapa anterior. Se não for possível corrigir os erros do código,
copie e cole o código completo na janela Script antes de continuar.
4. Verifique a sintaxe de ClassB.as da mesma maneira que foi feito para ClassA.as.
Se houver algum erro no painel Output, copie e cole o código completo na janela Script
antes de continuar:
class com.macromedia.utils.ClassB {
static var _className:String;

function ClassB() {
trace("ClassB constructor");
}
function doSomething():Void {
trace("ClassB - doSomething()");
}
}

5. Salve os dois arquivos do ActionScript antes de continuar.


Você pode inicializar as propriedades inline, ou seja, quando as declara, com os valores padrão,
como mostra o seguinte exemplo:
class Person {
var age:Number = 50;
var username:String = "John Doe";
}

Quando você inicializa as propriedades inline, a expressão à direita de uma atribuição deve ser
uma constante de tempo de compilação. Ou seja, a expressão não pode se referir a algo
definido durante a execução. As constantes de tempo de compilação incluem literais de
seqüência de caracteres, números, valores booleanos, null e undefined, bem como funções
construtoras para as seguintes classes de nível superior: Array, Boolean, Number, Object e
String.

Para inicializar propriedades inline:


1. Abra ClassA.as e ClassB.as na ferramenta de criação do Flash.
2. Modifique o arquivo de classe ClassA de acordo com o seguinte ActionScript (as alterações
a serem feitas estão em negrito):
class com.macromedia.utils.ClassA {
static var _className:String = "ClassA";

function ClassA() {
trace("ClassA constructor");

Exemplo: Criando classes personalizadas 287


}
function doSomething():Void {
trace("ClassA - doSomething()");
}
}

A única diferença entre o arquivo de classe existente e o bloco de código anterior é que
agora há um valor definido para a variável estática _className, “ClassA”.
3. Modifique o arquivo de classe ClassB e adicione a propriedade inline, alterando o valor para
“ClassB”.
4. Salve os dois arquivos do ActionScript antes de continuar.
Essa regra aplica-se apenas a variáveis de instância (variáveis que são copiadas em cada
instância de uma classe), e não a variáveis de classe (variáveis que pertencem à classe).
N OT A

Quando você inicializa arrays inline, apenas um array é criado para todas as instâncias
da classe.

Para continuar a criar o arquivo de classe, consulte “Controlando o acesso de membros em


classes” na página 288.

Controlando o acesso de membros em classes


O padrão é que qualquer propriedade ou método de uma classe possa ser acessado por
qualquer outra classe: todos os membros de uma classe são públicos por padrão. Entretanto,
em alguns casos, talvez você queira proteger os dados ou os métodos de uma classe do acesso
de outras classes. Você precisará tornar esses membros privados (disponíveis apenas para a
classe que os declara ou os define).
Especifique membros públicos ou privados usando o atributo de membro public ou private.
Por exemplo, o código a seguir declara uma variável privada (uma propriedade) e um método
privado (uma função). A classe a seguir (LoginClass) define uma propriedade privada
chamada userName e um método privado chamado getUserName().
class LoginClass {
private var userName:String;
private function getUserName():String {
return this.userName;
}
// Construtor:
public function LoginClass(user:String) {
this.userName = user;
}
}

288 Classes
Os membros privados (propriedades e métodos) são acessíveis apenas para a classe que define
esses membros e para as subclasses dessa classe original. As instâncias da classe original, ou as
instâncias das subclasses dessa classe, não podem acessar as propriedades e os métodos
declarados de forma privada; ou seja, os membros privados só podem ser acessados nas
definições da classe, e não no nível da instância. No exemplo a seguir, você alterará o acesso a
membros em seus arquivos de classes.
NO TA

Este exercício faz parte do “Exemplo: Criando classes personalizadas” na página 278.
Se você não desejar avançar no exemplo, faça o download dos arquivos de classe em
www.helpexamples.com/flash/learnas/classes/.

Para controlar o acesso a membros:


1. Abra ClassA.as e ClassB.as na ferramenta de criação do Flash.
2. Modifique o arquivo ActionScript ClassA.as para que o conteúdo esteja de acordo com o
seguinte ActionScript (as alterações a serem feitas estão em negrito):
class com.macromedia.utils.ClassA {
private static var _className:String = "ClassA";

public function ClassA() {


trace("ClassA constructor");
}
public function doSomething():Void {
trace("ClassA - doSomething()");
}
}

O código anterior define os dois métodos (o construtor de ClassA e o método


doSomething()) como públicos; isso significa que eles podem ser acessados por scripts
externos. A variável estática _className é definida como privada e, portanto, só pode ser
acessada a partir da classe, e não por scripts externos.
3. Modifique o arquivo ClassB.as do ActionScript e adicione o acesso aos mesmos métodos e
propriedades que os da classe ClassA.
4. Salve os dois arquivos do ActionScript antes de continuar.
Uma instância de classe ClassA ou ClassB não pode acessar membros privados. Por exemplo, o
código a seguir, adicionado ao Frame 1 (Quadro 1) da Timeline (Linha de tempo) em um
arquivo FLA, resultará em um erro do compilador indicando que o método é privado e não
pode ser acessado:
import com.macromedia.utils.ClassA;
var a:ClassA = new ClassA();
trace(a._className); // Erro. O membro é privado e não pode ser acessado.

Exemplo: Criando classes personalizadas 289


O controle de acesso a membros é um recurso somente de tempo de compilação; durante a
execução, o Flash Player não distingue entre membros privados e públicos.
Para continuar a criar o arquivo de classe, consulte “Documentando as classes” na página 290.

Documentando as classes
O uso de comentários em suas classes e interfaces é importante ao documentá-las para outros
usuários. Por exemplo, talvez você deseje distribuir seus arquivos de classes na comunidade
Flash ou esteja trabalhando com uma equipe de designers ou desenvolvedores que usarão esses
arquivos em seu trabalho ou como parte de um projeto do qual você participe. A
documentação ajuda outros usuários a compreender a finalidade e as origens da classe.
Há dois tipos de comentários em uma classe ou arquivo de interface típico: comentários de
documentação e comentários de implementação. Use comentários de documentação para
descrever as especificações do código, mas não a implementação. Use comentários de
implementação para fazer comentários sobre o código ou sobre a implementação de seções
específicas do código. Os dois tipos de comentários usam delimitadores ligeiramente
diferentes. Os comentários de documentação são delimitados por /** e */, e os de
implementação são delimitados por /* e */.
N OT A

Os comentários da documentação não são uma construção de linguagem no


ActionScript 2.0. No entanto, eles são uma maneira comum de estruturar comentários
em um arquivo de classe que você pode usar nos arquivos AS.

Use os comentários de documentação para descrever interfaces, classes, métodos e constuções.


Inclua um comentário de documentação para cada classe, interface ou membro e coloque-o
diretamente antes da declaração.
Se precisar documentar mais informações que não caibam nos comentários de documentação,
use comentários de implementação (no formato de bloco ou de uma única linha, conforme
descrito em “Sobre comentários” na página 139). Quando adicionados, os comentários de
implementação devem vir logo após a declaração.
N OT A

Não inclua comentários que não estejam diretamente relacionados à classe que está
sendo lida. Por exemplo, não inclua comentários que descrevam o pacote
correspondente.
N O TA

Este exercício faz parte do “Exemplo: Criando classes personalizadas” na página 278.
Se você não desejar avançar no exemplo, faça o download dos arquivos de classe em
www.helpexamples.com/flash/learnas/classes/.

Para documentar os arquivos de classes:


1. Abra ClassA.as e ClassB.as na ferramenta de criação do Flash.

290 Classes
2. Modifique o arquivo de classe ClassA e adicione o novo código ao início do arquivo (as
alterações a serem feitas estão em negrito):
/**
ClassA class
version 1.1
6/21/2005
copyright Macromedia, Inc.
*/
class com.macromedia.utils.ClassA {
private static var _className:String = "ClassA";

public function ClassA() {


trace("ClassA constructor");
}
public function doSomething():Void {
trace("ClassA - doSomething()");
}
}

O código acima adicionou um comentário ao início do arquivo de classe. É sempre


recomendável adicionar comentários aos arquivos do ActionScript e do Flash para que
você possa incluir informações úteis, como autor da classe, data da última modificação,
informações de copyright ou possíveis problemas/erros existentes no arquivo.
3. Adicione um comentário semelhante ao início do arquivo ClassB.as do ActionScript,
alterando o nome da classe e outras informações aplicáveis.
4. Salve os dois arquivos do ActionScript antes de continuar.
Você também pode adicionar comentários em bloco, de uma linha ou finais ao código da
classe. Para obter informações sobre a criação de comentários úteis no código, consulte
“Criando comentários adequados” na página 780. Para obter informações gerais sobre
comentários, consulte “Comentários de linha única” na página 140, “Comentários de várias
linhas” na página 140 e “Comentários finais” na página 142.
Para aprender a usar esses arquivos de classes personalizados em um arquivo SWF, consulte
“Exemplo: Usando arquivos de classes personalizados no Flash” na página 291.

Exemplo: Usando arquivos de classes


personalizados no Flash
Esse exemplo usa arquivos de classe criados no exemplo chamado “Exemplo: Criando classes
personalizadas” na página 278, ou você pode fazer download deles em
www.helpexamples.com/flash/learnas/classes/. Se você concluiu “Exemplo: Criando classes
personalizadas” na página 278, localize os arquivos ClassA.as e ClassB.as no disco rígido.

Exemplo: Usando arquivos de classes personalizados no Flash 291


Como o nome do pacote do arquivo de classe ClassA é com.macromedia.utils.ClassA,
você precisará salvar os arquivos de classes na estrutura de diretório adequada. Crie uma
subpasta chamada com no diretório atual. Na pasta com, adicione uma nova pasta chamada
macromedia. Nessa pasta, adicione um terceiro e último subdiretório chamado utils. Salve os
arquivos de classes ClassA.as e ClassB.as na pasta utils. Agora você está pronto para continuar
com o exemplo.
Você poderá usar as classes personalizadas criadas no “Exemplo: Criando classes
personalizadas” na página 278 com um arquivo FLA. Neste exemplo, você usará as classes
personalizadas para criar um pequeno aplicativo no Flash. Suas classes serão compiladas no
arquivo SWF quando você publicar o documento e, depois, tudo funcionará de forma
integrada. Nos exercícios a seguir, você aprenderá o funcionamento dos caminhos de classe,
aprenderá a usar os arquivos de classe no aplicativo, e a importar classes e pacotes.
Para continuar esse exemplo, vá para “Importando classes e pacotes” na página 292.

Importando classes e pacotes


Para fazer referência a uma classe em outro script, você deve incluir o nome do pacote da classe
antes do nome da classe. A combinação do nome da classe e do caminho do pacote
correspondente é o nome da classe totalmente qualificado. Se uma classe estiver em um
diretório do caminho de classe de nível superior, e não em um subdiretório do diretório do
caminho de classe, seu nome de classe totalmente qualificado será o nome da classe.
Para especificar caminhos de pacote, use a notação de ponto (.) para separar os nomes de
diretórios de pacote. Os caminhos de pacote são hierárquicos; ou seja, cada ponto representa
um diretório aninhado. Por exemplo, suponha que você tenha criado uma classe chamada
ClassName que resida no pacote com/macromedia/docs/learnAs2 no caminho de classe.
Para criar uma instância dessa classe, você pode especificar o seu nome totalmente qualificado.
Também é possível usar o nome totalmente qualificado da classe para atribuir um tipo às
variáveis, como mostra o seguinte exemplo:
var myInstance:com.macromedia.docs.learnAs2.ClassName = new
com.macromedia.docs.learnAs2.ClassName();

Você pode usar a instrução import para importar pacotes para um script, o que permite usar o
nome abreviado de uma classe em vez de seu nome de classe totalmente qualificado. Também
pode usar o caractere curinga (*) para importar todas as classes de um pacote. Se usar o
caractere curinga, você não precisará usar o nome totalmente qualificado da classe toda vez
que usar a classe.

292 Classes
Por exemplo, suponha que você tenha importado a classe acima para um script usando a
instrução import, como mostra o seguinte exemplo:
import com.macromedia.docs.learnAs2.util.UserClass;

Posteriormente, no mesmo script, você poderia fazer referência a essa classe por seu nome
abreviado, como neste exemplo:
var myUser:UserClass = new UserClass();

Você pode usar o caractere curinga (*) para importar todas as classes de determinado pacote.
Suponha que você tenha um pacote chamado com.macromedia.utils com dois arquivos de
classes do ActionScript, ClassA.as e ClassB.as. Em outro script, você poderia importar as duas
classes desse pacote usando o caractere curinga, como no seguinte código:
import com.macromedia.utils.*;

O exemplo a seguir mostra que é possível fazer referência às duas classes diretamente no
mesmo script:
var myA:ClassA = new ClassA();
var myB:ClassB = new ClassB();

A instrução import aplica-se apenas ao script atual (quadro ou objeto) no qual ela é chamada.
Se uma classe importada não for utilizada em um script, ela não será incluída no bytecode do
arquivo SWF resultante e não estará disponível para os arquivos SWF que poderão ser
carregados pelo arquivo FLA que contém a instrução import.
NO T A

O exercício a seguir faz parte do “Exemplo: Usando arquivos de classes personalizados


no Flash” na página 291 que continua os exemplos de “Exemplo: Criando classes
personalizadas”. Se você precisar das classes ClassA e ClassB, faça o download dos
arquivos de classe em www.helpexamples.com/flash/learnas/classes/.

Para importar uma classe ou um pacote:


1. Abra o arquivo chamado package_test.fla.
2. Digite o seguinte código na janela Script:
import com.macromedia.utils.*;
var a = new ClassA(); // Construtor ClassA
var b = new ClassB(); // Construtor ClassB

O bloco de código anterior importa primeiro cada uma das classes do pacote
com.macromedia.utils usando o caractere curinga (*). Em seguida, você cria uma nova
instância da classe ClassA, que faz com que o método construtor envie uma mensagem
para o painel Output (Saída). Uma instância da classe ClassB também é criada e envia
mensagens de depuração para o painel Output.
3. Salve as alterações no documento do Flash antes de continuar.

Exemplo: Usando arquivos de classes personalizados no Flash 293


Para continuar usando esses arquivos de classes em um arquivo do Flash, consulte “Criando
instâncias de classes em um exemplo” na página 294.

Criando instâncias de classes em um exemplo


As instâncias são objetos que contêm todas as propriedades e métodos de determinada classe.
Por exemplo, arrays são instâncias da classe Array; portanto, você pode usar quaisquer
métodos ou propriedades dessa classe com qualquer instância de um array. Você também
poderia criar sua própria classe, como UserSettings, e, depois, criar uma instância dessa classe.
No exemplo iniciado em “Exemplo: Usando arquivos de classes personalizados no Flash”
na página 291, você modificou um arquivo FLA para importar as classes de modo que não
precisasse fazer sempre referência a elas por seus nomes totalmente qualificados.
A próxima etapa deste exemplo (“Exemplo: Usando arquivos de classes personalizados no
Flash” na página 291) será criar uma instância das classes ClassA e ClassB em um script, como
um script de quadro no documento do Flash package_test.fla, e atribuir uma variável a ela.
Para criar uma instância de uma classe personalizada, use o operador new, como faria ao criar
uma instância de uma classe de nível superior do ActionScript (como a classe Date ou Array).
Faça referência à classe usando o seu nome totalmente qualificado ou importe-a (como
demonstrado em “Importando classes e pacotes” na página 292.)
NO TA

O exercício a seguir faz parte do “Exemplo: Usando arquivos de classes personalizados


no Flash” na página 291 que continua os exemplos de “Exemplo: Criando classes
personalizadas”.

Para criar uma nova instância das classes ClassA e ClassB:


1. Abra o arquivo chamado package_test.fla.
2. Digite o seguinte código em negrito na janela Script:
import com.macromedia.utils.*;
var a:ClassA = new ClassA(); // Construtor ClassA
a.doSomething(); // chama o método doSomething() do ClassA
var b:ClassB = new ClassB(); // Construtor ClassB
b.doSomething(); // chama o método doSomething() do ClassB

A atribuição de um tipo de dados aos objetos nesse exemplo de código permite ao


compilador garantir que você não tentará acessar as propriedades ou os métodos que não
estão definidos em sua classe personalizada. Para obter mais informações sobre como
atribuir tipos de dados estritos, consulte “Sobre a atribuição de tipos de dados e a
atribuição estrita de tipos de dados” na página 85. A exceção é se você declarar a classe
como dinâmica usando a palavra-chave dynamic. Consulte “Criando classes dinâmicas”
na página 274.

294 Classes
3. Salve as alterações no arquivo FLA antes de continuar.
Agora você já deve saber como criar e usar classes em documentos do Flash. Lembre-se de que
também é possível criar instâncias de classes internas ou de nível superior do ActionScript
(consulte “Sobre como trabalhar com classes internas” na página 312.).
Para continuar usando esses arquivos de classes em um arquivo do Flash, consulte “Atribuindo
uma classe a símbolos no Flash” na página 295.

Atribuindo uma classe a símbolos no


Flash
Você também pode atribuir uma classe aos símbolos usados em um arquivo do Flash, como
um objeto de clipe de filme no Stage (Palco).

Para atribuir uma classe a um símbolo de clipe de filme:


1. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
2. Selecione File > Save As (Salvar como), atribua o nome Animal.as e salve o arquivo no disco
rígido.
3. Digite o seguinte código na janela Script:
class Animal {
public function Animal() {
trace("Animal::constructor");
}
}

Esse ActionScript cria uma nova classe chamada Animal que possui um método
construtor que envia uma seqüência de caracteres para o painel Output (Saída).
4. Salve as alterações no arquivo do ActionScript.
5. Selecione File > New Flash Document (Documento do Flash) para criar um arquivo FLA
e clique em OK.
6. Selecione File > Save As, atribua o nome animal_test.fla ao arquivo e salve o arquivo na
mesma pasta que o arquivo Animal.as criado na etapa 2.
7. Selecione Insert (Inserir) > New Symbol (Novo símbolo) para iniciar a caixa de diálogo
Create New Symbol (Criar novo símbolo).
8. Insira o nome do símbolo de animal e selecione a opção Movie Clip (Clipe de filme).
9. Clique no botão Advanced (Avançado) no canto inferior direito da caixa de diálogo Create
New Symbol (Criar novo símbolo) para ativar mais opções.

Atribuindo uma classe a símbolos no Flash 295


O botão Advanced está disponível quando se está no modo básico da caixa de diálogo
Create New Symbol.
10. Clique na caixa de seleção Export for ActionScript (Exportar para ActionScript) na seção
Linkage (Vinculação).
A ativação dessa opção permite anexar instâncias desse símbolo dinamicamente aos
documentos do Flash durante a execução.
11. Insira o valor de identificador animal_id e defina a classe ActionScript 2.0 como Animal
(para que corresponda ao nome de classe especificado na etapa 3).
12. Selecionea caixa de seleção Export in First Frame (Exportar no primeiro quadro) e clique
em OK para aplicar as alterações e fechar a caixa de diálogo.
13. Salve o documento do Flash e selecione Control (Controlar) > Test Movie (Testar filme).
O painel Output exibe o texto da função construtora da classe Animal.
NO TA

Se precisar modificar as propriedades de vinculação de Movie Clip, clique com o


botão direito do mouse no símbolo na biblioteca do documento e selecione
Properties (Propriedades) ou Linkage no menu de contexto.

Compilando e exportando classes


Por padrão, as classes usadas por um arquivo SWF são empacotadas e exportadas no primeiro
quadro desse arquivo. Também é possível especificar um quadro diferente onde as classes serão
empacotadas e exportadas. Esse recurso é útil, por exemplo, quando um arquivo SWF usa
muitas classes que exigem um longo tempo de download (como componentes). Se as classes
forem exportadas no primeiro quadro, o usuário deverá aguardar o download de todo o
código das classes até o quadro aparecer. Especificando um quadro posterior na Timeline, você
pode exibir uma curta animação do carregamento nos primeiros quadros da Timeline durante
o download do código das classes do quadro posterior.

Para especificar o quadro de exportação das classes de um documento Flash:


1. Selecione File > New e, em seguida, selecione Flash Document (Documento Flash). Salve
o novo documento como exportClasses.fla.
2. Renomeie a camada padrão como content, arraste um componente ProgressBar do painel
Components (Components) até o Stage e atribua o nome de instância my_pb.
3. Crie uma nova camada, arraste-a por cima da camada de conteúdo e renomeia-a como
actions.

296 Classes
4. Adicione o seguinte código ActionScript ao Frame 1 (Quadro 1) da camada actions na
Timeline principal:
my_pb.indeterminate = true;

5. Crie um novo quadro-chave no Frame 2 (Quadro 2) da camada actions e adicione o


seguinte código ActionScript:
var classesFrame:Number = 10;
if (_framesloaded < classesFrame) {
trace(this.getBytesLoaded() + " of " + this.getBytesTotal() + " bytes
loaded");
gotoAndPlay(1);
} else {
gotoAndStop(classesFrame);
}

6. Crie um novo quadro-chave no Frame 10 da camada actions e adicione o seguinte


ActionScript:
stop();

7. Crie um novo quadro-chave no Frame 10 da camada de conteúdo e arraste diversos


componentes para o Stage.
8. Clique com o botão direito do mouse em cada componente (exceto ProgressBar) no painel
Library (Biblioteca) e selecione Linkage (Vinculação) em um menu de contexto para iniciar
a caixa de diálogo Linkage Properties (Propriedades de vinculação).
9. Na caixa de diálogo Linkage Properties, verifique se Export for ActionScript (Exportar para
ActionScript) está selecionada, desmarque a seleção da caixa Export in First Frame
(Exportar no primeiro quadro) e clique em OK.
10. Selecione File > Publish Settings (Configurações de publicação).
11. Na caixa de diálogo Publish Settings, selecione a guia Flash.
12. Clique no botão Settings perto do menu pop-up da versão do ActionScript para abrir a
caixa de diálogo ActionScript Settings (Configurações do ActionScript).
13. Na caixa de texto Export Frame for Classes (Exportar quadro para classes), digite o número
do quadro para o qual deseja exportar o código das classes (Frame 10).
Se o quadro especificado não existir na Timeline, você receberá uma mensagem de erro ao
publicar o arquivo SWF.
14. Clique em OK para fechar a caixa de diálogo ActionScript Settings e, em seguida, clique
em OK para fechar a caixa de diálogo Publish Settings.

Compilando e exportando classes 297


15. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash. Se o painel Components for carregado rápido demais, selecione View (Exibir) >
Simulate Download (Simular download) no arquivo SWF. O Flash simula o download do
documento Flash em uma velocidade menor, o que permite que você veja a animação do
componente de barra de progresso enquanto ocorre o download dos arquivos de classe.
Para obter mais informações sobre arquivos ASO, consulte “Usando arquivos ASO”
na página 298.

Usando arquivos ASO


Durante a compilação, o Flash cria, às vezes, arquivos com extensões .aso no subdiretório /aso
do diretório de caminho de classe global padrão (consulte “Sobre a definição e a modificação
do caminho de classe” na página 255). A extensão .aso significa ActionScript object(ASO,
objeto do ActionScript). Para cada arquivo do ActionScript 2.0 importado implícita ou
explicitamente e compilado com êxito, o Flash gera um arquivo ASO. O arquivo contém o
bytecode produzido a partir do arquivo ActionScript (AS) associado. Portanto, esses arquivos
contêm a forma compilada (o bytecode) de um arquivo de classe.
O Flash só precisará gerar novamente um arquivo ASO quando ocorrerem os seguintes
cenários:
■ O arquivo AS correspondente tiver sido modificado.
■ Os arquivos do ActionScript que contêm as definições importadas ou usadas pelo arquivo
correspondente do ActionScript tiverem sido modificados.
■ Os arquivos do ActionScript incluídos pelo arquivo correspondente do ActionScript
tiverem sido modificados.
O compilador cria arquivos ASO para fins de armazenamento em cache. Observe que a sua
primeira compilação é mais lenta do que as compilações subseqüentes. Isso ocorre porque
somente os arquivos AS que foram alterados são compilados em arquivos ASO. No caso dos
arquivos AS não alterados, o compilador lê o bytecode já compilado diretamente do arquivo
ASO, em vez de recompilar o arquivo AS.
O formato de arquivo ASO é um formato intermediário desenvolvido apenas para uso
interno. Ele não é um formato documentado e não deve ser redistribuído.
Se perceber que o Flash está compilando versões mais antigas de um arquivo que você editou,
exclua os arquivos ASO e recompile-os. Se planejar excluir os arquivos ASO, exclua-os quando
o Flash não estiver executando outras operações, como verificação de sintaxe ou exportação de
SWFs.

298 Classes
Para excluir arquivos ASO:
Se você estiver editando um arquivo FLA e desejar excluir um arquivo ASO, selecione uma
das opções a seguir no ambiente de criação:
■ Selecione Control (Controle) > Delete ASO Files (Excluir arquivos ASO) para excluir os
arquivos ASO e continue editando.
■ Selecione Control > Delete ASO Files e Test Movie (Testar filme) para excluir os arquivos
ASO e testar o aplicativo.
Se você estiver editando um documento ActionScript na janela Script:
■ Selecione Control > Delete ASO Files para excluir os arquivos ASO e continue editando.
■ Selecione Control > Delete ASO Files e Test Project (Testar projeto) para excluir os
arquivos ASO e testar o aplicativo.
Há um limite para a quantidade de código que pode ser colocada em uma única classe: o
bytecode de uma definição de classe em um arquivo SWF exportado não poderá ser superior a
32.767 bytes. Se o bytecode exceder esse limite, será exibida uma mensagem de aviso.
Não é possível prever o tamanho da representação de bytecode de determinada classe, mas
classes com até 1.500 linhas geralmente não ultrapassam o limite.
Caso a classe ultrapasse o limite, mova parte do código para outra classe. Em geral, uma
prática recomendada de OOP é manter as classes relativamente curtas.

Noções básicas sobre classes e escopo


Ao mover o código ActionScript para classes, talvez você precise alterar o modo como a
palavra-chave this é usada. Por exemplo, se um método de determinada classe usar uma
função de retorno de chamada (como o método onLoad() da classe LoadVars), poderá ser
difícil saber se a palavra-chave this se refere à classe ou ao objeto LoadVars. Nessa situação,
talvez seja necessário criar um ponteiro para a classe atual, como mostra o exemplo a seguir.

Para compreender o escopo e os arquivos de classes externos:


1. Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
2. Digite ou cole o seguinte código na janela Script:
/**
Classe do produto
Product.as
*/
class Product {
private var productsXml:XML;
// construtor

Noções básicas sobre classes e escopo 299


// targetXmlStr - seqüência de caracteres, contém o caminho para um
arquivo XML
function Product(targetXmlStr:String) {
/* Cria uma referência local à classe atual.
Mesmo que esteja dentro do manipulador de eventos onLoad do XML,
você
pode fazer referência à classe atual, em vez de somente ao pacote
XML.
*/
var thisObj:Product = this;
// Cria uma variável local, usada para carregar o arquivo XML.
var prodXml:XML = new XML();
prodXml.ignoreWhite = true;
prodXml.onLoad = function(success:Boolean) {
if (sucesso) {
/* Se o XML for carregado e analisado com sucesso,
defina a variável productsXml da classe para o documento XML
analisado e chame a função init.
*/
thisObj.productsXml = this;
thisObj.init();
} else {
/* Houve erro ao carregar o arquivo XML. */
trace("error loading XML");
}
};
// Comece a carregar o documento XML.
prodXml.load(targetXmlStr);
}
public function init():Void {
// Exiba o pacote XML.
trace(this.productsXml);
}
}

Como você está tentando fazer referência à variável de membro privada em um


manipulador onLoad, a palavra-chave this se refere à instância prodXml, e não à classe
Product, como era de se esperar. Por isso, você deve criar um ponteiro para o arquivo de
classes local para que possa fazer referência direta à classe do manipulador onLoad. Agora
você poderá usar essa classe com um documento do Flash.
3. Salve o código anterior do ActionScript como Product.as.
4. Crie um novo documento do Flash chamado testProduct.fla no mesmo diretório.
5. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) principal.
6. Digite o seguinte ActionScript no painel Actions (Ações):
var myProduct:Product = new Product("http://www.helpexamples.com/
crossdomain.xml");

300 Classes
7. Selecione Control (Controlar) > Test Movie (Testar filme) para testar esse código no
ambiente de teste.
O conteúdo do documento XML especificado é exibido no painel Output (Saída).
Outro tipo de escopo que você encontrará ao trabalhar com essas classes são as variáveis e as
funções estáticas. A palavra-chave static determina que uma variável ou função seja criada
somente uma vez por classe, em vez de ser criada em todas as instâncias dessa classe. Você pode
acessar um membro estático da classe sem criar uma instância da classe usando a sintaxe
someClassName.username. Para obter mais informações sobre variáveis e funções estáticas,
consulte “Sobre propriedades (membros) e métodos públicos, privados e estáticos”
na página 262 e “Usando membros de classe” na página 269.
Outra vantagem das variáveis estáticas é que elas não perdem seus valores quando o seu escopo
é encerrado. O exemplo a seguir demonstra como usar a palavra-chave static para criar um
contador que controla quantas instâncias da classe o Flash criou. Como a variável
numInstances é estática, ela é criada apenas uma vez para a classe inteira, e não para cada
instância.

Para usar a palavra-chave static:


1. Selecione File > New, selecione ActionScript File e, em seguida, clique em OK.
2. Digite o seguinte código na janela Script:
class User {
private static var numInstances:Number = 0;
public function User() {
User.numInstances++;
}
public static function get instances():Number {
return User.numInstances;
}
}

O código anterior define uma classe User que controla o número de vezes que o construtor
foi chamado. Uma variável estática privada (User.numInstances) é incrementada no
método construtor.
3. Salve o documento como User.as.
4. Selecione File > New, selecione Flash Document (Documento do Flash) para criar um
novo arquivo FLA e salve-o no mesmo diretório que o arquivo User.as.
5. Digite o seguinte código ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de
tempo):
trace(User.instances); // 0
var user1:User = new User();
trace(User.instances); // 1

Noções básicas sobre classes e escopo 301


var user2:User = new User();
trace(User.instances); // 2

A primeira linha de código chama o método getter instances() estático, que retorna o
valor da variável numInstances estática privada. O restante do código cria novas
instâncias da classe User e exibe o valor atual retornado pelo método getter instances().
6. Selecione Control (Controlar) > Test Movie (Testar filme) para testar os documentos.
Para obter informações sobre o uso da palavra-chave this em classes, consulte “Sobre o uso da
palavra-chave this em classes” na página 277.

Sobre classes de nível superior e internas


Além das construções e dos elementos de linguagem básicos do ActionScript (as repetições
for e while loops, por exemplo) e dos tipos de dados primitivos (números, seqüências de
carateres e booleanos) descritos anteriormente nesse manual (consulte o Capítulo 4, “Dados e
tipos de dados”, na página 75 e o Capítulo 5, “Fundamentos da sintaxe e da linguagem”, na
página 119), o ActionScript também fornece várias classes internas (tipos de dados complexos).
Essas classes oferecem vários recursos e funcionalidades de script. Nos capítulos anteriores,
você usou classes de nível superior e outras classes internas que fazem parte da linguagem
ActionScript e continuará a usá-las nos capítulos restantes. Várias classes fornecidas com o
Flash são usadas para criar interatividade e funcionalidade nos arquivos SWF e também
podem ser usadas para criar aplicativos complexos. Por exemplo, você pode usar a classe Math
para executar equações em seus aplicativos ou a classe BitmapData para criar pixels e
animações com script.
As classes de nível superior, listadas em “Classes de nível superior” na página 304, são criadas
no Flash Player. Na caixa de ferramentas Actions (Ações), essas classes estão localizadas no
diretório Classes do ActionScript 2.0. Algumas dessas classes se baseiam na especificação de
linguagem ECMAScript (ECMA-262) edição 3 e são chamadas classes básicas do ActionScript.
Array, Boolean, Date e Math são exemplos de classes básicas. Para obter mais informações
sobre pacotes, consulte “Trabalhando com pacotes” na página 244.
Você pode encontrar as classes ActionScript instaladas no disco rígido. Você pode encontrar as
pastas de classes aqui:
■ Windows: Hard Disk\Documents and Settings\user\Local Settings\Application
Data\Macromedia\Flash 8\idioma\Configuration\Classes.
■ Macintosh: Hard Disk/Users/usuário/Library/Application Support/Macromedia/Flash 8/
idioma/Configuration/Classes.
Leia o documento Read Me localizado nesse diretório para obter mais informações sobre a
estrutura.

302 Classes
Para entender a diferença entre as classes básicas do ActionScript e as classes específicas do
Flash, considere a distinção entre JavaScript básico e cliente. As classes JavaScript do cliente
permitem controlar o ambiente do cliente (o conteúdo do navegador e da página da Web), e
as classes específicas do Flash permitem controlar, durante a execução, a aparência e o
comportamento de um aplicativo Flash.
As demais classes internas do ActionScript são específicas do modelo de objeto do
Macromedia Flash e do Flash Player. Camera, MovieClip e LoadVars são exemplos dessas
classes. Outras classes são organizadas em pacotes, como flash.display. Todas essas classes são
às vezes chamadas classes internas (classes predefinidas que podem ser usadas para adicionar
funcionalidade aos aplicativos).
As seções a seguir apresentam classes internas do ActionScript e descrevem as tarefas básicas
que podem ser realizadas com essas classes. Para obter uma visão geral sobre o trabalho com
classes e objetos na programação orientada a objeto, consulte “Sobre como trabalhar com
classes internas” na página 312. Exemplos de código usando essas classes estão incluídos em
todo o manual Learning ActionScript 2.0 in Flash.
Para obter informações sobre elementos de linguagem (como constantes, operadores e
diretivas), consulte o Capítulo 5, “Fundamentos da sintaxe e da linguagem”, na página 119.
Para obter mais informações sobre classes internas e de nível superior, consulte os seguintes
tópicos:
■ “Classes de nível superior” na página 304
■ “Pacote flash.display” na página 308
■ “Pacote flash.external” na página 309
■ “Pacote flash.filters” na página 309
■ “Pacote flash.geom” na página 310
■ “Pacote flash.net” na página 311
■ “Pacote flash.text” na página 311
■ “Pacote mx.lang” na página 311
■ “Pacotes System e TextField” na página 312

Sobre classes de nível superior e internas 303


Outros elementos de linguagem
Há outros elementos de linguagem que compõem o ActionScript, fora das classes. São eles:
diretivas, constantes, funções globais, propriedades globais, operadores e instruções. Para obter
informações sobre como usar cada um desses elementos de linguagem, consulte os seguintes
tópicos:
■ Capítulo 5, “Fundamentos da sintaxe e da linguagem”
■ Capítulo 6, “Funções e métodos”
Você pode encontrar uma lista desses elementos de linguagem nas seguintes seções do
ActionScript 2.0 Language Reference (Referência da linguagem ActionScript):
■ %{Compiler Directives}%
■ %{Constants}%
■ %{Global Functions}%
■ %{Global Properties}%
■ %{Operators}%
■ %{Statements}%

Classes de nível superior


O nível superior contém as classes e as funções globais do ActionScript, muitas das quais
fornecem funcionalidade básica a seus aplicativos. As classes básicas, emprestadas diretamente
do ECMAScript, incluem Array, Boolean, Date, Error, Function, Math, Number, Object,
String e System. Para descobrir mais informações sobre cada classe, consulte a seguinte tabela.
N OT A

As classes CustomActions e XMLUI estão disponíveis somente no ambiente de criação


do Flash.

Classe Description (Descrição)


Acessibilidade A classe Accessibility gerencia a comunicação entre os arquivos SWF
e os aplicativos de leitura de tela. Use os métodos dessa classe junto
com a propriedade _accProps global para controlar as propriedades
acessíveis de clipes de filme, botões e campos de texto durante a
execução. Consulte %{Accessibility}%.

Array A classe Array representa os arrays no ActionScript, e todos os objetos


de array são instâncias dessa classe. A classe Array contém métodos e
propriedades para o trabalho com os objetos de array. Consulte
%{Array}%.

304 Classes
Classe Description (Descrição)
AsBroadcaster Fornece recursos de notificação de eventos e gerenciamento de
ouvinte que podem ser adicionados a outros objetos. Consulte
%{AsBroadcaster}%.

Boolean A classe Boolean é um envoltório para valores booleanos (true ou


false). Consulte %{Boolean}%.>.

Button A classe Button fornece métodos, propriedades e manipuladores de


eventos para trabalhar com botões. Consulte %{Button}%. Observe
que a classe interna Button é diferente da classe de componente
Button, associada ao componente Button de versão 2.

Camera (Câmera) A classe Camera fornece acesso à câmera do usuário, se houver uma
instalada. Quando ela é usada com o Flash Communication Server, o
arquivo SWF pode capturar, transmitir e gravar imagens e vídeo da
câmera do usuário. Consulte %{Camera}%.

Color A classe Color permite definir o valor de cor RGB (vermelho, verde e
azul) e a transformação de cor de instâncias de clipes de filme, bem
como recuperar esses valores após eles serem definidos. A classe
Color tornou-se obsoleta no Flash Player 8 tendo sido substituída pela
classe ColorTransform. Para obter mais informações sobre
transformações de cores, consulte %{ColorTransform
(flash.geom.ColorTransform)}%.

ContextMenu A classe ContextMenu permite controlar o conteúdo do menu de


contexto do Flash Player durante a execução. Você pode associar
objetos ContextMenu separados a objetos MovieClip, Button ou
TextField usando a propriedade menu disponível para essas classes.
Também é possível adicionar itens de menu personalizados a um
objeto ContextMenu usando a classe ContextMenuItem. Consulte
%{ContextMenu}%.

ContextMenuItem A classe ContextMenuItem permite que você crie novos itens de menu
que aparecem no menu de contexto do Flash Player. Para adicionar ao
menu de contexto do Flash Player novos itens de menu criados com
essa classe, use a classe ContextMenu. Consulte
%{ContextMenuItem}%.

CustomActions A classe CustomActions permite que você gerencie qualquer ação do


cliente registrada com a ferramenta de criação. Consulte
%{CustomActions}%.

Date A classe Date mostra como as datas e as horas são representadas no


ActionScript e oferece suporte às operações de manipulação de datas
e horas. Essa classe também permite obter a data e a hora atuais a
partir do sistema operacional. Consulte %{Date}%.

Sobre classes de nível superior e internas 305


Classe Description (Descrição)
Error A classe Error contém informações sobre os erros que ocorrem nos
scripts durante a execução. Em geral, use a instrução throw para gerar
uma condição de erro, que você pode manipular com uma instrução
try..catch..finally. Consulte %{Error}%.

Function A classe Function é a representação de classe de todas as funções do


ActionScript, incluindo aquelas que são nativas do ActionScript e as
que você define. Consulte %{Function}%.

Key A classe Key fornece métodos e propriedades para obter informações


sobre o teclado e os pressionamentos de teclas. Consulte %{Key}%.
LoadVars A classe LoadVars permite transferir variáveis entre um arquivo SWF e
um servidor em pares nome/valor. Consulte %{LoadVars}%.
LocalConnection A classe LocalConnection permite desenvolver arquivos SWF que
enviam instruções uns para os outros sem usar o método fscommand()
ou o JavaScript. Consulte %{LocalConnection}%.

Math A classe Math permite o acesso conveniente a constantes


matemáticas comuns, bem como fornece várias funções matemáticas
comuns. Todas as propriedades e métodos da classe Math são
estáticos e devem ser chamados com a sintaxe
Math.método(parâmetro) ou Math.constante. Consulte %{Math}%.

Microphone A classe Microphone fornece acesso ao microfone do usuário, se


(Microfone) houver um instalado. Quando ela é usada com o Flash Communication
Server, o arquivo SWF pode transmitir e gravar áudio a partir do
microfone do usuário. Consulte %{Microphone}%.

Mouse A classe Mouse fornece controle sobre o mouse em um arquivo SWF;


por exemplo, essa classe permite que você oculte ou mostre o ponteiro
do mouse. Consulte %{Mouse}%.

MovieClip Cada clipe de filme em um arquivo SWF é uma instância da classe


MovieClip. Use os métodos e propriedades dessa classe para controlar
objetos de clipe de filme. Consulte %{MovieClip}%.

MovieClipLoader Esta classe permite implementar retornos de chamada de ouvinte que


fornecem informações de status enquanto os arquivos SWF, JPEG,
GIF e PNG estão sendo carregados em instâncias de clipes de filme.
Consulte %{MovieClipLoader}%.

NetConnection A classe NetConnection estabelece uma conexão de fluxo local para


reproduzir um arquivo FLV (Flash Video) de um endereço HTTP
(Hypertext Transfer Protocol, Protocolo de Transferência de
Hipertexto) ou do sistema de arquivos local. Consulte
%{NetConnection}%.

306 Classes
Classe Description (Descrição)
NetStream A classe NetStream controla a reprodução de arquivos FLV de um
sistema de arquivos local ou de um endereço HTTP. Consulte
%{NetStream}%.

Number A classe Number é um envoltório para o tipo de dados de número


primitivo. Consulte %{Number}%.

Object A classe Object encontra-se na raiz da hierarquia de classes do


ActionScript; todas as outras classes herdam seus métodos e
propriedades. Consulte %{Object}%.

PrintJob A classe PrintJob permite imprimir o conteúdo de um arquivo SWF,


incluindo o conteúdo renderizado dinamicamente, e documentos de
várias páginas. Consulte %{PrintJob}%.
Selection A classe Selection permite definir e controlar o campo de texto no qual
está localizado o ponto de inserção (o campo de texto que possui o
foco). Consulte %{Selection}%.

SharedObject A classe SharedObject oferece o armazenamento de dados local


persistente no computador cliente, de maneira semelhante aos
cookies. Essa classe permite o compartilhamento de dados em tempo
real entre objetos no computador do cliente. Consulte
%{SharedObject}%.

Sound A classe Sound fornece controle sobre os sons em um arquivo SWF.


Consulte %{Sound}%.

Stage A classe Stage fornece informações sobre as dimensões, o


alinhamento e o modo de escala de um arquivo SWF. Ela também
informa eventos de redimensionamento do Stage (Palco). Consulte
%{Stage}%.

String A classe String é um envoltório para o tipo de dados String primitivo,


que permite o uso dos métodos e das propriedades do objeto String
para manipular tipos de valores String primitivos. Consulte
%{String}%.

System A classe System fornece informações sobre o Flash Player e o sistema


em que o Flash Player está em execução (por exemplo, resolução da
tela e linguagem do sistema atual). Ela também permite que você
mostre ou oculte o painel Settings (Configurações) do Flash Player e
modifique as configurações de segurança do arquivo SWF. Consulte
%{System}%.

TextField A classe TextField fornece controle sobre campos de texto dinâmicos


e de entrada, como a recuperação de informações de formatação, a
chamada de manipuladores de eventos e a alteração de propriedades
como alfa ou cor de fundo. Consulte %{TextField}%.

Sobre classes de nível superior e internas 307


Classe Description (Descrição)
TextFormat A classe TextFormat permite aplicar estilos de formatação a caracteres
e parágrafos em um objeto TextField. Consulte %{TextFormat}%.
TextSnapshot O objeto TextSnapshot permite acessar texto estático, bem como criar
o seu layout, em um clipe de filme. Consulte %{TextSnapshot}%.

Video A classe Video permite exibir objetos de vídeo em um arquivo SWF.


Você pode usá-la com o Flash Communication Server para exibir
fluxos de vídeo ao vivo em um arquivo SWF file ou no Flash para exibir
um arquivo FLV (Flash Video). Consulte %{Video}%.

XML Esta classe contém métodos e propriedades usados com objetos XML.
Consulte %{XML}%.

XMLNode A classe XMLNode representa um único nó em uma árvore de


documentos XML. Trata-se da superclasse da classe XML. Consulte
%{XMLNode}%.

XMLSocket A classe XMLSocket permite criar uma conexão de soquete


persistente entre um computador servidor e um cliente que executa o
Flash Player. Os soquetes do cliente permitem a transferência de
dados de baixa latência, como a necessária para aplicativos de bate-
papo em tempo real. Consulte %{XMLSocket}%.

XMLUI O objeto XMLUI permite a comunicação com arquivos SWF que são
usados como uma interface do usuário personalizada para os recursos
de extensibilidade da ferramenta de criação do Flash (como Behaviors,
Commands, Effects e Tools). Consulte %{XMLUI}%.

Pacote flash.display
O pacote flash.display contém a classe BitmapData que pode ser usada para criar exibições
visuais.

Classe Description (Descrição)


BitmapData A classe BitmapData permite criar imagens bitmaps opacas ou
transparentes, dimensionadas de forma arbitrária, no documento e
manipulá-las de várias maneiras durante a execução. Consulte
%{BitmapData (flash.display.BitmapData)}%.

308 Classes
Pacote flash.external
O pacote flash.external permite que você se comunique com o recipiente do Flash Player
usando código ActionScript. Por exemplo, se você incorporar um arquivo SWF em uma
página HTML, essa página será o recipiente. Você poderia se comunicar com a página HTML
usando a classe ExternalInterface e o JavaScript. Também chamada de API externa.

Classe Description (Descrição)


ExternalInterface A classe ExternalInterface é a API External, um subsistema que permite
a comunicação entre o ActionScript e o recipiente do Flash Player
(como uma página HTML que usa o JavaScript) ou um aplicativo
desktop que usa o Flash Player. Consulte %{ExternalInterface
(flash.external.ExternalInterface)}%.

Pacote flash.filters
O pacote flash.filters contém classes para os efeitos de filtro de bitmap disponíveis no Flash
Player 8. Os filtros permitem aplicar efeitos visuais sofisticados, como embaçamento, chanfro,
brilho e sombreamento, às instâncias de Image e MovieClip. Para obter mais informações
sobre cada classe, consulte as referências cruzadas fornecidas na tabela a seguir.

Classe Description (Descrição)


BevelFilter A classe BevelFilter permite adicionar um efeito de chanfro a uma
instância de clipe de filme. Consulte %{BevelFilter
(flash.filters.BevelFilter)}%.

BitmapFilter A classe BitmapFilter é uma classe base para todos os efeitos de


filtro. Consulte %{BitmapFilter (flash.filters.BitmapFilter)}%.

BlurFilter A classe BlurFilter permite aplicar um efeito de embaçamento a


instâncias de clipes de filme. Consulte %{BlurFilter
(flash.filters.BlurFilter)}%.

ColorMatrixFilter A classe ColorMatrixFilter permite aplicar uma matriz de


transformação 4x5 aos valores alfa e de cor RGBA (vermelho,
verde, azul e alfa) de cada pixel na imagem de entrada. Após aplicar
a transformação, você poderá produzir um resultado com um novo
conjunto de valores alfa e de cor RGBA. Consulte
%{ColorMatrixFilter (flash.filters.ColorMatrixFilter)}%.

ConvolutionFilter A classe ConvolutionFilter permite aplicar um efeito de filtro de


convolução de matriz. Consulte %{ConvolutionFilter
(flash.filters.ConvolutionFilter)}%.

Sobre classes de nível superior e internas 309


Classe Description (Descrição)
DisplacementMapFilte A classe DisplacementMapFilter permite usar os valores de pixel de
r uma imagem especificada (imagem de mapa de deslocamento) para
deslocar espacialmente a instância original (um clipe de filme) à qual
o filtro foi aplicado. Consulte %{DisplacementMapFilter
(flash.filters.DisplacementMapFilter)}%.

DropShadowFilter A classe DropShadowFilter permite adicionar um sombreamento a


um clipe de filme. Consulte %{DropShadowFilter
(flash.filters.DropShadowFilter)}%.

GlowFilter A classe GlowFilter permite adicionar um efeito de brilho a um clipe


de filme. Consulte %{GlowFilter (flash.filters.GlowFilter)}%.

GradientBevelFilter A classe GradientBevelFilter permite aplicar um efeito de chanfro


gradiente a um clipe de filme. Consulte %{GradientBevelFilter
(flash.filters.GradientBevelFilter)}%.

GradientGlowFilter A GradientGlowFilter permite aplicar um efeito de gradiente de


brilho a um clipe de filme. Consulte %{GradientGlowFilter
(flash.filters.GradientGlowFilter)}%.

Pacote flash.geom
O pacote flash.geom contém classes de geometria, como pontos, retângulos e matrizes de
transformação. Essas classes oferecem suporte à classe BitmapData e ao recurso de
armazenamento de bitmap em cache. Para obter mais informações sobre cada classe, consulte
as referências cruzadas fornecidas na tabela a seguir.

Classe Description (Descrição)


ColorTransform A classe ColorTransform permite definir matematicamente o valor de
cor RGB (vermelho, verde e azul) e a transformação de cor de uma
instância. É possível recuperar esses valores após eles serem
definidos. Consulte %{ColorTransform
(flash.geom.ColorTransform)}%.
Matrix Representa uma matriz de transformação que determina como mapear
pontos de um espaço de coordenadas para outro. Consulte %{Matrix
(flash.geom.Matrix)}%.

Point O objeto Point representa um local em um sistema de coordenadas


bidimensional, onde x representa o eixo horizontal e y representa o
eixo vertical. Consulte %{Point (flash.geom.Point)}%.

310 Classes
Classe Description (Descrição)
Rectangle A classe Rectangle é usada para criar e modificar objetos Rectangle.
(Retângulo) Consulte %{Rectangle (flash.geom.Rectangle)}%.
Transform Coleta dados sobre transformações de cores e manipulações
(Transformar) coordenadas que são aplicadas em uma instância de objeto. Consulte
%{Transform (flash.geom.Transform)}%.

Pacote flash.net
O pacote flash.net contém classes que permitem fazer upload e download de um ou mais
arquivos entre o computador do usuário e o servidor. Para obter mais informações sobre cada
classe, consulte as referências cruzadas fornecidas na tabela a seguir.

Classe Description (Descrição)


FileReference A classe FileReference permite fazer upload e download de um ou
mais arquivos entre o computador do usuário e um servidor. Consulte
%{FileReference (flash.net.FileReference)}%.
FileReferenceList A classe FileReferenceList permite fazer upload de um ou mais
arquivos do computador do usuário em um servidor. Consulte
%{FileReferenceList (flash.net.FileReferenceList)}%.

Pacote flash.text
O pacote flash.text contém a classe TextRenderer para trabalhar com o recurso sem serrilhado
avançado disponível no Flash Player 8.

Classe Description (Descrição)


TextRenderer Esta classe oferece a funcionalidade para o recurso sem serrilhado
avançado no Flash Player 8. Consulte %{TextRenderer
(flash.text.TextRenderer)}%.

Pacote mx.lang
O pacote mx.lang contém a classe Locale para trabalhar com texto multilíngüe.

Classe Description (Descrição)


Locale Essa classe permite controlar como o texto multilíngüe é exibido em um
arquivo SWF. Consulte %{Locale (mx.lang.Locale)}%.

Sobre classes de nível superior e internas 311


Pacotes System e TextField
O pacote System contém as classes capabilities, IME e security. Essas classes controlam as
configurações do cliente que podem afetar o seu aplicativo no Flash Player. Para obter mais
informações sobre cada classe, consulte as referências cruzadas fornecidas na tabela a seguir.

Classe Description (Descrição)


capabilities A classe Capabilities determina as capacidades do sistema e do Flash
Player que está hospedando o arquivo SWF. Isso permite personalizar
o conteúdo para diversos formatos. Consulte %{capabilities
(System.capabilities)}%.

IME A classe IME permite manipular diretamente o IME (Input Method


Editor, Editor de método de entrada) do sistema operacional no
aplicativo Flash Player executado em um computador cliente. Consulte
%{IME (System.IME)}%.

segurança A classe Security contém métodos que especificam como os arquivos


SWF de diversos domínios podem se comunicar uns com os outros.
Consulte %{security (System.security)}%.

O pacote TextField contém a classe StyleSheet que é usada para aplicar estilos CSS (Cascading
StyleSheets, Folhas de estilos em cascata) ao texto.

Classe Description (Descrição)


StyleSheet A classe StyleSheet permite criar um objeto de folha de estilos que
contém as regras de formatação de texto, como tamanho da fonte, cor
e outros estilos de formatação. Consulte %{StyleSheet
(TextField.StyleSheet)}%.

Sobre como trabalhar com classes


internas
Na programação orientada a objeto, uma classe define uma categoria de objeto. Uma classe
descreve as propriedades (dados) e o comportamento (métodos) de um objeto, da mesma
maneira que uma planta arquitetônica descreve as características de uma construção. Para
obter informações sobre classes e outros conceitos de programação orientada a objetos,
consulte as seguintes seções:
■ “Princípios da programação orientada a objeto” na página 246
■ “Criando arquivos de classes personalizados” na página 249

312 Classes
O Flash 8 possui muitas classes internas que você pode usar no código (consulte “Sobre classes
de nível superior e internas” na página 302), para ajudar a adicionar interatividade aos
aplicativos. Para usar as propriedades e os métodos definidos por uma classe interna, você
geralmente cria primeiro uma instância dessa classe (exceto no caso de classes com membros
estáticos). A relação entre uma instância e sua classe é semelhante à relação entre uma casa e
sua planta arquitetônica, conforme discutido em “Sobre classes de nível superior e internas”
na página 302.
Para obter mais informações sobre o uso de classes internas no Flash 8, consulte os seguintes
tópicos:
■ “Sobre a criação de uma nova instância de uma classe interna” na página 313
■ “Acessando propriedades de objetos internos” na página 313
■ “Sobre a chamada de métodos de objetos internos” na página 314
■ “Sobre os membros de classe (estáticos)” na página 315
■ “Pré-carregando arquivos de classe” na página 316
■ “Excluindo classes” na página 315

Sobre a criação de uma nova instância de uma classe


interna
Para criar uma instância de uma classe do ActionScript, use o operador new para chamar a
função construtora da classe. A função construtora sempre tem o mesmo nome da classe e
retorna uma instância da classe, que você normalmente atribui a uma variável.
Por exemplo, o código a seguir cria um novo objeto Sound:
var song_sound:Sound = new Sound();

Em alguns casos, não é necessário criar uma instância de uma classe para usar suas
propriedades e métodos. Para obter mais informações, consulte “Sobre os membros de classe
(estáticos)” na página 315.

Acessando propriedades de objetos internos


Use o operador ponto (.) para acessar o valor de uma propriedade em um objeto. Insira o
nome do objeto à esquerda do ponto e o nome da propriedade à direita. Por exemplo, na
instrução a seguir, my_obj é o objeto e firstName é a propriedade:
my_obj.firstName

O código a seguir cria um novo objeto Array e, em seguida, mostra sua propriedade length:

Sobre como trabalhar com classes internas 313


var my_array:Array = new Array("apples", "oranges", "bananas");
trace(my_array.length); // 3

Também é possível usar o operador de acesso de array ([]) para acessar as propriedades de um
objeto; por exemplo, você pode usá-lo para fins de depuração. O exemplo a seguir executa
uma repetição em um objeto para exibir cada uma de suas propriedades.

Para executar uma repetição no conteúdo de um objeto:


1. Crie um novo documento do Flash e salve-o como forin.fla.
2. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
var results:Object = {firstName:"Tommy", lastName:"G", age:7, avg:0.336,
b:"R", t:"L"};
for (var i:String in results) {
trace("the value of [" + i + "] is: " + results[i]);
}

O código anterior define um novo objeto chamado de resultados e define valores para
firstName, lastName, age, avg, b e t. Uma repetição for..in apresenta cada
propriedade no objeto de resultados e apresenta o valor para o painel Output (Saída).
3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
Para obter mais informações sobre operadores, incluindo operadores de acesso dot e array,
consulte “Sobre operadores” na página 185. Para obter mais informações sobre métodos e
propriedades, consulte Capítulo 6, “Funções e métodos”, na página 213. Para obter exemplos
de como trabalhar com propriedades da classe interna MovieClip, consulte o Capítulo 11,
“Trabalhando com clipes de filme”, na página 369. Para obter exemplos de como trabalhar
com propriedades das classes TextField, String, TextRenderer e TextFormat, consulte o
Capítulo 12, “Trabalhando com texto e seqüências de caracteres”, na página 403.

Sobre a chamada de métodos de objetos internos


Você pode chamar o método de um objeto usado o operador ponto (.) seguido do
método. Por exemplo, o código a seguir cria um novo objeto Sound e chama o seu método
setVolume():
var my_sound:Sound = new Sound(this);
my_sound.setVolume(50);

Para obter exemplos de como trabalhar com métodos da classe interna MovieClip, consulte o
Capítulo 11, “Trabalhando com clipes de filme”, na página 369. Para obter exemplos de como
trabalhar com métodos das classes internas TextField, String, TextRenderer e TextFormat,
consulte o Capítulo 12, “Trabalhando com texto e seqüências de caracteres”, na página 403.

314 Classes
Sobre os membros de classe (estáticos)
Algumas classes internas do ActionScript apresentam membros de classe (membros estáticos). Os
membros de classe (propriedades e métodos) são acessados ou chamados não em uma
instância da classe, mas no próprio nome da classe. Portanto, não é necessário criar uma
instância da classe para usar essas propriedades e métodos.
Por exemplo, todas as propriedades da classe Math são estáticas. O código a seguir chama o
método max() da classe Math para determinar o maior de dois números:
var largerNumber:Number = Math.max(10, 20);
trace(largerNumber); // 20

Para obter mais informações sobre métodos estáticos da classe Math, e exemplos de como usá-
los, consulte %{Math}% em ActionScript 2.0 Language Reference (Referência da linguagem
ActionScript).

Excluindo classes
Para reduzir o tamanho de um arquivo SWF, você poderá excluir classes da compilação, mas
ainda será capaz de acessá-las e usá-las para verificação de tipo. Por exemplo, você poderá fazer
isso se estiver desenvolvendo um aplicativo que utilize vários arquivos SWF ou bibliotecas
compartilhadas, especialmente os que acessam várias das mesmas classes. A exclusão das classes
ajudará a evitar que elas sejam duplicadas nesses arquivos.
Para obter mais informações sobre como excluir classes, consulte os seguintes tópicos:
■ “Pré-carregando arquivos de classe” na página 316

Para excluir classes da compilação:


1. Crie um novo arquivo XML.
2. Atribua o nome Nome_do_arquivo_FLA_exclude.xml ao arquivo XML, onde
Nome_do_arquivo_FLA é o nome do arquivo FLA sem a extensão.
Por exemplo, se o arquivo FLA for sellStocks.fla, o nome do arquivo XML deverá ser
sellStocks_exclude.xml.
3. Salve o arquivo no mesmo diretório que o arquivo FLA.
4. Coloque as seguintes marcas no arquivo XML:
<excludeAssets>
<asset name="className1" />
<asset name="className2" />
</excludeAssets>

Sobre como trabalhar com classes internas 315


Os valores especificados para os atributos de nome nas marcas <asset> são os nomes das
classes que você deseja excluir do arquivo SWF. Adicione quantas classes precisar para o
seu aplicativo. Por exemplo, o arquivo XML a seguir exclui as classes mx.core.UIObject e
mx.screens.Slide do arquivo SWF:
<excludeAssets>
<asset name="mx.core.UIObject" />
<asset name="mx.screens.Slide" />
</excludeAssets>

Para obter informações sobre o pré-carregamento de classes, consulte “Pré-carregando


arquivos de classe” na página 316.

Pré-carregando arquivos de classe


Essa seção descreve algumas das metodologias usadas para pré-carregamento e exportação de
classes no Flash 8 (incluindo as classes usadas por componentes na versão 2 do Macromedia
Component Architecture). Pré-carregamento envolve o carregamento de alguns dados para o
arquivo SWF antes que o usuário comece a interagir com ele. O Flash importa classes no
primeiro quadro de um arquivo SWF quando são usadas classes externas e esses dados são os
primeiros elementos a serem carregados no arquivo SWF. Isso é semelhante para as classes de
componente, porque o framework para componentes também é carregado no primeiro
quadro de um arquivo SWF. Ao criar grandes aplicativos, o tempo de carregamento pode ser
demorado quando é necessário importar dados; sendo assim, é preciso lidar com esses dados
de forma inteligente, conforme mostrado nos seguintes procedimentos.
Como as classes são os primeiros dados a serem carregados, você pode ter problemas ao criar
uma barra de progresso ou ao carregar animações se as classes forem carregadas antes da barra
de progresso, porque é desejável que ela reflita o progresso do carregamento de todos os dados
(incluindo classes). Portanto, carregue as classes depois de outras partes do arquivo SWF, mas
antes de usar componentes.
O seguinte procedimento mostra como alterar o quadro no qual as classes são carregadas no
arquivo SWF.

Para selecionar um quadro diferente para o carregamento das classes no


arquivo SWF:
1. Selecione File > Publish Settings (Configurações de publicação).
2. Selecione a guia Flash e clique no botão Settings (Configurações).
3. Na caixa de texto Export Frame for Classes (Exportar quadro para classes), digite o número
de um novo quadro para determinar quando as classes devem ser carregadas.
4. Clique em OK.

316 Classes
Você não pode usar classes até que a reprodução atinja o quadro escolhido para o qual as
classes devem ser carregadas. Por exemplo, como os componentes da versão 2 exigem classes
para garantir a funcionalidade, você deve carregar componentes depois de Export frame for
classes (Exportar quadro para classes) no ActionScript 2.0. Se você exportar para o Frame 3
(Quadro 3), não poderá usar nenhuma classe até que a reprodução atinja o Frame 3 e carregue
os dados.
Se você quiser pré-carregar um arquivo que use classes, como as classes de componente da
versão 2, deve pré-carregar os componentes no arquivo SWF. Para isso, você deve definir os
componentes para exportarem para um quadro diferente no arquivo SWF. Por padrão, os
componentes de interface de usuário exportam no Frame 1 do arquivo SWF; portanto,
desmarque a opção Export in First Frame (Exportar no primeiro quadro) da caixa de diálogo
Linkage (Vinculação) do componente.
Se os componentes não forem carregados no primeiro quadro, você pode criar uma barra de
progresso personalizada para o primeiro quadro do arquivo SWF. Não faça referência a
nenhum componente no ActionScript nem inclua componentes no Stage até carregar as
classes para o quadro especificado na caixa de texto Export Frame for Classes (Exportar
quadro para classes).
A T E NÇ Ã O

Você deve exportar componentes após as classes ActionScript que eles usam.

Sobre como trabalhar com classes internas 317


318 Classes
CAPÍTULO 8

Herança 8
No Capítulo 7, “Classes,”, você aprendeu a criar arquivos de classes e como as classes podem
ajudá-lo a organizar o código em arquivos externos. Você também viu como organizar
arquivos de classes em pacotes relacionados. O objetivo deste capítulo é mostrar como criar
classes mais avançadas que estendem a funcionalidade de uma classe existente. Este assunto é
útil, pois talvez você precise estender suas classes personalizadas ou as classes existentes para
adicionar novos métodos e propriedades.
Para obter mais informações sobre herança, consulte “Sobre herança” na página 319. Para
obter mais informações sobre métodos e propriedades, consulte Capítulo 6, “Funções e
métodos”, na página 213.
Para obter mais informações sobre herança, consulte os seguintes tópicos:
Sobre herança. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Sobre a criação de subclasses no Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
Usando o polimorfismo em um aplicativo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327

Sobre herança
No Capítulo 7, “Classes,”, você viu como criar um arquivo de classe para criar tipos de dados
personalizados. Aprendendo a criar arquivos de classes personalizados, você saberá como
mover o código da Timeline (Linha de tempo) para arquivos externos. Quando o código é
movido para arquivos externos, é mais fácil editá-lo. Agora que está familiarizado com os
conceitos básicos de criação de classes personalizadas, você aprenderá uma técnica de OOP
(Object-Oriented Programming, Programação orientada a objeto) chamada criação de
subclasses ou extensão de classes, que permite criar novas classes com base em outra existente.

319
Uma das vantagens da OOP é que ela permite criar subclasses de uma classe. A subclasse herda
todas as propriedades e métodos de uma superclasse. Por exemplo, ao estender a classe
MovieClip (ou criar uma subclasse dela), você criará uma classe personalizada que estenderá
essa classe. A subclasse herda todas as propriedades e métodos da classe MovieClip. Também é
possível criar um conjunto de classes como uma extensão de uma superclasse personalizada.
Por exemplo, a classe Lettuce pode ser uma extensão da superclasse Vegetable.
A subclasse geralmente define métodos e propriedades adicionais que podem ser usados em
seu aplicativo; portanto, ela estende a superclasse. As subclasses também substituem (fornecem
suas próprias definições para) os métodos herdados de uma superclasse. Se uma subclasse
substituir um método herdado da superclasse correspondente, você não poderá mais acessar a
definição da superclasse dentro da subclasse. A única exceção à regra acima é que, caso esteja
na função construtura da subclasse, você poderá acessar o construtor da superclasse usando a
instrução super. Para obter mais informações sobre substituição, consulte “Substituindo
métodos e propriedades” na página 324.
Por exemplo, você pode criar uma classe chamada Mammal, que define certas propriedades e
comportamentos comuns a todos os mamíferos e, em seguida, criar uma classe Cat que
estenda essa classe. O uso de subclasses permite reutilizar o código de modo que, em vez de
recriar todo o código comum às duas classes, você poderia simplesmente estender uma classe
existente. Outra subclasse, a classe Siamese, poderia estender a classe Cat e assim por diante.
Em um aplicativo complexo, determinar como estruturar a hierarquia das classes é uma
grande parte do projeto.
A herança e a criação de subclasses são muito úteis em aplicativos maiores, pois permitem criar
várias classes relacionadas que podem compartilhar funcionalidade. Por exemplo, você poderia
criar uma classe Employee que define as propriedades e os métodos básicos de um funcionário
típico de uma empresa. Em seguida, poderia criar uma nova classe chamada Contractor que
estende a classe Employee e herda todos os seus métodos e propriedades. A classe Contractor
poderia adicionar os seus próprios métodos e propriedades ou substituir os métodos e as
propriedades definidos na classe Employee. Depois, você poderia criar uma nova classe
chamada Manager, que também estende a classe Employee e define métodos e propriedades
adicionais, como hire(), fire(), raise() e promote(). Você também poderia estender
uma subclasse, como Manager, e criar uma nova classe chamada Director, que, por sua vez,
adiciona novos métodos ou substitui os métodos existentes.
Toda vez que uma classe é estendida, a nova classe herda todos os métodos e propriedades
atuais da subclasse. Se as classes não estivessem relacionadas, você precisaria recriar cada
método e propriedade em cada arquivo de classe separado, mesmo que as classes relacionadas
tivessem a mesma funcionalidade. Você gastaria muito mais tempo não só codificando, como
também depurando o aplicativo e mantendo um projeto caso uma lógica semelhante fosse
alterada em vários arquivos.

320 Herança
No ActionScript, você usa a palavra-chave extends para estabelecer a herança entre uma
classe e sua superclasse ou para estender uma interface. Para obter mais informações sobre o
uso da palavra-chave extends, consulte “Sobre a criação de subclasses no Flash”
na página 321 e “Sobre a criação de uma subclasse” na página 322. Para obter mais
informações sobre a palavra-chave extends, consulte %{extends statement}% em ActionScript
2.0 Language Reference (Referência da linguagem ActionScript 2.0).

Sobre a criação de subclasses no Flash


Na programação orientada a objeto, uma subclasse pode herdar as propriedades e os métodos
de outra classe, a superclasse. Você pode estender suas classes personalizadas, bem como várias
das classes básicas e do ActionScript do Flash Player, mas não pode estender a classe TextField
nem as classes estáticas, como Math, Key e Mouse.
Para criar esse tipo de relacionamento entre duas classes, use a cláusula extends da instrução
class. Para especificar uma superclasse, use a seguinte sintaxe:
class SubClass extends SuperClass {}

A classe especificada em SubClass herda todas as propriedades e métodos definidos em


SuperClass.
Por exemplo, você pode criar uma classe Mammal, que define propriedades e métodos
comuns a todos os mamíferos. Para criar uma variação da classe Mammal, por exemplo, uma
classe Marsupial, você estenderá a classe Mammal, ou seja, criará uma subclasse dessa classe,
da seguinte maneira:
class Marsupial extends Mammal {}

A subclasse herda todas as propriedades e métodos da superclasse, incluindo as propriedades


ou os métodos declarados como privados usando a palavra-chave private.
Para obter mais informações sobre a extensão de classes, consulte os seguintes tópicos:
■ “Sobre a criação de uma subclasse” na página 322
■ “Substituindo métodos e propriedades” na página 324
Para obter mais informações sobre membros privados, consulte “Sobre propriedades
(membros) e métodos públicos, privados e estáticos” na página 262. Para ver um exemplo que
cria uma subclasse, consulte “Exemplo: Estendendo a classe Widget” na página 322.

Sobre a criação de subclasses no Flash 321


Sobre a criação de uma subclasse
O código a seguir define a classe personalizada JukeBox, que estende a classe Sound. Ele
define um array chamado song_arr e um método chamado playSong(), que reproduz uma
música e chama o método loadSound(), que herda as características da classe Sound.
class JukeBox extends Sound {
public var song_arr:Array = new Array("beethoven.mp3", "bach.mp3",
"mozart.mp3");
public function playSong(songID:Number):Void {
super.loadSound(song_arr[songID], true);
}
}

Se você não fizer uma chamada para super() na função construtora de uma subclasse, o
compilador gerará automaticamente uma chamada para o construtor da superclasse imediata,
sem parâmetros como a primeira instrução da função. Se a superclasse não tiver um
construtor, o compilador criará uma função vazia e depois gerará a chamada para ela a partir
da subclasse. Entretanto, se a superclasse utilizar parâmetros em sua definição, será necessário
criar um construtor na subclasse e chamar a superclasse com os parâmetros necessários.
A herança múltipla, ou herança de mais de uma classe, não é permitida no ActionScript 2.0.
Entretanto, as classes poderão herdar efetivamente as características de diversas classes se você
utilizar instruções extends individuais, como mostra o seguinte exemplo:
// não permitido
class C extends A, B {} // **Error: Uma classe não pode estender mais do que
uma classe.

// permitido
class B extends A {}
class C extends B {}

Também é possível usar interfaces para implementar uma forma limitada de herança múltipla.
Para obter mais informações sobre interfaces, consulte Capítulo 9, “Interfaces”, na
página 331. Para ver um exemplo que cria uma subclasse, consulte “Exemplo: Estendendo a
classe Widget” na página 322. Para obter mais informações sobre super, consulte %{super
statement}% em ActionScript 2.0 Language Reference.

Exemplo: Estendendo a classe Widget


Os membros da classe propagam-se para as subclasses da superclasse que define esses
membros. O exemplo a seguir demonstra como criar uma classe Widget, que pode ser
estendida (subclasse) com a criação de outra chamada SubWidget.

Para criar a classe Widget e a subclasse SubWidget:


1. Crie um novo arquivo do ActionScript e salve-o como Widget.as.

322 Herança
2. Adicione o seguinte código ao novo documento:
class Widget {
public static var widgetCount:Number = 0;
public function Widget() {
Widget.widgetCount++;
}
}

3. Salve as alterações no arquivo do ActionScript.


4. Crie um novo arquivo do ActionScript e salve-o como SubWidget.as no mesmo diretório
que a classe Widget.
5. Em SubWidget.as, digite o seguinte código na janela Script:
class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget # "+Widget.widgetCount);
}
}

6. Salve as alterações em SubWidget.as.


7. Crie um novo arquivo FLA e salve-o como subWidgetTest.fla no mesmo diretório dos
arquivos de classes anteriores do ActionScript.
8. Nesse arquivo, digite o seguinte código no Frame 1 (Quadro 1) da Timeline (Linha de
tempo) principal:
var sw1:SubWidget = new SubWidget();
var sw2:SubWidget = new SubWidget();
trace("Widget.widgetCount = " + Widget.widgetCount);
trace("SubWidget.widgetCount = " + SubWidget.widgetCount);

O código anterior cria duas instâncias da classe SubWidget: sw1 e sw2. Cada chamada do
construtor de SubWidget rastreia o valor atual da propriedade estática
Widget.widgetCount. Como SubWidget é uma subclasse da classe Widget, você poderá
acessar a propriedade widgetCount por meio dessa subclasse, e o compilador recriará a
referência (no bytecode, não no arquivo ActionScript) como Widget.widgetCount. Se
você tentar acessar a propriedade estática widgetCount a partir de instâncias da classe
Widget ou SubWidget, como sw1 ou sw2, o compilador gerará um erro.
9. Salve as alterações no documento.
10. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
O painel Output (Saída) exibirá o seguinte:
Creating subwidget #1
Creating subwidget #2

Sobre a criação de subclasses no Flash 323


Widget.widgetCount = 2
SubWidget.widgetCount = 2

Essa saída é exibida porque, embora o construtor da classe Widget nunca seja chamado
explicitamente, o construtor da classe SubWidget o chama para você. Como resultado, o
construtor da classe Widget incrementa a variável estática widgetCount dessa classe.
O compilador ActionScript 2.0 pode resolver as referências a membros estáticos nas
definições de classes.
Se você não especificar o nome da classe da propriedade Widget.widgetCount, mas fizer
referência somente a widgetCount, o compilador ActionScript 2.0 resolverá a referência
como Widget.widgetCount e exportará corretamente essa propriedade. Da mesma
forma, se você fizer referência à propriedade como SubWidget.widgetCount, o
compilador recriará a referência (no bytecode, e não no arquivo do ActionScript) como
Widget.widgetCount porque SubWidget é uma subclasse da classe Widget.
A TE N Ç Ã O

Se você tentar acessar a variável estática widgetCount da classe Widget usando a


instância sw1 ou sw2, o Flash gerará um erro informando que só é possível acessar
os membros estáticos diretamente através de classes.

Para garantir a legibilidade máxima do seu código, a Macromedia recomenda que você use
sempre referências explícitas a variáveis de membro estático no código, como no exemplo
anterior. O uso de referências explícitas permite identificar facilmente onde a definição de um
membro estático reside.

Substituindo métodos e propriedades


Quando uma subclasse estende uma superclasse, a subclasse herda todos os métodos e as
propriedades da superclasse. Uma das vantagens de se trabalhar com classes e estendê-las é que
isso permite adicionar uma nova funcionalidade às classes existentes, bem como modificar
uma funcionalidade já existente. Por exemplo, considere a classe Widget criada no “Exemplo:
Estendendo a classe Widget” na página 322. Você poderia criar um novo método na
superclasse (Widget) e, em seguida, substituir o método na subclasse (SubWidget) ou
simplesmente usar o método herdado da classe Widget. O exemplo a seguir mostra como
substituir os métodos existentes nas classes.

Para substituir os métodos em uma subclasse:


1. Crie um novo documento do ActionScript e salve-o como Widget.as.
2. Em Widget.as, digite o seguinte código ActionScript na janela Script:
Nota: Se tiver criado a classe Widget em um exemplo anterior, modifique o código
existente adicionando o método doSomething(), da seguinte maneira:

324 Herança
class Widget {
public static var widgetCount:Number = 0;
public function Widget() {
Widget.widgetCount++;
}
public function doSomething():Void {
trace("Widget::doSomething()");
}
}

3. Salve as alterações no documento do ActionScript.


Agora a classe Widget define um construtor e um método público chamado
doSomething().
4. Crie um novo arquivo do ActionScript chamado SubWidget.as e salve-o no mesmo
diretório que Widget.as.
NO TA

Se tiver criado a classe SubWidget no “Exemplo: Estendendo a classe Widget”


na página 322, você poderá usá-la.

5. Em SubWidget.as, digite o seguinte código ActionScript na janela Script:


class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget # "+Widget.widgetCount);
doSomething();
}
}

6. Salve as alterações em SubWidget.as.


Observe que o construtor da classe SubWidget chama o método doSomething() definido
na superclasse.
7. Crie um novo documento do Flash e salve-o como subWidgetTest.fla no mesmo diretório
que os documentos do ActionScript.
8. Em subWidgetTest.fla, digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline
(Linha de tempo) principal :
var sw1:SubWidget = new SubWidget();
var sw2:SubWidget = new SubWidget();

9. Salve as alterações no documento do Flash.


10. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash. Você observa o seguinte no painel Output (Saída):
Creating subwidget # 1
Widget::doSomething()
Creating subwidget # 2
Widget::doSomething()

Sobre a criação de subclasses no Flash 325


Essa saída mostra que o construtor da classe SubWidget chama o construtor de sua
superclasse (Widget), que incrementa a propriedade estática widgetCount. O construtor
de SubWidget rastreia a propriedade estática da superclasse e chama o método
doSomething(), que herda as características da superclasse.
11. Abra a classe SubWidget e adicione um novo método chamado doSomething().
Modifique sua classe de acordo com o seguinte código (adicione o código em negrito):
class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget # "+Widget.widgetCount);
doSomething();
}
public function doSomething():Void {
trace("SubWidget::doSomething()");
}
}

12. Salve as alterações no arquivo de classe e, em seguida, abra subwidgetTest.fla novamente.


13. Selecione Control > Test Movie para testar o arquivo. Você observa o seguinte no painel
Output:
Creating subwidget # 1
SubWidget::doSomething()
Creating subwidget # 2
SubWidget::doSomething()

A saída anterior mostra que o método doSomething() do construtor da classe SubWidget


chama o método doSomething() da classe atual, e não da superclasse.
Abra a classe SubWidget novamente e modifique o construtor dessa classe para chamar o
método doSomething() (adicione o código em negrito):
public function SubWidget() {
trace("Creating subwidget # "+Widget.widgetCount);
super.doSomething();
}

Como demonstrado, você pode adicionar a palavra-chave super para chamar o método
doSomething() da superclasse, em vez do método doSomething() da classe atual. Para
obter mais informações sobre super, consulte a entrada correspondente em ActionScript
2.0 Language Reference.
14. Salve o arquivo de classe SubWidget com o construtor modificado e selecione Control >
Test Movie para publicar novamente o documento do Flash.
O painel Output exibe o conteúdo do método doSomething() da classe Widget.

326 Herança
Usando o polimorfismo em um aplicativo
A programação orientada a objeto permite expressar as diferenças entre classes individuais com
uma técnica chamada polimorfismo, pela qual as classes podem substituir os métodos de suas
superclasses e definir implementações especializadas desses métodos.
Por exemplo, você pode criar inicialmente uma classe chamada Mammal com os métodos
play() e sleep() e, em seguida, criar as subclasses Cat, Monkey e Dog para estender essa
classe. As subclasses substituem o método play() da classe Mammal para refletir os hábitos
desses tipos específicos de animais. Monkey implementa o método play() para pendurar-se
nos galhos de árvores; Cat implementa o método play() para avançar em um novelo de lã;
Dog implementa o método play() para apanhar uma bola. Como a funcionalidade sleep()
é semelhante entre os animais, você usaria a implementação de superclasse. O procedimento a
seguir demonstra esse exemplo no Flash.

Para usar o polimorfismo em um aplicativo:


1. Crie um novo documento do ActionScript e salve-o como Mammal.as.
Esse documento é a classe base de várias classes diferentes de animais que você criará na
etapas subseqüentes.
2. Em Mammal.as, digite o seguinte código ActionScript na janela Script:
class Mammal {
private var _gender:String;
private var _name:String = "Mammal";

// construtor
public function Mammal(gender:String) {
this._gender = gender;
}

public function toString():String {


return "[object " + speciesName + "]";
}
public function play():String {
return "Chase another of my kind.";
}
public function sleep():String {
return "Close eyes.";
}

public function get gender():String {


return this._gender;
}
public function get speciesName():String {
return this._name;
}

Usando o polimorfismo em um aplicativo 327


public function set speciesName(value:String):Void {
this._name = value;
}
}

A classe anterior define duas variáveis privadas, __gender e __name, que são usadas para
armazenar o tipo de mamífero e o sexo do animal. Em seguida, o construtor Mammal é
definido. O construtor precisa de um único parâmetro, gender, que é usado para definir a
variável privada _gender especificada anteriormente. Três métodos públicos adicionais
também são especificados: toString(), play() e sleep(), sendo que cada um retorna
objetos String. Os três métodos finais são getters e setters das propriedades _gender e
_name do mamífero.
3. Salve o documento do ActionScript.
Essa classe funciona como a superclasse das classes Cat, Dog e Monkey, que você criará em
breve. Você pode usar o método toString() da classe Mammal para exibir uma
representação de seqüência de caracteres de qualquer instância dessa classe (ou de qualquer
instância que estendesse essa classe).
4. Crie um novo arquivo do ActionScript e salve-o como Cat.as no mesmo diretório do
arquivo de classe Mammal.as criada na etapa 1.
5. Em Cat.as, digite o seguinte código ActionScript na janela Script:
class Cat extends Mammal {
// construtor
public function Cat(gender:String) {
super(gender);
speciesName = "Cat";
}

public function play():String {


return "Pounce a ball of yarn.";
}
}

Observe que você está substituindo o método play() da superclasse Mammal. A classe
Cat define somente dois métodos, um método construtor e outro play(). Como a classe
Cat estende a classe Mammal, os métodos e as propriedades dessa classe são herdados pela
classe Cat. Para obter mais informações sobre substituição, consulte “Substituindo
métodos e propriedades” na página 324.
6. Salve as alterações no documento do ActionScript.
7. Crie um novo documento do ActionScript e salve-o como Dog.as no mesmo diretório que
os dois arquivos de classes anteriores.
8. Em Dog.as, digite o seguinte código ActionScript na janela Script:
class Dog extends Mammal {

328 Herança
// construtor
public function Dog(gender:String) {
super(gender);
speciesName = "Dog";
}

public function play():String {


return "Fetch a stick.";
}
}

Observe que a classe Dog tem uma estrutura muito semelhante à da classe Cat, com
exceção de alguns valores que foram alterados. Mais uma vez, a classe Dog estende a classe
Mammal e herda todos os seus métodos e propriedades. O construtor de Dog utiliza uma
única propriedade, gender, que ele passa à classe pai da classe Dog, Mammal. A variável
speciesName também é substituída e definida como a seqüência de caracteres Dog. O
método play() também é substituído a partir da classe pai.
9. Salve as alterações no documento do ActionScript.
10. Crie outro documento do ActionScript no mesmo diretório que os seus outros arquivos e
salve-o como Monkey.as.
11. Em Monkey.as, digite o seguinte código ActionScript na janela Script:
class Monkey extends Mammal {
// construtor
public function Monkey(gender:String) {
super(gender);
speciesName = "Monkey";
}

public function play():String {


return "Swing from a tree.";
}
}

Como as duas classes anteriores, Cat e Dog, a classe Monkey estende a classe Mammal. O
construtor da classe Monkey chama o construtor da classe Mammal, passando a
propriedade gender para ele e definindo speciesName como a seqüência de caracteres
Monkey. A classe Monkey também substitui o comportamento do método play().
12. Salve as alterações no documento do ActionScript.
13. Agora que você criou três subclasses da classe Mammal, crie um novo documento do Flash
chamado mammalTest.fla.
14. Em mammalTest.fla, digite o seguinte código ActionScript no Frame (Quadro) 1 da
Timeline (Linha de tempo) principal:
var mammals_arr:Array = new Array();

Usando o polimorfismo em um aplicativo 329


this.createTextField("info_txt", 10, 10, 10, 450, 80);
info_txt.html = true;
info_txt.multiline = true;
info_txt.border = true;
info_txt.wordWrap = true;

createMammals()
createReport()

function createMammals():Void {
mammals_arr.push(new Dog("Female"));
mammals_arr.push(new Cat("Male"));
mammals_arr.push(new Monkey("Female"));
mammals_arr.push(new Mammal("Male"));
}

function createReport():Void {
var i:Number;
var len:Number = mammals_arr.length;
// Exiba as informações de Mammal em quatro colunas de texto HTML
usando interrupções de tabulação.
info_txt.htmlText = "<textformat tabstops='[110, 200, 300]'>";
info_txt.htmlText += "<b>Mammal\tGender\tSleep\tPlay</b>";
for (i = 0; i < len; i++) {
info_txt.htmlText += "<p>" + mammals_arr[i].speciesName
+ "\t" + mammals_arr[i].gender
+ "\t" + mammals_arr[i].sleep()
+ "\t" + mammals_arr[i].play() + "</p>";
// A instrução trace chama o método Mammal.toString().
trace(mammals_arr[i]);
}
info_txt.htmlText += "</textformat>";
}

O código de mammalTest.fla é um pouco mais complexo do que as classes anteriores.


Primeiro ele importa as três classes de animal.
15. Salve o documento do Flash e selecione Control (Controlar) > Test Movie (Testar filme)
para testar o documento.
Você verá as informações de Mammal exibidas em um campo de texto no Stage (Palco) e o
seguinte texto no painel Output (Saída):
[object Dog]
[object Cat]
[object Monkey]
[object Mammal]

330 Herança
CAPÍTULO 9

Interfaces 9
Na OOP (Object-Oriented Programming, Programação orientada a objeto), uma interface é
um documento que permite declarar (porém não definir) os métodos que devem aparecer em
uma classe. Quando você trabalha em equipes de desenvolvedores ou cria aplicativos maiores
no Flash, as interfaces podem ser muito úteis durante o desenvolvimento. Elas permitem que
os desenvolvedores identifiquem facilmente os métodos base das classes do ActionScript. Esses
métodos devem ser implementados quando os desenvolvedores usam cada interface.
Este capítulo examina algumas interfaces de exemplo e, ao concluí-lo, você será capaz de criar
seus próprios arquivos de interface. Se não estiver familiarizado com a criação de classes, leia o
Capítulo 7, “Classes,” antes de tentar fazer os tutoriais e ler os exemplos apresentados neste
capítulo.
Para obter mais informações sobre o trabalho com interfaces, consulte os seguintes tópicos:
Sobre interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Criando interfaces como tipos de dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Noções básicas sobre herança e interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .339
Exemplo: Usando interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
Exemplo: Criando uma interface complexa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .342

Sobre interfaces
Na programação orientada a objeto, as interfaces assemelham-se a classes cujos métodos não
são implementados (definidos), ou seja, elas não “fazem” nada. Portanto, uma interface
consiste em métodos “vazios”. Outra classe poderá implementar os métodos declarados pela
interface. No ActionScript, a distinção entre interface e objeto aplica-se somente à verificação
de erros durante a compilação e à imposição de regras de linguagem.

331
Uma interface não é uma classe; porém, essa afirmativa não é completamente verdadeira no
ActionScript durante a execução pois uma interface é abstrata. As interfaces do ActionScript
realmente existem na execução para permitir a conversão de tipos (a alteração de um tipo
existente de dados em outro tipo). O modelo de objeto do ActionScript 2.0 não oferece
suporte à herança múltipla. Portanto, uma classe pode herdar as características de uma única
classe pai. Essa classe pai pode ser uma classe básica ou do Flash Player ou, ainda, uma classe
definida pelo usuário (personalizada). É possível usar interfaces para implementar uma forma
limitada de herança múltipla, pela qual uma classe herda mais de uma classe.
Por exemplo, em C++, a classe Cat pode estender a classe Mammal, bem como uma classe
Playful, que contém os métodos chaseTail() e eatCatNip(). Como o Java, o ActionScript
2.0 não permite que uma classe estenda várias classes diretamente, mas permite que ela
estenda uma única classe e implemente várias interfaces. Portanto, você pode criar uma
interface Playful que declara os métodos chaseTail() e eatCatNip(). Uma classe Gato, ou
qualquer outra classe, pode implementar essa interface e fornecer definições para esses
métodos.
Uma interface também pode ser considerada como um “contrato de programação” que pode
ser usado para impor os relacionamentos entre classes não relacionadas de outra maneira. Por
exemplo, suponha que você esteja trabalhando com uma equipe de programadores, cada um
responsável por uma classe diferente do mesmo aplicativo. Ao projetar o aplicativo, você
estabelece um conjunto de métodos que as diferentes classes usarão para se comunicar. Você
cria uma interface que declara esses métodos, seus parâmetros e tipos de retorno. Qualquer
classe que implemente essa interface deve fornecer definições para esses métodos; caso
contrário, ocorrerá um erro do compilador. A interface é como um protocolo de comunicação
ao qual todas as classes devem aderir.
Uma maneira de fazer isso é criar uma classe que defina todos esses métodos e, em seguida,
fazer com que cada classe seja estendida a partir dessa superclasse ou herde as características
dela. Como o aplicativo consiste em classes que não estão relacionadas, não faz sentido impor
uma hierarquia de classe comum a elas. Uma solução melhor é criar uma interface que declare
os métodos que essas classes usam para se comunicar e, em seguida, fazer cada classe
implementar (fornecer suas próprias definições para) esses métodos.
Normalmente, você pode programar bem sem usar interfaces. Entretanto, quando usadas
apropriadamente, as interfaces podem tornar o projeto dos aplicativos mais elegante,
dimensionável e fácil de manter.

332 Interfaces
As interfaces do ActionScript existem durante a execução para permitir a conversão de tipos;
consulte Capítulo 4, “Sobre a conversão de objetos”, na página 117. Embora uma interface
não seja um objeto ou uma classe, o fluxo de trabalho é semelhante ao existente quando se
trabalha com classes. Para obter mais informações sobre o fluxo de trabalho de classes,
consulte “Criando arquivos de classes personalizados” na página 249. Para ver um tutorial
sobre como criar um aplicativo com interfaces, consulte “Exemplo: Usando interfaces”
na página 340.
Para obter mais informações sobre o uso de interfaces, consulte as seguintes seções:
■ “Sobre a palavra-chave interface” na página 333
■ “Sobre a atribuição de nomes a interfaces” na página 334
■ “Definindo e implementado interfaces” na página 334

Sobre a palavra-chave interface


A palavra-chave interface define uma interface. Uma interface é semelhante a uma classe,
com as seguintes diferenças relevantes:
■ As interfaces contêm somente descrições de métodos e não sua implementação. Ou seja,
toda classe que implementa uma interface deve fornecer uma implementação para cada
método definido na interface.
■ Somente membros públicos são permitidos em uma definição de interface; membros
estáticos e de classe não são permitidos.
■ As instruções get e set não são permitidas em definições de interface.
■ Para usar a palavra-chave interface, é necessário especificar ActionScript 2.0 e Flash
Player 6 ou uma versão posterior na guia Flash da caixa de diálogo Publish Settings
(Configurações de publicação) do arquivo FLA.
A palavra-chave interface é suportada somente quando usada em arquivos de script
externos, não em scripts criados no painel Actions (Ações).

Sobre interfaces 333


Sobre a atribuição de nomes a interfaces
Como os nomes de classes, os nomes de interfaces iniciam em letra maiúscula. Esses nomes
são geralmente adjetivos como Printable. O nome de interface a seguir, IEmployeeRecords,
usa uma inicial maiúscula e palavras concatenadas em letras maiúsculas e minúsculas:
interface IEmployeeRecords {}
NO TA

Alguns desenvolvedores iniciam os nomes das interfaces com um “I” maiúsculo para
diferenciá-las das classes. A adoção dessa prática é recomendada, pois permite
distinguir rapidamente entre interfaces e classes comuns.

Para obter mais informações sobre convenções de atribuição de nome, consulte Capítulo 19,
“Melhores práticas e convenções de codificação para ActionScript 2.0”, na página 767.

Definindo e implementado interfaces


O processo de criação de uma interface é igual ao de criação de uma classe. Assim como as
classes, só é possível definir interfaces nos arquivos externos do ActionScript. O fluxo de
trabalho para a criação de uma interface envolve, no mínimo, as seguintes etapas:
■ Definir uma interface em um arquivo externo do ActionScript.
■ Salvar o arquivo da interface em um diretório de caminho de classe designado (o local em
que o Flash procura as classes) ou no mesmo diretório que o arquivo FLA do aplicativo
■ Criar uma instância da classe em outro script, em um documento do Flash (FLA) ou em
um arquivo de script externo, ou criar subinterfaces com base na interface original
■ Criar uma classe que implemente a interface em um arquivo de script externo
Para declarar uma interface, use a palavra-chave interface, seguida do nome da interface e
de chaves ({}), que definem o corpo da interface, como mostra o seguinte exemplo:
interface IEmployeeRecords {
// declarações de método de interface
}

Uma interface só pode conter declarações de métodos (funções), incluindo parâmetros, tipos
de parâmetro e tipos de retorno de função.
Para obter mais informações sobre convenções de estruturação de classes e interfaces, consulte
Capítulo 19, “Melhores práticas e convenções de codificação para ActionScript 2.0”, na
página 767. Para ver um tutorial sobre a criação de um aplicativo que usa uma interface,
consulte “Exemplo: Usando interfaces” na página 340.

334 Interfaces
Por exemplo, o código a seguir declara uma interface chamada IMyInterface que contém
dois métodos, method1() e method2(). O primeiro método, method1(), não possui
parâmetros e especifica o tipo de retorno Void (que indica que ele não retorna um valor). O
segundo método, method2(), tem um único parâmetro de tipo String e especifica um tipo de
retorno Boolean.

Para criar uma interface simples:


1. Crie um novo arquivo do ActionScript e salve-o como IMyInterface.as.
2. Digite o seguinte código ActionScript na janela Script:
interface IMyInterface {
public function method1():Void;
public function method2(param:String):Boolean;
}

3. Salve as alterações no arquivo do ActionScript.


Para usar a interface em um aplicativo, é necessário criar primeiro uma classe que
implemente a nova interface.
4. Crie um novo arquivo do ActionScript e salve-o como MyClass.as no mesmo diretório que
IMyInterface.as.
5. No arquivo de classe MyClass, digite o seguinte código ActionScript na janela Script:
class MyClass {
}

Para instruir a classe personalizada (MyClass) a usar a interface (IMyInterface), é


necessário usar a palavra-chave implements, a qual especifica que uma classe deve definir
todos os métodos declarados na(s) interface(s) implementada(s).
6. Modifique o código ActionScript em MyClass.as (adicione o código em negrito) de acordo
com o seguinte trecho:
class MyClass implements IMyInterface {
}

Coloque a palavra-chave implements depois do nome da classe.


7. Clique no botão Check Syntax (Verificar sintaxe).
O Flash exibe um erro no painel Output (Saída) informando que MyClass deve
implementar o método X da interface IMyInterface. Essa mensagem de erro é exibida
porque toda classe que estende uma interface deve definir cada método listado no
documento da interface.
8. Modifique o documento MyClass novamente (adicione o código em negrito) e crie o
código ActionScript para os métodos method1() e method2(), como mostra o seguinte
trecho:

Sobre interfaces 335


class MyClass implements IMyInterface {
public function method1():Void {
// ...
};
public function method2(param:String):Boolean {
// ...
return true;
}
}

9. Salve o documento MyClass.as e clique em Check Syntax.


O painel Output não exibe mais mensagens de erro ou avisos porque agora você definiu os
dois métodos.
O arquivo de classe criado não se limita aos métodos públicos definidos no arquivo de
interface. O arquivo de interface descreve apenas os métodos mínimos que devem ser
implementados, bem como os tipos de retorno e as propriedades desses métodos. As classes
que implementam uma interface quase sempre incluem métodos getter e setter, variáveis e
métodos adicionais.
Os arquivos de interface não podem conter declarações de variáveis nem atribuições. As
funções declaradas em uma interface não podem conter chaves. Por exemplo, a interface a
seguir não é compilada:
interface IBadInterface {
// Erro do compilador. Declarações de variáveis não permitidas em
interfaces.
public var illegalVar:String;

// Erro do compilador. Corpos de função não permitidos em interfaces.


public function illegalMethod():Void {
}

// Erro do compilador. Não são permitidos métodos privados em interfaces.


private function illegalPrivateMethod():Void;

// Erro do compilador. Não são permitidos getters/setters em interfaces.


public function get illegalGetter():String;
}

Para ver um tutorial que demonstra como criar uma interface complexa, consulte “Exemplo:
Usando interfaces” na página 340.
As regras para atribuir nome a interfaces e armazená-las nos pacotes são as mesmas usadas para
as classes; consulte “Sobre a atribuição de nomes a arquivos de classes” na página 280.

336 Interfaces
Criando interfaces como tipos de dados
Como uma classe, uma interface define um novo tipo de dados. Qualquer classe que
implementa uma interface pode ser considerada como sendo do tipo definido pela interface.
Esse recurso é útil para determinar se um objeto específico implementa uma determinada
interface. Por exemplo, considere a interface IMovable, criada no exemplo a seguir.

Para criar uma interface como um tipo de dados:


1. Crie um novo documento do ActionScript e salve-o no disco rígido como IMovable.as.
2. Em IMovable.as, digite o seguinte código ActionScript na janela Script:
interface IMovable {
public function moveUp():Void;
public function moveDown():Void;
}

3. Salve as alterações no arquivo do ActionScript.


4. Crie um novo documento do ActionScript e salve-o como Box.as no mesmo diretório que
IMovable.as.
Nesse documento, crie uma classe Box que implementa a interface IMovable criada em
uma etapa anterior.
5. Em Box.as, digite o seguinte código ActionScript na janela Script:
class Box implements Movable {
public var xPos:Number;
public var yPos:Number;

public function Box() {


}

public function moveUp():Void {


trace("moving up");
// definição de método
}
public function moveDown():Void {
trace("moving down");
// definição de método
}
}

6. Salve as alterações no documento do ActionScript.


7. Crie um novo documento do Flash chamado boxTest.fla e salve-o no mesmo diretório que
os dois documentos anteriores do ActionScript.

Criando interfaces como tipos de dados 337


8. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo), abra o editor do
ActionScript e digite o seguinte código ActionScript no painel Actions (Ações) (ou janela
Script):
var newBox:Box = new Box();

Esse código ActionScript cria uma instância da classe Box, que você declara como uma
variável do tipo Box.
9. Salve as alterações no documento do Flash e selecione Control (Controlar) > Test Movie
(Testar filme) para testar o arquivo SWF.
No Flash Player 7 e versões posteriores, você pode converter uma expressão em um tipo de
interface ou em outro tipo de dados durante a execução. Diferentemente das interfaces do
Java, as interfaces do ActionScript existem durante a execução, o permite a conversão de
tipos. Se a expressão for um objeto que implemente a interface ou tenha uma superclasse
que implemente a interface, o objeto será retornado. Caso contrário, será retornado null.
Esse recurso é útil para verificar se determinado objeto implementa uma interface
específica. Para obter mais informações sobre conversão de tipos, consulte Capítulo 4,
“Sobre a conversão de objetos”, na página 117.
10. Adicione o código a seguir ao final do código ActionScript em boxTest.fla:
if (IMovable(newBox) != null) {
newBox.moveUp();
else {
trace("box instance is not movable");
}

Esse código ActionScript verifica se a instância newBox implementa a interface IMovable


antes da chamada do método moveUp() no objeto.
11. Salve o documento do Flash e selecione Control > Test Movie para testar o arquivo SWF.
Como a instância Box implementa a interface IMovable, o método Box.moveUp() é
chamado, e o texto “moving up” é exibido no painel Output (Saída).
Para obter mais informações sobre conversão, consulte Capítulo 4, “Sobre a conversão de
objetos”, na página 117.

338 Interfaces
Noções básicas sobre herança e
interfaces
Você pode usar a palavra-chave extends para criar subclasses de uma interface. Isso poderá ser
muito útil em projetos maiores quando se deseja estender uma interface existente (ou criar
uma subclasse dela) e adicionar outros métodos. Esses métodos devem ser definidos por todas
as classes que implementam essa interface.
Uma consideração a ser feita ao estender interfaces é que serão exibidas mensagens de erro no
Flash se vários arquivos de interface declararem funções com os mesmos nomes, mas tiverem
parâmetros ou tipos de retorno diferentes.
O exemplo a seguir demonstra como uma criar uma subclasse de um arquivo de interface com
a palavra-chave extends.

Para estender uma interface:


1. Crie um novo arquivo do ActionScript e salve-o como Ia.as.
2. Em Ia.as, digite o seguinte código ActionScript na janela Script:
interface Ia {
public function f1():Void;
public function f2():Void;
}

3. Salve as alterações no arquivo do ActionScript.


4. Crie um novo arquivo do ActionScript e salve-o como Ib.as na mesma pasta que o arquivo
Ia.as criado na etapa 1.
5. No arquivo Ib.as, digite o seguinte código ActionScript na janela Script:
interface Ib extends Ia {
public function f8():Void;
public function f9():Void;
}

6. Salve as alterações no arquivo do ActionScript.


7. Crie um novo arquivo do ActionScript e salve-o como ClassA.as no mesmo diretório que
os dois arquivos anteriores.
8. Em ClassA.as, digite o seguinte código ActionScript na janela Script:
class ClassA implements Ib {
// f1() e f2() são definidos na interface Ia.
public function f1():Void {
}
public function f2():Void {
}

Noções básicas sobre herança e interfaces 339


// f8() e f9() são definidos na interface Ib, que estende Ia.
public function f8():Void {
}
public function f9():Void {
}
}

9. Salve o arquivo de classe e clique no botão Check Syntax (Verificar sintaxe) acima da janela
Script.
O Flash não gerará mensagens de erro desde que todos os quatro métodos sejam definidos
e correspondam às definições de seus respectivos arquivos de interface.
NO T A

No ActionScript 2.0, as classes só podem estender uma classe, embora seja


possível usá-las para implementar tantas interfaces quantas forem desejadas.

Para que a classe ClassA implemente várias interfaces no exemplo anterior, separe
simplesmente as interfaces com vírgulas. Ou, se uma classe estendesse uma superclasse e
implementasse várias interfaces, você usaria um código semelhante ao seguinte:
class ClassA extends ClassB implements Ib, Ic, Id {...}.

Exemplo: Usando interfaces


Neste exemplo, você criará uma interface simples que poderá ser reutilizada entre várias classes
diferentes.

Para criar uma interface:


1. Crie um novo arquivo do ActionScript e salve-o como IDocumentation.as.
2. Em IDocumentation.as, digite o seguinte código ActionScript na janela Script:
interface IDocumentation {
public function downloadUpdates():Void;
public function checkForUpdates():Boolean;
public function searchHelp(keyword:String):Array;
}

3. Salve as alterações efetuadas no arquivo de interface do ActionScript.


4. Crie um novo arquivo do ActionScript no mesmo diretório que IDocumentation.as e salve-
o como FlashPaper.as.
5. Em FlashPaper.as, digite o seguinte código ActionScript na janela Script:
class FlashPaper implements IDocumentation {
}
6. Salve as alterações efetuadas no arquivo do ActionScript.

340 Interfaces
7. Clique no botão Check Syntax (Verificar sintaxe) referente à classe do ActionScript.
É exibida uma mensagem de erro semelhante a esta:
**Error** path\FlashPaper.as: Line 1: The class must implement method
'checkForUpdates' from interface 'IDocumentation'.
class FlashPaper implements IDocumentation {
Total ActionScript Errors: 1 Reported Errors: 1

Esse erro aparece porque a classe FlashPaper atual não define nenhum dos métodos
públicos que você definiu na interface IDocumentation.
8. Abra o arquivo de classe FlashPaper.as novamente e modifique o código ActionScript de
acordo com o seguinte código:
class FlashPaper implements IDocumentation {
private static var __version:String = "1,2,3,4";
public function downloadUpdates():Void {
};
public function checkForUpdates():Boolean {
return true;
};
public function searchHelp(keyword:String):Array {
return []
};
}

9. Salve as alterações no arquivo do ActionScript e clique em Check Syntax novamente.


Desta vez, nenhum erro é exibido no painel Output (Saída).
N OT A

Você pode adicionar ao arquivo de classe FlashPaper quantas variáveis ou métodos


estáticos, públicos ou privados desejar. O arquivo de interface define somente um
conjunto de métodos mínimos que devem aparecer em qualquer classe que
implemente essa interface.

10. Abra o documento de interface IDocumentation novamente e adicione a seguinte linha de


código em negrito (abaixo do método searchHelp()):
interface IDocumentation {
public function downloadUpdates():Void;
public function checkForUpdates():Boolean;
public function searchHelp(keyword:String):Array;
public function addComment(username:String, comment:String):Void;
}

11. Salve as alterações no arquivo de interface e reabra o documento FlashPaper.as.

Exemplo: Usando interfaces 341


12. Ao clicar no botão Check Syntax, você vê uma nova mensagem de erro no painel Output:
**Error** path\FlashPaper.as: Line 1: The class must implement method
'addComment' from interface 'IDocumentation'.
class FlashPaper implements IDocumentation {
Total ActionScript Errors: 1 Reported Errors: 1

O erro anterior aparece porque o arquivo de classe FlashPaper.as não define mais todas as
classes descritas no arquivo de interface. Para corrigir esse erro, adicione o método
addComment() à classe FlashPaper ou remova a definição do método do arquivo de
interface IDocumentation.
13. Adicione o seguinte método à classe FlashPaper:
public function addComment(username:String, comment:String):Void {
/* Envie parâmetros para a página do servidor, que insere um
comentário no banco de dados. */
}

14. Salve as alterações em FlashPaper.as e clique no botão Check Syntax; depois disso, você não
deverá receber mais erros.
Na seção anterior, você criou uma classe com base no arquivo de interface IDocumentation.
Nesta seção, você criará uma nova classe que também implementará a interface
IDocumentation, embora ela adicione alguns outros métodos e propriedades.
Este tutorial demonstra a utilidade de usar interfaces quando você deseja criar outra classe que
estenda a interface IDocumentation, pois será possível identificar facilmente os métodos
necessários na nova classe.

Exemplo: Criando uma interface


complexa
O exemplo a seguir mostra várias maneiras de definir e implementar interfaces. Neste tutorial,
você aprenderá a criar um arquivo de interface simples e uma classe que implemente várias
interfaces. Aprenderá também a fazer com que as interfaces estendam outras interfaces para
criar estruturas de dados mais complexas.

Para criar uma interface complexa:


1. Crie um novo documento do ActionScript e salve-o como InterfaceA.as.
2. Crie uma nova pasta chamada complexInterface e salve InterfaceA.as nesse diretório.
Salve todos os arquivos criados para este tutorial nesse diretório.

342 Interfaces
3. Em Interface.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: InterfaceA.as
interface InterfaceA {
public function k():Number;
public function n(z:Number):Number;
}

4. Salve o documento do ActionScript; em seguida, crie um novo documento do ActionScript


chamado ClassB.as e salve-o no diretório complexInterface.
ClassB.as implementa a interface InterfaceA criada anteriormente.
5. Em ClassB.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: ClassB.as
class ClassB implements InterfaceA {
public function k():Number {
return 25;
}
public function n(z:Number):Number {
return (z + 5);
}
}

6. Salve as alterações no documento ClassB.as; em seguida, crie um novo documento do Flash


e salve-o como classbTest.fla no diretório complexInterface.
Esse arquivo de classe testa a classe ClassB criada anteriormente.
7. Em classbTest.fla, digite o seguinte código ActionScript no Frame 1 (Quadro 1) da
Timeline (Linha de tempo):
// nome do arquivo: classbTest.fla
import ClassB;
var myB:ClassB = new ClassB();
trace(myB.k()); // 25
trace(myB.n(7)); // 12

8. Salve as alterações no documento do Flash e selecione Control (Controlar) > Test Movie
(Testar filme) para testar o documento.
O painel Output (Saída) exibe dois números, 25 e 12, que são os resultados dos métodos
k() e n() da classe ClassB.
9. Crie um novo arquivo do ActionScript e salve-o como ClassC.as no diretório
complexInterface.
Esse arquivo de classe implementa a interface InterfaceA criada na etapa 1.

Exemplo: Criando uma interface complexa 343


10. Em ClassC.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: ClassC.as
class ClassC implements InterfaceA {
public function k():Number {
return 25;
}
// **Erro** A classe também deve implementar o método 'n' da interface
'InterfaceA'.
}

Se você clicar no botão Check Syntax (Verificar sintaxe) referente ao arquivo de classe
ClassC, o Flash exibirá uma mensagem de erro no painel Output informando que a classe
atual deve implementar o método n() definido na interface InterfaceA. Ao criar classes
que implementam uma interface, é importante definir métodos para cada entrada da
interface.
11. Crie um novo documento do ActionScript e salve-o como InterfaceB.as no diretório
complexInterface.
12. Em InterfaceB.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: InterfaceB.as
interface InterfaceB {
public function o():Void;
}

13. Salve as alterações no documento InterfaceB.as; em seguida, crie um novo documento do


ActionScript e salve-o como classD.as no diretório complexInterface.
Essa classe implementa as interfaces InterfaceA e InterfaceB criadas em etapas anteriores. A
ClassD deve incluir implementações de cada um dos métodos listados em cada arquivo de
interface.
14. Em ClassD.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: ClassD.as
class ClassD implements InterfaceA, InterfaceB {
public function k():Number {
return 15;
}
public function n(z:Number):Number {
return (z * z);
}
public function o():Void {
trace("o");
}
}

344 Interfaces
15. Salve as alterações no arquivo ClassD.as; em seguida, crie um novo documento do Flash e
salve-o como classdTest.fla.
Esse documento do Flash testa a classe ClassD criada anteriormente.
16. Em classdTest.fla, adicione o seguinte código ActionScript ao Frame 1 da Timeline:
// nome do arquivo: classdTest.fla
import ClassD;
var myD:ClassD = new ClassD();
trace(myD.k()); // 15
trace(myD.n(7)); // 49
myD.o(); // o

17. Salve as alterações no arquivo classdTest.fla e selecione Control > Test Movie para testar o
arquivo.
Os valores 15, 49 e a letra o devem ser exibidos no painel Output. Esses valores são os
resultados dos métodos ClassD.k(), ClassD.n() e ClassD.o() respectivamente.
18. Crie um novo documento do ActionScript e salve-o como InterfaceC.as.
Essa interface estende a interface InterfaceA criada anteriormente e adiciona uma nova
definição de método.
19. Em InterfaceC.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: InterfaceC.as
interface InterfaceC extends InterfaceA {
public function p():Void;
}

20.Salve as alterações no arquivo do ActionScript; em seguida, crie um novo arquivo do


ActionScript e salve-o como ClassE.as no diretório complexInterface.
Essa classe implementa duas interfaces, InterfaceB e InterfaceC.
21. No arquivo ClassE.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: ClassE.as
class ClassE implements InterfaceB, InterfaceC {
public function k():Number {
return 15;
}
public function n(z:Number):Number {
return (z + 5);
}
public function o():Void {
trace("o");
}
public function p():Void {
trace("p");
}
}

Exemplo: Criando uma interface complexa 345


22.Salve as alterações no documento do ActionScript; em seguida, crie um novo documento
do Flash e salve-o como classeTest.fla no diretório complexInterface.
23.No arquivo classeTest.fla, digite o seguinte código ActionScript no Frame 1 da Timeline:
// nome do arquivo: classeTest.fla
import ClassE;
var myE:ClassE = new ClassE();
trace(myE.k()); // 15
trace(myE.n(7)); // 12
myE.o(); // o
myE.p(); // p

24.Salve o documento do Flash e selecione Control > Test Movie para testar o arquivo SWF.
Os valores 15, 12, o e p são exibidos no painel Output. Esses valores são retornados pelos
métodos ClassE.k(), ClassE.n(), ClassE.o() e ClassE.p(). Como a classe ClassE
implementou as interfaces InterfaceB e InterfaceC, cada método dos dois arquivos de
interface deve ser definido. Embora as interfaces InterfaceB e InterfaceC definam somente
os métodos o() e p(), a InterfaceC estende a InterfaceA. Isso significa que todos os
métodos definidos por ela, k() e n(), também devem ser implementados.

346 Interfaces
CAPÍTULO 10

Manipulando eventos 10
Eventos são ações que ocorrem enquanto um arquivo SWF é reproduzido. Um evento, como
um clique com o mouse ou um pressionamento de tecla, é chamado de evento do usuário, já
que é o resultado de uma interação direta com o usuário. Um evento gerado automaticamente
pelo Flash Player, como a aparência inicial de um clipe de filme no Stage (Palco), chama-se
evento do sistema, porque não é gerado diretamente pelo usuário.
Para que seu aplicativo reaja a eventos, você deve usar manipuladores de eventos, um código
ActionScript associado a um objeto e a um evento específicos. Por exemplo, quando um
usuário clicar em um botão no Stage (Palco), você poderá avançar a reprodução até o próximo
quadro. Ou, depois que um arquivo XML for carregado pela rede, o seu conteúdo poderá ser
exibido em um campo de texto.
Você pode manipular eventos no ActionScript de várias maneiras:
■ “Usando métodos manipuladores de eventos” na página 348
■ “Usando ouvintes de eventos” na página 351
■ “Usando manipuladores de eventos de botão e de clipe de filme” na página 355,
especificamente, %{on handler}% e %{onClipEvent handler}%.
■ “Transmitindo eventos de instâncias de componentes” na página 360
O uso de manipuladores de eventos com %{loadMovie (MovieClip.loadMovie method)}%
pode ser imprevisível. Se você anexar um manipulador de eventos a um botão usando on(),
ou se criar um manipulador dinâmico usando um método como %{onPress
(MovieClip.onPress handler)}% e, em seguida, chamar loadMovie(), o manipulador de
eventos não estará disponível depois que o novo conteúdo for carregado. Entretanto, se você
usar %{onClipEvent handler}% ou %{on handler}% para anexar um manipulador de eventos
a um clipe de filme e, em seguida, chamar loadMovie() nesse clipe, o manipulador de
eventos ainda estará disponível depois que o novo código for carregado.

347
Para obter mais informações sobre a manipulação de eventos, consulte as seguintes seções:
Usando métodos manipuladores de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .348
Usando ouvintes de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
Usando ouvintes de eventos com componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . .353
Usando manipuladores de eventos de botão e de clipe de filme. . . . . . . . . . . . . . .355
Transmitindo eventos de instâncias de componentes . . . . . . . . . . . . . . . . . . . . . . . 360
Criando clipes de filme com estados de botão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
Escopo do manipulador de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .362
Escopo da palavra-chave this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .365
Usando a classe Delegate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .366

Usando métodos manipuladores de


eventos
Um método manipulador de eventos é o método de uma classe que é chamado quando ocorre
um evento em uma instância dessa classe. Por exemplo, a classe MovieClip define um
manipulador de eventos onPress que é chamado sempre que o botão do mouse é pressionado
em um objeto de clipe de filme. Ao contrário de outros métodos de classe, porém, o
manipulador de eventos não é chamado diretamente; o Flash Player chama esse manipulador
automaticamente quando ocorre o evento apropriado.
As seguintes classes do ActionScript são exemplos de classes que definem manipuladores de
exemplos: Button, ContextMenu, ContextMenuItem, Key, LoadVars, LocalConnection,
Mouse, MovieClip, MovieClipLoader, Selection, SharedObject, Sound, Stage, TextField,
XML e XMLSocket. Para obter mais informações sobre os manipuladores de eventos
fornecidos por elas, consulte as entradas correspondentes a cada classe em ActionScript 2.0
Language Reference (Referência da linguagem ActionScript 2.0). A palavra handler é
adicionada ao título de cada manipulador de eventos.
Por padrão, os métodos manipuladores de eventos são indefinidos: quando ocorre um evento
específico, o manipulador correspondente é chamado, mas o aplicativo não responde mais ao
evento. Para que seu aplicativo responda ao evento, defina uma função com a instrução de
função e atribua essa função ao manipulador de eventos apropriado. A função atribuída ao
manipulador de eventos é chamada automaticamente sempre que o evento ocorre.

348 Manipulando eventos


Um manipulador de eventos consiste em três partes: o objeto ao qual se aplica o evento, o
nome do método manipulador de eventos do objeto e a função atribuída ao manipulador de
eventos. O exemplo a seguir mostra a estrutura básica de um manipulador de eventos:
object.eventMethod = function () {
// Insira seu código aqui em resposta ao evento.
}

Por exemplo, imagine que exista um botão chamado next_btn no Stage (Palco). O código a
seguir atribui uma função ao manipulador de eventos onPress do botão; essa função avança a
reprodução até o próximo quadro na linha de tempo atual:
next_btn.onPress = function () {
nextFrame();
}

Atribuindo uma referência de função No código anterior, a função nextFrame() é


atribuída diretamente a um manipulador de eventos onPress. Também é possível atribuir
uma referência de função (nome) a um método manipulador de eventos e, posteriormente,
definir a função, como mostra este exemplo:
// Atribua uma referência de função ao manipulador de eventos onPress do
botão.
next_btn.onPress = goNextFrame;

// Defina a função goNextFrame().


function goNextFrame() {
nextFrame();
}

No exemplo a seguir, observe que você atribui a referência da função, e não seu valor de
retorno, ao manipulador de eventos onPress:
// Incorreto!
next_btn.onPress = goNextFrame();
// Correto.
next_btn.onPress = goNextFrame;

Recebendo parâmetros passados Alguns manipuladores de eventos recebem parâmetros


passados com informações sobre o evento ocorrido. Por exemplo, o manipulador de eventos
TextField.onSetFocus é chamado quando uma instância de campo de texto ganha o foco
do teclado. Esse manipulador de eventos recebe uma referência ao objeto de campo de texto
que tinha o foco do teclado.

Usando métodos manipuladores de eventos 349


Por exemplo, o código a seguir insere um texto em um campo de texto que não tem mais o
foco do teclado:
this.createTextField("my_txt", 99, 10, 10, 200, 20);
my_txt.border = true;
my_txt.type = "input";
this.createTextField("myOther_txt", 100, 10, 50, 200, 20);
myOther_txt.border = true;
myOther_txt.type = "input";
myOther_txt.onSetFocus = function(my_txt:TextField) {
my_txt.text = "I just lost keyboard focus";
};

Manipuladores de eventos de objetos criados durante a execução Também é possível


atribuir funções a manipuladores de eventos de objetos criados durante a execução. Por
exemplo, o código a seguir cria uma nova instância de clipe de filme (newclip_mc) e atribui
uma função ao manipulador de eventos onPress do clipe.
this.attachMovie("symbolID", "newclip_mc", 10);
newclip_mc.onPress = function () {
trace("You pressed me");
}

Para obter mais informações, consulte “Criando clipes de filme durante a execução”
na página 378.
Substituindo métodos manipuladores de eventos A criação de uma classe que estenda
uma classe do ActionScript permite substituir os métodos manipuladores de eventos pelas
funções criadas. Você pode definir um manipulador de eventos em uma nova subclasse que
poderá ser reutilizada para diversos objetos, vinculando qualquer símbolo da biblioteca da
classe estendida à nova subclasse. O código a seguir substitui o manipulador de eventos
onPress da classe MovieClip por uma função que diminui a transparência do clipe de filme:
// Classe FadeAlpha – define a transparência quando você clica no clipe de
filme.
class FadeAlpha extends MovieClip {
function onPress() {
this._alpha -= 10;
}
}

Para obter instruções específicas sobre a extensão de uma classe do ActionScript e a vinculação
a um símbolo da biblioteca, consulte os exemplos fornecidos em “Atribuindo uma classe a
símbolos no Flash” na página 295. Para obter informações sobre a criação e o trabalho com
classes personalizadas, consulte Capítulo 7, “Classes.”

350 Manipulando eventos


Usando ouvintes de eventos
Os ouvintes de eventos permitem que um objeto, chamado objeto ouvinte, receba eventos
transmitidos por outro objeto, chamado objeto transmissor. O objeto transmissor registra o
objeto ouvinte para que receba eventos gerados por ele. Por exemplo, você pode registrar um
objeto de clipe de filme para que receba notificações onResize do Stage (Palco), ou uma
instância de botão pode receber notificações onChanged de um objeto de campo de texto. É
possível registrar vários objetos ouvintes, para que recebam eventos de um único transmissor, e
registrar um único objeto ouvinte, para que receba eventos de vários transmissores.
Diferentemente dos métodos manipuladores de eventos, o modelo de ouvinte/transmissor de
eventos permite que vários códigos ouçam o mesmo evento sem que haja conflito. Os modelos
de eventos que não usam o modelo de ouvinte/transmissor, como XML.onLoad(), podem
criar problemas quando vários códigos ouvem o mesmo evento; os diversos códigos entram
em conflito ao tentarem controlar essa referência única da função de retorno de chamada
XML.onLoad. Com o modelo de ouvinte/transmissor, é possível adicionar facilmente ouvintes
ao mesmo evento sem que haja gargalos de código.
As seguintes classes do ActionScript podem transmitir eventos: %{Key}%, %{Mouse}%,
%{MovieClipLoader}%, %{Selection}%, %{Stage}% e %{TextField}%. Para ver os ouvintes
disponíveis para uma classe, consulte a entrada correspondente a cada classe no ActionScript
2.0 Language Reference.
Para obter mais informações sobre ouvintes de eventos, consulte os seguintes tópicos:
■ “Modelo de ouvinte de evento” na página 351
■ “Exemplo de ouvinte de eventos” na página 352
A classe Stage podem transmitir eventos. É possível encontrar um arquivo de origem de
exemplo, stagesize.fla, na pasta Samples no disco rígido. Esse exemplo demonstra como a
propriedade Stage.scaleMode afeta os valores de Stage.width e Stage.height quando a
janela do navegador é redimensionada.
■ No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\StageSize.
■ No Macintosh, navegue até HD do Macintosh/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/StageSize.

Modelo de ouvinte de evento


O modelo de evento para ouvintes de eventos é semelhante ao de manipuladores de eventos
(consulte “Usando métodos manipuladores de eventos” na página 348), com duas diferenças
principais:

Usando ouvintes de eventos 351


■ O manipulador de eventos é atribuído ao objeto ouvinte, e não ao objeto que transmite o
evento.
■ Você chama um método especial do objeto transmissor, addListener(), que registra o
objeto ouvinte para receber seus eventos.
O código a seguir descreve o modelo de ouvinte de eventos:
var listenerObject:Object = new Object();
listenerObject.eventName = function(eventObj:Object) {
// Aqui entra o seu código
};
broadcasterObject.addListener(listenerObject);

O código inicia com um objeto, listenerObject, com a propriedade eventName. O objeto


ouvinte pode ser qualquer objeto, como uma instância de um objeto, clipe de filme ou botão
existente no Stage (Palco); ele também pode ser uma instância de uma classe do ActionScript.
Por exemplo, um clipe de filme personalizado poderia implementar os métodos ouvintes para
os ouvintes do Stage. Também poderia existir um objeto que ouvisse vários tipos de ouvintes.
A propriedade eventName é um evento que ocorre em broadcasterObject, o qual transmite
o evento para listenerObject. Você pode registrar vários ouvintes para um transmissor de
eventos.
Atribua uma função ao ouvinte de eventos que responda de alguma forma ao evento.
Finalmente, chame o método addListener() no objeto transmissor, passando para ele o
objeto ouvinte.
Para cancelar o registro de um objeto ouvinte para o recebimento de eventos, chame o método
removeEventListener() do objeto transmissor, passando para ele o nome do evento a ser
removido e do objeto ouvinte.
broadcasterObject.removeListener(listenerObject);

Exemplo de ouvinte de eventos


O exemplo a seguir mostra como usar o ouvinte de eventos onSetFocus na classe Selection
para criar um gerenciador de foco simples para um grupo de campos de texto de entrada.
Nesse caso, a borda do campo de texto que recebe o foco do teclado é ativada (exibida), e a
borda do campo de texto que perdeu o foco é desativada.

Para criar um gerenciador de foco simples com ouvintes de eventos:


1. Com a ferramenta Text (Texto), crie um campo de texto no Stage (Palco).
2. Selecione o campo de texto e, no inspetor Properties (Propriedades), selecione Input
(Entrada) no menu pop-up Text Type (Tipo de texto) e selecione a opção Show Border
Around Text (Mostrar borda em torno do texto).

352 Manipulando eventos


3. Crie outro campo de texto de entrada abaixo do primeiro.
Verifique se a opção Show Border Around Text não está selecionada para esse campo de
texto. Você pode continuar a criar os campos de texto de entrada.
4. Selecione Frame 1 (Quadro 1) na Timeline (Linha de tempo) e abra o painel Actions
(Ações), em Window (Janela) > Actions.
5. Para criar um objeto que ouça a notificação de foco da classe Selection, digite o seguinte
código no painel Actions:
// Cria um objeto ouvinte, focusListener.
var focusListener:Object = new Object();
// Define a função do objeto ouvinte.
focusListener.onSetFocus = function(oldFocus_txt:TextField,
newFocus_txt:TextField) {
oldFocus_txt.border = false;
newFocus_txt.border = true;
}

Esse código cria um objeto chamado focusListener que define a propriedade


onSetFocus e atribui uma função a ela. A função usa dois parâmetros: uma referência ao
campo de texto que perdeu o foco, e outra ao campo de texto que ganhou o foco. A função
define a propriedade border do campo de texto que perdeu o foco como false e a
propriedade border do campo de texto que ganhou o foco como true.
6. Para registrar o objeto focusListener para receber eventos do objeto Selection, adicione
o seguinte código ao painel Actions:
// Registra focusListener no transmissor.
Selection.addListener(focusListener);

7. Teste o aplicativo em Control (Controlar) > Test Movie (Testar filme), clique no primeiro
campo de texto e pressione a tecla Tab para alternar o foco entre os campos.

Usando ouvintes de eventos com


componentes
A sintaxe do ouvinte de eventos é ligeiramente diferente quando se trabalha com
componentes. Os componentes geram eventos que devem ser ouvidos por meio de um objeto
ouvinte ou de uma função personalizada.
O exemplo a seguir mostra como usar ouvintes de eventos para monitorar o andamento do
download de uma imagem carregada dinamicamente.

Usando ouvintes de eventos com componentes 353


Para ouvir eventos do componente Loader:
1. Arraste uma instância do componente Loader do painel Components (Componentes) para
o Stage (Palco).
2. Selecione o carregador e digite my_ldr na caixa de texto Instance Name (Nome da
instância) no inspetor Properties (Propriedades).
3. Adicione o código a seguir ao Frame 1 (Quadro 1) da Timeline (Linha de tempo) principal;
System.security.allowDomain("http://www.helpexamples.com");

var loaderListener:Object = new Object();


loaderListener.progress = function(evt_obj:Object):Void {
trace(evt_obj.type); // progress
trace("\t" + evt_obj.target.bytesLoaded + " of " +
evt_obj.target.bytesTotal + " bytes loaded");
}
loaderListener.complete = function(evt_obj:Object):Void {
trace(evt_obj.type); // complete
}

my_ldr.addEventListener("progress", loaderListener);
my_ldr.addEventListener("complete", loaderListener);
my_ldr.load("http://www.helpexamples.com/flash/images/image1.jpg");

Esse código ActionScript define um objeto ouvinte chamado loaderListener, que ouve
dois eventos: progress e complete. Quando cada um desses eventos for disparado, o
código correspondente será executado e o texto de depuração será exibido no painel
Output (Saída), se você testar o arquivo SWF na ferramenta de criação.
Em seguida, instrua a instância my_ldr a ouvir cada um dos dois eventos especificados
(progress e complete) e especifique a função ou o objeto ouvinte a ser executado quando
o evento é disparado. Finalmente, o método Loader.load() é chamado e ativa o
download da imagem.
4. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o arquivo SWF.
O download da imagem é feito na instância Loader no Stage, e várias mensagens são
exibidas no painel Output. Dependendo do tamanho da imagem para download, e se a
imagem tiver sido armazenada em cache no sistema local do usuário, o evento progress
poderá ser disparado várias vezes, enquanto o evento complete só será disparado depois
que o download da imagem tiver sido concluído.
Ao trabalhar com componentes e disparar eventos, você usará uma sintaxe ligeiramente
diferente daquelas mostradas nos exemplos anteriores para os ouvintes de eventos. A
principal diferença é que você deverá usar o método addEventListener() em vez de
chamar addListener(). Depois, especifique o evento que deseja ouvir bem como a
função ou o objeto ouvinte de eventos.

354 Manipulando eventos


Em vez de usar um objeto ouvinte, como no primeiro procedimento em “Usando ouvintes de
eventos com componentes” na página 353, é possível usar uma função personalizada. O
código do exemplo anterior poderia ser recriado da seguinte maneira:
System.security.allowDomain("http://www.helpexamples.com");

my_ldr.addEventListener("progress", progressListener);
my_ldr.addEventListener("complete", completeListener);
my_ldr.load("http://www.helpexamples.com/flash/images/image1.png");

function progressListener(evt_obj:Object):Void {
trace(evt_obj.type); // progress
trace("\t" + evt_obj.target.bytesLoaded + " of " +
evt_obj.target.bytesTotal + " bytes loaded");
}
function completeListener(evt_obj:Object):Void {
trace(evt_obj.type); // complete
}
N OT A

Nos exemplos anteriores, os ouvintes de eventos são sempre adicionados antes da


chamada do método Loader.load(). Se você chamar o método Loader.load() antes
de especificar os ouvintes de eventos, é possível que o carregamento seja concluído
antes da definição completa dos ouvintes. Isso significa que o conteúdo poderá ser
exibido, e o evento complete talvez não seja capturado.

Usando manipuladores de eventos de


botão e de clipe de filme
Você pode anexar manipuladores de eventos diretamente a uma instância de um botão ou
clipe de filme no Stage (Palco) usando os manipuladores de eventos onClipEvent() e on().
O manipulador onClipEvent() transmite eventos de clipes de filme, e o manipulador on()
manipula eventos de botões.
Para anexar um manipulador de eventos a uma instância de um botão ou de um clipe de
filme, clique na instância no Stage para colocá-la em foco e, em seguida, insira o código no
painel Actions (Ações). O título do painel Actions indica se o código será anexado ao botão ou
ao clipe de filme: Actions Panel - Button (Painel Ações - Botão) ou Actions Panel - Movie Clip
(Painel Ações - Clipe de filme). Para obter diretrizes sobre o uso de código anexado a
instâncias de botão ou de clipe de filme, consulte “Anexando código a objetos” na página 783.
N OT A

Não confunda manipuladores de eventos de botão e de clipe de filme com eventos de


componentes, como SimpleButton.click, UIObject.hide e UIObject.reveal, que
devem ser anexados a instâncias de componentes e são abordados em Using
Components (Usando componentes).

Usando manipuladores de eventos de botão e de clipe de filme 355


Você só pode anexar onClipEvent() e on() a instâncias de clipes de filme colocadas no Stage
durante a criação. Não é possível anexar onClipEvent() ou on() a instâncias de clipes de
filme criadas durante a execução (por exemplo, com o método attachMovie()). Para anexar
manipuladores de eventos a objetos criados durante a execução, use métodos manipuladores
de eventos ou ouvintes de eventos. (Consulte “Usando métodos manipuladores de eventos”
na página 348 e “Usando ouvintes de eventos” na página 351.)
NO TA

Anexar os manipuladores onClipEvent() e on() não é uma prática recomendada. Em vez


disso, coloque o código em scripts de quadro ou em um arquivo de classes, como
demonstrado neste manual. Para obter mais informações, consulte “Usando métodos
manipuladores de eventos” na página 348 e “Anexando código a objetos”
na página 783.

Para obter mais informações sobre manipuladores de eventos de botão e de clipe de filme,
consulte os seguintes tópicos:
■ “Usando on e onClipEvent com métodos manipuladores de eventos” na página 356
■ “Especificando eventos para os métodos on ou onClipEvent” na página 358
■ “Anexando ou atribuindo vários manipuladores a um objeto” na página 359

Usando on e onClipEvent com métodos


manipuladores de eventos
Em alguns casos, você poderá usar diversas técnicas para manipular eventos sem conflito. Não
há conflito entre o uso dos métodos on() e onClipEvent() e dos métodos manipuladores de
eventos definidos por você.
Por exemplo, suponha que um arquivo SWF contenha um botão; o botão pode ter um
manipulador on(press), que instrui o arquivo SWF a ser reproduzido, e pode ter um método
onPress(), para o qual você define uma função que instrui um objeto do Stage (Palco) a
girar. Quando você clica no botão, o arquivo SWF é reproduzido e o objeto gira. Dependendo
dos tipos de eventos que você deseja chamar e de quando eles serão chamados, é possível usar
os métodos on() e onClipEvent(), métodos manipuladores de eventos ou as duas técnicas de
manipulação de eventos.
Entretanto, o escopo de variáveis e objetos em manipuladores on() e onClipEvent() é
diferente daquele em manipuladores e ouvintes de eventos. Consulte “Escopo do manipulador
de eventos” na página 362.

356 Manipulando eventos


Use também on() com clipes de filme para criar clipes que recebem eventos de botão. Para
obter mais informações, consulte “Criando clipes de filme com estados de botão”
na página 361. Para obter informações sobre a especificação de eventos para on() e
onClipEvent(), consulte “Especificando eventos para os métodos on ou onClipEvent”
na página 358.

Para usar um manipulador on e um manipulador de eventos onPress:


1. Crie um novo documento do Flash e salve-o como handlers.fla.
2. Selecione a ferramenta Rectangle (Retângulo) e desenhe um quadrado grande no Stage.
3. Selecione a ferramenta Selection (Seleção), clique duas vezes no quadrado no Stage e
pressione F8 para acessar a caixa de diálogo Convert to Symbol (Converter em símbolo).
4. Digite o nome de um símbolo para a caixa, defina o tipo de clipe como Movie (Filme) e
clique em OK.
5. Atribua ao clipe de filme no Stage o nome de instância box_mc.
6. Adicione o ActionScript a seguir diretamente no símbolo do clipe de filme no Stage:
on(press){
trace("on (press) {...}");
}

7. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)


principal:
box_mc.onPress = function() {
trace("box_mc.onPress = function() {...};");
};

8. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
Quando você clica no símbolo do clipe de filme no Stage, a saída a seguir é enviada para o
painel Output:
on (press) {...}
box_mc.onPress = function() {...};
N OT A

Anexar os manipuladores onClipEvent() e on() não é uma prática recomendada. Em


vez disso, coloque o código em scripts de quadro ou em um arquivo de classes,
como demonstrado neste manual. Para obter mais informações, consulte “Usando
métodos manipuladores de eventos” na página 348 e “Anexando código a objetos”
na página 783.

Usando manipuladores de eventos de botão e de clipe de filme 357


Especificando eventos para os métodos on ou
onClipEvent
Para usar um manipulador on() ou onClipEvent(), anexe-o diretamente a uma instância de
um botão ou clipe de filme no Stage (Palco) e especifique o evento a ser manipulado para essa
instância. Para obter uma lista completa de eventos suportados pelos manipuladores de
eventos on() e onClipEvent(), consulte %{on handler}% e %{onClipEvent handler}% em
ActionScript 2.0 Language Reference.
Por exemplo, o manipulador de eventos on() a seguir é executado sempre que o usuário clica
no botão ao qual ele está anexado.
on (press) {
trace("Thanks for pressing me.");
}

É possível especificar dois ou mais eventos para cada manipulador on(), separados por
vírgulas. O ActionScript em um manipulador é executado quando um dos eventos
especificados pelo manipulador ocorre. Por exemplo, este manipulador on() anexado a um
botão é executado sempre que o mouse passa sobre o botão:
on (rollOver, rollOut) {
trace("You rolled over, or rolled out");
}

Também é possível adicionar eventos de pressionamento de tecla usando manipuladores on().


Por exemplo, o código a seguir rastreia uma seqüência de caracteres quando você pressiona o
número 3 no teclado. Selecione uma instância de botão ou de clipe de filme e adicione o
seguinte código ao painel Actions (Ações):
on (keyPress "3") {
trace("You pressed me");
}

Como alternativa, se quiser rastrear quando a tecla Enter é pressionada por um usuário, use o
formato de código a seguir. Selecione uma instância de botão ou de clipe de filme e adicione o
seguinte código ao painel Actions:
on (keyPress "<Enter>") {
trace("Enter Pressed");
}

358 Manipulando eventos


Selecione Control (Controlar) > Test Movie (Testar filme) e pressione a tecla Enter para ver a
seqüência de caracteres rastreada no painel Output (Saída). Se nenhuma seqüência for
rastreada, selecione Control > Disable Keyboard Shortcuts (Desativar atalhos de teclado) e
tente novamente. Para obter mais informações sobre a adição de interatividade de
pressionamento de tecla a aplicativos, consulte %{Key}%.
NO T A

Anexar os manipuladores onClipEvent() e on() não é uma prática recomendada. Em vez


disso, coloque o código em scripts de quadro ou em um arquivo de classes, como
demonstrado neste manual. Para obter mais informações, consulte “Usando métodos
manipuladores de eventos” na página 348 e “Anexando código a objetos”
na página 783.

Anexando ou atribuindo vários manipuladores a um


objeto
Você também poderá anexar mais de um manipulador a um objeto se desejar que scripts
diferentes sejam executados quando ocorrerem eventos distintos. Por exemplo, é possível
anexar os manipuladores onClipEvent() a seguir à mesma instância de clipe de filme. O
primeiro é executado quando o primeiro clipe de filme é carregado, ou quando aparece no
Stage (Palco); o segundo é executado quando o clipe de filme é descarregado do Stage.
on (press) {
this.unloadMovie()
}
onClipEvent (load) {
trace("I've loaded");
}
onClipEvent (unload) {
trace("I've unloaded");
}
N OT A

Anexar os manipuladores onClipEvent() e on() não é uma prática recomendada. Em vez


disso, coloque o código em scripts de quadro ou em um arquivo de classes, como
demonstrado neste manual. Para obter mais informações, consulte “Usando métodos
manipuladores de eventos” na página 348 e “Anexando código a objetos”
na página 783.

Para anexar vários manipuladores a um objeto usando o código colocado na Timeline (Linha
de tempo), consulte o exemplo a seguir. O código anexa os manipuladores onPress e
onRelease a uma instância de clipe de filme.

Usando manipuladores de eventos de botão e de clipe de filme 359


Para atribuir vários manipuladores a um objeto:
1. Crie um novo documento do Flash e atribua o nome assignMulti.fla a ele.
2. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e adicione o seguinte
código ao painel Actions (Ações):
this.createEmptyMovieClip("img_mc", 10);
var mclListener:Object = new Object();
mclListener.onLoadInit = function(target_mc:MovieClip) {
target_mc.onPress = function() {
target_mc.startDrag();
};
target_mc.onRelease = function() {
target_mc.stopDrag();
};
}
mclListener.onLoadError = function(target_mc:MovieClip) {
trace("error downloading image");
}
var img_mcl:MovieClipLoader = new MovieClipLoader();
img_mcl.addListener(mclListener);
img_mcl.loadClip("http://www.helpexamples.com/flash/images/image1.jpg",
img_mc);

3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento.
A imagem é carregada na instância img_mc e os manipuladores de eventos onPress() e
onRelease() permitem arrastá-la pelo Stage (Palco).

Transmitindo eventos de instâncias de


componentes
Para qualquer instância de componente, é possível especificar como um evento é manipulado.
Os eventos de componentes são manipulados de maneira diferente dos eventos transmitidos
por objetos nativos do ActionScript.
Para obter mais informações, consulte “Handling Component Events” em Using Components
(Usando componentes).

360 Manipulando eventos


Criando clipes de filme com estados de
botão
Quando você anexa um manipulador on() a um clipe de filme ou atribui uma função a um
dos manipuladores de eventos de mouse MovieClip para uma instância de clipe de filme, o
clipe responde aos eventos do mouse da mesma forma que um botão. Também é possível criar
estados de botão automáticos (Up, Over e Down) em um clipe de filme adicionando os
rótulos de quadro _up, _over e _down à Timeline (Linha de tempo) do clipe de filme.
Quando o usuário move o mouse sobre o clipe de filme ou clica nele, a reprodução é enviada
para o quadro com o rótulo de quadro apropriado. Para designar a área sensível utilizada por
um clipe de filme, use a propriedade %{hitArea (MovieClip.hitArea property)}%.

Para criar estados de botão em um clipe de filme:


1. Crie um novo documento do Flash e salve-o como mcbutton.fla.
2. Com a ferramenta Rectangle (Retângulo), desenhe um pequeno retângulo (de cerca de 100
pixels de largura por 20 pixels de altura) no Stage (Palco).
3. Clique duas vezes na forma com a ferramenta Selection (Seleção) e pressione F8 para acessar
a caixa de diálogo Convert to Symbol (Converter em símbolo).
4. Digite o nome de símbolo mcbutton, defina o tipo de símbolo para o clipe de filme e clique
em OK.
5. Clique duas vezes no símbolo do clipe de filme no Stage para alternar para o modo de
edição de símbolo.
6. Crie uma nova camada na Timeline (Linha de tempo) do clipe de filme e atribua a ela o
nome labels.
7. Digite o rótulo de quadro _up no inspetor Property (Propriedade).
8. Crie uma nova camada acima da camada padrão e da camada labels.
9. Renomeie a nova camada actions e adicione o ActionScript a seguir ao Frame 1 (Quadro
1) da Timeline do clipe de filme:
stop();

10. Selecione Frame 10, todas as três camadas e Insert (Inserir) > Timeline > Keyframe
(Quadro-chave).
11. Adicione a ação stop() ao Frame 10 da camada actions e o rótulo de quadro _over ao
Frame 10 da camada labels.
12. Selecione o retângulo no Frame 10 e use o inspetor Property para selecionar outra cor de
preenchimento.

Criando clipes de filme com estados de botão 361


13. Crie novos quadros-chave no Frame 20 de cada uma das três camadas e adicione o rótulo
de quadro _down no inspetor Property.
14. Modifique a cor do retângulo no Frame 20 para que cada estado dos três botões tenha uma
cor diferente.
15. Retorne à Timeline principal.
16. Para fazer com que o clipe de filme responda a eventos do mouse, siga um destes
procedimentos:
■ Anexe um manipulador de eventos on() à instância de clipe de filme, como abordado
em “Usando manipuladores de eventos de botão e de clipe de filme” na página 355.
■ Atribua uma função a um dos manipuladores de eventos de mouse do objeto de clipe
de filme (onPress, onRelease etc.), conforme analisado em “Usando métodos
manipuladores de eventos” na página 348.
17. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
Quando você move o ponteiro do mouse sobre a instância do clipe de filme no Stage, o
estado do clipe é alterado automaticamente para _over. Quando você clica na instância do
clipe de filme, a reprodução é alterada automaticamente para o estado _down do clipe de
filme.

Escopo do manipulador de eventos


O escopo, ou contexto, de variáveis e comandos que você declara e executa em um
manipulador de eventos depende do tipo de manipulador utilizado: manipuladores de eventos
ou ouvintes de eventos, ou manipuladores on() e onClipEvent(). Se você estiver definindo
um manipulador de eventos em uma nova classe do ActionScript, o escopo também
dependerá de como o manipulador de eventos é definido. Esta seção contém exemplos do
ActionScript 1.0 e do ActionScript 2.0.
Exemplos do ActionScript 1.0 As funções atribuídas a métodos manipuladores de eventos e
ouvintes de eventos (como todas as funções do ActionScript criadas por você) definem o
escopo de uma variável local, mas os manipuladores on() e onClipEvent() não fazem isso.
Por exemplo, considere os dois manipuladores de eventos a seguir. O primeiro é um
manipulador de eventos onPress associado a um clipe de filme chamado clip_mc. O
segundo é um manipulador on() anexado à mesma instância de clipe de filme.
// Anexado à Timeline do clipe pai de clip_mc:
clip_mc.onPress = function () {
var shoeColor; // variável de função local
shoeColor = "blue";

362 Manipulando eventos


}
// manipulador on() anexado a clip_mc:
on (press) {
var shoeColor; // sem escopo de variável local
shoeColor = "blue";
}

Embora contenham o mesmo código, os dois manipuladores de eventos produzem resultados


diferentes. No primeiro caso, a variável color é local para a função definida para onPress. No
segundo caso, como o manipulador on() não define um escopo de variável local, a variável é
definida no escopo da Timeline (Linha de tempo) do clipe de filme clip_mc.
Para manipuladores de eventos on() anexados a botões, e não a clipes de filme, as variáveis
(bem como as chamadas de funções e métodos) são chamadas no escopo da Timeline que
contém a instância do botão.
Por exemplo, o manipulador de eventos on() a seguir produzirá resultados diferentes,
dependendo de sua anexação a um objeto de clipe de filme ou de botão. No primeiro caso, a
chamada da função play() inicia a reprodução da Timeline que contém o botão; no segundo
caso, a chamada da mesma função inicia a Timeline do clipe de filme ao qual o manipulador
está anexado.
// Anexado ao botão.
on (press) {
play(); // Reproduz a timeline mãe.
}
// Anexado ao clipe de filme.
on (press) {
play(); // Reproduz a timeline do clipe de filme.
}

Quando anexada a um objeto de botão, a função play() aplica-se à Timeline que contém o
botão, isto é, à Timeline mãe do botão. Entretanto, quando o manipulador on(press) estiver
anexado a um objeto de clipe de filme, a chamada da função play() se aplicará ao clipe de
filme que utiliza o manipulador. Se o código a seguir for anexado a um clipe de filme, a
Timeline mãe será reproduzida:
// Anexado ao clipe de filme.
on (press) {
_parent.play(); // Reproduz a timeline mãe.
}

Em uma definição de manipulador de eventos ou de ouvinte de eventos, a mesma função


play() se aplica à Timeline que contém a definição da função. Por exemplo, suponha que
você declare o método manipulador de eventos my_mc.onPress a seguir na Timeline que
contém a instância de clipe de filme my_mc:

Escopo do manipulador de eventos 363


// Função definida em uma timeline
my_mc.onPress = function () {
play(); // Reproduz a timeline onde ela está definida.
};

Para reproduzir o clipe de filme que define o manipulador de eventos onPress, faça referência
explicitamente ao clipe usando a palavra-chave this, desta forma:
// Função definida na timeline raiz
my_mc.onPress = function () {
this.play(); // reproduz a timeline de my_mc clip.
};

Entretanto, o mesmo código colocado na Timeline raiz de uma instância de botão


reproduziria a Timeline raiz:
my_btn.onPress = function () {
this.play(); // reproduz a timeline raiz
};

Para obter mais informações sobre o escopo da palavra-chave this em manipuladores de


eventos, consulte “Escopo da palavra-chave this” na página 365.
Exemplo do ActionScript 2.0 A classe TextLoader a seguir é usada para carregar um
arquivo de texto e exibir um texto após carregar o arquivo com êxito.
// TextLoader.as
class TextLoader {
private var params_lv:LoadVars;
public function TextLoader() {
params_lv = new LoadVars();
params_lv.onLoad = onLoadVarsDone;
params_lv.load("http://www.helpexamples.com/flash/params.txt");
}
private function onLoadVarsDone(success:Boolean):Void {
_level0.createTextField("my_txt", 999, 0, 0, 100, 20);
_level0.my_txt.autoSize = "left";
_level0.my_txt.text = params_lv.monthNames; // undefined
}
}

364 Manipulando eventos


Esse código não funciona corretamente, pois há um problema envolvendo o escopo dos
manipuladores de eventos e não está claro se a palavra-chave this faz referência à classe ou ao
manipulador de eventos onLoad. O comportamento esperado nesse exemplo é que o método
onLoadVarsDone() seja chamado no escopo do objeto TextLoader; porém, ele é chamado no
escopo do objeto LoadVars porque o método foi extraído do objeto TextLoader e inserido no
objeto LoadVars. Em seguida, o objeto LoadVars chama o manipulador de eventos
this.onLoad depois que o arquivo de texto é carregado, e a função onLoadVarsDone() é
chamada com a palavra-chave this definida como LoadVars, e não como TextLoader. O
objeto params_lv reside no escopo dessa palavra-chave quando chamado, embora a função
onLoadVarsDone() dependa desse objeto por referência. Portanto, a função
onLoadVarsDone() espera uma instância params_lv.params_lv que não existe.
Para chamar corretamente o método onLoadVarsDone() no escopo do objeto TextLoader,
use a seguinte estratégia: use um literal de função para criar uma função anônima que chame a
função desejada. O objeto owner ainda está visível no escopo da função anônima e, portanto,
pode ser usado para localizar o objeto TextLoader que está fazendo a chamada.
// TextLoader.as
class TextLoader {
private var params_lv:LoadVars;
public function TextLoader() {
params_lv = new LoadVars();
var owner:TextLoader = this;
params_lv.onLoad = function (success:Boolean):Void {
owner.onLoadVarsDone(success);
}
params_lv.load("http://www.helpexamples.com/flash/params.txt");
}
private function onLoadVarsDone(success:Boolean):Void {
_level0.createTextField("my_txt", 999, 0, 0, 100, 20);
_level0.my_txt.autoSize = "left";
_level0.my_txt.text = params_lv.monthNames; //
janeiro,fevereiro,março,...
}
}

Escopo da palavra-chave this


A palavra-chave this refere-se ao objeto do escopo em execução no momento. Dependendo
do tipo de técnica de manipulação de eventos usada, this poderá se referir a objetos
diferentes.
Em uma função de manipulador de eventos ou de ouvinte de eventos, this refere-se ao
objeto que define o método manipulador de eventos ou ouvinte de eventos. Por exemplo, no
código a seguir, this refere-se a my_mc:

Escopo da palavra-chave this 365


// Manipulador de eventos onPress() anexado à timeline principal:
my_mc.onPress = function () {
trace(this); // _level0.my_mc
}

Em um manipulador on() anexado a um clipe de filme, this refere-se ao clipe de filme ao


qual o manipulador on() está anexado, como mostra o código a seguir:
// Anexado ao clipe de filme my_mc na timeline principal
on (press) {
trace(this); // _level0.my_mc
}

Em um manipulador on() anexado a um botão, this refere-se à Timeline que contém o


botão, como mostra o seguinte código:
// Anexado ao botão na timeline principal
on (press) {
trace(this); // _level0
}

Usando a classe Delegate


A classe Delegate permite executar uma função em um escopo específico. Essa classe é
fornecida para disparar o mesmo evento em duas funções diferentes, consulte “Delegating
events to functions” em Using Components (Usando componentes), e para chamar funções no
escopo da classe em que está contida.
Quando você passa uma função como um parâmetro para
EventDispatcher.addEventListener(), a função é chamada no escopo da instância do
componente transmissor, e não no objeto em que ela está declarada. Consulte “Delegating the
scope of a function” in Using Components (Usando componentes). É possível usar
Delegate.create() para chamar a função dentro do escopo do objeto declarante.

O exemplo a seguir mostra os três métodos de audição de eventos de uma instância do


componente Button. Dependendo da forma como você adiciona ouvintes de eventos a uma
instância do componente Button, o evento é disparado em um escopo diferente.

Para usar a classe Delegate para ouvir eventos:


1. Crie um novo documento do Flash e salve-o como delegate.fla.
2. Arraste um componente Button da pasta User Interface do painel Components
(Componentes) para a biblioteca.
Adicione e posicione a instância do botão no Stage (Palco) usando ActionScript em uma
etapa posterior.

366 Manipulando eventos


3. Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
import mx.controls.Button;
import mx.utils.Delegate;

function clickHandler(eventObj:Object):Void {
trace("[" + eventObj.type + "] event on " + eventObj.target + "
instance.");
trace("\t this -> " + this);
}

var buttonListener:Object = new Object();


buttonListener.click = function(eventObj:Object):Void {
trace("[" + eventObj.type + "] event on " + eventObj.target + "
instance.");
trace("\t this -> " + this);
};

this.createClassObject(Button, "one_button", 10, {label:"One"});


one_button.move(10, 10);
one_button.addEventListener("click", clickHandler);

this.createClassObject(Button, "two_button", 20, {label:"Two"});


two_button.move(120, 10);
two_button.addEventListener("click", buttonListener);

this.createClassObject(Button, "three_button", 30, {label:"Three"});


three_button.move(230, 10);
three_button.addEventListener("click", Delegate.create(this,
clickHandler));

O código anterior é dividido em seis seções (separadas por uma linha em branco). A
primeira seção importa a classe Button (para o componente Button) e a classe Delegate. A
segunda seção do código define uma função chamada quando o usuário clica em alguns
dos botões. A terceira seção do código cria um objeto usado como um ouvinte de evento e
o objeto ouve um único evento, click.
As três seções restantes do código criam uma nova instância do componente Button no
Stage, reposicionam a instância e adicionam um ouvite de evento para o evento click. O
primeiro botão adiciona um ouvinte para o evento click e passa uma referência
diretamente a uma função manipuladora click. O segundo botão adiciona um ouvinte
para o evento click e passa uma referência para um objeto ouvinte, que contém um
manipulador para esse evento. Por fim, a terceira função adiciona um ouvinte para o
evento click, usa a classe Delegate para disparar esse evento no escopo this (em que
this equivale a _level0) e passa uma referência para a função manipuladora click.

Usando a classe Delegate 367


4. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
5. Clique em cada instância do botão no Stage para ver o escopo em que o evento é
manipulado.
a. Clique no primeiro botão no Stage para rastrear o texto a seguir no painel Output
(Saída):
[click] event on _level0.one_button instance.
this -> _level0.one_button

Quando você clica na instância one_button, o escopo this faz referência à própria
instância do botão.
b. Clique no segundo botão no Stage para rastrear o texto a seguir no painel Output:
[click] event on _level0.two_button instance.
this -> [object Object]

Quando voc