Para quem vem acompanhando os meus artigos, talvez tenha percebido, ou não, que meu objetivo é escrever matérias que se complementem e para quem está iniciando o aprendizado em ActionScript 3.0, Flex ou mesmo o Flash, consiga ter uma sequência num aprendizado junto comigo.

Não adianta querermos aprender o avançado antes de termos uma base sólida nos conceitos fundamentais, seja o que for que estivermos estudando. Logo, antes mesmo de desenvolvermos em ActionScript 3.0, é importante saber como a linguagem deve ser escrita. Ou seja, qual a sua sintaxe.

A sintaxe de uma linguagem define as regras que devem ser seguidas quando escrever código executável.

Case sensitivity

ActionScript é uma linguagem case-sensitive, o que significa que os identificadores diferem em case (letras maiúsculas de minúsculas). Abaixo, como exemplo duas variáveis diferentes:

var num1:int;
var Num1:int;

Sintaxe de ponto (Dot sintax)

O operador ponto (.) disponibiliza um caminho para acessar as propriedades e métodos de um objeto. Por exemplo, considere a classe:

class ExemploPonto {
	public var prop1 : String;
	public function metodo1() : void {}
}

Acessando a propriedade e o método da classe a partir de uma instância.

var meuPonto : ExemploPonto = new ExemploPonto();
meuPonto.prop1 = "oi";
meuPonto.metodo1();

Podemos usar dot sintax para definir pacotes, usando o operador ponto (.) para referir a pacotes internos. Por exemplo, a classe EventDispatcher está dentro de um pacote chamado events, que está dentro de um pacote chamado flash. Você pode fazer referência ao pacote events usando a seguinte expressão:

flash.events

Você também pode referir-se a classe EventDispatcher usando esta espressão:

flash.events.EventDispatcher

Literais

Um literal é um valor que aparece diretamente no seu código. Os exemplos abaixo são todos literais:

17
"oi"
-3
9.4
null
undefined
true
false

Literais também podem ser agrupados para formar literais compostos. Arrays literais são escritos dentro de colcheteses ([ ]) e são usadas virgulas para se separar os elementos do array.

Um array literal pode ser usado para inicializar um array. Abaixo exemplo de dois arrays sendo inicializados usando arrays literais. Você pode usar a declaração new e passar o literal composto como um parâmetro para o construtor da classe Array, mas você também pode declarar valores literais diretamente quando instancia instâncias das classes: Object, Array, String, Number, int, uint, XML, XMLList e Boolean.

// Usando a declaração new.
var minhasStrings:Array = new Array(["alpha", "beta", "gamma"]);
var meusNumeros:Array = new Array([1,2,3,5,8]);
// Declarando diretamente com literais.
var minhasStrings:Array = ["alpha", "beta", "gamma"];
var meusNumeros:Array = [1,2,3,5,8];

Literais podem ser usadas para inicializar um objeto genérico. Um objeto genérico é uma instância da classe Object. literais Object são colocados dentro de chaves ({ }) e usa vírgulas para separaras propriedades do objeto. Cada propriedade é declarada com dois pontos ( : ), que separa o nome da propriedade do valor da propriedade. Você pode usar a declaração new e passar o literal composto como um parâmetro para o construtor da classe Object. Veja o exemplo a seguir:

// Usando a declaração new.
var meuObjeto:Object = new Object({propA:1, propB:2, propC:3});
// Declarando diretamente com literais.
var myObject:Object = {propA:1, propB:2, propC:3};

Ponto e vírgura ( ; )

Você pode usar ponto e vírgula para terminar uma declaração. Alternativamente, se você omitir o ponto e vírgula, o compilador irá assumir que cada linha de código representa uma declaração.

Parênteses

Você irá usar parênteses em 3 casos:

1. Para alterar a ordem das operações em uma expressão. Operações agrupadas dentro de parênteses são executadas primeiro.

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

2. Você pode usar parênteses com o operador vírgula ( , ) para avaliar uma série de expressões e retornar o resultado no final da expressão.

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

3. Você usa parênteses para passar um ou mais parênteses para funções ou métodos.

trace("oi");

Comentários

O código ActionScript 3.0 suporta dois tipos de comentários: um linhas e de várias linhas. O compilador ignora o que estiver marcado como um comentário.

// comentário de uma linha
/*
comentário
de várias
linhas
*/

Palavras-chave

Palavras-chave não podem ser usadas como identificadores em seu código, pois estas palavras são reservadas para o ActionScript. As palavras reservadas incluem palavras-chave léxicas, que são transferidas para o namespace do programa pelo compilador. O compilador pode retornar um erro se você usar uma palavra léxica como um identificador. Abaixo uma lista de palavras léxicas:

• as
• break
• case
• catch
• class
• const
• continue
• default
• delete
• do
• else
• extends
• false
• finally
• for
• function
• if
• implements
• import
• in
• instanceof
• interface
• internal
• is
• native
• new
• null
• package
• private
• protected
• public
• return
• super
• switch
• this
• throw
• to
• true
• try
• typeof
• use
• var
• void
• while
• with

Este é um grupo de palavras-chave, chamado palavras-chave sintática, estas podem ser usadas como identificadores, mas tem um significado especial em certos contextos. Abaixo a lista de palavras-chave sintáticas:

• each
• get
• set
• namespace
• include
• dynamic
• final
• native
• override
• static

Estes também são alguns identificadores que às vezes são referidos como futuras palavras reservadas. Estes identificadores não são reservados para o ActionScript 3.0, apesar de terem que ser tratadas como palavras-chave para produtos ActionScript 3.0 incorporados. Você esta apto a usar vários destes identificadores em seu código, mas a Adobe recomenda você não usar pois poderão aparecer como palavras-chave em futuras versões da linguagem.

• abstract
• boolean
• byte
• cast
• char
• debugger
• double
• enum
• export
• float
• goto
• intrinsic
• long
• prototype
• short
• synchronized
• throws
• to
• transient
• type
• virtual
• volatile

Conhecendo a sintaxe estamos melhor preparados para desenvolver de forma mais sólida e correta.

Um abraço e até o próximo artigo!