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:

[as3]var num1:int;
var Num1:int;[/as3]

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:

[as3]class ExemploPonto {
public var prop1 : String;
public function metodo1() : void {}
}
[/as3]

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


[as3]var meuPonto : ExemploPonto = new ExemploPonto();
meuPonto.prop1 = “oi”;
meuPonto.metodo1();[/as3]

Podemos usar dot sintax para definir pacotes, usando o operador ponto (.) para referir-se 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 referencia ao pacote events usando a seguinte expressão:

[as3]flash.events[/as3]

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

[as3]flash.events.EventDispatcher[/as3]

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.

[as3]// 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];[/as3]

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:

[as3]// 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};[/as3]

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.

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

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.

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

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

[as3]trace(“oi”);[/as3]

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.

[as3]// comentário de uma linha
/*
comentário
de várias
linhas
*/[/as3]

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 palavrasa lexicas:

• 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

(via carlos tristacci)

Certamente a principal diferença entre as versões anteriores e o Actionscript 3.0 é que antes existiam diversos locais onde era possível a utilização dos códigos (timelines, movies, buttons, arquivos externos e etc). Hoje com o as3.0 a utilização é baseada em classes, onde os códigos são colocados dentro de métodos da classe.

No Actionscript 2.0:

class mx.transitions.Tween {
}

A estrutura mínima de uma Classe quando programamos em Actionscript 3.0 é a seguinte:

package {
    public class MinhaClasse {
        // aqui, funções da minha classe
    }
}

Apenas uma classe pública é permitida por classe. Outras classes podem ser declaradas no mesmo arquivo, mas apenas uma pode ser pública.

É de extrema importância o conhecimento básico de orientação a objetos, facilitará e muito o uso.

Uma classe de as3 é um arquivo com extensão “.as” contendo o bloco de código. O nome do arquivo deve ser exatamente igual ao da classe, incluindo diferenças entre maiúsculas e minúsculas.

No exemplo acima, o nome do meu arquivo seria “MinhaClasse.as”.

Todo projeto desenvolvido utilizando a framework Adobe Flash tem como raiz a mesma pasta do arquivo FLA. Em nosso exemplo, eu devo colocar o arquivo MinhaClasse.as no mesmo local que o FLA que irá utilizá-lo.

Você poderá utilizar pastas e subpastas, é para isso que o Package serve, organização.

Por exemplo, se você quiser utilizar o arquivo as dentro da pasta “aplicacao”, seu script ficaria assim:

package aplicacao {
    public class MinhaClasse {
        // aqui, funções da minha classe

    }
}

Se fosse na pasta “aplicacao”, subpasta “geral” o script deve ser mudado para:

package aplicacao.geral {
    public class MinhaClasse {
        // aqui, funções da minha classe

    }
}

Quando se omite o package, a classe e definida por padrão como top-level.

Você sempre terá que escrever em qual lugar a classe estará, isso é extremamente necessário tanto para organização, quanto para funcionamento, sem esquecer das maiúsculas e minúsculas.

Duas classes com mesmo nome!?

Pode acontecer. Caso você tenha duas classes com o mesmo nome, a utilização do Package é essencial para não ocorrer erros no projeto. É só informar qual a classe o o Package que você esta requisitando.

Antes de começar a praticar, é importante o conhecimento sobre Orientação a Objetos, vou falar um pouco sobre isso e logo depois a prática.

Document Class

Document Class é como se fosse a Classe inicial do seu projeto. Mesmo que você esqueça de criar a sua classe inicial, o flash criará uma para você automaticamente durante o processo de compilação do projeto.

Nosso objetivo é utilizar todo o projeto usando arquivos externos .as e não códigos desorganizados dentro do arquivo .fla, então vamos sempre definir claramente nossa Document Class.

Extensão de Classe

A extensão de uma classe, é uma das definições da Orientação a Objetos.

É importante saber o que se esta escrevendo e testando, por isso saber por que usamos o “extends” na definição de uma classe é essencial.

Extender uma classe é utilizar recursos de uma classe já existente, adicionando ou modificando eventos. Assim tudo que existe na classe original continua funcionando na classe que foi extendida.

Exemplificando: Tenho a classe Animal e classe Gato. Sendo que Gato extends Animal, ou seja, todas as características padrões instanciadas na classe Animal, serão extendidas a classe Gato, porém as novas funções adicionadas em Gato, não serão de Animal.

Finalizando, quando eu compilo meu projeto .fla eu gero um swf, este é um MovieClip. O MovieClip é uma Classe. A minha Document Class tem que funcionar como o MovieClip, logo minha Document Class tem que ser uma extenção da Classe MovieClip.

Exemplo:

package {
	import flash.display.MovieClip
    public class MinhaClasse extends MovieClip {
        // aqui, funções da minha classe

    }
}

Já diria Pelé!: “entende!??”

Ops! Para que aquele import? Eu tenho que dizer ao aplicativo, quem é a Classe MovieClip que MinhaClasse vai extender!

Todas as classes importadas devem ser definidas logo na abertura do package antes da definição da classe.

Você poderá usar a Classe Sprite (import flash.display.Sprite;), que é semelhante a classe MovieClip, mas não possui uma timeline.

Vamos a prática!

Vamos ao famoso Hello World. Como diria …, vamos por partes, a muita coisa para ser vista e testada.

package {

	import flash.display.MovieClip

    public class MinhaClasse extends MovieClip {
		public  function  MinhaClasse() {
			trace("Hello World  joww!!");
  		}
	}
}

Você deve ter percebido que criei uma function com o mesmo nome da class, esta é uma função construtora que iniciará a classe, o nome da função construtora deve ter exatamente o mesmo nome da classe (MinhaClasse).

No inspetor de propriedades em “Document class:” coloque o nome da classe a ser executada.

Teste…

Agora que temos o nosso “MinhaClasse.as”, seguinte:

1. Crie um novo arquivo FLA com ActionScript 3 e salve com um nome qualquer!
2. Coloque o arquivo “MinhaClasse.as” na mesma pasta que o FLA;
3. Nas propriedades do FLA, preencha o valor da Document Class apenas com a palavra MinhaClasse;
4. CTRL + Enter!

Até a próxima pessoal!