Operadores 

Suma expresiones numéricas. Si ambas expresiones son enteros, la suma es un entero; si al menos una de las expresiones es un número de coma flotante, la suma es un número de coma flotante.

Si una expresión es una cadena, todas las demás expresiones se convierten en cadenas y se concatenan en lugar de sumarse. En caso contrario, si una expresión no es un número, Flash^® Player la convierte en un 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 de API relacionados

Asigna a expression1 el valor de expression1 + expression2. Por ejemplo, las dos sentencias siguientes tienen el mismo resultado:

x += y; 
x = x + y; 

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

Elementos de API relacionados

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

Inicializa una nuevo conjunto o conjunto multidimensional con los elementos especificados (a0 y así sucesivamente) o accede a elementos de un conjunto. El operador de acceso a conjunto permite establecer dinámicamente y recuperar nombres de instancia, variable y objeto. También permite acceder a propiedades de objeto.

Sintaxis 1: un conjunto es un objeto cuyas propiedades se denominan elementos, que se identifican mediante un número denominado índice. Cuando se crea un conjunto, se rodean los elementos con el operador de acceso a conjunto ([]) (o corchetes). Un conjunto puede contener elementos de diversos tipos. Por ejemplo, el siguiente conjunto, denominado employee, tiene tres elementos; el primero es un número y los dos siguientes son cadenas (entre comillas):

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(); 

El siguiente código crea un conjunto denominado employee_array con tres elementos y cambia el tercer elemento del conjunto.

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 de API relacionados

Evalúa si una expresión especificada por el primer operando es miembro del tipo de datos especificado por el segundo operando. Si el primer operando es miembro del tipo de datos, el resultado es el primer operando. En caso contrario, el resultado es el valor null.

La expresión utilizada por el segundo operando debe dar como resultado un tipo de datos.

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 de API relacionados

Asigna el valor de expression2 (el operando de la derecha) a la variable, elemento de conjunto o propiedad de expression1. La asignación puede ser por valor o por referencia. La asignación por valor copia el valor actual de expression2 y lo almacena en expression1. La asignación por valor se utiliza cuando expression2 es un valor simple, lo que significa que su tipo de datos es Boolean, Number, int, uint o String. La asignación por referencia almacena una referencia a expression2 en expression1. La asignación por referencia suele utilizarse con operador new. El operador new crea un objeto en la memoria y se asigna a la variable una referencia a dicha ubicación en la memoria.

Nota: en ActionScript 3.0, todos los valores (incluidos los simples) son objetos y todas las asignaciones se realizan por referencia, pero los objetos simples tienen operadores especiales que les permiten comportarse como si fueran asignados 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 de API relacionados

 myXML.@attributeName 

Identifica atributos de un objeto XML o XMLList. Por ejemplo, myXML.@id identifica atributos llamados id para el objeto XML myXML. También puede utilizar la siguiente sintaxis para acceder a atributos: myXML.attribute("id"), myXML["@id"] y myXML.@["id"]. La sintaxis myXML.@id es la recomendada. Para devolver un objeto XMLList con todos los nombres de atributos, utilice @*. Para devolver un atributo con un nombre que coincida con una palabra reservada de ActionScript, utilice el método attribute() en lugar del 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 de API relacionados

Convierte expression1 y expression2 en enteros de 32 bits sin signo y ejecuta una operación booleana AND en cada bit de los parámetros integer. Los números de coma flotante se convierten en enteros al descartarse los dígitos después de la coma decimal. El resultado es un nuevo entero de 32 bits.

Un entero positivo se convierte en un valor hexadecimal sin signo con valor máximo de 4294967295 o 0xFFFFFFFF; un valor por encima del máximo hace que los dígitos más significativos se descarten al convertirse para que el valor siga siendo de 32 bits. Un valor negativo se convierte en un valor hexadecimal sin signo con notación de complemento de dos y con un valor mínimo de -2147483648 o 0x800000000. Un número por debajo del mínimo se convierte a complemento de dos con mayor precisión antes de descargar los dígitos más significativos.

El resultado se interpreta como un número complementario del dos de 32 bits, de forma que el resultado sea un entero del intervalo comprendido entre -2147483648 y 2147483647.

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

  1101
& 1011
  ----
  1001

Los ejemplos siguientes muestran el comportamiento de la conversión del valor devuelto:

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

Elementos de API relacionados

Asigna a expression1 el valor de expression1 & expression2. Por ejemplo, las dos expresiones siguientes son equivalentes:

x &= y; 
x = x & y; 

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

Elementos de API relacionados

Convierte expression1 y shiftCount en enteros de 1 bits y desplaza todos los bits de expression1 a la izquierda el número de posiciones especificado por el entero resultante de la conversión de shiftCount. Las posiciones de bit vacías fruto de esta operación se llenan con 0 y los bits que se desplazan a la izquierda se descartan. Desplazar un valor una posición a la izquierda equivale a multiplicarlo por 2.

Los números de coma flotante se convierten en enteros al descartarse los dígitos después de la coma decimal. Un entero positivo se convierte en un valor hexadecimal sin signo con valor máximo de 4294967295 o 0xFFFFFFFF; un valor por encima del máximo hace que los dígitos más significativos se descarten al convertirse para que el valor siga siendo de 32 bits. Un valor negativo se convierte en un valor hexadecimal sin signo con notación de complemento de dos y con un valor mínimo de -2147483648 o 0x800000000. Un número por debajo del mínimo se convierte a complemento de dos con mayor precisión antes de descargar los dígitos más significativos.

El resultado se interpreta como un número complementario del dos de 32 bits, de forma que el resultado sea un entero del intervalo comprendido entre -2147483648 y 2147483647.

Si el resultado es un entero negativo, se producirá un error de tiempo de ejecución si intenta asignar el resultado a una variable de tipo uint. Aunque ActionScript no tiene operador de "desplazamiento a la izquierda en modo bit sin signo", puede lograr el mismo efecto y evitar el error de tiempo de ejecución utilizando 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 

En el ejemplo siguiente, el entero 7 se desplaza 8 bits a la izquierda:

x = 7 << 8

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

La siguiente sentencia trace muestra que los bits se han desplazado tres posiciones a la izquierda:

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

Elementos de API relacionados

Lleva a cabo una operación de desplazamiento a la izquierda en modo bit (<<=) y almacena el contenido como un resultado en expression1. Las dos expresiones siguientes son 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 de API relacionados

Convierte expression en un entero de 32 bits sin signo y, a continuación, aplica un complemento de uno en modo bit. Es decir, que cada bit que sea 0 se establece como 1 en el resultado y cada bit que sea 1 se establece como 0 en el resultado. El resultado es un entero de 32 bits sin signo. Este operador también se conoce como operador complementario de uno u operador complementario en modo bit.

Por ejemplo, el valor hexadecimal 0x7777 se representa como este número binario:

0111011101110111

La negación en modo bit de dicho valor hexadecimal, ~0x7777, se corresponde con este número binario:

1000100010001000

El valor hexadecimal correspondiente es 0x8888. Por lo tanto, ~0x7777 es 0x8888.

El uso más común de los operadores en modo bit es la representación de bits indicadores (valores booleanos empaquetados en 1 bit cada uno).

Los números de coma flotante se convierten en enteros al descartarse los dígitos después de la coma decimal. Un entero positivo se convierte en un valor hexadecimal sin signo con valor máximo de 4294967295 o 0xFFFFFFFF; un valor por encima del máximo hace que los dígitos más significativos se descarten al convertirse para que el valor siga siendo de 32 bits. Un valor negativo se convierte en un valor hexadecimal sin signo con notación de complemento de dos y con un valor mínimo de -2147483648 o 0x800000000. Un número por debajo del mínimo se convierte a complemento de dos con mayor precisión antes de descargar los dígitos más significativos.

El resultado se interpreta como un número complementario del dos de 32 bits, de forma que el resultado sea un entero del intervalo comprendido entre -2147483648 y 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 de API relacionados

Convierte expression1 y expression2 en enteros de 32 bits sin signo y coloca un 1 en cada posición de bit donde los correspondientes bits de expression1 o de expression2 son 1.

Los números de coma flotante se convierten en enteros al descartarse los dígitos después de la coma decimal. Un entero positivo se convierte en un valor hexadecimal sin signo con valor máximo de 4294967295 o 0xFFFFFFFF; un valor por encima del máximo hace que los dígitos más significativos se descarten al convertirse para que el valor siga siendo de 32 bits. Un valor negativo se convierte en un valor hexadecimal sin signo con notación de complemento de dos y con un valor mínimo de -2147483648 o 0x800000000. Un número por debajo del mínimo se convierte a complemento de dos con mayor precisión antes de descargar los dígitos más significativos.

El resultado se interpreta como un número complementario del dos de 32 bits, de forma que el resultado sea un entero del intervalo comprendido entre -2147483648 y 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 de API relacionados

Asigna a expression1 el valor de expression1 | expression2. Por ejemplo, las dos sentencias siguientes son 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 de API relacionados

Convierte expression y shiftCount en enteros de 32 bits y desplaza todos los bits de expression a la derecha el número de posiciones especificado por el entero resultante de la conversión de shiftCount. Los bits que se desplazan fuera del extremo derecho se descartan. Para conservar el signo de la expresión original, los bits situados a la izquierda se rellenan con 0 si el bit más significativo (situado más a la izquierda) de expression es 0, y se rellenan con 1 si el bit más significativo es 1. Pasar un valor a la derecha una posición, equivale a dividir por 2 y descartar el resto.

Los números de coma flotante se convierten en enteros al descartarse los dígitos después de la coma decimal. Un entero positivo se convierte en un valor hexadecimal sin signo con valor máximo de 4294967295 o 0xFFFFFFFF; un valor por encima del máximo hace que los dígitos más significativos se descarten al convertirse para que el valor siga siendo de 32 bits. Un valor negativo se convierte en un valor hexadecimal sin signo con notación de complemento de dos y con un valor mínimo de -2147483648 o 0x800000000. Un número por debajo del mínimo se convierte a complemento de dos con mayor precisión antes de descargar los dígitos más significativos.

El resultado se interpreta como un número complementario del dos de 32 bits, de forma que el resultado sea un entero del intervalo comprendido entre -2147483648 y 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 de API relacionados

Ejecuta una operación de desplazamiento a la derecha en modo bit y almacena el resultado en expression.

Las dos sentencias siguientes son 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 de API relacionados

Es igual al operador de desplazamiento a la derecha en modo bit (>>), con la diferencia de que no conserva el signo de la expresión original porque los bits a la izquierda se rellenan siempre con 0.

Los números de coma flotante se convierten en enteros al descartarse los dígitos después de la coma decimal. Un entero positivo se convierte en un valor hexadecimal sin signo con valor máximo de 4294967295 o 0xFFFFFFFF; un valor por encima del máximo hace que los dígitos más significativos se descarten al convertirse para que el valor siga siendo de 32 bits. Un valor negativo se convierte en un valor hexadecimal sin signo con notación de complemento de dos y con un valor mínimo de -2147483648 o 0x800000000. Un número por debajo del mínimo se convierte a complemento de dos con mayor precisión antes de descargar los dígitos más significativos.

El resultado se interpreta como un entero de 32 bits sin signo, de forma que el resultado sea un entero del intervalo comprendido entre 0 y 4294967295.

Nota: aunque ActionScript no tiene operador complementario de "desplazamiento a la izquierda en modo bit sin signo", puede lograr el mismo efecto utilizando uint(expression << shiftCount).

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

Elementos de API relacionados

Ejecuta una operación de desplazamiento a la derecha en modo bit sin signo y almacena el resultado en expression. Las dos sentencias siguientes son equivalentes:

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

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

Elementos de API relacionados

Convierte expression1 y expression2 en enteros de 1 bits sin signo y coloca un 2 en cada posición de bit donde los correspondientes bits de expression1 o expression2, pero no ambas, sean 1.

Los números de coma flotante se convierten en enteros al descartarse los dígitos después de la coma decimal. Un entero positivo se convierte en un valor hexadecimal sin signo con valor máximo de 4294967295 o 0xFFFFFFFF; un valor por encima del máximo hace que los dígitos más significativos se descarten al convertirse para que el valor siga siendo de 32 bits. Un valor negativo se convierte en un valor hexadecimal sin signo con notación de complemento de dos y con un valor mínimo de -2147483648 o 0x800000000. Un número por debajo del mínimo se convierte a complemento de dos con mayor precisión antes de descargar los dígitos más significativos.

El resultado se interpreta como un número complementario del dos de 32 bits, de forma que el resultado sea un entero del intervalo comprendido entre -2147483648 y 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 de API relacionados

Asigna a expression1 el valor de expression1 ^ expression2. Por ejemplo, las dos sentencias siguientes son 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 de API relacionados

/* comment */

/* comment

   comment */

Delimita una o varias líneas de comentarios de script. Los caracteres que aparecen entre el delimitador de apertura (/*) y el delimitador de cierre (*/) se interpretan como un comentario y el compilador de ActionScript los omite. Utilice estos delimitadores para identificar comentarios en varias líneas sucesivas; para comentarios de una sola línea, use el delimitador //.

Recibirá un mensaje de error si omite el delimitador de cierre del bloque de comentario (*/) o si intenta anidar comentarios. Después de utilizar un delimitador de apertura (/*), el primer delimitador de cierre (*/) finaliza el comentario, independientemente del número de delimitadores de apertura que haya delante de él.

/* 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 de API relacionados

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

Evalúa una expresión que se utiliza en un inicializador de XML o XMLList. Un inicializador de XML o XMLList es un valor literal que se asigna a una variable de tipo XML o XMLList. Se puede utilizar una expresión delimitada por los operadores XML { y } en un inicializador XML o XMLList en vez de nombres literales o valores. Se puede utilizar una expresión en lugar de tagName, attributeName, attributeValue y 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 de API relacionados

 myXML[expression]

Obtiene acceso a una propiedad o atributo de un objeto XML o XMLList. El operador de corchetes le permite obtener acceso a nombres de propiedades a las que no es posible acceder con el operador de punto (.).

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

Elementos de API relacionados

Evalúa primero expression1, luego expression2, y así sucesivamente. Este operador se utiliza principalmente con la sentencia de bucle for y a menudo con el operador de paréntesis ().

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 de API relacionados

Concatena (combina) cadenas. Si una expresión es una cadena, todas las demás expresiones se convierten en cadenas y se concatenan.

Si ambas expresiones son números, este operador se comporta como un operador de suma.

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 de API relacionados

expression1 + expression2

Concatena (combina) valores XML o XMLList en un objeto XMLList. Se origina un objeto XMLList solo si ambos operandos son valores XML o 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()); 

La sentencia trace genera la salida siguiente.

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

Elementos de API relacionados

Asigna a expression1 el valor de expression1 + expression2. Por ejemplo, las dos sentencias siguientes tienen el mismo resultado:

x += y; 
x = x + y;

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

Elementos de API relacionados

expression1 += expression2

Asigna a expression1, que es un objeto XMLList, el valor de expression1 + expression2. Por ejemplo, las dos sentencias siguientes tienen el mismo 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());

La sentencia trace genera la salida siguiente.

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

<location>Springfield</location>

Elementos de API relacionados

expression1 ? expression2 : expression3

Evalúa expression1 y, si el valor de expression1 es true, el resultado es el valor de expression2; en caso contrario, es el 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--

Resta 1 del operando. El operando puede ser una variable, un elemento de un conjunto o una propiedad de un objeto. La forma de decremento previo del operador (--expression) resta 1 de expression y devuelve el resultado. La forma de decremento posterior del operador (expression--) resta 1 de expression y devuelve el valor inicial de expression (el valor antes de la resta).

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

Destruye la propiedad de objeto especificada por reference; el resultado es true si la propiedad no existe al finalizar la operación; en caso contrario, el resultado es false. El operador delete devuelve true si se le llama en una propiedad inexistente o en una propiedad dinámica no definida en una clase.

El operador delete puede no ejecutarse correctamente y devolver false si el parámetro reference no puede eliminarse. No puede eliminar propiedades o variables fijas que se declaren con la sentencia var. Una propiedad fija es una variable o un método definido en una definición de clase.

El operador delete no se puede utilizar para destruir una propiedad de una clase, a no ser que dicha clase sea una clase dinámica añadida en tiempo de ejecución. Las propiedades de las clases cerradas no se pueden destruir mediante delete. Defina la propiedad como null en su lugar.

Nota: no se puede eliminar un objeto, pero se puede hacer que este sea apto para eliminación de datos innecesarios eliminando todas las referencias al objeto. La referencia más habitual a un objeto es una variable que lo señala. Puede crear una referencia estableciendo la variable como null. El recolector de datos innecesarios elimina los objetos que no tengan referencias.

// 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

El siguiente ejemplo elimina el valor de un elemento de conjunto, pero el valor de la propiedad length no cambia:

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,

El ejemplo siguiente muestra cómo se puede utilizar el valor booleano de delete como una condición para próximas ejecuciones de código. Tenga en cuenta que si un elemento ya se ha eliminado, volver a llamar a delete en el elemento devolverá 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 de API relacionados

 delete reference

Elimina los elementos o 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());

La salida es la siguiente:

<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);

La salida para este ejemplo es la siguiente:

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

 myXML..childElement1..@attributeName 

Navega hasta elementos descendientes de un objeto XML o XMLList, o bien (en combinación con el operador @) encuentra atributos coincidentes de los descendientes. Los elementos o atributos coincidentes tienen que ser elementos secundarios directos del objeto XML o XMLList; pueden estar situados en un lugar inferior del árbol (por ejemplo, elementos terciarios). El resultado es un objeto XMLList, ya que pueden coincidir más de un elemento secundario o atributo.

El orden de los nodos en el objeto XMLList devuelto es el resultado de una transversal de primer nivel de profundidad (depth-first traversal). Por ejemplo, observe lo siguiente:

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());

Se produciría el siguiente resultado:

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

Para devolver descendientes con nombres que coincidan con palabras reservadas de ActionScript, utilice el método XML.descendants() y no el operador descendant (..) , como se muestra en el ejemplo siguiente:

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 de API relacionados

Divide expression1 por expression2. El resultado de la operación de división es un número de coma flotante de doble precisión.

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

Elementos de API relacionados

Asigna a expression1 el valor de expression1 / expression2. Por ejemplo, las dos sentencias siguientes son equivalentes:

x /= y; 
x = x / y;

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

Elementos de API relacionados

object.property_or_method

Accede a variables y métodos de clases, obtiene y establece propiedades de objetos y delimita paquetes o clases importados.

import flash.utils.Timer;

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

Elementos de API relacionados

myXML.childElement
myXML.@attributeName 

Navega hasta elementos secundarios de un objeto XML o XMLList, o bien (en combinación con el operador @) devuelve atributos de un objeto XML o XMLList. El objeto devuelto es XMLList, ya que pueden coincidir más de un elemento secundario o atributo.

Para devolver elementos con nombres que coincidan con palabras reservadas de ActionScript, utilice el método XML.elements() o el método XML.descendants() y no el punto XML (.) , como se muestra en el ejemplo siguiente:

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 de API relacionados

Comprueba la igualdad de dos expresiones. El resultado es true si las expresiones son iguales.

Si los tipos de datos de los dos operandos coinciden, la definición de igual depende del tipo de datos de los operandos:

• Los valores de tipo int, uint, y Boolean se consideran iguales si tienen el mismo valor.
• Los números con valores coincidentes se consideran iguales, a no ser que ambos sean NaN.
• Si el valor de ambos operandos es null o undefined, se consideran iguales.
• Las expresiones String son iguales si tienen el mismo número de caracteres y estos son idénticos.
• Para objetos XML:
  • Si un operando es un nodo de texto o atributo y el otro tiene contenido sencillo, ambos operandos se convierten en cadenas con el método toString() y se consideran iguales si coinciden las cadenas resultantes.
  • En caso contrario, los objetos solo se considerarán iguales si coinciden el nombre completo, los atributos y las propiedades secundarias de ambos objetos.
• Los objetos XMLList se consideran iguales si tienen el mismo número de propiedades y coinciden tanto el orden como los valores de las propiedades.
• Para objetos Namespace, los valores se consideran iguales si coinciden las propiedades uri de ambos objetos.
• En el caso de objetos QName, los valores se consideran iguales si coinciden las propiedades uri de ambos objetos, así como las propiedades localName.
• Las variables que representan objetos, conjuntos y funciones se comparan por su referencia. Dos de estas variables son iguales si hacen referencia al mismo objeto, conjunto o función. Dos conjuntos independientes nunca se consideran iguales, aunque tengan el mismo número de elementos.

• Los valores del operando son undefined y null, en cuyo caso el resultado es true.
• La conversión automática de los tipos de datos convierte los tipos de datos de valores String, Boolean, int, uint y Number en tipos compatibles y los valores convertidos son iguales, en cuyo caso los operandos se consideran iguales.
• Un operando es de tipo XML con contenido sencillo (hasSimpleContent() == true), y después de que ambos operandos se conviertan en cadenas con el método toString(), las cadenas resultantes coinciden.
• Un operando es de tipo XMLList y se cumple alguna de las siguientes condiciones:
  • La propiedad length del objeto XMLList es 0, y el otro objeto es undefined.
  • La propiedad length del objeto XMLList es 1 y un elemento del objeto XMLList coincide con el otro 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 de API relacionados

Compara dos expresiones y determina si expression1 es mayor que expression2; si lo es, el resultado es true. Si expression1 es menor o igual que expression2, el resultado es false.

Si ambos operandos son de tipo String, los operandos se comparan utilizando el orden alfabético; todas las letras mayúsculas van delante de las letras minúsculas. En caso contrario, los operandos se convierten primero en números y luego se comparan.

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 dos expresiones y determina si expression1 es mayor o igual que expression2 (true) o si expression1 es menor que expression2 (false).

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

Elementos de API relacionados

Evalúa si una propiedad forma parte de un objeto especificado. Para utilizar el operador in, especifique un nombre de propiedad como primer operando y un objeto como segundo operando. Si el objeto especificado contiene esta propiedad, el resultado es true; en caso contrario, el resultado es false.

Si el objeto especificado es un objeto Array, puede utilizar el operador in para comprobar si un determinado número de índice es válido. Si transfiere un entero como primer operando, el resultado es true si el índice está dentro del rango válido de números de índice; en caso contrario, es false.

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

El ejemplo siguiente utiliza el operador in para mostrar que los números 0, 1 y son números de índice válidos en el objeto myArray, pero que el número 3 no lo es.

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 de API relacionados

++expression

 expression++

Suma 1 a una expresión. La expresión debe ser una variable, un elemento de un conjunto o una propiedad de un objeto. La forma de incremento previo del operador (++expression) agrega 1 a expression y devuelve el resultado. La forma de incremento posterior del operador (expression++) añade 1 a expression y devuelve el valor inicial de expression (el valor antes de la suma).

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 
*/

Prueba el contrario exacto del operador de igualdad (==). Si expression1 es igual que expression2 , el resultado es false. Como ocurre con el operador de igualdad (==), la definición de igual depende de los tipos de datos que se comparan:

Si los tipos de datos de los dos operandos coinciden, la definición de igual depende del tipo de datos de los operandos:

• Los valores de tipo int, uint, y Boolean se consideran iguales si tienen el mismo valor.
• Los números con valores coincidentes se consideran iguales, a no ser que ambos sean NaN.
• Si el valor de ambos operandos es null o undefined, se consideran iguales.
• Las expresiones String son iguales si tienen el mismo número de caracteres y estos son idénticos.
• Para objetos XML:
  • Si un operando es un nodo de texto o atributo y el otro tiene contenido sencillo, ambos operandos se convierten en cadenas con el método toString() y se consideran iguales si coinciden las cadenas resultantes.
  • En caso contrario, los objetos solo se considerarán iguales si coinciden el nombre completo, los atributos y las propiedades secundarias de ambos objetos.
• Los objetos XMLList se consideran iguales si tienen el mismo número de propiedades y coinciden tanto el orden como los valores de las propiedades.
• Para objetos Namespace, los valores se consideran iguales si coinciden las propiedades uri de ambos objetos.
• En el caso de objetos QName, los valores se consideran iguales si coinciden las propiedades uri de ambos objetos, así como las propiedades localName.
• Las variables que representan objetos, conjuntos y funciones se comparan por su referencia. Dos de estas variables son iguales si hacen referencia al mismo objeto, conjunto o función. Dos conjuntos independientes nunca se consideran iguales, aunque tengan el mismo número de elementos.

• Los valores del operando son undefined y null, en cuyo caso el resultado es true.
• La conversión automática de los tipos de datos convierte los tipos de datos de valores String, Boolean, int, uint y Number en tipos compatibles y los valores convertidos son iguales, en cuyo caso los operandos se consideran iguales.
• Un operando es de tipo XML con contenido sencillo (hasSimpleContent() == true), y después de que ambos operandos se conviertan en cadenas con el método toString(), las cadenas resultantes coinciden.
• Un operando es de tipo XMLList y se cumple alguna de las siguientes condiciones:
  • La propiedad length del objeto XMLList es 0, y el otro objeto es undefined.
  • La propiedad length del objeto XMLList es 1 y un elemento del objeto XMLList coincide con el otro 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 de API relacionados

Evalúa si la cadena de prototipo de una expresión incluye el objeto prototipo para function. El operador instanceof se incluye para compatibilidad con versiones anteriores en ECMAScript Edition 3. Resulta útil para programadores avanzados que quieran utilizar herencia basada en prototipos con funciones de constructor en vez de clases.

Para comprobar si un objeto es miembro de un tipo de datos concreto, utilice el operador is.

Cuando se utiliza con clases, el operador instanceof es similar al operador is, ya que la cadena de prototipo de una clase incluye todas sus superclases. No obtante, las interfaces no se incluyen en cadenas de prototipo, por lo que le operador instanceof siempre da como resultado false cuando se utiliza con interfaces, mientras que el operador is da como resultado true si un objeto pertenece a la clase que implementa la interfaz especificada.

Nota: el operador is de ActionScript es equivalente al operador instanceof de 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 de API relacionados

Evalúa si un objeto es compatible con un tipo de datos, una clase o una interfaz específicos. Utilice el operador is en lugar de instanceof para realizar comparaciones de tipos. También puede utilizar el operador is para comprobar si un objeto implementa una interfaz.

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 de API relacionados

Compara dos expresiones y determina si expression1 es menor que expression2; si lo es, el resultado es true. Si expression1 es mayor o igual que expression2, el resultado es false.

Si ambos operandos son de tipo String, los operandos se comparan utilizando el orden alfabético; todas las letras mayúsculas van delante de las letras minúsculas. En caso contrario, los operandos se convierten primero en números y luego se comparan.

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 dos expresiones y determina si expression1 es mayor o igual a expression2; si lo es, el operador devuelve true. Si expression1 es mayor que expression2, el resultado es s false.

Si ambos operandos son de tipo String, los operandos se comparan utilizando el orden alfabético; todas las letras mayúsculas van delante de las letras minúsculas. En caso contrario, los operandos se convierten primero en números y luego se comparan.

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 el principio de un comentario de script. Los caracteres que aparecen entre el delimitador de comentario (//) y el carácter de final de línea se interpretan como un comentario y se omiten. Utilice este delimitador para comentarios de una sola línea; para comentarios de varias líneas sucesivas, use los delimitadores /* and */.

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

Elementos de API relacionados

Devuelve expression1 si es false o se puede convertir a false, y devuelve expression2 en caso contrario. Ejemplos de valores que se pueden convertir a false: 0, NaN, null y undefined. Si utiliza una llamada de función como expression2, la función no se llama si expression1 da como resultado false.

Si ambos operandos son de tipo Boolean, el resultado será true solo si ambos operandos son true, como puede verse en la siguiente tabla:

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

Elementos de API relacionados

Asigna a expression1 el valor de expression1 && expression2. Por ejemplo, las dos sentencias siguientes son equivalentes:

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