Instruções, palavras-chave e diretivas 

function functionName(parameter0, parameter1, ...rest){ 
	// statement(s) 
} 

Especifica se uma função aceitará qualquer número de argumentos delimitados por vírgulas. A lista de argumentos torna-se uma matriz que fica disponível por todo o corpo da função. O nome da matriz é especificado depois dos caracteres ... na declaração do parâmetro. O parâmetro pode ter qualquer nome que não seja uma palavra reservada.

Se usado com outros parâmetros, a declaração do parâmetro ... (restante) deve ser o último parâmetro especificado. A matriz do parâmetro ... (restante) será preenchida somente se o número de argumentos passados para a função exceder o número de outros parâmetros.

Cada argumento na lista de argumentos delimitados por vírgulas é colocado em um elemento da matriz. Se você passar uma ocorrência da classe Array, a matriz inteira será colocada em um elemento único da matriz do parâmetro ... (restante).

Usar este parâmetro torna o objeto arguments indisponível. Embora o parâmetro ... (restante) ofereça a mesma funcionalidade que a matriz arguments e a propriedade arguments.length, ele não fornece funcionalidade similar para aquele fornecido pelo arguments.callee. Certifique-se de que não precisa usar arguments.callee antes de usar o parâmetro ... (restante).

package {
	import flash.display.MovieClip;
	
	public class RestParamExample extends MovieClip {
		public function RestParamExample() {
			traceParams(100, 130, "two"); // 100,130,two
			trace(average(4, 7, 13));     // 8
		}
	}
}


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

Elementos da API relacionados

Define métodos e propriedades das principais classes ActionScript que são propriedades fixas em vez de propriedades de protótipo. Quando você define a opção de compilador "-as3" como true (que é a configuração padrão no Flex Builder 2), o namespace AS3 é aberto automaticamente para todas as classes centrais. Isso significa que uma ocorrência de uma classe principal usará as propriedades e métodos fixos em vez das versões das mesmas propriedades e métodos que são anexadas ao objeto do protótipo da classe. O uso das propriedades fixas normalmente fornece um melhor desempenho, mas ao custo da compatibilidade inversa com a especificação de linguagem (ECMA-262) do ECMAScript edição 3.

Elementos da API relacionados

Aparece dentro de um ciclo (for, for...in, for each..in, do..while ou while) ou dentro de um bloco de instruções associadas a um caso particular dentro de uma instrução switch. Quando usado em uma repetição, a instrução break informa ao Flash para ignorar o restante do corpo da repetição, interromper a ação de repetição e executar a instrução que acompanha a instrução da repetição. Quando usado em uma instrução switch, break informa ao Flash para ignorar o restante das instruções nesse bloco de case e pular para a primeira instrução que acompanha a instrução switch de encerramento.

Nas repetições aninhadas, break só ignora o restante da repetição imediata e não interrompe a série inteira das repetições aninhadas. Para interromper uma série inteira de repetições aninhadas, use label ou try...catch..finally.

A instrução break pode ter uma marca opcional que deve corresponder a uma instrução marcada externa. Usar uma marca que não corresponde à marca de uma instrução externa é um erro de sintaxe. As instruções break marcadas podem ser usadas para interromper vários níveis de instruções de repetição aninhada, instruções switch ou instruções block. Por exemplo, veja a entrada para a instrução label.

var i:int = 0;
while (true) { 
	trace(i); 
	if (i >= 10) { 
		break; // this will terminate/exit the loop 
	} 
	i++; 
} 
/*
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

Elementos da API relacionados

case jumpTarget: statements

Define um destino de salto para a instrução switch. Se o parâmetro jumpTarget for igual ao parâmetro expression da instrução switch que usa a igualdade estrita ( ===), o Flash Player executa as instruções no parâmetro statements até encontrar uma instrução break ou o final da instrução switch.

Se você usar a instrução case fora de uma instrução switch, ela produzirá um erro e o script não será compilado.

var thisMonth:int = new Date().getMonth(); 
switch (thisMonth) { 
	case 0 : 
		trace("January"); 
		break; 
	case 1 : 
		trace("February"); 
		break; 
	case 5 : 
	case 6 : 
	case 7 : 
		trace("Some summer month"); 
		break; 
	case 8 : 
		trace("September"); 
		break; 
	default : 
		trace("some other month"); 
}

Elementos da API relacionados

[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] { 
	// class definition here
}

Define uma classe, que permite que você exemplifique objetos que compartilham métodos e propriedades que você define. Por exemplo, se você estivesse desenvolvendo um sistema de controle de fatura, poderia criar uma classe Invoice, que define todos os métodos e propriedades que cada fatura deve ter. Você usaria então o comando new Invoice() para criar objetos Invoice.

Cada arquivo de origem do ActionScript pode conter somente uma classe que é visível aos outros arquivos ou scripts de origem. A classe visível externamente pode ser uma classe pública ou interna e deve ser definida em uma instrução de pacote. Se você incluir outras classes no mesmo arquivo, as classes deverão ser colocadas fora da instrução do pacote e no fim do arquivo.

O nome da classe visível externamente deve corresponder ao nome do arquivo de origem do ActionScript que contém a classe. O nome do arquivo de origem deve ser o nome da classe com a extensão de arquivo .as adicionada. Por exemplo, se você nomear uma classe como Estudante, o arquivo que define a classe deve ser denominado Estudante.as.

Você não pode aninhar as definições de classe; ou seja, você não pode definir as classes adicionais em uma definição de classe.

Você pode definir um método de construtor, que é um método executado sempre que uma nova ocorrência da classe é criada. O nome do método do construtor deve corresponder ao nome da classe. Se você não definir um método do construtor, um construtor padrão será criado para você.

Para indicar que os objetos podem adicionar e acessar propriedades dinâmicas no tempo de execução, anteceda a instrução de classe com a palavra-chave dynamic. Para declarar que uma classe implementa uma interface, use a palavra-chave implements. Para criar subclasses de uma classe, use a palavra-chave extends. (Uma classe pode estender somente uma classe, mas pode implementar várias interfaces). Você pode usar implements e extends em uma única instrução. Os exemplos a seguir mostram os usos típicos das palavras-chave implements e extends:

class C implements Interface_i, Interface_j // OK 
class C extends Class_d implements Interface_i, Interface_j // OK 
class C extends Class_d, Class_e // not OK 

// Filename Plant.as 
package {
  public class Plant { 
	// Define property names and types 
	private var _leafType:String; 
	private var _bloomSeason:String; 
	// Following line is constructor 
	// because it has the same name as the class 
	public function Plant(param_leafType:String, param_bloomSeason:String) { 
		// Assign passed values to properties when new Plant object is created 
		_leafType = param_leafType; 
		_bloomSeason = param_bloomSeason; 
	} 
	// Create methods to return property values, because best practice 
	// recommends against directly referencing a property of a class 
	public function get leafType():String { 
		return _leafType; 
	} 
	public function get bloomSeason():String { 
		return _bloomSeason; 
	} 
  }
}

var pineTree:Plant = new Plant("Evergreen", "N/A"); 
// Confirm parameters were passed correctly 
trace(pineTree.leafType); 
trace(pineTree.bloomSeason); 

Elementos da API relacionados

const identifier = value 

Especifica uma constante, que é uma variável que pode ser atribuída a um valor somente uma vez.

Você pode digitar exatamente uma constante colocando o caractere dois pontos (:) seguido do tipo de dados.

const MIN_AGE:int = 21;
MIN_AGE = 18; // error

const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); // array operations are allowed
product_array = ["Other"];  // assignment is an error
trace(product_array); 

Elementos da API relacionados

continue [label]

Salta todas as instruções restantes passadas na repetição interna e inicia a próxima iteração da repetição como se o controle tivesse passado normalmente para o final da repetição. A instrução continue não tem efeito fora de uma repetição. Nas repetições aninhadas, use o parâmetro opcional label para ignorar mais do que apenas a repetição interna.

A instrução continue pode ter um rótulo opcional que deve corresponder a uma instrução rotulada externa. Usar uma marca que não corresponde à marca de uma instrução externa é um erro de sintaxe. As instruções continue rotuladas podem ser usadas para ignorar vários níveis de instruções de repetição aninhadas.

var i:int = 0; 
while (i < 10) { 
	if (i % 3 == 0) { 
		i++; 
		continue; 
	} 
	trace(i); 
	i++; 
}

 
for (var i:int = 0; i < 10; i++) { 
	if (i % 3 == 0) { 
		continue; 
	} 
	trace(i); 
}

Elementos da API relacionados

default: statements 

Define a instrução case default para uma instrução switch. As instruções serão executadas se o parâmetro expression da instrução switch não for igual a (usando a operação de igualdade estrita [ ===]) qualquer um dos parâmetros expression que acompanham as palavras-chave case para uma determinada instrução switch.

Uma instrução switch não requer uma instrução case default. Uma instrução case default não precisa ser a última na lista. Se você usar uma instrução default fora de uma instrução switch, ela produz um erro e o script não é compilado.

var dayOfWeek:int = new Date().getDay(); 
switch (dayOfWeek) { 
	case 1 : 
		trace("Monday"); 
		break; 
	case 2 : 
		trace("Tuesday"); 
		break; 
	case 3 : 
		trace("Wednesday"); 
		break; 
	case 4 : 
		trace("Thursday"); 
		break; 
	case 5 : 
		trace("Friday"); 
		break; 
	default : 
		trace("Weekend"); 
}

Elementos da API relacionados

A diretiva default xml namespace define o namespace padrão a ser usado para os objetos XML.

Se você não definir default xml namespace, o namespace padrão será o namespace sem nome (com o URI definido como uma string vazia). O escopo de uma declaração default xml namespace está em um bloco de funções, como o escopo de uma variável.

var nsDefault1:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault1;
	    
var x1:XML = ;
trace("x1 ns: " + x1.namespace());
			
scopeCheck();	

var x2:XML = ;
trace("x2 ns: " + x2.namespace());
		
function scopeCheck(): void {
	
	var x3:XML = ;
	trace("x3 ns: " + x3.namespace());
				
	var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
	default xml namespace = nsDefault2;
		    
	var x4:XML = ;
	trace("x4 ns: " + x4.namespace());

}

var nsDefault:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault;
            
var x1:XML = ;

trace(x1.namespace());
	// http://www.example.com/namespaces/

var x2:XML = ;
trace(x2.namespace());
	// http://www.w3.org/1999/XSL/Transform/

var x3:XML = ;
trace(x3.namespace());
	// http://www.example.com/namespaces/

Elementos da API relacionados

do { statement(s) } while (condition)

Similar a uma repetição while, exceto que as instruções são executadas uma vez antes da avaliação inicial da condição. Subsequentemente, as instruções são executadas somente se a condição avaliar como true.

Um ciclo do..while garante que o código na repetição seja executado pelo menos uma vez. Embora você também possa fazer isso com um ciclo while colocando uma cópia das instruções a serem executadas antes de o ciclo while ser iniciado, muitos programadores acreditam que os ciclos do...while são mais fáceis de ler.

Se a condição sempre tiver o valor true, então o ciclo do..while será infinito. Se você inserir uma repetição infinita, você encontrará problemas com o Flash Player e eventualmente receberá uma mensagem de aviso ou falha do player. Sempre que possível, use uma repetição for se souber a quantidade de vezes que deseja realizar a repetição. Embora os ciclos for sejam fáceis de ler e depurar, não podem substituir os ciclos do..while em todas as circunstâncias.

var myVar:Number = 0; 
do { 
	trace(myVar); 
	myVar++; 
} 
while (myVar < 5); 
/*
0 
1 
2 
3 
4
*/

Elementos da API relacionados

dynamic class className { // class definition here }

Especifica se as ocorrências de uma classe podem ter propriedades dinâmicas adicionadas no tempo de execução. Se você usar o atributo dynamic em uma classe, poderá adicionar propriedades às ocorrências dessa classe no tempo de execução. As classes que não são marcadas como dynamic são consideradas seladas , o que significa que as propriedades não podem ser adicionadas às ocorrências da classe.

Se uma classe for selada (não dinâmica), as tentativas de obter ou definir as propriedades nas ocorrências da classe resultam em um erro. Se você tiver o compilador definido para o modo completo e especificar o tipo de dados ao criar as ocorrências, as tentativas de adicionar as propriedades aos objetos selados geram um erro do compilador; caso contrário, ocorre um erro de tempo de execução.

O atributo dynamic não é herdado pelas subclasses. Se você estender uma classe dinâmica, a subclasse só ficará dinâmica se você declarar a subclasse com o atributo dynamic.

package {

	dynamic class Expando  {
	}
	
	class Sealed {
	}
}

var myExpando:Expando = new Expando();
myExpando.prop1 = "new";
trace(myExpando.prop1); // new

var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // error

Elementos da API relacionados

if (condition) { 
	// statement(s)
} 
else {
	// statement(s)
}

Especifica as instruções a serem executadas se a condição na instrução if retornar false. Os colchetes ( {}) que incluem as instruções a serem executadas pela instrução else não serão necessários se apenas uma instrução for executada.

if (age_txt.text>=18) { 
	trace("welcome, user"); 
} 
else { 
	trace("sorry, junior"); 
	userObject.minor = true; 
	userObject.accessAllowed = false;
}

if (age_txt.text>18) { 
	trace("welcome, user");
} 
else trace("sorry, junior");

if (score_txt.text>90) { 
	trace("A"); 
} 
else if (score_txt.text>75) { 
	trace("B"); 
} 
else if (score_txt.text>60) { 
	trace("C"); 
} 
else { 
	trace("F"); 
}

Elementos da API relacionados

class className extends otherClassName {}
interface interfaceName extends otherInterfaceName {} 

Define uma classe que é uma subclasse de outra classe. A subclasse herda todos os métodos, propriedades, funções e assim por diante que são definidas na superclasse. As classes que são marcadas como final não podem ser estendidas.

Você também pode usar a palavra-chave extends para estender uma interface. Uma interface que estende outra interface inclui todas as declarações de método da interface original.

package {
	class Vehicle { 
	    var numDoors:Number; 
	    var color:String; 
	    public function Vehicle(param_numDoors:Number = 2, param_color:String = null) { 
	        numDoors = param_numDoors; 
	        color = param_color; 
	    } 
	    public function start():void { 
	        trace("[Vehicle] start"); 
	    } 
	    public function stop():void { 
	        trace("[Vehicle] stop"); 
	    } 
	    public function reverse():void { 
	        trace("[Vehicle] reverse"); 
	    } 
	}	
}

package {

	public class Car extends Vehicle { 
	    var fullSizeSpare:Boolean; 
	    public function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) { 
	        numDoors = param_numDoors; 
	        color = param_color; 
	        fullSizeSpare = param_fullSizeSpare; 
	    } 
	    public function activateCarAlarm():void { 
	        trace("[Car] activateCarAlarm"); 
	    } 
	    public override function stop():void { 
	        trace("[Car] stop with antilock brakes"); 
	    } 
	}
}

var myNewCar:Car = new Car(2, "Red", true); 
myNewCar.start(); // [Vehicle] start 
myNewCar.stop(); // [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // [Car] activateCarAlarm

package {
	class Truck extends Vehicle {
		var numWheels:Number;
		public function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) { 
			super(param_numDoors, param_color); 
			numWheels = param_numWheels; 
		} 
		public override function reverse():void { 
			beep();
			super.reverse();
		} 
		public function beep():void { 
			trace("[Truck] make beeping sound"); 
		} 
	}
}

var myTruck:Truck = new Truck(2, "White", 18); 
myTruck.reverse(); // [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // [Vehicle] stop

Elementos da API relacionados

false

Falsa representação do valor Booliano. O valor Booliano é true ou false; o contrário de false é true.

Quando a digitação automática dos dados converte false em um número, ela se torna 0; quando ela converte false em uma string, ela se torna "false".

Nota: A sequência de caracteres "false" se transforma no valor booliano true.

var bool1:Boolean = Boolean(false);

// converts it to the number 0
trace(1 + bool1); // outputs 1

// converts it to a string
trace("String: " + bool1); // outputs String: false

trace(Boolean("false")); // true

if ("false") {
	trace("condition expression evaluated to true");
}
else {
	trace("condition expression evaluated to false");
}
// condition expression evaluated to true

Elementos da API relacionados

final function methodName() { 
	// your statements here 
}
final class className {}

Especifica que um método não pode ser substituído ou que uma classe não pode ser estendida. Uma tentativa de substituir um método ou estender uma classe, marcada como final resulta em erro.

Elementos da API relacionados

Define métodos da classe Proxy. Os métodos da classe Proxy estão em seu próprio namespace para evitar conflitos de nomes em situações em que a subclasse Proxy contém nomes do método da ocorrência que correspondem a qualquer um dos nomes do método da classe Proxy.

Elementos da API relacionados

for ([init]; [condition]; [next]) { 
	// statement(s)
}

Avalia a expressão init (inicializar) uma vez e depois inicia uma sequência de repetição. A sequência de repetição começa avaliando a expressão condition. Se a expressão condition é avaliada como true, statement é executada e next é avaliado. A sequência de repetição começa então com a avaliação da expressão condition.

Os colchetes ( {}) que incluem o bloco de instruções a serem executadas pela instrução for não serão necessários se apenas uma instrução for executada.

var my_array:Array = new Array(); 
for (var i:Number = 0; i < 10; i++) { 
	my_array[i] = (i + 5) * 10;  
} 
trace(my_array); // 50,60,70,80,90,100,110,120,130,140 

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) { 
	sum += i; 
} 
trace(sum); // 5050

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) 
	sum += i; 
trace(sum); // 5050

Elementos da API relacionados

for (variableIterant:String in object){ 
	// statement(s)
} 

Repete novamente as propriedades dinâmicas de um objeto ou elementos em uma matriz e executa statement para cada propriedade ou elemento. As propriedades do objeto não ficam em nenhuma ordem específica, assim, as propriedades podem ser exibidas aparentemente em uma ordem aleatória. As propriedades fixas, como variáveis e métodos definidos em uma classe, não são enumeradas pela instrução for...in. Para obter uma lista das propriedades fixas, use a função describeType(), que está no pacote flash.utils.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var prop in myObject) { 
	trace("myObject."+prop+" = "+myObject[prop]); 
} 
/*
myObject.firstName = Tara 
myObject.age = 27 
myObject.city = San Francisco
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var name in myObject) { 
	if (typeof (myObject[name]) == "string") { 
		trace("I have a string property named "+name); 
	} 
}
/*
I have a string property named city
I have a string property named firstName
*/

Elementos da API relacionados

for each (variableIterant in object){ 
	// statement(s)
} 

Repete os itens de uma coleta e executa statement para cada item. Introduzida como parte das extensões da linguagem E4X, a instrução for each..in pode ser usada não somente para objetos XML, mas também para objetos e matrizes. A repetição for each..in é repetida somente por meio das propriedades dinâmicas de um objeto, não pelas propriedades fixas. Uma propriedade fixa é uma propriedade que é definida como parte de uma definição de classe. Para usar a instrução for each..in com uma ocorrência de uma classe definida pelo usuário, é necessário declarar a classe com o atributo dynamic.

Ao contrário da instrução for...in, a instrução for each...inrepete-se nos valores das propriedades de um objeto, em vez dos nomes da propriedade.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
	trace(item); 
} 
/*
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
	trace(item); 
/*
one
two
three
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
	if (item is String) {  
		trace("I have a string property with value " + item); 
	} 
}

/*
I have a string property with value Tara
I have a string property with value San Francisco
*/

var doc:XML = 
		
			
Hello
			
Hola
			

			
Bonjour
		;
for each (var item in doc.p) {
	trace(item);
}

/*
Hello
Hola
Bonjour
*/

function functionName([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 

Compreende um conjunto de instruções que você define para realizar uma determinada tarefa. Você pode definir uma função em um local e invocá-la ou chamá-la a partir de diferentes scripts em um arquivo SWF. Ao definir uma função, você também pode especificar parâmetros para a função. Os parâmetros são marcadores de posição para os valores nos quais a função opera. Você pode passar diferentes parâmetros para uma função toda vez que você chamá-la para que você possa reutilizar a função em diferentes situações.

Use a instrução return em um bloco de função statement(s) para fazer com que uma função crie, ou retorne , um valor.

Uso 1: você pode usar a palavra-chave function para definir uma função com o nome de função, parâmetros e instruções especificados. Quando um script chama uma função, as instruções na definição da função são executadas. Uma referência antecipada é permitida; no mesmo script, uma função pode ser declarada após ser chamada. Uma definição de função substitui qualquer definição anterior da mesma função. Você pode utilizar essa sintaxe sempre que uma instrução for permitida.

Uso 2: você pode também usar function para criar uma função anônima e retornar uma referência a ela. Essa sintaxe é usada em expressões e é particularmente útil na instalação de métodos em objetos.

Para obter uma funcionalidade adicional, você pode usar o objeto arguments na definição de sua função. O objeto arguments é normalmente usado para criar uma função que aceita um número variável de parâmetros e para criar uma função anônima recursiva.

function sqr(xNum:Number) { 
	return Math.pow(xNum, 2); 
} 
var yNum:Number = sqr(3); 
trace(yNum); // 9

var yNum:Number = sqr(3); 
trace(yNum); // 9 
function sqr(xNum:Number) { 
	return Math.pow(xNum, 2); 
}

Elementos da API relacionados

function get property() : returnType{ 
	// your statements here 
}

Define um getter, que é um método que pode ser lido como uma propriedade. Um getter é uma função especial que retorna o valor de uma propriedade declarada com a palavra-chave var ou const. Ao contrário dos outros métodos, um getter é chamado sem parênteses ( ()), o que faz com que ele pareça ser uma variável.

Os getters permitem que você aplique o princípio da ocultação das informações possibilitando que você crie uma interface pública para uma propriedade privada. A vantagem da ocultação de informações é que a interface pública permanece a mesma, mesmo se a implementação básica da propriedade privada for alterada.

Outra vantagem dos getters é que eles podem ser substituídos nas subclasses, ao passo que as propriedades declaradas com var ou const não podem.

Um getter pode ser combinado com um setter para criar uma propriedade de leitura e gravação. Para criar uma propriedade somente de leitura, crie um getter sem um setter correspondente. Para criar uma propriedade somente de gravação, crie um setter sem um getter correspondente.

package {
	public class Team { 
		var teamName:String; 
		var teamCode:String; 
		var teamPlayers:Array = new Array(); 
		public function Team(param_name:String, param_code:String) { 
			teamName = param_name; 
			teamCode = param_code; 
		} 
		public function get name():String { 
			return teamName; 
		} 
		public function set name(param_name:String):void { 
			teamName = param_name; 
		}
	} 
}

var giants:Team = new Team("San Fran", "SFO"); 
trace(giants.name); 
giants.name = "San Francisco"; 
trace(giants.name); 
/*
San Fran San Francisco */

Elementos da API relacionados

if (condition) {
	// statement(s)
}

Avalia uma condição para determinar a próxima instrução a ser executada. Se a condição for true, o Flash Player executa as instruções que acompanham a condição dentro dos colchetes ( {}). Se a condição for false, o Flash Player ignora as instruções dentro dos colchetes e as executa acompanhando os colchetes. Use a instrução if juntamente com a instrução else para criar uma ramificação lógica em seus scripts.

As chaves {}) que incluem as instruções a serem executadas pela instrução else não serão necessárias se apenas uma instrução for executada.

Elementos da API relacionados

myClass implements interface01 [, interface02 , ...] 

Especifica se a classe implementa uma ou mais interfaces. Quando uma classe implementar uma interface, ela deve definir todos os métodos declarados na interface. Qualquer ocorrência de uma classe que implementa uma interface é considerada um membro do tipo de dados definido pela interface. Como resultado, o operador is retorna true quando a ocorrência da classe é o primeiro operando e a interface é o segundo; além disso, as coerções de tipo para e a partir do tipo de dados definido pelo trabalho da interface.

Elementos da API relacionados

import packageName.className 
import packageName.*

Torna externamente definidas as classes e pacotes disponíveis em seu código. Por exemplo, se você quiser usar a classe flash.display.Sprite em um script, você deve importá-la. Essa necessidade é diferente das versões anteriores do ActionScript, nas quais a diretiva import era opcional.

Após usar a diretiva import, você pode usar o nome de classe completo, que inclui o nome do pacote ou apenas o nome da classe.

 
import flash.display.Sprite; 

// name of class only
var mySprite:Sprite = new Sprite();

// full class name
var mySprite:flash.display.Sprite = new flash.display.Sprite();

Se houver várias classes no pacote que você deseja acessar, você pode importá-las em uma única instrução, conforme mostrado no seguinte exemplo:

import flash.display.*;

A diretiva import importa somente as classes, funções e variáveis que residem no nível superior do pacote importado. Os pacotes aninhados devem ser explicitamente importados.

Se você importar uma classe, mas não usá-la em seu script, a classe não será exportada como parte do arquivo SWF. Isso significa que você pode importar grandes pacotes sem se preocupar com o tamanho do arquivo SWF; o código de bytes associado a uma classe será incluído em um arquivo SWF somente se a classe for realmente utilizada. Uma desvantagem de importar classes que você não precisa é que você aumenta a probabilidade de conflitos de nomes.

// On Frame 1 of a FLA: 
import adobe.example.*; 
var myFoo:foo = new foo();

include "[path]filename.as"

Inclui o conteúdo do arquivo especificado, como se os comandos no arquivo fizessem parte do script de chamada. A diretiva include é chamada no momento da compilação. Portanto, se você fizer alguma alteração a algum arquivo incluído, será necessário salvar o arquivo e recompilar todos os arquivos SWF que o usam.

 interface InterfaceName [extends InterfaceName ] {}

Define uma interface. As interfaces são tipos de dados que definem um conjunto de métodos; os métodos devem ser definidos por qualquer classe que implemente a interface.

Uma interface é parecida com uma classe, com as seguintes importantes diferenças:

• As interfaces contêm somente declarações de métodos, não sua implementação. Isso significa que cada classe que implementa uma interface deve fornecer uma implementação para cada método declarado na interface.
• As definições do método de interface não podem ter nenhum atributo como public ou private, mas os métodos implementados devem ser marcados como public na definição da classe que implementa a interface.
• Várias interfaces podem ser herdadas por uma interface por meio da instrução extends ou por uma classe por meio da instrução implements.

Ao contrário do ActionScript 2.0, o ActionScript 3.0 permite o uso dos métodos de getter e setter nas definições da interface.

Elementos da API relacionados

[internal] var varName
[internal] const kName
[internal] function functionName()  { 
	// your statements here 
}
[internal] class className{
	// your statements here 
}
[internal] namespace nsName

Especifica que uma classe, variável, constante ou função está disponível para qualquer chamador no mesmo pacote. As classes, propriedades e métodos pertencem ao namespace internal por padrão.

Elementos da API relacionados

label: statement
label: {
    statements
}

Associa uma instrução a um identificador que pode ser referenciada pelo break ou continue. Nas repetições aninhadas, uma instrução break ou continue que não faz referência a um rótulo pode ignorar o restante da repetição imediato e não ignorar a série inteira de repetições. Entretanto, se a instrução que define a série inteira de repetições tiver um rótulo associado, uma instrução break ou continue pode ignorar a série inteira de repetições referindo-se a esse rótulo.

Os rótulos também permitem que você interrompa uma instrução em bloco. Você não pode colocar uma instrução break que não faz referência a um rótulo em uma instrução em bloco a menos que a instrução em bloco faça parte de uma repetição. Se a instrução em bloco tiver um rótulo associado, você pode colocar uma instrução break que se refere a este rótulo na instrução em bloco.

outerLoop: for (var i:int = 0; i < 10; i++) {
	for (var j:int = 0; j < 10; j++) {
		if ( (i == 8) && (j == 0)) {
			break outerLoop;
		}
		trace(10 * i + j);
	}
}
/*
1
2
...
79
*/

foo: {
	trace("a");
	break foo;
	trace("b");
}
// a

Elementos da API relacionados

namespace name [= uri]

Permite que você controle a visualização das definições. Os namespaces predefinidos incluem public, private, protected e internal.

As etapas a seguir mostram como criar, aplicar e fazer referência a um namespace:

• Primeiro, defina o namespace personalizado usando a palavra-chave namespace. Por exemplo, o código namespace version1 cria um namespace chamado version1.
• Em segundo ligar, aplique o namespace a uma propriedade ou método usando seu namespace personalizado na declaração da propriedade ou método. Por exemplo, o código version1 myProperty:String cria uma propriedade chamada myProperty que pertence ao namespace version1
• Em terceiro lugar, faça referência ao namespace usando a palavra-chave use ou colocando como prefixo um identificador com o namespace. Por exemplo, o código use namespace version1; refere-se ao namespace version1 das linhas subsequentes do código, e o código version1::myProperty se refere ao namespace version1 da propriedade myProperty.

Elementos da API relacionados

native function functionName();
class className { 
	native function methodName();
}

Especifica que uma função ou método é implementado pelo Flash Player no código comum. O Flash Player usa a palavra-chave native internamente para declarar funções e métodos na API (Interface de Programação do Aplicativo) do ActionScript. Essa palavra-chave não pode ser usada em seu próprio código.  

null

Valor especial que pode ser atribuído a variáveis ou retornado por uma função se nenhum dado tiver sido fornecido. Você pode usar null para representar os valores que estão faltando ou que não têm um tipo definido de dados.

O valor null não deve ser confundido com o valor especial undefined. Quando null e undefined são comparados com o operador de igualdade (==), eles são comparados como iguais. Entretanto, quando null e undefined são comparados com o operador de igualdade estrita (===), eles são comparados como não iguais.

var testArray:Array = new Array();
testArray[0] = "fee";
testArray[1] = "fi";
testArray[4] = "foo";

for (i = 0; i < 6; i++) {
    if (testArray[i] == null) {
        trace("testArray[" + i + "] == null");
    }
}

/* 
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/

Elementos da API relacionados

Define métodos da classe ObjectProxy. Os métodos da classe ObjectProxy estão em seu próprio namespace para evitar conflitos de nomes em situações em que a subclasse Proxy contém nomes do método da ocorrência que correspondem a qualquer um dos nomes do método da classe Proxy.

override function name() { 
	// your statements here 
}

Especifica se um método substitui um método herdado. Para substituir um método herdado, é necessário usar o atributo override e garantir que o nome, o número, o tipo de parâmetros e o tipo de retorno correspondam exatamente. É um erro tentar substituir um método sem usar o atributo override. Do mesmo modo, é um erro usar o atributo override se o método não tem um método herdado correspondente.

Você não pode usar o atributo override em nenhum dos seguintes itens:

• Variáveis
• Constantes
• Métodos estáticos
• Métodos que não são herdados
• Métodos que implementam um método de interface
• Métodos herdados que são marcados como final na superclasse

Embora você não possa substituir uma propriedade declarada com var ou const, você pode atingir uma funcionalidade similar tornando a propriedade da classe de base um getter-setter substituindo os métodos definidos por get e set.

Elementos da API relacionados

package packageName {
    class someClassName { 
    } 
}

Permite que você organize seu código em grupos distintos que podem ser importados por outros scripts. Você deve usar a palavra-chave package para indicar que uma classe é um membro de um pacote.

Elementos da API relacionados

class className{ 
	private var varName;
	private const kName;
	private function methodName() { 
		// your statements here 
	}
	private namespace nsName;
}

Especifica se uma variável, constante ou método está disponível somente para a classe que a declara ou a define. Ao contrário do que ocorre no ActionScript 2.0, no ActionScript 3.0, o private não fornece mais acesso às subclasses. Além disso, o private restringe o acesso no período de compilação e no tempo de execução. Por padrão, uma variável ou função está disponível para qualquer chamador no mesmo pacote. Use esta palavra-chave se quiser restringir o acesso a uma variável ou função.

Você pode usar essa palavra-chave somente nas definições de classe, não nas definições de interface. Você não pode aplicar private a uma classe ou a quaisquer outras definições do nível de pacote.

class A { 
  private var alpha:String = "visible only inside class A"; 
  public var beta:String = "visible everywhere"; 
}
	
class B extends A {
  function B() {
    alpha = "Access attempt from subclass"; // error
  }
}

Elementos da API relacionados

class className{ 
	protected var varName;
	protected const kName;
	protected function methodName() { 
		// your statements here 
	}
	protected namespace nsName;
}

Especifica se uma variável, constante, método ou namespace está disponível somente para a classe que o define e a quaisquer subclasses desta classe. A definição de protected no ActionScript 3.0 é parecida com a definição do ActionScript 2.0 versão do private, exceto que protected restringe o acesso ao período de compilação e ao tempo de execução. Por padrão, uma variável ou função está disponível para qualquer chamador no mesmo pacote. Use esta palavra-chave se quiser restringir o acesso a uma variável ou função.

Você pode usar essa palavra-chave somente nas definições de classe, não nas definições de interface. Você não pode aplicar private a uma classe ou a quaisquer outras definições do nível de pacote.

A definição de protected no ActionScript 3.0 é mais restritiva do que aquela do protected na linguagem de programação Java. No ActionScript 3.0, o protected limita o acesso estritamente às subclasses, enquanto no Java, o protected também permite acesso a qualquer classe no mesmo pacote. Por exemplo, se uma classe chamada Base contiver uma propriedade marcada como protected, no ActionScript 3.0 somente as classes que estendem a Base podem acessar a propriedade protegida. No Java, qualquer classe no mesmo pacote como Base tem acesso à propriedade protegida mesmo se a classe não for uma subclasse da Base.

class A { 
  private var alpha:String = "visible only inside class A"; 
  protected var beta:String = "visible inside class A and its subclasses"; 
}
	
class B extends A {
  public function B() {
    beta = "Access attempt from subclass succeeded";
    trace(beta);  // Access attempt from subclass succeeded
  }
}

Elementos da API relacionados

public var varName
public const kName
public function functionName()  { 
	// your statements here 
}
public class className {
	// your statements here 
}
public namespace nsName

Especifica que uma classe, variável, constante ou método está disponível para qualquer chamador. As classes, variáveis e métodos são internamente determinados por padrão, o que significa que são visíveis somente no pacote atual. Para tornar uma classe, variável ou método visível a todos os chamadores, é necessário usar o atributo public.

class User { 
	public var age:Number; 
	public var fname:String; 
} // end of class User definition
 
var jimmy:User = new User(); 
jimmy.age = 27; 
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // 27 jimmy

Elementos da API relacionados

function functionName () {
	return [expression]
}

Faz com que a execução retorne imediatamente à função de chamada. Se a instrução return for acompanhada por uma expressão, a expressão é avaliada e o resultado retornado.

Se uma definição de função inclui um tipo de retorno, a instrução return deve ser acompanhada por uma expressão. Se nenhum tipo de retorno for especificado e a instrução return for usada sozinha, ela retorna undefined.

Você não pode retornar vários valores. Se você tentar, somente o último valor será retornado. No exemplo a seguir, c é retornado:

return a, b, c ;

Se você precisar retornar vários valores, use uma matriz ou um objeto em vez disso.

function sum(a:Number, b:Number, c:Number):Number { 
	return (a + b + c); 
} 
var newValue:Number = sum(4, 32, 78); 
trace(newValue); // 114

Elementos da API relacionados

function set property(newValue:*) : void{ 
	// your statements here 
}

Define um setter, que é um método que aparece na interface pública como uma propriedade. Um setter é um método especial que define o valor de uma propriedade declarada com a palavra-chave var. Ao contrário dos outros métodos, um setter é chamado sem parênteses ( ()), o que faz com que ele pareça ser uma variável.

Os setters permitem que você aplique o princípio da ocultação das informações possibilitando que você crie uma interface pública para uma propriedade privada. A vantagem da ocultação de informações é que a interface pública permanece a mesma, mesmo se a implementação básica da propriedade privada for alterada.

Outra vantagem dos setters é que eles podem ser substituídos nas subclasses, ao passo que as propriedades declaradas com var não podem.

O tipo de retorno de um setter deve ser void ou não especificado.

Um setter pode ser combinado com um getter para criar uma propriedade de leitura e gravação. Para criar uma propriedade somente de leitura, crie um getter sem um setter correspondente. Para criar uma propriedade somente de gravação, crie um setter sem um getter correspondente.

package {
	class User { 
	    private var userAge:Number; 
	    
	    public function get age():Number {
	    	return userAge;
	    }
	    
	    public function set age(x:Number):void {
	    	userAge = x;	
	    }
	} 
} 

var myUser:User = new User();
myUser.age = 25;
trace(myUser.age); // 25

Elementos da API relacionados

class someClassName{ 
	static var varName; 
	static const kName;
	static function methodName() { 
		// your statements here
	} 
}

Especifica que uma variável, constante ou método pertence à classe, não às ocorrências da classe.

Para acessar um membro de classe static, use o nome da classe em vez do nome de uma ocorrência. Por exemplo, a classe Data tem um método estático chamado parse(), que só pode ser chamado com o uso da seguinte sintaxe:

Date.parse()

O método parse() não pode ser chamado em uma ocorrência da classe Date. Por exemplo, o código a seguir gera um erro:

var myDate:Date = new Date();
            myDate.parse("Jan 01 00:00:00 2006"); // error

Você pode usar static somente nas definições de classe, não nas definições de interface.

Os membros da classe static não são herdados. Você não pode se referir a um membro de classe static usando o nome de uma subclasse, uma vez que você pode usar em Java e C++. Entretanto, você pode se referir a uma variável ou método static em uma classe ou subclasse, sem usar qualquer qualificador. Veja o exemplo abaixo.

Você não pode usar a instrução super ou a palavra-chave this em um método estático.

class Users { 
	private static var numInstances:Number = 0; 
	function Users() { 
		numInstances++; 
	} 
	static function get instances():Number { 
		return numInstances; 
	} 
}

trace(Users.instances); 
var user1:Users = new Users(); 
trace(Users.instances); 
var user2:Users = new Users(); 
trace(Users.instances); 

class PowerUsers extends Users{
    function PowerUsers() {
        instances++;  // unqualified reference to static property Users.instances is legal
    }
}

trace(PowerUsers.instances); // error, cannot access static property using PowerUsers class

super([arg1, ..., argN])
super.method([arg1, ..., argN])

Chama a versão da superclasse ou pai de um método ou construtor. Quando usada no corpo de um construtor de classe, a instrução super() chama a versão da superclasse do construtor. A chamada para o construtor da superclasse deve ter o número correto de argumentos. Note que o construtor da superclasse é sempre chamado, quer você chame-o explicitamente ou não. Se você não chamá-lo explicitamente, uma chamada sem argumentos é automaticamente inserida antes da primeira instrução no corpo do construtor da subclasse. Isso significa que se você definir uma função de construtor em uma subclasse, e o construtor da superclasse tiver um ou mais argumentos, você deve explicitamente chamar o construtor da superclasse com o número correto de argumentos ou ocorrerá um erro. A chamada para o construtor da superclasse, entretanto, não precisa ser a primeira instrução em seu construtor da subclasse, conforme requerido no ActionScript 2.0.

Quando usado no corpo de um método de ocorrência, super pode ser usado com o operador de ponto (.) para chamar a versão da superclasse de um método e pode opcionalmente transmitir os argumentos (arg1 ... argN) para o método da superclasse. Isso é útil para criar métodos de subclasse que não só incluem comportamento adicional aos métodos de superclasse, mas também chamam os métodos de superclasse para executar seu comportamento original.

Você não pode usar a instrução super em um método estático.

Elementos da API relacionados

switch (expression) {
	caseClause: 
	[defaultClause:] 
}

Gera o controle de transferência para uma das várias instruções, dependendo do valor de uma expressão. Todas as instruções switch devem incluir uma formatação padrão que será executada se nenhuma das instruções case corresponder à expressão. Cada instrução case deve terminar com uma instrução break, o que evita uma ocorrência de falha. Quando uma formatação falha, ela executa o código na próxima instrução case, mesmo que essa formatação não corresponda à expressão de teste.

var switchExpression:int = 3;
		
switch (switchExpression) {
	case 0:
		trace(0);
		break;
	case 1:
		trace(1);
		break;
	case 2:
		trace(2);
		break;
	default:
		trace("Not 0, 1, or 2");
}

// Not 0, 1, or 2

Elementos da API relacionados

this

Referência a um objeto que contém o método. Quando um script é executado, a palavra-chave this faz referência ao objeto que contém o script. Em um corpo do método, a palavra-chave this faz referência à ocorrência da classe que contém o método chamado.

// incorrect version of Simple.as
/*
dynamic class Simple {
    function callfunc() {
        func();
    }
}
*/
// correct version of Simple.as
dynamic class Simple {
    function callfunc() {
        this.func();
    }
}

var simpleObj:Simple = new Simple();
simpleObj.func = function() {
	trace("hello there");
}
simpleObj.callfunc();

throw expression 

Cria ou lança um erro que pode ser manipulado ou pego , por um bloco de códigos catch. Se uma exceção não for pega por um bloco catch, a representação da string do valor lançado é enviada ao painel Saída. Se uma exceção não for capturada por um bloco catch ou finally, a representação da string do valor lançado será enviada ao arquivo de registro.

Normalmente, você lança ocorrências da classe de Erro ou suas subclasses (veja a seção Exemplo).

function checkEmail(email:String) { 
	if (email.indexOf("@") == -1) { 
		throw new Error("Invalid email address"); 
	} 
} 
checkEmail("someuser_theirdomain.com");

try { 
	checkEmail("Joe Smith"); 
} 
catch (e) { 
	trace(e); 
}
// Error: Invalid email address.

// Define Error subclass InvalidEmailError 
class InvalidEmailAddress extends Error { 
    public function InvalidEmailAddress() {
    	message = "Invalid email address."; 
    }
}

import InvalidEmailAddress; 
function checkEmail(email:String) { 
	if (email.indexOf("@") == -1) { 
		throw new InvalidEmailAddress(); 
	} 
} 
try { 
	checkEmail("Joe Smith"); 
} 
catch (e) { 
	trace(e);
}
// Error: Invalid email address.

Elementos da API relacionados

true

Representação verdadeira do valor Booliano. O valor booliano é true ou false; o contrário de false é true. Quando a digitação automática dos dados converte true em um número, ela se torna 1; quando converte true em uma sequência de caracteres, ela se torna "true".

var shouldExecute:Boolean;
// ...
// code that sets shouldExecute to either true or false goes here
// shouldExecute is set to true for this example:

shouldExecute = true;

if (shouldExecute == true) {
    trace("your statements here");
}

// true is also implied, so the if statement could also be written:
// if (shouldExecute) {
//         trace("your statements here");
// }

var myNum:Number;
myNum = 1 + true;
trace(myNum); // 2

Elementos da API relacionados

try { 
    // try block 
} finally { 
    // finally block  
} 

try { 
    // try block 
} catch(error[:ErrorType1]) {
    // catch block 
} [catch(error[:ErrorTypeN]) { 
    // catch block 
}] [finally {
    // finally block 
}]

Inclui um bloco de códigos no qual um erro pode ocorrer, e depois responde ao erro. O controle de exceção, que é implementado usando instruções try..catch..finally, é o principal mecanismo para controlar condições de erro de execução no ActionScript 3.0. Quando ocorre um erro de tempo de execução, o Flash Player emite uma exceção, o que significa que o Flash Player suspende a execução normal e cria um objeto especial do tipo Error. O Flash Player então transmite ou lança o objeto Error para o primeiro bloco catch disponível. Se nenhum bloco catch estiver disponível, a exceção é considerada uma exceção não captada. As exceções não captadas fazem com que o script seja encerrado.

Você pode usar a instrução throw para lançar explicitamente as exceções em seu código. Você pode lançar qualquer valor, mas a melhor prática é lançar um objeto porque ele fornece flexibilidade e corresponde ao comportamento do Flash Player.

Para captar uma exceção, quer ela seja lançada pelo Flash Player, quer pelo seu próprio código, empregue o código que pode lançar a exceção em um bloco try. Se qualquer código no bloco try lançar uma exceção, o controle é transmitido para o bloco catch, se houver, e depois para o bloco finally, se houver. O bloco finally sempre é executado, independentemente de uma exceção ter sido lançada. Se o código no bloco try não lançar uma exceção (ou seja, se o bloco try for concluído normalmente), o código no bloco catch será ignorado, mas o código no bloco finally ainda será executado. O bloco finally é executado mesmo se o bloco try for encerrando com o uso de uma instrução return.

Um bloco try deve ser acompanhado por um bloco catch, um bloco finally ou ambos. Um único bloco try pode ter vários blocos catch, mas somente um bloco finally. Você pode aninhar os blocos try quantos níveis de profundidade desejar.

O parâmetro error especificado em um manipulador catch deve ser um identificador simples como e ou theException ou x. O parâmetro também pode ser digitado. Quando usados com vários blocos catch, os parâmetros digitados permitem que você capture vários tipos de objetos de erro lançados a partir de um único bloco try.

Se a exceção lançada for um objeto, o tipo combinará se o objeto lançado for uma subclasse do tipo especificado. Se um erro de um tipo específico for lançado, o bloco catch que manipula o erro correspondente será executado. Se uma exceção que não é do tipo especificado for lançada, o bloco catch não será executado e a exceção será automaticamente lançada para fora do bloco try em um manipulador catch que corresponder a ela.

Se um erro for lançado em uma função e a função não incluir um manipulador catch, o Flash Player fechará essa função, assim como quaisquer funções do chamador, até que um bloco catch seja encontrado. Durante esse processo, finally os manipuladores são chamados em todos os níveis.

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
	spr.addChild(spr);
}
catch (e:ArgumentError) {
	trace (e); // ArgumentError: Error #2024: An object may not be added as a child of itself.
}

class RecordSetException extends Error { 
	public function RecordSetException () {
		message = "Record set exception occurred."; 
	}
}

class MalformedRecord extends Error { 
	public function MalformedRecord {
		message = "Malformed record exception occurred."; 
	}
}

class RecordSet { 
	public function sortRows() { 
		var returnVal:Number = randomNum(); 
		if (returnVal == 1) { 
			throw new RecordSetException(); 
		} 
		else if (returnVal == 2) { 
			throw new MalformedRecord(); 
		} 
	}
	public function randomNum():Number { 
		return Math.round(Math.random() * 10) % 3; 
	}
}

import RecordSet; 
var myRecordSet:RecordSet = new RecordSet();
try { 
	myRecordSet.sortRows(); 
	trace("everything is fine"); 
} 
catch (e:RecordSetException) { 
	trace(e.toString()); 
} 
catch (e:MalformedRecord) { 
	trace(e.toString()); 
}

Elementos da API relacionados

use namespace ns1[, ns2, ...nsN]

Faz com que os namespaces especificados sejam adicionados ao conjunto de namespaces abertos. Os namespaces especificados são removidos do conjunto de namespaces abertos quando o bloco de códigos atual é encerrado. A diretiva use namespace pode aparecer no nível superior de um programa, definição de pacote ou definição de classe.

Elementos da API relacionados

var variableName [= value1][...,variableNameN[=valueN]] 

Especifica uma variável. Se você declarar variáveis em uma função, as variáveis serão locais. Elas serão definidas para a função e expirarão ao final da chamada da função.

Você não pode declarar uma variável que esteja no escopo de outro objeto como uma variável local.

my_array.length = 25; // ok 
var my_array.length = 25; // syntax error 

Você pode atribuir um tipo de dados a uma variável inserindo o caractere dois pontos seguido do tipo de dados.

Você pode declarar múltiplas variáveis em uma instrução, separando as declarações por vírgulas (embora essa sintaxe possa reduzir a clareza em seu código):

var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";

var product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); 
trace(product_array); 
// Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

Elementos da API relacionados

while (condition) { 
	// statement(s)
}

Avalia uma condição e, se esta for avaliada como true, executa uma ou mais instruções antes de fazer a repetição de volta para avaliar a condição novamente. Após a condição ser avaliada como false, as instruções são ignoradas e a repetição termina.

A instrução while executa as seguintes séries de etapas. Cada repetição das etapas 1 a 4 é chamada de iteração da repetição. A condição é testada no início de cada iteração, conforme mostrado nas etapas a seguir:

1. A expressão condition é avaliada.
2. Se condition for avaliada como true ou um valor que é convertido para o valor Booliano true, como um número diferente de zero, vá para a etapa 3. Caso contrário, a instrução while é concluída e a execução é retomada na próxima instrução após a repetição while.
3. Execute o bloco de instruções statement(s). Se uma instrução continue for encontrada, ignore as instruções restantes e vá para a etapa 1. Se uma instrução break for encontrada, a instrução while será concluída e a execução será retomada na próxima instrução após a repetição while.
4. Vá para a etapa 1.

A repetição é normalmente usada para realizar uma ação enquanto uma variável do contador for menor do que um valor especificado. Ao final de cada repetição, o contador é aumentado até que o valor especificado é alcançado. Nesse momento, condition não é mais true e a repetição termina.

As chaves {}) que incluem as instruções a serem executadas pela instrução while não serão necessárias se apenas uma instrução for executada.

var i:Number = 0; 
while (i < 20) { 
	trace(i); 
	i += 3; 
}
/*
0 
3 
6 
9 
12
15 
18
*/

Elementos da API relacionados

with (object:Object) { 
	// statement(s)
}

Estabelece um objeto padrão a ser usado para a execução de uma instrução ou instruções, reduzindo potencialmente a quantidade de códigos que precisam ser gravados.

O parâmetro object torna-se o contexto no qual as propriedades, variáveis e funções no parâmetro statement(s) são lidas. Por exemplo, se object for my_array e duas das propriedades especificadas forem length e concat, essas propriedades serão automaticamente lidas como my_array.length e my_array.concat. Em outro exemplo, se object for state.california, quaisquer ações ou instruções na instrução with serão chamadas a partir da ocorrência .

Para encontrar o valor de um identificador no parâmetro statement(s), o ActionScript começa no início da cadeia do escopo especificada pelo object e procura o identificador em cada nível da cadeia do escopo, em uma ordem específica.

A cadeia do escopo usada pela instrução with para determinar os identificadores começa com o primeiro item na lista a seguir e continua até o último item:

• Objeto especificado no parâmetro object na instrução interna with
• Objeto especificado no parâmetro object na instrução externa with
• Objeto Ativação (um objeto temporário que é automaticamente criado quando o script chama uma função que mantém as variáveis locais chamadas na função)
• Objeto que contém o script executado atualmente
• Objeto Global (objetos incorporados como Math e String)

Para definir uma variável em uma instrução with, é necessário ter declarado a variável fora da instrução with ou você deve digitar o caminho completo para a linha de tempo na qual você deseja que a variável fique. Se você definir uma variável em uma instrução with sem declará-la, a instrução with procurará o valor de acordo com a cadeia do escopo. Se a variável ainda não existir, o novo valor será definido na linha de tempo a partir da qual a instrução with foi chamada.

function polar(r:Number):void { 
	var a:Number, x:Number, y:Number; 
	with (Math) { 
		a = PI * pow(r, 2); 
		x = r * cos(PI); 
		y = r * sin(PI / 2); 
	} 
	trace("area = " + a); 
	trace("x = " + x); 
	trace("y = " + y); 
} polar(3);
/* 
area = 28.2743338823081 
x = -3 
y = 3
*/