Sintaxe

O ActionScript 3.0 é uma linguagem que diferencia maiúsculas e minúsculas. Os identificadores que diferem somente em maiúsculas e minúsculas são considerados identificadores diferentes. Por exemplo, o código a seguir cria duas variáveis diferentes:

var num1:int; 
var Num1:int;

O operador dot ( . ) fornece uma maneira de acessar as propriedades e os métodos de um objeto. Com o uso da sintaxe de pontos, é possível fazer referência a uma propriedade ou um método de classe usando um nome de ocorrência, seguido do operador dot e do nome da propriedade ou do método. Por exemplo, considere a seguinte definição de classe:

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

Com o uso da sintaxe de pontos, é possível acessar a propriedade prop1 e o método method1() usando o nome da instância criado no seguinte código:

var myDotEx:DotExample = new DotExample(); 
myDotEx.prop1 = "hello"; 
myDotEx.method1();

É possível usar a sintaxe de pontos para definir pacotes. O operador dot é usado para fazer referência a pacotes aninhados. Por exemplo, a classe EventDispatcher reside em um pacote chamado eventos que é aninhado dentro do pacote chamado flash. Você pode fazer referência aos pacotes de eventos usando a seguinte expressão:

flash.events

Você também pode fazer referência à classe EventDispatcher usando esta expressão:

flash.events.EventDispatcher

A sintaxe de barras não é suportada no ActionScript 3.0. Ela foi usada nas versões anteriores do ActionScript para indicar o caminho de um clipe de filme ou variável.

Um literal é um valor que aparece diretamente em seu código. Os seguintes exemplos são de literais:

17 
"hello" 
-3 
9.4 
null 
undefined 
true 
false

Os literais também podem ser agrupados para formar literais compostos. Os literais de matriz são colocados entre colchetes ( [] ) e usam a vírgula para separar elementos de matriz.

Um literal de matriz pode ser usado para inicializar uma matriz. Os exemplos a seguir mostram duas matrizes que são inicializadas usando literais de matriz. É possível usar a instrução new e transmitir o literal composto como um parâmetro para o construtor de classe Array, mas você também pode atribuir valores literais diretamente ao instanciar ocorrências das seguintes classes centrais do ActionScript: Object, Array, String, Number, int, uint, XML, XMLList e Boolean.

// Use new statement. 
var myStrings:Array = new Array(["alpha", "beta", "gamma"]); 
var myNums:Array = new Array([1,2,3,5,8]); 
 
// Assign literal directly. 
var myStrings:Array = ["alpha", "beta", "gamma"]; 
var myNums:Array = [1,2,3,5,8];

Os literais também podem ser usado para inicializar um objeto genérico. Um objeto genérico é uma ocorrência da classe Object. Os literais Object são colocados entre chaves ( {} ) e usam a vírgula para separar propriedades de objetos. Cada propriedade é declarada com o caractere dois-pontos ( : ), 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 de classe Objeto ou atribuir o literal de objeto diretamente à ocorrência que você está declarando. O exemplo a seguir demonstra duas formas alternativas de criar um novo objeto genérico e inicializar o objeto com três propriedades ( propA , propB e propC ), cada uma com valores definidos como 1, 2, e 3, respectivamente:

// Use new statement and add properties. 
var myObject:Object = new Object(); 
myObject.propA = 1; 
myObject.propB = 2; 
myObject.propC = 3; 
 
// Assign literal directly. 
var myObject:Object = {propA:1, propB:2, propC:3};

Você pode usar o caractere ponto-e-vírgula ( ; ) para encerrar uma instrução. Opcionalmente, se omitir o caractere ponto-e-vírgula, o compilador presume que cada linha de código representa uma única instrução. Como muitos programadores estão acostumados a usar o ponto-e-vírgula para denotar o fim de uma instrução, seu código poderá ser mais fácil de ler se você usar consistentemente ponto-e-vírgula para encerrar as instruções.

O uso de um ponto-e-vírgula para encerrar uma instrução permite colocar mais de uma instrução em uma única linha, mas isso pode tornar o código mais difícil de ler.

Você pode usar parênteses ( () ) de três formas no ActionScript 3.0. Em primeiro lugar, você pode usar parênteses para alterar a ordem das operações em uma expressão. As operações que são agrupadas dentro de parênteses são sempre executadas primeiro. Por exemplo, os parênteses são usados para alterar a ordem das operações no seguinte código:

trace(2 + 3 * 4); // 14 
trace((2 + 3) * 4); // 20

Em segundo lugar, você pode usar parênteses com o operador vírgula ( , ) para avaliar uma série de expressões e retornar o resultado da expressão final, como mostra o seguinte exemplo:

var a:int = 2; 
var b:int = 3; 
trace((a++, b++, a+b)); // 7

Em terceiro lugar, você pode usar parênteses para transmitir um ou mais parâmetros para funções ou métodos, como mostra o exemplo a seguir, que transmite um valor String para a função trace() :

trace("hello"); // hello

O código do ActionScript 3.0 oferece suporte a dois tipos de comentários: comentários de uma única linha e de várias linhas. Esses mecanismos de comentários são semelhantes aos do C++ e Java. O compilador ignora o texto marcado com um comentário.

Os comentários de uma única linha começam com dois caracteres de barra inclinada ( // ) e continuam até o fim da linha. Por exemplo, o seguinte código contém um comentário de uma única linha:

var someNumber:Number = 3; // a single line comment

Os comentários de várias linhas começam com uma barra inclinada e um asterisco ( /* ) e terminam com um asterisco e uma barra inclinada ( */ ).

/* This is multiline comment that can span 
more than one line of code. */

As palavras reservadas são palavras que não podem ser usadas como identificadores no código porque são para uso do ActionScript. Elas incluem palavras-chave léxicas , que são removidas do espaço para nomes do programa pelo compilador. O compilador relata um erro se você usar uma palavra-chave léxica como identificador. A seguinte tabela lista as palavras-chave léxicas do ActionScript 3.0.

Há um pequeno conjunto de palavras-chave, chamado palavras-chave sintáticas , que pode ser usado como identificador, mas têm um significado especial em determinados contextos. A tabela a seguir lista as palavras-chave sintáticas do ActionScript 3.0.

Também há vários identificadores que, às vezes, são referidos como palavras reservadas futuras . Eles não são reservados pelo ActionScript 3.0, embora alguns sejam tratados como palavras-chave pelo software que incorpora o ActionScript 3.0. Você pode usar vários desses identificadores no seu código, mas a Adobe não recomenda essa prática porque eles podem aparecer como palavras-chave em uma versão subseqüente da linguagem.

O ActionScript 3.0 oferece suporte à instrução const , que você pode usar para criar constantes. As constantes são propriedades com um valor fixo que não pode ser alterado. Você pode atribuir um valor a uma constante apenas uma vez, e a atribuição deve ocorrer próxima à declaração da constante. Por exemplo, se uma constante for declarada como um membro de uma classe, você poderá atribuir-lhe um valor somente como parte da declaração ou dentro do construtor de classe.

O seguinte código declara duas constantes. A primeira, MINIMUM , tem um valor atribuído como parte da instrução de declaração. A segunda, MAXIMUM , tem um valor atribuído no construtor. Observe que este exemplo é compilado apenas no modo padrão porque o modo estrito só permite que um valor de constante seja atribuído em tempo de inicialização.

class A 
{ 
    public const MINIMUM:int = 0; 
    public const MAXIMUM:int; 
 
    public function A() 
    { 
        MAXIMUM = 10; 
    } 
} 
 
var a:A = new A(); 
trace(a.MINIMUM); // 0 
trace(a.MAXIMUM); // 10

Um erro será gerado se você tentar atribuir um valor inicial a uma constante de qualquer outra forma. Por exemplo, se você tentar definir o valor inicial de MAXIMUM fora da classe, ocorre um erro de tempo de execução.

class A 
{ 
public const MINIMUM:int = 0; 
public const MAXIMUM:int; 
} 
 
var a:A = new A(); 
a["MAXIMUM"] = 10; // run-time error

O ActionScript 3.0 define uma ampla gama de constantes para sua conveniência. Por convenção, as constantes do ActionScript usam tudo em letras maiúsculas, com as palavras separadas pelo caractere de sublinhado ( _ ). Por exemplo, a definição de classe MouseEvent usa essa convenção de nomenclatura para suas constantes, cada uma representando um evento relacionado à entrada do mouse:

package flash.events 
{ 
    public class MouseEvent extends Event 
    { 
    public static const CLICK:String = "click"; 
    public static const DOUBLE_CLICK:String = "doubleClick"; 
    public static const MOUSE_DOWN:String = "mouseDown"; 
    public static const MOUSE_MOVE:String = "mouseMove"; 
    ... 
    } 
}