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; 

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

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

Elementos de API relacionados

Invierte el valor booleano de una variable o expresión. Si expression es una variable con valor true absoluto o convertido, el valor de !expression es false. Si la expresión x && y da como resultado false, la expresión !(x && y) da como resultado true.

Las siguientes expresiones ilustran el resultado del uso del operador NOT lógico (!):

• !true devuelve false.
• !false devuelve true.

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

Elementos de API relacionados

Devuelve expression1 si es true o se puede convertir a true y devuelve expression2 en caso contrario. Si utiliza una llamada de función como expression2, no se llamará a la función si expression1 da como resultado true.

Si ambos operandos son de tipo Boolean, el resultado será true si una o ambas expresiones son true; el resultado será false solo si ambas expresiones son false como se muestra en la tabla siguiente:

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

El ejemplo siguiente demuestra cómo el uso de una llamada de función como segundo operando puede producir resultados imprevistos. Si la expresión de la izquierda del operador da como resultado true, ese resultado se devolverá sin evaluar la expresión de la derecha (no se llamará a la función fx2()).

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

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; 

myVar ||= "default";

Elementos de API relacionados

Calcula el resto de expression1 dividido por expression2. Si uno de los operandos es no numérico, el operador de módulo (%) intenta convertirlo en un número.

El signo del resultado del módulo coincide con el signo del dividendo (el primer número). Por ejemplo, -4 % 3 y -4 % -3 ambos devuelven -1.

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

Elementos de API relacionados

Asigna a expression1 el valor de expression1 % expression2. Las dos sentencias siguientes son equivalentes:

x %= y; 
x = x % y; 

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

Elementos de API relacionados

Multiplica dos expresiones numéricas. Si ambas expresiones son enteros, el producto es un entero. Si una o ambas expresiones son números de coma flotante, el producto es un número de coma flotante.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

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

x *= y 
x = x * y 

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

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

Elementos de API relacionados

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Identifica el espacio de nombres de una propiedad, un método, una propiedad XML o un atributo XML.

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

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

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

Elementos de API relacionados

Crea una instancia de clase. El operador new puede utilizarse con una clase o una variable de tipo Class para crear una instancia de una clase. El operador new suele utilizarse con un objeto de clase para crear la instancia de una clase. Por ejemplo, la sentencia new Sprite() crea una instancia de la clase Sprite.

El operador new también puede utilizarse para asociar una clase con un activo incorporado, que es un objeto externo, como una imagen, un sonido o una fuente compilada en un archivo SWF. Cada activo incorporado se representa mediante una clase de activo incorporado. Para obtener acceso a un activo incorporado, debe utilizar el operador new para crear una instancia de su clase asociada. Posteriormente, puede llamar a los métodos y las propiedades adecuados de la clase del activo incorporado para manipularlo.

Si prefiere definir clases con objetos Function en lugar de la palabra clave class, puede utilizar el operador new para crear objetos basados en funciones constructoras. No debe confundir las funciones constructoras con los métodos constructores de una clase. Una función constructora es un objeto Function que se define con la palabra clave function, pero que no forma parte de una definición de clase. Si utiliza funciones constructoras para crear objetos, deberá utilizar la herencia de prototipo en lugar de la herencia de clase.

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

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

var golfCourse:Array = new Array(18);

Elementos de API relacionados

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

Crea un nuevo objeto y lo inicializa con los pares de propiedades especificadas name y value. Utilizar este operador equivale a utilizar la nueva sintaxis de newObject y llenar los pares de propiedades con el operador de asignación. El prototipo del objeto recién creado se denomina de forma genérica el objeto Object.

Este operador se utiliza además para marcar bloques de código contiguo asociado con sentencias de control de flujo (for, while, if, else, switch) y funciones.

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

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

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

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

Elementos de API relacionados

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Ejecuta una operación de agrupación en uno o varios parámetros, lleva a cabo una evaluación secuencial de las expresiones o rodea uno o varios parámetros y los pasa como argumentos a una función que precede al paréntesis.

Sintaxis 1: controla el orden de ejecución de los operadores. Los paréntesis sustituyen el orden de precedencia normal y pueden hacer que las expresiones entre paréntesis se evalúen primero. Cuando se anidan los paréntesis, el contenido de los paréntesis más interiores se evalúa antes que el contenido de los más exteriores.

Sintaxis 2: da como resultado una serie de expresiones, separadas por comas, en una secuencia y devuelve el resultado de la expresión final.

Sintaxis 3: rodea uno o varios parámetros y los pasa a la función que precede al paréntesis.

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

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

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

Elementos de API relacionados

myXML.(expression)

Evalúa una expresión en una construcción XML ECMAScript para XML (E4X). Por ejemplo, myXML.(lastName == "Smith") identifica elementos XML con el nombre lastName y el valor "Smith". El resultado es un objeto XMLList.

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

Elementos de API relacionados

/pattern/flags

Si se utiliza antes y después de caracteres, indica que los caracteres tienen un valor literal y se consideran una expresión regular (RegExp), no una variable, una cadena u otro elemento de ActionScript. Tenga en cuenta, no obstante, que dos caracteres de barra diagonal seguidos (//) indican el comienzo de un comentario.

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

Elementos de API relacionados

Comprueba la igualdad de dos expresiones, pero no realiza la conversión automática de los datos. El resultado es true si ambas expresiones, incluidos sus tipos de datos, son iguales.

El operador de igualdad estricta (===) es igual que el operador de igualdad (==) en tres aspectos:

• Los valores Number y Boolean se comparan por su valor y se consideran iguales si tienen el mismo valor.
• Las expresiones String son iguales si tienen el mismo número de caracteres y estos son idénticos.
• 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.

• El operador de igualdad estricta realiza conversión automática de datos solo para tipos numéricos (Number, int y uint), mientras que el operador de igualdad realiza conversión automática de datos para todos los tipos de datos primitivos.
• Cuando se compara null y undefined, el operador de igualdad estricta devuelve false.

En primer lugar, las comparaciones entre valores simples y objetos simples que contienen el mismo valor devuelven true en ActionScript 3.0, mientras que en versiones anteriores devuelven false. En versiones anteriores, el tipo de datos de un valor simple es Boolean o Number o String, mientras que el tipo de datos de un objeto simple es siempre Object y no Boolean, Number o String. Esta diferencia, a efectos prácticos, origina que el siguiente código devuelva false en la versiones anteriores de ActionScript porque los tipos de datos de los operandos no coinciden, mientras que el resultado es true en ActionScript 3.0 debido a que el tipo de datos de los valores simples es Boolean, Number, int, uint o String, independientemente de si están o no dentro de un objeto envolvente.

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

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

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

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

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

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

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

Elementos de API relacionados

Prueba el contrario exacto del operador de igualdad estricta (===). El operador de desigualdad estricta realiza lo mismo que el operador de desigualdad, con la diferencia de que solo se convierten los tipos de datos int y uint.

Si expression1 es igual que expression2, y sus tipos de datos son iguales, el resultado es false.

El operador de desigualdad estricta (!==) se asemeja al del operador de desigualdad (!=) en tres aspectos:

• Los valores Number y Boolean se comparan por su valor y se consideran iguales si tienen el mismo valor.
• Las expresiones String son iguales si tienen el mismo número de caracteres y estos son idénticos.
• 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.

• El operador de desigualdad estricta (!==) lleva a cabo la conversión automática de los datos solo para los tipos númericos Number, int y uint, mientras que el operador de desigualdad (!=) realiza la conversión automática de datos para todos los tipos de datos simples.
• Cuando se comparan null y undefined, el operador de desigualdad estricta (!==) devuelve true.

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

Elementos de API relacionados

 "text" 

Si se utiliza antes y después de caracteres, indica que los caracteres tienen un valor literal y se consideran una cadena y no una variable, un valor numérico u otro elemento de ActionScript.

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

Elementos de API relacionados

-expression

 expression1 - expression2

Se emplea para negar o restar.

Sintaxis 1: si se utiliza para negar, el operador invierte el signo de una expresión numérica.

Sintaxis 2: Si se utiliza para restar, el operador ejecuta una resta aritmética en dos expresiones numéricas, restando expression2 de expression1. Si ambas expresiones son enteros, la diferencia es un entero. Si una o ambas expresiones son números de coma flotante, la diferencia es un número de coma flotante.

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

trace(5 - 2); // 3 

La sentencia siguiente resta el número de coma flotante 1,5 del número de coma flotante 3,25:

trace(3.25 - 1.5); // 1.75 

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

x -= y ;
x = x - y;

Las expresiones de cadenas deben convertirse a números; en caso contrario, el resultado es NaN (que no es número).

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

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

Elementos de API relacionados

[modifiers] var variableName:type

function functionName():type { ... }

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

Se utiliza para asignar un tipo de datos; este operador especifica el tipo de variable, el tipo de devolución de función o el tipo de parámetro de función. Cuando se utiliza en una asignación o declaración de variable, este operador especifica el tipo de la variable; cuando se utiliza en una declaración o definición de función, este operador especifica el tipo de devolución de la función; cuando se utiliza con un parámetro de función en una definición de función, este operador especifica el tipo de variable que se espera para dicho parámetro.

La comprobación de tipos siempre tiene lugar en tiempo de ejecución. Sin embargo, cuando el compilador se establece en modo estricto, todos los tipos se comprueban durante la compilación y se generan errores cuando hay una discordancia. Pueden producirse discordancias durante las operaciones de asignación, llamadas a funciones y eliminación de referencias a miembros de clase con el operador de punto (.).

Los tipos que pueden utilizarse son todos los tipos de objetos nativos, clases e interfaces definidas y void. Los tipos nativos reconocidos son Boolean, Number, int, uint y String. También se admiten como tipos nativos todas las clases incorporadas.

Si no asigna un tipo de datos, se considerará que la variable, el valor de devolución de la función o el parámetro de la función no tienen tipo asignado, lo que significa que el valor puede tener cualquier tipo de datos. Si quiere dejar clara su intención de usar un valor sin tipo, puede recurrir al carácter asterisco (*) como anotación de tipo. Cuando se utiliza como anotación de tipo, el carácter de asterisco equivale a dejar una variable, un tipo de devolución de función o un parámetro de función sin tipo asignado.

var userName:String = ""; 

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

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

Elementos de API relacionados

Evalúa expression y devuelve una cadena que especifica el tipo de datos de la expresión. El resultado se limita a seis posibles valores de cadena: boolean, function, number, object, string y xml. Si aplica este operador a una instancia de una clase definida por el usuario, el resultado será la cadena object. El operador typeof se incluye para lograr compatibilidad retroactiva. Utilice el operador is para comprobar la compatibilidad de tipos.

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

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

Elementos de API relacionados

Evalúa una expresión y, a continuación, descarta su valor, devolviendo undefined. El operador void se emplea a menudo en comparaciones que utilizan el operador == para comprobar valores undefined.

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

Define una etiqueta XML en un literal XML. Utilice la barra diagonal / para definir la etiqueta de cierre.

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

Elementos de API relacionados