Princípios básicos do ActionScript para desenvolvedores de JavaScript

O Adobe® ActionScript® 3.0 é uma linguagem de programação como JavaScript, ambas baseadas em ECMAScript. O ActionScript 3.0 foi liberado com o Adobe® Flash® Player 9, e você pode, portanto, desenvolver aplicativos elaborados para Internet com ele no Adobe® Flash® CS3 Professional, Adobe® Flash® CS4 Professional e Adobe® Flex™ 3.

A versão atual do ActionScript 3.0 estava disponível quando se desenvolveu o conteúdo SWF para Flash Player 9 no navegador. Agora também está disponível para desenvolver conteúdo SWF no Adobe® AIR®.

A Referência API do Adobe AIR para desenvolvedores de HTML inclui documentação para essas classes que são úteis no código JavaScript em um aplicativo baseado em HTML. Trata-se de um subconjunto do conjunto inteiro de classes no tempo de execução. Outras classes no tempo de execução são úteis para desenvolver aplicativos baseados em SWF (a classe DisplayObject, por exemplo, que define a estrutura do conteúdo visual). Se você precisar usar essas classes em JavaScript, consulte a documentação seguinte de ActionScript:

Diferenças entre ActionScript e JavaScript: panorama

ActionScript, como JavaScript, se baseia na especificação da linguagem ECMAScript; portanto, as duas linguagens têm uma sintaxe central comum. Por exemplo, o código a seguir funciona igual no JavaScript e no ActionScript:

var str1 = "hello"; 
var str2 = " world."; 
var str = reverseString(str1 + str2); 
     
function reverseString(s) { 
    var newString = ""; 
    var i; 
    for (i = s.length - 1; i >= 0; i--) { 
        newString += s.charAt(i); 
    } 
    return newString; 
}

No entanto, há diferenças na sintaxe e no funcionamento das duas linguagens. Por exemplo, o exemplo de código precedente pode ser escrito da seguinte forma no ActionScript 3.0 (em um arquivo SWF):

function reverseString(s:String):String { 
    var newString:String = ""; 
    for (var i:int = s.length - 1; i >= 0; i--) { 
        newString += s.charAt(i); 
    } 
    return newString; 
}

A versão do JavaScript suportada no conteúdo HTML no Adobe AIR é JavaScript 1.7. As diferenças entre JavaScript 1.7 e ActionScript 3.0 são descrits em todo este tópico.

O tempo de execução inclui algumas classes incorporadas que fornecem recursos avançados. No tempo de execução, JavaScript em uma página HTML pode acessar essas classes. As mesmas classes do tempo de execução estão disponíveis para ActionScript (em um arquivo SWF) e JavaScript (em um arquivo HMTL que é executado em um navegador). No entanto, a documentação atual da API para essas classes (que não estão incluídas na Referência API do Adobe AIR para desenvolvedores de HTML) as descreve usando a sintaxe de ActionScript. Em outras palavras, para alguns dos recursos avançados do tempo de execução, consulte a Referência do AdobScript 3.0 para Adobe Flash Platform. Compreender os princípios básicos de ActionScript o ajuda a entender como usar essas classes de tempo de execução em JavaScript.

Por exemplo, o seguinte código de JavaScript reproduz o som de um arquivo MP3:

var file = air.File.userDirectory.resolve("My Music/test.mp3"); 
var sound = air.Sound(file); 
sound.play();

Cada uma dessas linhas de código chama a funcionalidade do tempo de execução de JavaScript.

Em um arquivo SWF, o código de ActionScript pode acessar esses recursos de tempo de execução como no código a seguir:

var file:File = File.userDirectory.resolve("My Music/test.mp3"); 
var sound = new Sound(file); 
sound.play();

Tipos de dados de ActionScript 3.0

ActionScript 3.0 é uma linguagem fortemente tipada. Significa que você pode atribuir um tipo de dado a uma variável. Por exemplo, a primeira linha do exemplo anterior poderia ser escrita da seguinte forma:

var str1:String = "hello";

Aqui, a variável str1 é declarada como do tipo String. Todas as atribuições subsequentes da variável str1 atribuem à variável os valores String.

Você pode atribuir tipos às variáveis, parâmetros de funções e retornar os tipos de funções. Portanto, a declaração de função no exemplo anterior se parece com o seguinte no ActionScript:

function reverseString(s:String):String { 
       var newString:String = ""; 
       for (var i:int = s.length - 1; i >= 0; i--) { 
           newString += s.charAt(i); 
       } 
       return newString; 
}
Nota: O parâmetro s e o valor de retorno da função são atribuídos ao tipo String.

Embora a atribuição de tipos seja opcional no ActionScript, há vantagens em declarar os tipos para objetos:

  • Objetos digitados permitem a verificação de tipos de dados em tempo de execução e em tempo de compilação se você usar o modo estrito. A verificação de tipos em tempo de compilação ajuda a identificar erros. (O modo estrito é uma opção do compilador.)

  • Usar objetos tipados cria aplicativos que são mais eficientes.

    Por essa razão, os exemplos na documentação do ActionScript usa tipos de dados. Em geral, você pode converter o código de amostragem de ActionScript para JavaScript simplesmente removendo as instruções de tipo (como ":String").

Tipos de dados que correspondem às classes personalizadas

Um objeto ActionScript 3.0 pode ter um tipo de dados que corresponde às classes de nível superior, como String, Number ou Date.

No ActionScript 3.0, você pode definir as classes personalizadas. Cada classe personalizada também define um tipo de dados. Isso significa que uma variável de ActionScript, um parâmetro de função ou um retorno de função pode ter uma anotação de tipo definida por essa classe. Para obter mais informações, consulte Classes personalizadas do ActionScript 3.0.

O tipo de dados void

O tipo de dado void é usado como valor de retorno para uma função que, de fato, não retorna nenhum valor. (Uma função que não inclui uma instrução return não retorna nenhum valor.)

O tipo de dados *

Usar o caractere de asterisco (*) como tipo de dados é o mesmo que não atribuir um tipo de dados. Por exemplo, a função a seguir inclui um parâmetro, n, e um valor de retorno; ambos não recebem um tipo de dados:

function exampleFunction(n:*):* { 
       trace("hi, " + n); 
}

O uso do * como tipo de dados não está definindo um tipo de dados. Você usa o asterisco no código do ActionScript 3.0 para ser explícito de que nenhum tipo de dados é definido.

Classes, pacotes e espaços de nome do ActionScript 3.0

O ActionScript 3.0 inclui os recursos relacionados às classes que não são encontradas no JavaScript 1.7.

Classes de tempo de execução

O tempo de execução inclui classes incorporadas, e muitas delas também são incluídas no JavaScript padrão, como as classes Array, Date, Math e String (e outras). No entanto, o tempo de execução também inclui classes que não são encontradas no JavaScript padrão. Essas classes adicionais têm diversos usos, que vão de reproduzir mídias interativas (como sons) a interagir com soquetes.

A maioria das classes de tempo de execução no pacote flash ou um dos pacotes contidos no pacote flash. Os pacotes são uma forma de organizar as classes do ActionScript 3.0 (consulte os Pacotes do ActionScript 3.0).

Classes personalizadas do ActionScript 3.0

O ActionScript 3.0 permite que os desenvolvedores criem suas próprias classes personalizadas. Por exemplo, o código a seguir define uma classe personalizada chamada ExampleClass:

public class ExampleClass { 
    public var x:Number; 
    public function ExampleClass(input:Number):void { 
        x = input; 
    } 
    public function greet():void { 
        trace("The value of x is: ", x); 
    } 
}

Essa classe tem os seguintes membros:

  • Um método construtor, ExampleClass(), que lhe permite instanciar novos objetos do tipo ExampleClass.

  • Uma propriedade pública, x (do tipo Number), que você pode obter e definir para objetos do tipo ExampleClass.

  • Um método público, greet(), com o qual você pode chamar objetos do tipo ExampleClass.

    Nesse exemplo, a propriedade x e o método greet() estão no espaço para nomes public. O espaço para nomes public torna os métodos e as propriedades acessíveis a partir de objetos e classes que estão fora da classe.

Pacotes do ActionScript 3.0

Os pacotes fornecem os meios de organizar as classes do ActionScript 3.0. Por exemplo, muitas classes relacionadas ao funcionamento com arquivos e diretórios no computador estão incluídas no pacote flash.filesystem. Neste caso, o flash é um pacote que contém outro pacote, filesystem. E esse pacote pode conter outras classes ou pacotes. Na verdade, o pacote flash.filesystem contém as seguintes classes: File, FileMode e FileStream. Para fazer referência à classe File no ActionScript, você pode escrever o seguinte:

flash.filesystem.File

As classes incorporadas e personalizadas podem ser organizadas em pacotes.

Ao fazer referência a um pacote do ActionScript a partir de JavaScript, use o objeto especial runtime. Por exemplo, o código a seguir instancia um novo objeto File do ActionScript no JavaScript:

var myFile = new air.flash.filesystem.File();

Aqui, o método File() é a função construtora que corresponde à classe do mesmo nome (File).

Espaços de nome do ActionScript 3.0

No ActionScript 3.0, os espaços de nome definem o escopo para o qual as propriedades e as funções nas classes podem ser acessadas.

Apenas essas propriedades e métodos no espaço de nome public estão disponíveis em JavaScript.

Por exemplo, a classe File (no pacote flash.filesystem) inclui as propriedades e métodos public, tais como userDirectory e resolve(). Ambas estão disponíveis como propriedades de uma variável de JavaScript que instancia um objeto File (através do método construtor runtime.flash.filesystem.File()).

Há quatro espaços de nome predefinidos:

Namespace

Descrição

public

Qualquer código que instancia um objeto de um certo tipo pode acessar as propriedades e métodos públicos na classe que define esse tipo. Além disso, qualquer código pode acessar as propriedades e métodos estáticos públicos e uma classe pública.

private

As propriedades e métodos designados como privados só estão disponíveis para código dentro da classe. Elas não podem ser acessadas como propriedades ou métodos de um objeto definido por essa classe. As propriedades e métodos no espaço de nome privado não estão disponíveis no JavaScript.

protected

As propriedades e métodos designados como protegidos só estão disponíveis para códigos na definição de classe e nas classes que herdam essa classe. As propriedades e métodos no espaço de nome protegido não estão disponíveis no JavaScript.

internal

As propriedades e métodos designados como internos estão disponíveis para qualquer chamador no mesmo pacote. As classes, propriedades e métodos pertencem ao espaço de nome interno por padrão.

Além disso, as classes personalizadas podem usar outros espaços de nome que não estão disponíveis ao código de JavaScript.

Parâmetros obrigatórios e valores padrão nas funções de ActionScript 3.0

No ActionScript 3.0 e no JavaScript, as funções podem incluir parâmetros. No ActionScript 3.0, os parâmetros podem ser obrigatórios ou opcionais, ao passo que, em JavaScript, os parâmetros são sempre opcionais.

O seguinte código de ActionScript 3.0 define uma função para a qual um parâmetro, n, é obrigatório:

function cube(n:Number):Number { 
    return n*n*n; 
}

O código do ActionScript 3.0 a seguir define uma função para a qual é necessário o parâmetro n. Também inclui o parâmetro p, que é opcional, com o valor padrão 1:

function root(n:Number, p:Number = 1):Number { 
    return Math.pow(n, 1/p); 
}

Uma função de ActionScript 3.0 também pode receber qualquer número de argumentos, representados pela sintaxe ...rest no final de uma lista de parâmetros, como no seguinte:

function average(... args) : Number{ 
    var sum:Number = 0; 
    for (var i:int = 0; i < args.length; i++) { 
        sum += args[i]; 
    } 
    return (sum / args.length); 
}

Ouvintes de eventos de ActionScript 3.0

Na programação de ActionScript 3.0, todos os eventos são tratados com ouvintes de evento. O ouvinte de evento é uma função. Quando um objeto despacha um evento, o ouvinte responde a esse evento. O evento, que é um objeto ActionScript, é passado ao ouvinte do evento como um parâmetro da função. Esse uso do objeto de eventos difere do modelo de evento DOM usado no JavaScript.

Por exemplo, quando você chama o método load() de um objeto Som (para carregar um arquivo mp3), o objeto Som tenta carregar o som. Em seguida, o objeto Som envia um dos seguintes eventos:

Evento

Descrição

complete

Quando os dados foram carregados com sucesso.

id3

Quando dados ID3 mp3 estiverem disponíveis.

ioError

Quando ocorre um erro de entrada/saída que faz com que haja falha na operação de carga.

open

Quando tem início a operação de carga.

progress

Quando os dados são recebidos à medida que a operação de carga avança.

Qualquer classe que pode despachar eventos ou estende a classe EventDispatcher ou implementa a classe IEventDispatcher. (Uma interface do ActionScript 3.0 é o tipo de dados usado para definir um conjunto de métodos que uma classe pode implementar.) Em cada listagem de classe para essas classes na Referência do ActionScript® 3.0 para Adobe Flash® Professional CS5, há uma lista de eventos que a classe pode despachar.

Você pode registar uma função de ouvinte de evento para lidar com qualquer um desses eventos, usando o método addEventListener() do objeto que despacha o evento. Por exemplo, no caso de um objeto Sound, você pode se registrar para os eventos progress e complete, como mostrados no código a seguir de ActionScript:

var sound:Sound = new Sound(); 
var urlReq:URLRequest = new URLRequest("test.mp3"); 
sound.load(urlReq); 
sound.addEventListener(ProgressEvent.PROGRESS, progressHandler); 
sound.addEventListener(Event.COMPLETE, completeHandler); 
 
function progressHandler(progressEvent):void { 
      trace("Progress " + progressEvent.bytesTotal + " bytes out of " + progressEvent.bytesTotal); 
} 
 
function completeHandler(completeEvent):void { 
      trace("Sound loaded."); 
}

No conteúdo HTML executado no AIR, você pode registrar uma função do JavaScript como o ouvinte de eventos. O código a seguir ilustra isso. (Este código pressupõe que o documento HTML inclui um objeto TextArea chamado progressTextArea.)

var sound = new runtime.flash.media.Sound(); 
var urlReq = new runtime.flash.net.URLRequest("test.mp3"); 
sound.load(urlReq); 
sound.addEventListener(runtime.flash.events.ProgressEvent.PROGRESS, progressHandler); 
sound.addEventListener(runtime.flash.events.Event.COMPLETE, completeHandler); 
 
function progressHandler(progressEvent) { 
      document.progressTextArea.value += "Progress " + progressEvent.bytesTotal + " bytes out of " + progressEvent.bytesTotal; 
} 
 
function completeHandler(completeEvent) { 
      document.progressTextArea.value += "Sound loaded.";