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;