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"; 
    ... 
    } 
}