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

Véase también

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

Véase también

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

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

Sintaxis 1: una matriz es un objeto cuyas propiedades se denominan elementos, que se identifican mediante un número denominado índice. Cuando se crea una matriz, se rodean los elementos con el operador de acceso a matriz ([]) (o corchetes). Una matriz puede contener elementos de diversos tipos. Por ejemplo, la siguiente matriz, denominada 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 una matriz denominada employee_array con tres elementos y cambia el tercer elemento de la matriz.

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

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

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

Véase también

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

Véase también

Asigna el valor de expression2 (el operando de la derecha) a la variable, elemento de matriz o propiedad de expression1. La asignación puede ser por valor o por referencia. La asignación por valor copia el valor real 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 en expression2 de expression1. La asignación por referencia suele utilizarse con el 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

Véase también

 myXML.@attributeName 

Identifica atributos de un objeto XML o XMLList. Por ejemplo, myXML.@id identifica atributos denominados id para el objeto XML myXML. Puede también utilizar la siguiente sintaxis para obtener acceso a los atributos: myXML.attribute("id"), myXML["@id"] y myXML.@["id"]. Se recomienda la sintaxis myXML.@id. 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"));

Véase también

Convierte expression1 y expression2 en enteros de 32 bits sin signo y ejecuta una operación Boolean 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 un valor máximo de 4294967295 o 0xFFFFFFFF; los dígitos más significativos de un valor mayor que el valor máximo se descartan al convertirlo para que el valor continúe siendo de 32 bits. Un número negativo se convierte en un valor hexadecimal sin signo utilizando la notación complementaria del dos, siendo el mínimo -2147483648 o 0x800000000; un número inferior al mínimo se convierte en el complemento del dos con una mayor precisión antes de que se descarten sus 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 

Véase también

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 

Véase también

Convierte expression1 y shiftCount en enteros de 32 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 un valor máximo de 4294967295 o 0xFFFFFFFF; los dígitos más significativos de un valor mayor que el valor máximo se descartan al convertirlo para que el valor continúe siendo de 32 bits. Un número negativo se convierte en un valor hexadecimal sin signo utilizando la notación complementaria del dos, siendo el mínimo -2147483648 o 0x800000000; un número inferior al mínimo se convierte en el complemento del dos con una mayor precisión antes de que se descarten sus 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 

Véase también

Ejecuta 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 

Véase también

Convierte expression en un entero de 32 bits con 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 Boolean 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 un valor máximo de 4294967295 o 0xFFFFFFFF; los dígitos más significativos de un valor mayor que el valor máximo se descartan al convertirlo para que el valor continúe siendo de 32 bits. Un número negativo se convierte en un valor hexadecimal sin signo utilizando la notación complementaria del dos, siendo el mínimo -2147483648 o 0x800000000; un número inferior al mínimo se convierte en el complemento del dos con una mayor precisión antes de que se descarten sus 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 

Véase también

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 expression2 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 un valor máximo de 4294967295 o 0xFFFFFFFF; los dígitos más significativos de un valor mayor que el valor máximo se descartan al convertirlo para que el valor continúe siendo de 32 bits. Un número negativo se convierte en un valor hexadecimal sin signo utilizando la notación complementaria del dos, siendo el mínimo -2147483648 o 0x800000000; un número inferior al mínimo se convierte en el complemento del dos con una mayor precisión antes de que se descarten sus 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) 

Véase también

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) 

Véase también

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 a la izquierda se completan con un 0 si el bit más importante (el situado en el extremo izquierdo) de expression es 0, y con 1 si el bit más importante es 1. Desplazar un valor una posición a la derecha equivale a dividir entre 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 un valor máximo de 4294967295 o 0xFFFFFFFF; los dígitos más significativos de un valor mayor que el valor máximo se descartan al convertirlo para que el valor continúe siendo de 32 bits. Un número negativo se convierte en un valor hexadecimal sin signo utilizando la notación complementaria del dos, siendo el mínimo -2147483648 o 0x800000000; un número inferior al mínimo se convierte en el complemento del dos con una mayor precisión antes de que se descarten sus 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)

Véase también

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.

Véase también

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 un valor máximo de 4294967295 o 0xFFFFFFFF; los dígitos más significativos de un valor mayor que el valor máximo se descartan al convertirlo para que el valor continúe siendo de 32 bits. Un número negativo se convierte en un valor hexadecimal sin signo utilizando la notación complementaria del dos, siendo el mínimo -2147483648 o 0x800000000; un número inferior al mínimo se convierte en el complemento del dos con una mayor precisión antes de que se descarten sus 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 

Véase también

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 

Véase también

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 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 un valor máximo de 4294967295 o 0xFFFFFFFF; los dígitos más significativos de un valor mayor que el valor máximo se descartan al convertirlo para que el valor continúe siendo de 32 bits. Un número negativo se convierte en un valor hexadecimal sin signo utilizando la notación complementaria del dos, siendo el mínimo -2147483648 o 0x800000000; un número inferior al mínimo se convierte en el complemento del dos con una mayor precisión antes de que se descarten sus 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) 

Véase también

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) 

Véase también

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

Véase también

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

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. Una expresión delimitada por los operadores XML { y } puede utilizarse en un inicializador de XML o XMLList en lugar de nombres o valores literales. Se puede usar 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>

Véase también

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

Véase también

Evalúa primero expression1, a continuación, 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 

Véase también

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 

Véase también

expression1 + expression2

Concatena (combina) valores XML o XMLList en un objeto XMLList. Se origina un objeto XMLList sólo 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>

Véase también

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 

Véase también

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>

Véase también

expression1 ? expression2 : expression3

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

Véase también

--expression

expression--

Resta 1 del operando. El operando puede ser una variable, un elemento de una matriz 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);
}

Véase también

 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 la 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 éste 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 ejemplo siguiente elimina el valor de un elemento de matriz, 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 Boolean 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

Véase también

 delete reference

Elimina los elementos o atributos XML especificados por reference.

Cuando se utiliza con un operando XMLList, el resultado del operador delete es siempre true, ya que el operando XMLList siempre hace referencia a un objeto XMLList válido (aunque posiblemente vacío).

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 no 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 porque pueden coincidir más un elemento o atributo secundario.

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

Véase también

Divide expression1 entre 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

Véase también

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 

Véase también

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

Véase también

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, porque pueden coincidir más de un elemento o atributo secundario.

Para devolver elementos con nombres que coincidan con palabras reservadas de ActionScript, utilice el método XML.elements() o XML.descendants() en lugar del operador de 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

Véase también

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 éstos 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 sólo 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.
• Para los 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, matrices y funciones se comparan por su referencia. Dos de estas variables son iguales si hacen referencia al mismo objeto, matriz o función. Dos matrices independientes nunca se consideran iguales, aunque tengan el mismo número de elementos.

• Los valores de los operandos 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 cualquiera 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 

Véase también

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

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

Véase también

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 que especifica contiene dicha propiedad, el resultado es true; en caso contrario, el resultado es false.

Si el objeto especificado es Array, puede utilizar el operador in para comprobar si un número de índice determinado es o no válido. Si pasa un entero como primer operando, el resultado será true cuando el índice esté dentro del intervalo válido de números de índice; en caso contrario, el resultado será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 2 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

Véase también

++expression

 expression++

Suma 1 a una expresión. La expresión puede ser una variable, un elemento de una matriz o una propiedad de un objeto. La forma de incremento previo del operador (++expression) suma 1 a expression y devuelve el resultado. La forma de incremento posterior del operador (expression++) suma 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
*/

Véase también

Prueba el contrario exacto del operador de igualdad (==). Si expression1 es igual a 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 éstos 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 sólo 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.
• Para los 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, matrices y funciones se comparan por su referencia. Dos de estas variables son iguales si hacen referencia al mismo objeto, matriz o función. Dos matrices independientes nunca se consideran iguales, aunque tengan el mismo número de elementos.

• Los valores de los operandos 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 cualquiera 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

Véase también

Evalúa si la cadena de prototipo de una expresión incluye el objeto prototipo para function. El operador instanceof se incluye para conseguir compatibilidad retroactiva con ECMAScript edición 3, pero puede resultar útil para aquellos programadores avanzados que deseen utilizar la herencia de prototipo con funciones constructoras en lugar 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. Sin embargo, las interfaces no se incluyen en las cadenas de prototipo, por lo que el 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 una 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

Véase también

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

Véase también

Compara dos expresiones y determina si expression1 es menor que expression2; si lo es, el resultado es true. Si expression1 es mayor o igual a 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 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 menor o igual a expression2; si lo es, el resultado es true. Si expression1 es mayor 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);            // 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 /* y */.

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

Véase también

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

Si ambos operandos son de tipo Boolean, el resultado sólo será true si ambos operandos son true, como se muestra en la tabla siguiente:

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

Véase también

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

Véase también

Invierte el valor Boolean de una variable o expresión. Si expression es una variable con el valor absoluto o convertido true, 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
} 

Véase también

Devuelve expression1 si es true o se puede convertir en true, y 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 sólo 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 a la izquierda del operador da como resultado true, ese resultado se devolverá sin evaluar la expresión a 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");
}

Véase también

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

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

myVar ||= "default";

Véase también

Calcula el resto de expression1 dividido entre 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 dan como resultado -1.

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

Véase también

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 

Véase también

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 

Véase también

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 

Véase también

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

Véase también

Crea una instancia de clase. El operador new puede utilizarse con una clase o una variable de tipo Class para crear la 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);

Véase también

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

Crea un nuevo objeto y lo inicializa con los pares de propiedades name y value. Utilizar este operador equivale a usar la nueva sintaxis de new Object 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"; 

Véase también

(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 

Véase también

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

Véase también

/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 

Véase también

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 numéricos 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 éstos son idénticos.
• Las variables que representan objetos, matrices y funciones se comparan por su referencia. Dos de estas variables son iguales si hacen referencia al mismo objeto, matriz o función. Dos matrices independientes nunca se consideran iguales, aunque tengan el mismo número de elementos.

• El operador de igualdad estricta sólo realiza la conversión automática de datos para los tipos numéricos Number, int y uint, mientras que el operador de igualdad realiza la conversión automática de datos para todos los tipos de datos simples.
• Al comparar 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, 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

Véase también

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 sólo se convierten los tipos de datos int y uint.

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

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

• Los valores numéricos 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 éstos son idénticos.
• Las variables que representan objetos, matrices y funciones se comparan por su referencia. Dos de estas variables son iguales si hacen referencia al mismo objeto, matriz o función. Dos matrices independientes nunca se consideran iguales, aunque tengan el mismo número de elementos.

• El operador de desigualdad estricta (!==) sólo realiza la conversión automática de datos para los tipos numéricos (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.
• Al comparar 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 

Véase también

 "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

Véase también

-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 

Véase también

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 

Véase también

[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 desea dejar claro que su intención es utilizar un valor sin tipo asignado, puede emplear el carácter de asterisco (*) para la anotación del 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)); 

Véase también

Evalúa expression y devuelve una cadena que especifica el tipo de datos de la expresión. El resultado está limitado a seis valores de cadena posibles: 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

Véase también

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 no definidos.

Véase también

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

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

Véase también