Operadores 

Adiciona expressões numéricas. Se ambas as expressões são números inteiros, a soma é um número inteiro; se qualquer uma das expressões ou ambas são números de ponto flutuante, a soma é um número de ponto flutuante.

Se uma expressão é uma string, todas as outras expressões são convertidas em strings e concatenadas, em vez de somadas. Caso contrário, se uma expressão não for um número, o Flash ^® Player a converterá em um número.

trace(2 + 3); // 5

trace(2.5 + 3.25); // 5.75

trace("Number " + 8 + 0); // Number 80

var oldBalance:Number = 1345.23; 
var currentBalance = deposit_txt.text + oldBalance; 
trace(currentBalance); 

var oldBalance:Number = 1345.23; 
var currentBalance:Number = Number(deposit_txt.text) + oldBalance;
trace(currentBalance);

Elementos da API relacionados

Atribui a expression1 o valor de expression1 + expression2. Por exemplo, as duas instruções a seguir têm o mesmo resultado:

x += y; 
x = x + y; 

var x:Number = 5; 
var y:Number = 10; 
x += y; 
trace(x); // 15 

Elementos da API relacionados

myArray = [a0, a1,...aN]
myArray[i] = value 
myObject[propertyName]

Inicializa uma nova matriz ou matriz multidimensional com elementos específicos ( a0, etc.), ou acessa elementos em uma matriz. O operador de acesso à matriz permite definir e recuperar dinamicamente os nomes de ocorrência, variável e objeto. Permite também acessar as propriedades dos objetos.

Uso 1: matriz é um objeto com propriedades chamadas elementos, que são identificados individualmente por um número denominado índice. Ao criar uma matriz, você envolve os elementos com o operador (ou colchetes) de acesso ([]) à matriz. Uma matriz pode conter elementos de vários tipos. Por exemplo, a matriz a seguir, denominada employee, tem três elementos; o primeiro é um número e os dois elementos seguintes são strings (entre aspas):

var employee:Array = [15, "Barbara", "Jay"]; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
			
/* Select Debug > List Variables in test mode 
to see a list of the array elements.*/ 

var my_array:Array = new Array(); 
my_array[0] = 15; 
my_array[1] = "Hello"; 
my_array[2] = true; 

my_array[3] = "George"; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
trace(ticTacToe[1][2]); // 6 

var obj:Object = new Object();
obj.prop1 = "foo";
trace(obj["prop" + 1]); // foo
obj.prop2 = "bar";
for (j in obj) {
	trace(obj[j]);
} 
/* Output of for loop: 
foo
bar */

var my_array:Array = []; 
var my_array:Array = new Array(); 

O exemplo a seguir cria uma matriz denominada employee_array com três elementos, e altera o terceiro elemento na matriz.

var employee_array = ["Barbara", "George", "Mary"]; 
trace(employee_array); // Barbara,George,Mary 
employee_array[2] = "Sam"; 
trace(employee_array); // Barbara,George,Sam 

var obj:Object = new Object();
obj.prop1 = "foo";
obj.prop2 = "bar";

for (var i:int = 1;i < 3;i++) {
	trace(obj["prop"+i]);
}
/* Output of for loop:
foo
bar */ 

Elementos da API relacionados

Avalia se uma expressão especificada pelo primeiro operando é um membro do tipo de dados especificado pelo segundo operando. Se for, o resultado será o primeiro operando. Caso contrário, o resultado é o valor null.

A expressão usada para o segundo operando deve ser avaliada como um tipo de dados.

public var myArray:Array = ["one", "two", "three"];
trace(myArray as Array);  // one,two,three
trace(myArray as Number); // null
trace(myArray as int);    // null

Elementos da API relacionados

Atribui o valor de expression2 (o operando à direita) à variável, ao elemento de matriz ou à propriedade em expression1. A atribuição pode ser por valor ou por referência. A atribuição por valor copia o valor real de expression2 e o armazena em expression1. A atribuição por valor é usada quando expression2 é um valor primitivo, o que significa que seu tipo de dados é Boolean, Number, int, uint ou String. A atribuição por referência armazena uma referência a expression2 em expression1. A atribuição por referência é frequentemente utilizada com o operador new. O operador new cria um objeto na memória, e a referência a esse local na memória é atribuída a uma variável.

Nota:no ActionScript 3.0, todos os valores (incluindo valores primitivos) são objetos, e toda a atribuição é feita por referência. No entanto, os objetos primitivos têm operadores especiais, que permitem que os objetos se comportem como se fossem atribuídos por valor.

var z:Number = 5;

var x:String;
x = "hello";

var moonsOfJupiter:Array = new Array();
moonsOfJupiter[0] = "Callisto";

var mercury:Object = new Object();
mercury.diameter = 3030; // in miles
trace(mercury.diameter); // 3030

var merkur:Object = mercury;
merkur.diameter = 4878;  // in kilometers
trace(mercury.diameter); // 4878

Elementos da API relacionados

 myXML.@attributeName 

Identifica atributos de um objeto XML ou XMLList. Por exemplo, myXML.@id identifica atributos nomeados como id para o objeto XML myXML. Você também pode usar a seguinte sintaxe para acessar atributos: myXML.attribute("id"), myXML["@id"], e myXML.@["id"]. A sintaxe myXML.@id é recomendada. Para retornar um objeto XMLList de todos os nomes de atributos, use @*. Para retornar um atributo com um nome que corresponda a uma palavra reservada do ActionScript, use o método attribute(), em vez do operador @.

var myXML:XML = 
	<item id = "42">
		<catalogName>Presta tube</catalogName>
		<price>3.99</price>
	</item>;

trace(myXML.@id); // 42

var xml:XML =<example id='123' color='blue'/>
 var xml2:XMLList = xml.@*;
 trace(xml2 is XMLList); // true
 trace(xml2.length());  // 2
 for (var i:int = 0; i < xml2.length(); i++)
 { 
	trace(typeof(xml2[i]));    // xml
	trace(xml2[i].nodeKind()); // attribute
	trace(xml2[i].name());     // id and color
 } 

var xml:XML = <example class='123'/>
trace(xml.attribute("class"));

Elementos da API relacionados

Converte expression1 e expression2 em números inteiros sem sinal de 32 bits e realiza uma operação AND booliana em cada bit de parâmetros de números inteiros. Números de pontos flutuantes são convertidos em números inteiros descartando-se quaisquer dígitos após o separador decimal. O resultado é um número inteiro assinado de 32 bits.

Um número inteiro positivo é convertido em um valor hexadecimal sem sinal, com um valor máximo de 4294967295 ou 0xFFFFFFFF. Na conversão de valores maiores, serão descartados os dígitos mais significativos, de forma que o valor convertido ainda seja de 32 bits. Um número negativo é convertido em um valor hexadecimal sem sinal, usando a notação de complemento de dois, com um valor mínimo de -2147483648 ou 0x800000000. Um número menor será convertido para o complemento de dois com precisão maior, antes que os dígitos mais significativos sejam descartados.

O resultado é interpretado como um número de complemento de dois de 32 bits, portanto, o resultado é um número inteiro no intervalo de -2147483648 a 2147483647.

var insert:Number = 13; 
var update:Number = 11; 
trace(insert & update); // 9 (or 1001 binary) 

  1101
& 1011
  ----
  1001

Os exemplos a seguir mostram o comportamento da conversão de valores de retorno:

trace(0xFFFFFFFF); // 4294967295 
trace(0xFFFFFFFF & 0xFFFFFFFF); // -1 
trace(0xFFFFFFFF & -1); // -1 
trace(4294967295 & -1); // -1 
trace(4294967295 & 4294967295); // -1 

Elementos da API relacionados

Atribui a expression1 o valor de expression1 / expression2. Por exemplo, as duas expressões a seguir são equivalentes:

x &= y; 
x = x & y; 

var x:Number = 15; 
var y:Number = 9; 
trace(x &= y); // 9 

Elementos da API relacionados

Converte expression1 e shiftCount em números inteiros de 32 bits e desloca todos os bits em expression1 para a esquerda pela quantidade de casas decimais especificadas pelo número inteiro resultante da conversão de shiftCount. As posições de bits que são esvaziadas como resultado dessa operação são preenchidas com 0, e os bits deslocados da extremidade esquerda são descartados. Deslocar um valor para a esquerda em uma posição é equivalente a multiplicá-lo por 2.

Um número de ponto flutuante é convertido em um número inteiro, descartando os dígitos após o ponto decimal. Um número inteiro positivo é convertido em um valor hexadecimal sem sinal, com um valor máximo de 4294967295 ou 0xFFFFFFFF. Na conversão de valores maiores, serão descartados os dígitos mais significativos, de forma que o valor convertido ainda seja de 32 bits. Um número negativo é convertido em um valor hexadecimal sem sinal, usando a notação de complemento de dois, com um valor mínimo de -2147483648 ou 0x800000000. Um número menor será convertido para o complemento de dois com precisão maior, antes que os dígitos mais significativos sejam descartados.

O resultado é interpretado como um número de complemento de dois de 32 bits, portanto, o resultado é um número inteiro no intervalo de -2147483648 a 2147483647.

Se o resultado é um número inteiro negativo, ocorre um erro de tempo de execução, se você tentar atribuir o resultado a uma variável do tipo uint. Embora o ActionScript não tenha operadores de "deslocamento à esquerda bit a bit sem sinal", é possível obter o mesmo efeito e evitar o erro de tempo de execução, usando uint(expression1 << shiftCount):

var num1:uint = 0xFF;
var num2:uint = uint(num1 << 24); // uint() prevents runtime error

x = 1 << 10

   00000000001 binary 
<<          10 decimal
--------------
   10000000000 binary equals 1024 decimal 

No exemplo a seguir, o número inteiro 7 é deslocado 8 bits para a esquerda:

x = 7 << 8

   00000000111 binary 
<<           8 decimal
--------------
   11100000000 binary equals 1792 decimal 

A instrução trace a seguir mostra que os bits que foram empurrados três posições para a esquerda:

// 1 binary == 0001 
// 8 binary == 1000 
trace(1 << 3); // 8 

Elementos da API relacionados

Realiza uma operação de deslocamento bit a bit para a esquerda ( <<=) e armazena o conteúdo como um resultado em expression1. As duas expressões a seguir são equivalentes:

A <<= B
A = (A << B)

var x:Number = 4; 
// Shift all bits one slot to the left. 
x <<= 1; 
trace(x); // 8 
// 4 decimal = 0100 binary 
// 8 decimal = 1000 binary 

Elementos da API relacionados

Converte expression para um número inteiro assinado de 32 bits e, em seguida, aplica um complemento de um, bit a bit. Isso significa que cada bit que é 0 é definido como 1 no resultado, e cada bit que é 1 é definido como 0 no resultado. O resultado é um número inteiro assinado de 32 bits. Este operador também é conhecido como o operador do complemento de 1 ou o operador do complemento bit a bit.

Por exemplo, o valor hexadecimal 0x7777 é representado como este número binário:

0111011101110111

A negação bit a bit deste valor hexadecimal, ~0x7777, é um número binário:

1000100010001000

Em hexadecimal, isso é 0x8888. Portanto, ~0x7777 é 0x8888.

O uso mais comum dos operadores bit a bit é para representar bits de sinalizadores (valores Boolianos compactados em 1 bit cada um).

Um número de ponto flutuante é convertido em um número inteiro, descartando os dígitos após o ponto decimal. Um número inteiro positivo é convertido em um valor hexadecimal sem sinal, com um valor máximo de 4294967295 ou 0xFFFFFFFF. Na conversão de valores maiores, serão descartados os dígitos mais significativos, de forma que o valor convertido ainda seja de 32 bits. Um número negativo é convertido em um valor hexadecimal sem sinal, usando a notação de complemento de dois, com um valor mínimo de -2147483648 ou 0x800000000. Um número menor será convertido para o complemento de dois com precisão maior, antes que os dígitos mais significativos sejam descartados.

O resultado é interpretado como um número de complemento de dois de 32 bits, portanto, o resultado é um número inteiro no intervalo de -2147483648 a 2147483647.

var ReadOnlyFlag:int = 0x0001; // defines bit 0 as the read-only flag 
var flags:int = 0; 
trace(flags); 
/* To set the read-only flag in the flags variable, 
   the following code uses the bitwise OR: 
*/
flags |= ReadOnlyFlag; 
trace(flags); 
/* To clear the read-only flag in the flags variable, 
   first construct a mask by using bitwise NOT on ReadOnlyFlag. 
   In the mask, every bit is a 1 except for the read-only flag. 
   Then, use bitwise AND with the mask to clear the read-only flag. 
   The following code constructs the mask and performs the bitwise AND: 
*/ 
flags &= ~ReadOnlyFlag; 
trace(flags); 
// 0 1 0 

Elementos da API relacionados

Converte expression1 e expression2 em números inteiros de 32 bits sem sinal, e coloca um algarismo 1 em cada posição, onde os bits correspondentes em expression1 ou expression2 são 1.

Um número de ponto flutuante é convertido em um número inteiro, descartando os dígitos após o ponto decimal. Um número inteiro positivo é convertido em um valor hexadecimal sem sinal, com um valor máximo de 4294967295 ou 0xFFFFFFFF. Na conversão de valores maiores, serão descartados os dígitos mais significativos, de forma que o valor convertido ainda seja de 32 bits. Um número negativo é convertido em um valor hexadecimal sem sinal, usando a notação de complemento de dois, com um valor mínimo de -2147483648 ou 0x800000000. Um número menor será convertido para o complemento de dois com precisão maior, antes que os dígitos mais significativos sejam descartados.

O resultado é interpretado como um número de complemento de dois de 32 bits, portanto, o resultado é um número inteiro no intervalo de -2147483648 a 2147483647.

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 | 1001 = 1111 
trace(a | b); // returns 15 decimal (1111 binary) 

Elementos da API relacionados

Atribui a expression1 o valor de expression1 | expression2 . Por exemplo, as duas instruções a seguir são equivalentes:

x |= y; 
x = x | y; 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 |= 1001 = 1111 
trace(a |= b); // returns 15 decimal (1111 binary) 

Elementos da API relacionados

Converte expression e shiftCount em números inteiros de 32 bits, e desloca todos os bits em expression para a direita pela quantidade de casas decimais especificadas pelo número inteiro resultante da conversão de shiftCount. Os bits que forem deslocados da extremidade direita serão. Para preservar o sinal da expressão original, os bits à esquerda são preenchidos com 0, se o bit mais significativo (o bit mais à esquerda) de expression for 0, e são preenchidos com 1, se o bit mais significativo for 1. Deslocar o valor para a direita em uma posição equivale a dividi-lo por 2 e descartar o restante.

Um número de ponto flutuante é convertido em um número inteiro, descartando os dígitos após o ponto decimal. Um número inteiro positivo é convertido em um valor hexadecimal sem sinal, com um valor máximo de 4294967295 ou 0xFFFFFFFF. Na conversão de valores maiores, serão descartados os dígitos mais significativos, de forma que o valor convertido ainda seja de 32 bits. Um número negativo é convertido em um valor hexadecimal sem sinal, usando a notação de complemento de dois, com um valor mínimo de -2147483648 ou 0x800000000. Um número menor será convertido para o complemento de dois com precisão maior, antes que os dígitos mais significativos sejam descartados.

O resultado é interpretado como um número de complemento de dois de 32 bits, portanto, o resultado é um número inteiro no intervalo de -2147483648 a 2147483647.

var a:Number = 65535 >> 8; 
trace(a); // 255

    00000000000000001111111111111111 binary (65535 decimal)
>>                                 8 decimal
--------------------
    00000000000000000000000011111111 binary (255 decimal)

var a:Number = -8 >> 1;
trace(a); // -4

    11111111111111111111111111111000 binary (-8 decimal)
>>							    1 decimal
--------------------
    11111111111111111111111111111100 binary (-4 decimal)

Elementos da API relacionados

Realiza uma operação de deslocamento para a direita bit a bit e armazena o resultado em expression.

As duas instruções a seguir são equivalentes:

A >>= B; 
A = (A >> B);

function convertToBinary(numberToConvert:Number):String { 
	var result:String = ""; 
	for (var i = 0; i < 32; i++) { 
		// Extract least significant bit using bitwise AND. 
		var lsb:Number = numberToConvert & 1; 
		// Add this bit to the result.
		result = (lsb ? "1" : "0")+result; 
		// Shift numberToConvert right by one bit, to see next bit. 
		numberToConvert >>= 1; 
	} 
	return result; 
} 
trace(convertToBinary(479)); 
// Returns the string 00000000000000000000000111011111. 
// This string is the binary representation of the decimal number 479.

Elementos da API relacionados

O mesmo do operador de deslocamento para a direita bit a bit ( >>), exceto que ele não preserva o sinal da expressão original, porque os bits à esquerda são sempre preenchidos com 0.

Um número de ponto flutuante é convertido em um número inteiro, descartando os dígitos após o ponto decimal. Um número inteiro positivo é convertido em um valor hexadecimal sem sinal, com um valor máximo de 4294967295 ou 0xFFFFFFFF. Na conversão de valores maiores, serão descartados os dígitos mais significativos, de forma que o valor convertido ainda seja de 32 bits. Um número negativo é convertido em um valor hexadecimal sem sinal, usando a notação de complemento de dois, com um valor mínimo de -2147483648 ou 0x800000000. Um número menor será convertido para o complemento de dois com precisão maior, antes que os dígitos mais significativos sejam descartados.

O resultado é interpretado como um número inteiro de 32 bits sem sinal, portanto, o resultado é um número inteiro no intervalo de 0 a 4294967295.

Nota:o ActionScript não tem operadores complementares "deslocamento para a esquerda bit a bit sem sinal", mas é possível obter o mesmo efeito usando uint(expression << shiftCount).

var a:Number = -1 >>> 1; 
trace(a); // 2147483647 

Elementos da API relacionados

Realiza uma operação de deslocamento para a direita bit a bit sem sinal e armazena o resultado em expression. As duas instruções a seguir são equivalentes:

A >>>= B; 
A = (A >>> B); 

var a:Number = -1;
a >>>= 1; 
trace(a); // 2147483647 

Elementos da API relacionados

Converte expression1 e expression2 em números inteiros sem sinal de 32 bits e coloca um algarismo 1 em cada posição, onde os bits correspondentes em expression1 ou expression2, mas não ambos, são 1.

Um número de ponto flutuante é convertido em um número inteiro, descartando os dígitos após o ponto decimal. Um número inteiro positivo é convertido em um valor hexadecimal sem sinal, com um valor máximo de 4294967295 ou 0xFFFFFFFF. Na conversão de valores maiores, serão descartados os dígitos mais significativos, de forma que o valor convertido ainda seja de 32 bits. Um número negativo é convertido em um valor hexadecimal sem sinal, usando a notação de complemento de dois, com um valor mínimo de -2147483648 ou 0x800000000. Um número menor será convertido para o complemento de dois com precisão maior, antes que os dígitos mais significativos sejam descartados.

O resultado é interpretado como um número de complemento de dois de 32 bits, portanto, o resultado é um número inteiro no intervalo de -2147483648 a 2147483647.

// 15 decimal = 1111 binary 
// 9 decimal = 1001 binary 
var a:Number = 15 ^ 9; 
trace(a); 
// 1111 ^ 1001 = 0110 
// returns 6 decimal (0110 binary) 

Elementos da API relacionados

Atribui a expression1 o valor de expression1 / expression2. Por exemplo, as duas instruções a seguir são equivalentes:

x ^= y 
x = x ^ y 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
trace(a ^= b); // returns 6 decimal (0110 binary) 

Elementos da API relacionados

/* comment */

/* comment

   comment */

Delimita uma ou mais linhas de comentários de script. Os caracteres que aparecem entre o delimitador de abertura ( /*) e o delimitador de fechamento ( */) são interpretados como um comentário e ignorados pelo compilador do ActionScript. Use estes delimitadores para identificar comentários em várias linhas sucessivas; para comentários de uma linha, use o delimitador //.

Você receberá uma mensagem de erro, se omitir o delimitador de comentário de bloco de fechamento ( */), ou se tentar aninhar comentários. Após o uso de um delimitador de abertura ( /*), o primeiro delimitador de fechamento ( */) finaliza o comentário, independentemente do número de delimitadores de abertura colocados antes dele.

/* records the X and Y positions of 
the ball and bat movie clips */ 
var ballX:Number = ball_mc._x; 
var ballY:Number = ball_mc._y; 
var batX:Number = bat_mc._x; 
var batY:Number = bat_mc._y; 

/* This is an attempt to nest comments. 
/* But the first closing tag will be paired 
with the first opening tag */ 
and this text will not be interpreted as a comment */ 

Elementos da API relacionados

 myXML = <{tagName} {attributeName} = {attributeValue}>{content}

Avalia uma expressão que é usada em um inicializador XML ou XMLList. Um inicializador XML ou XMLList é um valor literal atribuído a um tipo de variável XML ou XMLList. Uma expressão delimitada pelos operadores { and } do XML pode ser utilizada em um inicializador XML ou XMLList, em vez de nomes literais ou valores. Também pode ser utilizada uma expressão no lugar de tagName, attributeName, attributeValue e content.

var tagname:String = "item"; 
var attributename:String = "id"; 
var attributevalue:String = "5"; 
var content:String = "Chicken"; 
var x:XML = <{tagname} {attributename}={attributevalue}>{content}</{tagname}>; 
trace(x.toXMLString()); // <item id="5">Chicken</item>

Elementos da API relacionados

 myXML[expression]

Acessa uma propriedade ou um atributo de um objeto XML ou XMLList. O operador de colchetes permite acessar nomes de propriedades que não são acessíveis com o operador ponto ( .).

var myXML:XML = <a><foo-bar>44</foo-bar></a>;
trace(myXML["foo-bar"]);

Elementos da API relacionados

Avalia expression1, em seguida, expression2 e assim por diante. Este operador é usado principalmente com a instrução de repetição for e é frequentemente usado com o operador parênteses ().

for (i = 0, j = 0; i < 3 && j < 3; i++, j+=2) { 
	trace("i = " + i + ", j = " + j); 
} 
// output: 
// i = 0, j = 0 
// i = 1, j = 2

var v:Number = 0; 
v = 4, 5, 6; 
trace(v); // 4 

var v:Number = 0; 
v = (4, 5, 6); 
trace(v); // 6 

var v:Number = 0; 
var z:Number = 0; 
v = v + 4 , z++, v + 6; 
trace(v); // 4 
trace(z); // 1 

var v:Number = 0; 
var z:Number = 0; 
v = (v + 4, z++, v + 6); 
trace(v); // 6 
trace(z); // 1 

Elementos da API relacionados

Concatena (combina) strings. Se uma expressão é uma string, todas as outras expressões são convertidas em strings e concatenadas.

Se ambas as expressões são números, este operador se comporta como um operador de adição.

var lastName:String = "Cola"; 
var instrument:String = "Drums"; 
trace(lastName + " plays " + instrument); // Cola plays Drums 

trace("Number " + 8 + 0); // Number 80

var a:String = 3 + 10 + "asdf"; 
trace(a); // 13asdf 
var b:String = "asdf" + 3 + 10; 
trace(b); // asdf310 

Elementos da API relacionados

expression1 + expression2

Concatena (combina) valores XML ou XMLList em um objeto XMLList. Um objeto XMLList resulta apenas se ambos os operadores são valores XML ou XMLList.

var x1:XML = 
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>;

var x2:XML = 
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>;

var myXMLList:XMLList = x1 + x2;
	
trace(myXMLList.toXMLString()); 

A instrução trace produz o seguinte resultado:

<employee id = "42">
	<firstName>Joe</firstName>
	<lastName>Smith</lastName>
</employee>
<employee id = "43">
	<firstName>Susan</firstName>
	<lastName>Jones</lastName>
</employee>
	

Elementos da API relacionados

Atribui a expression1 o valor de expression1 + expression2. Por exemplo, as duas instruções a seguir têm o mesmo resultado:

x += y; 
x = x + y;

var x1:String = "My name is "; 
x1 += "Gilbert"; 
trace(x1); // My name is Gilbert 

Elementos da API relacionados

expression1 += expression2

Atribui a expression1, que é um objeto XMLList, o valor de expression1 + expression2. Por exemplo, as duas instruções a seguir têm o mesmo resultado:

x += y; 
x = x + y; 

var x1:XML = <location>Athens</location>;	
var x2:XML = <location>Paris</location>;		
myXMLList = x1 + x2;

var x3:XML = <location>Springfield</location>;
myXMLList += x3;
		    
trace(myXMLList.toXMLString());

A instrução trace produz o seguinte resultado:

<location>Athens</location>
	
<location>Paris</location>	

<location>Springfield</location>

Elementos da API relacionados

expression1 ? expression2 : expression3

Avalia a expression1, e se o valor de expression1 for true, o resultado será o valor de expression2; caso contrário, o resultado será o valor de expression3.

var x:Number = 5; 
var y:Number = 10; 
var z = (x < 6) ? x: y; 
trace(z); // returns 5

var timecode:String = (new Date().getHours() < 11) ? "AM" : "PM"; 
trace(timecode); 

if (new Date().getHours() < 11) { 
	var timecode:String = "AM"; 
} else { 
	var timecode:String = "PM"; 
}
trace(timecode); 

--expression

expression--

Subtrai 1 do operando. O operando pode ser uma variável, um elemento em uma matriz ou uma propriedade de um objeto. A forma pré-redução do operador ( --expression) subtrai 1 de expression e retorna o resultado. A forma pós-redução do operador ( expression--) subtrai 1 de expression e retorna o valor inicial de expression (o valor anterior à subtração).

var x:Number = 3; 
var y:Number = --x; // y is equal to 2

var x:Number = 3; 
var y:Number = x--; // y is equal to 3

for (var i = 10; i > 0; i--) { 
	trace(i); 
}

 delete reference

Destrói a propriedade do objeto, especificada por reference; o resultado será true se a propriedade não existir depois da conclusão da operação; caso contrário, será false. O operador delete retornará true se for chamado em uma propriedade não inexistente ou em uma propriedade dinâmica não definida em uma classe.

O operador delete poderá falhar e retornar false, se o parâmetro reference não puder ser excluído. Não é possível excluir propriedades fixas ou variáveis que são declaradas com a instrução var. Uma propriedade fixa é uma variável ou um método definido em uma definição de classe.

O operador delete não pode ser usado para destruir uma propriedade de classe, a menos que essa classe seja uma classe dinâmica adicionada durante o tempo de execução. As propriedades das classes selecionadas não podem ser destruídas utilizando delete. Em vez disso, defina a propriedade como null.

Nota: não é possível excluir um objeto, mas é possível torná-lo qualificado para coleta de lixo removendo todas as referências ao objeto. A referência mais frequente a um objeto é uma variável que aponta para o objeto. Remova a referência definindo a variável como null. O coletor de lixo remove qualquer objeto que não tenha referências.

// create the new object "account" 
var account:Object = new Object(); 
// assign property name to the account 
account.name = "Jon"; 
// delete the property 
delete account.name; 
trace(account.name); // undefined

// delete a nonexistent property
var fooDeleted:Boolean = delete account.foo;
trace(fooDeleted); // true

O exemplo a seguir exclui o valor de um elemento de matriz, mas o valor da propriedade length fica inalterado:

var my_array:Array = new Array(); 
my_array[0] = "abc"; // my_array.length == 1 
my_array[1] = "def"; // my_array.length == 2 
my_array[2] = "ghi"; // my_array.length == 3 
// my_array[2] is deleted, but Array.length is not changed 
delete my_array[2]; 
trace(my_array.length); // 3 
trace(my_array); // abc,def,

O exemplo a seguir mostra como o Booliano retornado de delete pode ser usado como uma condição para a execução futura de códigos. Observe que, se um item já tiver sido excluído, uma nova chamada de delete no item retornará false.

var my_array:Array = [ "abc", "def", "ghi" ];
var deleteWasSuccessful:Boolean

deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[1];
deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[2];

trace(my_array) // outputs: undefined,undefined,ghi

Elementos da API relacionados

 delete reference

Exclui os elementos ou atributos XML especificados por reference.

 
var x1:XML = <x1>
				<a id = "52">AYY</a>
				<a>AYY 2 </a>
				<b>BEE</b>
				<c>CEE</c>
			</x1>;

trace(x1.toXMLString());
trace("___________");

delete x1.a.@id;

trace(x1.toXMLString());
trace("___________");

delete x1.b;

trace(x1.toXMLString());
trace("___________");

delete x1.a;

trace(x1.toXMLString());

O resultado é o seguinte:

<x1>
  <a id="52">AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <c>CEE</c>
</x1>
___________
<x1>
  <c>CEE</c>
</x1>

 
var xml:XML = 
			<order>
				<item id="121">hamburger</item>
				<item id="122">fries</item>
				<item id="123">chocolate shake</item>
			</order>;
delete xml.item[1].*;
delete xml.item[1].@*;
trace(xml);

O resultado deste exemplo é o seguinte:

<order>
  <tem id="121">hamburger</item>
  <item/>
  <item id="123">chocolate shake</item>
</order>

 myXML..childElement1..@attributeName 

Navega até elementos descendentes de um objeto XML ou XMLList, ou (combinado com o operador @) localiza atributos correspondentes aos descendentes. Não é necessário que os elementos ou atributos correspondentes sejam filhos diretos do objeto XML ou XMLList; eles podem estar mais abaixo na árvore (por exemplo, netos). O resultado é um objeto XMLList, porque mais de um elemento filho ou atributo podem ser correspondentes.

A ordem dos nós no objeto XMLList retornado é o resultado de uma busca em profundidade. Por exemplo, considere o seguinte:

var myXML:XML = <a>
			<b>one
				<c> 
					<b>two</b> 
				</c> 
			</b>
			<b>three</b>
		</a>;

trace(myXML..b[0].toXMLString());
trace("______________");
trace(myXML..b[1].toXMLString());
trace("______________");
trace(myXML..b[2].toXMLString());

A seguinte saída resultaria em:

<b>
  one
  <c>
    <b>two</b>
  </c>
</b>
______________
<b>two</b>
______________
<b>three</b>

Para retornar descendentes com nomes que correspondam às palavras reservadas do ActionScript, use o método XML.descendants(), em vez do operador descendentes (..), como mostrado no exemplo abaixo:

var xml:XML = 
<enrollees>
	<student id="239">
		<class name="Algebra" />
 		<class name="Spanish 2"/>
	</student>
	<student id="206">
		<class name="Trigonometry" />
 		<class name="Spanish 2" />
	</student>
 </enrollees>;
 trace(xml.descendants("class")); 
 

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Billy</firstName>
			<lastName>Einstein</lastName>
		</employee>
		<employee id = "43">
			<firstName>Sally</firstName>
			<lastName>Shostakovich</lastName>
		</employee>
	</employees>
	
trace(myXML..firstName); 
	// <firstName>Billy</firstName>
	// <firstName>Sally</firstName>
				
trace(myXML..@id); //4243

Elementos da API relacionados

Divide expression1 por expression2. O resultado da operação de divisão é um número de ponto flutuante, de precisão dupla.

trace(3/0);   // Infinity
trace(-3/0);  // -Infinity
trace(0/0);   // NaN

Elementos da API relacionados

Atribui a expression1 o valor de expression1 / expression2. Por exemplo, as duas instruções a seguir são equivalentes:

x /= y; 
x = x / y;

var a:Number = 10; 
var b:Number = 2; 
a /= b; trace(a); // 5 

Elementos da API relacionados

object.property_or_method

Acessa variáveis e métodos de classe, obtém e define propriedades do objeto e delimita os pacotes importados ou classes.

import flash.utils.Timer;

var obj:Object = new Object();
obj.propertyA = "hello";
trace(obj.propertyA);  // hello

Elementos da API relacionados

myXML.childElement
myXML.@attributeName 

Navega até elementos filho de um objeto XML ou XMLList, ou (combinado com o operador @) retorna atributos de um objeto XML ou XMLList. O objeto retornado é um XMLList, porque mais de um elemento filho ou atributo podem ser correspondentes.

Para retornar elementos com nomes que correspondam às palavras reservadas do ActionScript, use o método XML.elements() ou o método XML.descendants(), em vez do operador ponto (.) do XML, como mostrado neste exemplo:

var xml:XML = 
	<student id="206">
		<class name="Trigonometry" />
		<class name="Spanish 2" />
	</student>;
trace(xml.elements("class"));
trace(xml.descendants("class")); 

var myXML:XML = 
	<employee id = "42">
		<firstName>Billy</firstName>
		<lastName>Einstein</lastName>
	</employee>;

trace(myXML.firstName); // Billy
trace(myXML.@id);       // 42

Elementos da API relacionados

Testa a igualdade entre duas expressões. O resultado é true, se as expressões forem iguais.

Se os tipos de dados dos dois operandos forem correspondentes, a definição de igual depende do tipo de dados dos operandos:

• Os valores dos tipos int, uint e Booliano são considerados iguais, se tiverem o mesmo valor.
• Os números com valores correspondentes são considerados iguais, a menos que ambos sejam NaN.
• Se o valor de ambos os operandos for null ou undefined, eles serão considerados iguais.
• As expressões das strings serão iguais, se tiverem o mesmo número de caracteres e esses forem idênticos.
• Para objetos XML:
  • Se um operando for um texto ou nó de atributo, e o outro tiver um conteúdo simples, ambos os operandos são convertidos em strings com o método toString(), e são considerados iguais, se as strings resultantes forem correspondentes.
  • Caso contrário, os objetos são considerados iguais apenas se o nome qualificado, os atributos e as propriedades filho para ambos os objetos forem correspondentes.
• Os objetos XMLList são considerados iguais se tiverem o mesmo número de propriedades, e se a ordem e os valores das propriedades forem correspondentes.
• Para objetos Namespace, os valores são considerados iguais se as propriedades uri de ambos os objetos forem correspondentes.
• Para objetos QName, os valores serão considerados iguais se as propriedades uri de ambos os objetos forem correspondentes e se as propriedades localName dos objetos forem correspondentes.
• As variáveis que representam objetos, matrizes e funções são comparadas por referência. Duas variáveis serão iguais se fizerem referência ao mesmo objeto, à mesma matriz ou função. Duas matrizes separadas nunca são consideradas iguais, mesmo se tiverem um número idêntico de elementos.

• Os valores dos operandos são undefined e null; neste caso, o resultado é true.
• A conversão automática de tipo de dados converte os tipos de dados de valores de String, Boolean, int, uint e Number em tipos compatíveis, e os valores convertidos são iguais e, nesse caso, os operandos são considerados iguais.
• Um operando é do tipo XML com conteúdo simples ( hasSimpleContent() == true). Depois que os dois operandos forem convertidos em sequências de caracteres por meio do método toString(), as sequências de caracteres resultantes serão correspondentes.
• Um operando é do tipo XMLList, e nenhuma das seguintes condições é verdadeira:
  • A propriedade length do objeto XMLList é 0, e a do outro objeto é undefined.
  • A propriedade length do objeto XMLList é 1, e um elemento do objeto XMLList é correspondente ao outro operando.

var a:String = "David"
var b:String = "David"; 
if (a == b) { 
	trace("David is David"); 
} 

var a:Number = 5; 
var b:String = "5"; 
trace(a == b); // true

var c:Number = 1; 
var d:Boolean = true; 
trace(c == d); // true
var e:Number = 0; 
var f:Boolean = false; 
trace(e == f); // true

var g:String = "true";
var h:Boolean = true;
trace(g == h); // false

var firstArray:Array = new Array("one", "two", "three"); 
var secondArray:Array = new Array("one", "two", "three"); 
trace(firstArray == secondArray); // false 
/* Arrays are only considered equal 
if the variables refer to the same array. */
var thirdArray:Array = firstArray; 
trace(firstArray == thirdArray); // true 

Elementos da API relacionados

Compara duas expressões e determina se expression1 é maior do que expression2; se for, o resultado será true. Se expression1 for menor ou igual a expression2, o resultado será false.

Se ambos os operandos forem do tipo String, serão comparados em ordem alfabética, com as letras maiúsculas antecedendo as minúsculas. Caso contrário, os operandos serão primeiro convertidos em números e, em seguida, comparados.

var a:String = "first";
var b:String = "First";
trace(a > b); // true

var c:Number = 5;
var d:String = "4";
trace(c > d); // true

var e: Number = 2;
var f:Boolean = true;
trace(e > f); // true

Compara duas expressões e determina se expression1 é maior ou igual a expression2 ( true) ou expression1 é menor que expression2 ( false).

if (new Date().getHours() >= 12) { 
	trace("good afternoon"); 
} else { 
	trace("good morning"); 
}

Elementos da API relacionados

Avalia se uma propriedade é parte de um objeto específico. Para usar o operador in, especifique um nome de propriedade como o primeiro operando, e um objeto como o segundo operando. Se o objeto que você especificou tiver essa propriedade, o resultado será true; caso contrário, o resultado será false.

Se o objeto especificado for um objeto Matriz, utilize o operador in para verificar se é válido um determinado número de índice. Se você utilizar um número inteiro como o primeiro operando, caso o índice esteja no intervalo válido de números de índices o resultado será true; caso contrário, o resultado será false.

trace("PI" in Math);         // true
trace("myProperty" in Math); // false

O exemplo a seguir usa o operador in para mostrar que os números 0, 1 e 2 são números de índice válidos no objeto myArray, mas que o número 3 não é.

public var myArray:Array = ["zero", "one", "two"];
trace(0 in myArray); // true
trace(1 in myArray); // true
trace(2 in myArray); // true
trace(3 in myArray); // false

Elementos da API relacionados

++expression

 expression++

Adiciona 1 a uma expressão. A expressão pode ser uma variável, um elemento em uma matriz ou uma propriedade de um objeto. A forma pré-aumento do operador ( ++expression) adiciona 1 a ? expression e retorna o resultado. A forma pós-aumento do operador ( expression++) adiciona 1 a expression e retorna o valor inicial de expression (o valor anterior à adição).

var preInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
    preInc.push(++i); 
} 
trace(preInc); // 1,2,3,4,5,6,7,8,9,10 

 
var postInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
   postInc.push(i++); 
} 
trace(postInc); // 0,1,2,3,4,5,6,7,8,9 

var i:int = 0; 
while (i++ < 5) { 
	trace("this is execution " + i); 
} 
/* output: 
   this is execution 1 
   this is execution 2 
   this is execution 3 
   this is execution 4 
   this is execution 5 
*/

Testes para o oposto exato do operador de igualdade ( ==). Se expression1 for igual a expression2, o resultado será false. Da mesma forma que o operador de igualdade ( ==), a definição de igual depende dos tipos de dados que estão sendo comparados.

Se os tipos de dados dos dois operandos forem correspondentes, a definição de igual depende do tipo de dados dos operandos:

• Os valores dos tipos int, uint e Booliano são considerados iguais, se tiverem o mesmo valor.
• Os números com valores correspondentes são considerados iguais, a menos que ambos sejam NaN.
• Se o valor de ambos os operandos for null ou undefined, eles serão considerados iguais.
• As expressões das strings serão iguais, se tiverem o mesmo número de caracteres e esses forem idênticos.
• Para objetos XML:
  • Se um operando for um texto ou nó de atributo, e o outro tiver um conteúdo simples, ambos os operandos são convertidos em strings com o método toString(), e são considerados iguais, se as strings resultantes forem correspondentes.
  • Caso contrário, os objetos são considerados iguais apenas se o nome qualificado, os atributos e as propriedades filho para ambos os objetos forem correspondentes.
• Os objetos XMLList são considerados iguais se tiverem o mesmo número de propriedades, e se a ordem e os valores das propriedades forem correspondentes.
• Para objetos Namespace, os valores são considerados iguais se as propriedades uri de ambos os objetos forem correspondentes.
• Para objetos QName, os valores serão considerados iguais se as propriedades uri de ambos os objetos forem correspondentes e se as propriedades localName dos objetos forem correspondentes.
• As variáveis que representam objetos, matrizes e funções são comparadas por referência. Duas variáveis serão iguais se fizerem referência ao mesmo objeto, à mesma matriz ou função. Duas matrizes separadas nunca são consideradas iguais, mesmo se tiverem um número idêntico de elementos.

• Os valores dos operandos são undefined e null; neste caso, o resultado é true.
• A conversão automática de tipo de dados converte os tipos de dados de valores de String, Boolean, int, uint e Number em tipos compatíveis, e os valores convertidos são iguais e, nesse caso, os operandos são considerados iguais.
• Um operando é do tipo XML com conteúdo simples ( hasSimpleContent() == true), e depois que ambos os operandos são convertidos em sequências de caracteres com o método toString(), as sequências de caracteres são correspondentes.
• Um operando é do tipo XMLList, e nenhuma das seguintes condições é verdadeira:
  • A propriedade length do objeto XMLList é 0, e a do outro objeto é undefined.
  • A propriedade length do objeto XMLList é 1, e um elemento do objeto XMLList é correspondente ao outro operando.

trace(5 != 8); // true 
trace(5 != 5); // false 

var a:String = "David";
var b:String = "Fool";
if (a != b) { 
	trace("David is not a fool"); 
}

var a:Function = function() { trace("foo"); }; 
var b:Function = function() { trace("foo"); }; 
a(); // foo 
b(); // foo 
trace(a != b); // true 
a = b; 
a(); // foo 
b(); // foo 
trace(a != b); // false

var a:Array = [ 1, 2, 3 ]; 
var b:Array = [ 1, 2, 3 ]; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // true 
a = b; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // false

Elementos da API relacionados

Avalia se uma cadeia de protótipos de expressão inclui o objeto de protótipo para function. O operador instanceof é incluído para compatibilidade retroativa com a edição 3 do ECMAScript, e pode ser útil para programadores avançados que optam por usar a herança com base em protótipo, com funções de construtor, em vez de classes.

Para verificar se um objeto é um membro de um tipo de dados específico, use o operador is.

Quando utilizado com classes, o operador instanceof é semelhante ao operador is, porque uma cadeia de protótipos de classe inclui todas as suas superclasses. No entanto, as interfaces não estão incluídas nas cadeias de protótipos, de forma que o operador instanceof sempre resultará em false quando usado com interfaces, ao passo que o operador is resultará em true se o objeto pertencer a uma classe que implemente a interface especificada.

Nota: o operador is do ActionScript é equivalente ao operador instanceof do Java.

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof Sprite);        // true
trace(mySprite instanceof DisplayObject); // true

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof IBitmapDrawable); // false
trace(mySprite is IBitmapDrawable);         // true

Elementos da API relacionados

Avalia se um objeto é compatível com um tipo de dados, uma classe ou uma interface específica. Use o operador is, em vez do operador instanceof, para obter comparações de tipo. É possível usar também o operador is para verificar se um objeto implementa uma interface.

import flash.display.*;
import flash.events.IEventDispatcher;

var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite);           // true
trace(mySprite is DisplayObject);    // true
trace(mySprite is IEventDispatcher); // true

Elementos da API relacionados

Compara duas expressões e determina se expression1 é menor do que expression2; se for, o resultado será true. Se expression1 for maior ou igual a expression2, o resultado será false.

Se ambos os operandos forem do tipo String, serão comparados em ordem alfabética, com as letras maiúsculas antecedendo as minúsculas. Caso contrário, os operandos serão primeiro convertidos em números e, em seguida, comparados.

trace(5 < 10); // true 
trace(2 < 2);            // false 
trace(10 < 3);           // false 
trace("Allen" < "Jack"); // true 
trace("Jack" < "Allen"); // false 
trace("11" < "3");       // true 
trace("11" < 3);         // false (numeric comparison) 
trace("C" < "abc");      // true 
trace("A" < "a");        // true 

Compara duas expressões e determina se expression1 é menor do que ou igual a expression2; se for, o resultado será true. Se expression1 for maior do que expression2, o resultado será false.

Se ambos os operandos forem do tipo String, serão comparados em ordem alfabética, com as letras maiúsculas antecedendo as minúsculas. Caso contrário, os operandos serão primeiro convertidos em números e, em seguida, comparados.

trace(5 <= 10); // true 
trace(2 <= 2);            // true 
trace(10 <= 3);           // false 
trace("Allen" <= "Jack"); // true 
trace("Jack" <= "Allen"); // false 
trace("11" <= "3");       // true 
trace("11" <= 3);         // false (numeric comparison) 
trace("C" <= "abc");      // true 
trace("A" <= "a");        // true 

Indica o início de um comentário de script. Os caracteres que aparecem entre o delimitador de comentário ( //) e o caractere de final de linha são interpretados como um comentário, e são ignorados. Use este delimitador para comentários de uma linha; para comentários em várias linhas sucessivas, use os delimitadores /* e */.

// Any text following a line comment delimiter is ignored during compilation

Elementos da API relacionados

Retorna expression1, se for false ou passível de conversão em false; caso contrário, retorna expression2. Exemplos de valores que podem ser convertidos em false são 0, NaN, null e undefined. Se você usar uma chamada de função, como expression2, a função não será chamada se expression1 resultar em false.

Se ambos os operandos forem do tipo Booliano, o resultado será true, apenas quando os operandos forem true, como mostrado na tabela a seguir:

var turns:Number = 2; 
var score:Number = 77; 
if ((turns <= 3) && (score >= 75)) { 
	trace("You Win the Game!"); 
} else { 
	trace("Try Again!"); 
} 

Elementos da API relacionados

Atribui a expression1 o valor de expression1 && expression2. Por exemplo, as duas instruções a seguir são equivalentes:

x &&= y; 
x = x && y; 

var myVar:String = 'tag';
			myVar &&= "<" + myVar + "/>";
			trace (myVar); // output: <tag/>

var myVar:String = 'tag';
			if (myVar != '') {
			  myVar = "<" + myVar + "/>";
			}
			trace (myVar); // output: <tag/>

Elementos da API relacionados

Inverte o valor Booliano de uma variável ou expressão. Se expression for uma variável com valor absoluto ou convertido true, o valor de !expression será false. Se a expressão x && y resultar em false, a expressão !(x && y) resultará em true.

As expressões a seguir ilustram o resultado do uso do operador lógico NOT (!):

• !true retorna false.
• !false retorna true.

var happy:Boolean = false; 
if (!happy) { 
	trace("don't worry, be happy"); // don't worry, be happy 
} 

Elementos da API relacionados

Retorna expression1, se for false ou passível de conversão em false; caso contrário, retorna expression2. Se você usar uma chamada de função, como expression2, a função não será chamada se expression1 resultar em false.

Se ambos os operandos forem do tipo booliano, o resultado será true se ao menos uma das expressões for true, ou será false, se ambas as expressões forem false, como é mostrado na seguinte tabela:

var a:Number = 10; 
var b:Number = 250; 
var start:Boolean = false; 
if ((a > 25) || (b > 200) || (start)) { 
    trace("the logical OR test passed"); // the logical OR test passed 
} 

O exemplo a seguir demonstra como usar uma chamada de função, já que o segundo operador pode levar a resultados inesperados. Se a expressão à esquerda do operador resultar em true, o resultado é retornado sem a avaliação da expressão à direita (a função fx2() não é chamada).

function fx1():Boolean { 
	trace("fx1 called"); 
	return true; 
} 
function fx2():Boolean { 
	trace("fx2 called"); 
	return true; 
} 
if (fx1() || fx2()) { 
	trace("IF statement entered");
}

Elementos da API relacionados

Atribui a expression1 o valor de expression1 || expression2 . Por exemplo, as duas instruções a seguir são equivalentes:

x ||= y; 
x = x || y; 

myVar ||= "default";

Elementos da API relacionados

Calcula o restante de expression1 dividido por expression2. Se qualquer um dos operandos for não numérico, o operador de módulo ( %) tenta convertê-lo para um número.

O sinal do resultado do módulo corresponde ao sinal do dividendo (o primeiro número). Por exemplo, -4 % 3 e -4 % -3 são avaliados como -1.

trace(12 % 5);    // 2 
trace(4.3 % 2.1); // 0.0999999999999996 
trace(4 % 4);     // 0 

Elementos da API relacionados

Atribui a expression1 o valor de expression1 % expression2. As duas instruções a seguir são equivalentes:

x %= y; 
x = x % y; 

var a:Number = 14; 
var b:Number = 5; 
a %= b;
trace(a); // 4 

Elementos da API relacionados

Multiplica duas expressões numéricas. Se ambas as expressões são números inteiros, o produto é um número inteiro. Se qualquer uma das expressões ou ambas as expressões são números de pontos flutuantes, o produto é um número de ponto flutuante.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

Atribui a expression1 o valor de expression1 * expression2. Por exemplo, as duas expressões a seguir são equivalentes:

x *= y 
x = x * y 

var a:Number = 5; 
var b:Number = 10; 
trace(a *= b); // 50 

var i:Number = 5; 
var c:Number = 4 - 6; 
var d:Number = i + 2; 
trace(c *= d); // -14 

Elementos da API relacionados

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Identifica o namespace de uma propriedade, de um método, de uma propriedade XML ou de um atributo XML.

public class NamespaceExample extends Sprite {
	public namespace French;
	public namespace Hawaiian;
	public function NamespaceExample() {
		trace(Hawaiian::hello()); // aloha
		trace(French::hello()); // bonjour
	}
    Hawaiian function hello():String {
        return "aloha";
    }

    French function hello():String { 
        return "bonjour";
    }
}

var soap:Namespace = new Namespace("http://schemas.xmlsoap.org/wsdl/soap/");
var w:Namespace = new Namespace("http://weather.example.org/forecast");
var myXML:XML = 
	<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"> 
	 <soap:Body>
	  <w:forecast xmlns:w="http://weather.example.org/forecast">
	   <w:city>Quito</w:city>
	   <w:country>Ecuador</w:country>
	   <date>2006-01-14</date>
	  </w:forecast>
	  </soap:Body>
	</soap:Envelope>;
	
trace(myXML.soap::Body.w::forecast.w::city); // Quito

Elementos da API relacionados

Cria uma ocorrência a partir de uma ocorrência de classe. O operador new pode ser usado com uma classe ou uma variável do tipo Classe para criar uma ocorrência de uma classe. O operador new é frequentemente usado com um objeto de classe para criar uma ocorrência de uma classe. Por exemplo, a instrução new Sprite() cria uma ocorrência da classe Sprite.

O operador new também pode ser usado para associar uma classe a um recurso incorporado, que é um objeto externo, como uma imagem, um som ou uma fonte, compilado em um arquivo SWF. Cada recurso incorporado é representado por uma classe exclusiva de ativos incorporados. Para acessar um recurso incorporado, é necessário usar o operador new para criar uma ocorrência da classe associada. Em seguida, chame as propriedades e os métodos adequados da classe do recurso incorporado para manipular o recurso incorporado.

Se preferir definir classes com objetos Function, em vez da palavra-chave class, use o operador new para criar objetos com base em funções do construtor. Não confunda funções de construtor com métodos de construtor de uma classe. Uma função de construtor é um objeto de Função definido como a palavra-chave function, mas que não é parte de uma definição de classe. Se você usar as funções de construtor para criar objetos, será necessário usar a herança de protótipos, em vez da herança de classe.

class Book {
  var bName:String;
  var bPrice:Number;
  
  public function Book(nameParam:String, priceParam:Number){
    bName = nameParam;
    bPrice = priceParam;
  }
}

var book1:Book = new Book("Confederacy of Dunces", 19.95);
var book2:Book = new Book("The Floating Opera", 10.95);
trace(book1); // [object Book]

var golfCourse:Array = new Array(18);

Elementos da API relacionados

object = {name1 : value1, name2 : value2,... nameN : valueN}

Cria um novo objeto e o inicializa com os pares de propriedades name e value. A utilização deste operador é semelhante ao uso da sintaxe new Object e ao preenchimento dos pares de propriedades através do operador de atribuição. O protótipo do objeto recém-criado é genericamente nomeado como objeto Object.

O operador também é utilizado para marcar blocos de código adjacentes associados às instruções e funções de controle de fluxo ( for, while, if, else, switch).

var object:Object = {}; 
var object:Object = new Object(); 

var account:Object = {name:"Adobe Systems, Inc.", address:"601 Townsend Street", city:"San Francisco", state:"California", zip:"94103", balance:"1000"}; 
for (i in account) { 
	trace("account."+i+" = "+account[i]); 
} 

var person:Object = {name:"Gina Vechio", children:["Ruby", "Chickie", "Puppa"]}; 

var person:Object = new Object(); 
person.name = "Gina Vechio"; 
person.children = new Array(); 
person.children[0] = "Ruby"; 
person.children[1] = "Chickie"; 
person.children[2] = "Puppa"; 

Elementos da API relacionados

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Executa uma operação de agrupamento em um ou mais parâmetros, executa uma avaliação sequencial das expressões ou envolve um ou mais parâmetros e os aprova como argumentos para uma função que precede os parênteses.

Uso 1: controla a ordem em que os operadores são executados. Os parênteses substituem a ordem normal anterior e faz com que as expressões entre parênteses sejam avaliadas primeiro. Quando os parênteses são aninhados, o conteúdo dos parênteses internos é avaliado antes do conteúdo dos parênteses externos.

Uso 2: avalia uma série de expressões, separadas por vírgulas, em sequência, e retorna o resultado da expressão final.

Uso 3: envolve um ou mais parâmetros e os aprova para a função que precede os parênteses.

trace((2 + 3) * (4 + 5)); // 45 
trace(2 + (3 * (4 + 5))); // 29
trace(2 + (3 * 4) + 5);   // 19
trace(2 + (3 * 4) + 5);   // 19

var a:Number = 1; 
var b:Number = 2; 
function foo() { 
  a += b; 
} 
function bar() { 
  b *= 10; 
} 
trace((foo(), bar(), a + b)); // 23 

var today:Date = new Date(); 
trace(today.getFullYear()); // outputs current year 
function traceParameter(param):void { 
  trace(param); 
} 
traceParameter(2 * 2); // 4 

Elementos da API relacionados

myXML.(expression)

Avalia uma expressão em um ECMAScript para construção XML de XML (E4X). Por exemplo, myXML.(lastName == "Smith") identifica elementos XML com o nome lastName e o valor "Smith". O resultado é um objeto XMLList.

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>
		<employee id = "44">
			<firstName>Anne</firstName>
			<lastName>Smith</lastName>
		</employee>
	</employees>;
	
trace(myXML.employee.(lastName == "Smith").@id.toXMLString()); 
	// 42
	// 44
                
trace(myXML.employee.(Number(@id) > 42).@id.toXMLString()); 
	// 43
	// 44

Elementos da API relacionados

/pattern/flags

Quando usado antes e depois dos caracteres, indica que os caracteres têm um valor literal e são considerados uma expressão regular (RegExp), e não uma variável, uma string ou outro elemento do ActionScript. Observe, no entanto, que dois caracteres de barra sequenciais ( //) indicam o início de um comentário.

var myRegExp:RegExp = /foo-\d+/i; 
trace(myRegExp.exec("ABC Foo-32 def.")); // Foo-32 

Elementos da API relacionados

Testa a igualdade entre duas expressões, mas não realiza conversão de dados automática. O resultado é true, se ambas as expressões, incluindo seus tipos de dados, forem iguais.

O operador de igualdade restrita ( ===) se comporta da mesma forma que o operador de igualdade ( ==) nestes três casos:

• Os valores Number e Boolean são comparados pelo valor. Se tiverem o mesmo valor, serão considerados iguais.
• As expressões das strings serão iguais, se tiverem o mesmo número de caracteres e esses forem idênticos.
• As variáveis que representam objetos, matrizes e funções são comparadas por referência. Duas variáveis serão iguais se fizerem referência ao mesmo objeto, à mesma matriz ou função. Duas matrizes separadas nunca são consideradas iguais, mesmo se tiverem um número idêntico de elementos.

• O operador de igualdade restrita executa a conversão automática de dados apenas para tipos de números (Number, int e uint), enquanto o operador de igualdade executa a conversão automática de dados para todos os tipos de dados primitivos.
• Durante a comparação entre null e undefined, o operador de igualdade restrita retorna false.

No primeiro caso, as comparações entre os valores primitivos e objetos primitivos que contêm o mesmo valor retorna true no ActionScript 3.0, mas em versões anteriores retorna false. Nestas versões, o tipo de dados de um valor primitivo é Boolean, Number ou String, enquanto o tipo de dados de um objeto primitivo é sempre Object. O efeito prático desta diferença será mostrado no código a seguir. Nas versões anteriores do ActionScript, o resultado será false, porque os tipos de dados dos operandos não são correspondentes. Já no ActionScript 3.0, o resultado será true, porque os valores primitivos são do tipo Boolean, Number, int, uint ou String, agrupados em um objeto ou não.

var num1:Number = 1;
var num2:Number = new Number(1);
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0
			

var num1:Number = new Number(1);
var num2:Number = new Number(1);
trace(num1 == num2);  // true in ActionScript 3.0, false in ActionScript 2.0
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0

var string1:String = "5"; 
var string2:String = "5"; 
trace(string1 == string2);  // true 
trace(string1 === string2); // true

// The equality (==) operator converts 5 to "5", but the strict equality operator does not
var string1:String = "5"; 
var num:Number = 5; 
trace(string1 == num);  // true 
trace(string1 === num); // false 

var num:Number = 1;
var bool:Boolean = true;
trace(num == bool);  // true 
trace(num === bool); // false

var num1:Number = 1;
var num2:int = 1;
var num3:uint = 1;
trace(num1 === num2); // true
trace(num1 === num3); // true

trace(null == undefined);  // true 
trace(null === undefined); // false 

Elementos da API relacionados

Testes para o oposto exato do operador de igualdade restrita ( ===). O operador de desigualdade restrita funciona da mesma maneira que o operador de desigualdade, exceto que apenas os tipos de dados int e uint são convertidos.

Se expression1 for igual a expression2, e seus tipos de dados forem iguais, o resultado será false.

O operador de desigualdade restrita ( !==) é o mesmo do operador de desigualdade ( !=), de três maneiras:

• Os valores Number e Boolean são comparados pelo valor. Se tiverem o mesmo valor, serão considerados iguais.
• As expressões das strings serão iguais, se tiverem o mesmo número de caracteres e esses forem idênticos.
• As variáveis que representam objetos, matrizes e funções são comparadas por referência. Duas variáveis serão iguais se fizerem referência ao mesmo objeto, à mesma matriz ou função. Duas matrizes separadas nunca são consideradas iguais, mesmo se tiverem um número idêntico de elementos.

• O operador de desigualdade restrita ( !==) executa a conversão automática de dados apenas para tipos numéricos, Number, int, uint, enquanto o operador de desigualdade ( !=) executa a conversão automática de dados para todos os tipos de dados primitivos.
• Durante a comparação entre null e undefined, o operador de desigualdade restrita ( !==) retorna true.

var s1:String = "5"; 
var s2:String = "5"; 
var s3:String = "Hello"; 
var n:Number = 5; 
var b:Boolean = true; 
trace(s1 == s2);  // true 
trace(s1 == s3);  // false 
trace(s1 == n);   // true 
trace(s1 == b);   // false 
trace(s1 === s2); // true 
trace(s1 === s3); // false 
trace(s1 === n);  // false 
trace(s1 === b);  // false 
trace(s1 !== s2); // false 
trace(s1 !== s3); // true 
trace(s1 !== n);  // true 
trace(s1 !== b);  // true 

Elementos da API relacionados

 "text" 

Quando usado antes e depois dos caracteres, indica que os caracteres têm um valor literal e são considerados uma string, e não uma variável, um valor numérico nem outro elemento do ActionScript.

var yourGuess:String = "Prince Edward Island"; 
submit_btn.onRelease = function() { trace(yourGuess); }; 
// Prince Edward Island

Elementos da API relacionados

-expression

 expression1 - expression2

Usado para negar ou subtrair.

Uso 1: quando usado para negar, o operador inverte o sinal de uma expressão numérica.

Quando usado para subtrair, o operador executa uma subtração aritmética em duas expressões numéricas, subtraindo expression2 de expression1. Quando ambas as expressões são números inteiros, a diferença é um número inteiro. Quando qualquer uma das expressões ou ambas as expressões são números de pontos flutuantes, a diferença é um número de ponto flutuante.

trace(-(2 + 3)); // -5 

trace(5 - 2); // 3 

A instrução a seguir subtrai o número de ponto flutuante 1,5 do número de ponto flutuante 3,25:

trace(3.25 - 1.5); // 1.75 

Atribui a expression1 o valor de expression1 -expression2. Por exemplo, as duas instruções a seguir são equivalentes:

x -= y ;
x = x - y;

As expressões em strings devem ser convertidas em números; caso contrário, o resultado será NaN (não um número).

var x:Number = 5; 
var y:Number = 10; 
x -= y; 
trace(x); // -5 

var x:String = "5"; 
var y:String = "10"; 
x -= y; 
trace(x); // -5 

Elementos da API relacionados

[modifiers] var variableName:type

function functionName():type { ... }

function functionName(parameter1:type, ..., parameterN:type) [:type]{ ... } 

Usado para atribuir um tipo de dados; este operador especifica o tipo de variável, o tipo de retorno de função ou o tipo de parâmetro de função. Quando usado em uma declaração de variável ou atribuição, este operador especifica o tipo de variável; quando usado em uma declaração de função ou definição, este operador especifica o tipo de retorno da função; quando usado com um parâmetro de função em uma definição de função, este operador especifica o tipo de variável esperado para esse parâmetro.

A verificação de tipo ocorre sempre em tempo de execução. No entanto, quando o compilador está definido em modo restrito, todos os tipos também são verificados em tempo de compilação, e os erros são gerados quando ocorre uma não correspondência. As não correspondências podem ocorrer durante operações de atribuição, chamadas de função e cancelamento de referência de membros da classe, usando o operador ponto ( .).

Tipos que podem ser usados incluem todos os tipos de objetos nativos, classes e interfaces que você define e void. Os tipos nativos reconhecidos são Boolean, Number, int, uint e String. Todas as classes internas também são suportadas como tipos nativos.

Se você não atribuir um tipo de dados, a variável, o valor de retorno de função ou o parâmetro de função serão considerados sem tipo, o que significa que o valor pode ser de qualquer tipo de dados. Se você desejar tornar clara a sua intenção de usar um valor sem tipo, poderá usar o caractere de asterisco (*) como a anotação de tipo. Quando usado como uma anotação de tipo, o caractere de asterisco é o equivalente a deixar uma variável, um tipo de retorno de função ou um parâmetro de função sem tipo.

var userName:String = ""; 

function randomInt(integer:int):int { 
	return Math.round(Math.random()*integer); 
} 
trace(randomInt(8)); 

function squareRoot(val:Number):Number { 
	return Math.sqrt(val); 
} 
trace(squareRoot(121)); 

Elementos da API relacionados

Avalia expression e retorna uma string especificando o tipo de dados da expressão. O resultado é limitado a seis valores possíveis de sequências de caracteres: boolean, function, number, object, string e xml. Se você aplicar este operador a uma ocorrência de uma classe definida pelo usuário, o resultado é a string object. O operador typeof é incluído para compatibilidade retroativa. Use o operador is para verificar a compatibilidade de tipos.

trace(typeof Array); // object
trace(typeof Date);  // object
trace(typeof 3);     // number

var a:String = "sample";
var b:String = new String("sample");
trace(typeof a); // string
trace(typeof b); // string 

Elementos da API relacionados

Avalia uma expressão e, em seguida, descarta seu valor, retornando undefined. O operador void é usado frequentemente em comparações que utilizam o operador == para testar valores indefinidos.

 myXML= <{tagName} {attributeName} = {attributeValue}>{content}

Define uma marca XML em um XML literal. Use a barra (/) para definir a marca de fechamento.

var x:XML = <item id= "324">cola</item>; 

Elementos da API relacionados