function functionName(parameter0, parameter1,...rest){
	// statement(s)
} 

Especifica que una función acepta cualquier número de argumentos separados por comas. La lista de argumentos se convierte en una matriz que está disponible en todo el cuerpo de la función. El nombre de la matriz se especifica después de los caracteres ... en la declaración del parámetro. El parámetro puede tener cualquier nombre que no sea una palabra reservada.

Si se utiliza con otros parámetros, la declaración del parámetro ... (rest) debe ser el último parámetro especificado. La matriz del parámetro ... (rest) se llena de valores sólo si el número de argumentos de la función supera el número de otros parámetros.

Cada argumento de la lista de argumentos separados por comas se sitúa en un elemento de la matriz. Si pasa una instancia de la clase Array, toda la matriz se colocará en un único elemento de la matriz del parámetro ... (rest).

El uso de este parámetro hace que el objeto arguments no esté disponible. Aunque el parámetro ... (rest) le ofrece la misma funcionalidad que la matriz arguments y la propiedad arguments.length, no proporciona funcionalidad similar a la que ofrece arguments.callee. Asegúrese de que no necesita utilizar arguments.callee antes de utilizar el parámetro ... (rest).

package {
    import flash.display.MovieClip;

    public class RestParamExample extends MovieClip {
        public function RestParamExample() {
            traceParams(100, 130, "two"); // Output: 100,130,two
            trace(average(4, 7, 13));     // Output: 8
        }
    }
}


function traceParams(... rest) {
     trace(rest);
 }

function average(... args) : Number{
    var sum:Number = 0;
    for (var i:uint = 0; i < args.length; i++) {
        sum += args[i];
    }
    return (sum / args.length);
}

Véase también

Define métodos y propiedades de las clases principales de ActionScript que son propiedades fijas en lugar de propiedades prototipo. Al establecer la opción de compilador "-as3" con el valor true (which is the default setting in Flex Builder 2), el espacio de nombres AS3 se abre automáticamente para todas las clases principales. Esto significa que una instancia de una clase principal utilizará propiedades y métodos fijos en lugar de las versiones de dichas propiedades y métodos que se adjuntan al objeto prototipo de la clase. El uso de propiedades fijas normalmente proporciona un mejor rendimiento, pero supone la pérdida de compatibilidad retroactiva con la especificación del lenguaje ECMAScript edición 3 (ECMA-262).

Véase también

Aparece dentro de un bucle (for, for..in, for each..in, do..while o while) o en un bloque de sentencias asociadas a un determinado caso de una sentencia switch. Cuando se utiliza en un bucle, la sentencia break ordena a Flash que omita el resto del cuerpo del bucle, detenga la acción de bucle y ejecute la sentencia que sigue a la sentencia de bucle. Cuando se utiliza en una sentencia switch, la sentencia break ordena a Flash que omita el resto de sentencias en ese bloque case y que salte a la primera sentencia que vaya a continuación de switch.

En bucles anidados, break sólo omite el resto del bucle inmediato, no toda la serie de bucles anidados. Para salir de toda una serie de bucles anidados, debe usar label o try..catch..finally.

La sentencia break puede tener una etiqueta opcional que debe coincidir con una sentencia etiquetada exterior. El uso de una etiqueta que no coincide con la etiqueta de una sentencia exterior constituye un error de sintaxis. Las sentencias break etiquetadas pueden utilizarse para salir de varios niveles de sentencias de bucle anidadas, sentencias switch o block. Por ejemplo, consulte la entrada de la sentencia label.

var i:int = 0;
while (true) {
    trace(i);
    if (i >= 10) {
        break; // this will terminate/exit the loop
    }
    i++;
}
/* output:
0
1
2
3
4
5
6
7
8
9
10*/

Véase también

case jumpTarget: statements

Define el destino del salto para la sentencia switch. Si el parámetro jumpTarget es igual al parámetro expression de la sentencia switch que utiliza la igualdad estricta (===), Flash Player ejecutará las sentencias en el parámetro statements hasta que encuentre una sentencia break o el final de la sentencia switch.

Si se utiliza la sentencia case fuera de una sentencia switch, se produce un error y el script no se compila.

Nota: finalice siempre el parámetro statements con una sentencia break. Si omite la sentencia break del parámetro statements, continúa ejecutándose con la siguiente sentencia case en la lugar de salir de la sentencia switch existente.

var thisMonth:int = new Date().getMonth();
switch (thisMonth) {
    case 0 :
        trace("January");
        break;
    case 1 :
        trace("February");
        break;
    case 5 :
    case 6 :
    case 7 :
        trace("Some summer month");
        break;
    case 8 :
        trace("September");
        break;
    default :
        trace("some other month");
}

Véase también

[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] {
	// class definition here
}

Define una clase que permite crear instancias de objetos que comparten métodos y propiedades definidas por el usuario. Por ejemplo, si está desarrollando un sistema de seguimiento de facturas, podría crear una clase Invoice (factura) que definiera todos los métodos y propiedades que debe tener cada factura. Utilizaría entonces el comando new Invoice() para crear objetos Invoice.

Cada archivo de origen de ActionScript sólo puede contener una clase visible para otros archivos de origen o scripts. La clase visible de forma externa puede ser pública o interna, y se debe definir dentro de una sentencia de paquete. Si incluye otras clases en el mismo archivo, se deben colocar fuera de la sentencia de paquete y al final del archivo.

El nombre de la clase visible de forma externa debe coincidir con el nombre del archivo de origen de ActionScript que contiene la clase. El nombre del archivo de origen debe ser el mismo que el de la clase con la extensión de archivo.as. Por ejemplo, si se denomina a una clase Student, el archivo que defina la clase debe denominarse Student.as.

No es posible anidar definiciones de clase, es decir, no se pueden definir clases adicionales en una definición de clase.

Puede definir un método constructor, que es un método que se ejecuta siempre que se crea una instancia nueva de la clase. El nombre del método constructor debe coincidir con el nombre de la clase. Si no define un método constructor, se creará un constructor predeterminado.

Para indicar que los objetos pueden añadir propiedades dinámicas y acceder a ellas en tiempo de ejecución, incluya la palabra clave dynamic antes de la sentencia class. Para declarar que una clase implemente una interfaz, utilice la palabra clave implements. Para crear subclases de una clase, utilice la palabra clave extends. (Una clase sólo puede ampliar una clase pero puede implementar varias interfaces.) Puede utilizar implements y extends en una única sentencia. En el ejemplo siguiente se muestran diversos usos habituales de las palabras claves implements y extends :

class C implements Interface_i, Interface_j // OK
class C extends Class_d implements Interface_i, Interface_j // OK
class C extends Class_d, Class_e // not OK 

// Filename Plant.as
package {
  public class Plant {
    // Define property names and types
    private var _leafType:String;
    private var _bloomSeason:String;
    // Following line is constructor
    // because it has the same name as the class
    public function Plant(param_leafType:String, param_bloomSeason:String) {
        // Assign passed values to properties when new Plant object is created
        _leafType = param_leafType;
        _bloomSeason = param_bloomSeason;
    }
    // Create methods to return property values, because best practice
    // recommends against directly referencing a property of a class
    public function get leafType():String {
        return _leafType;
    }
    public function get bloomSeason():String {
        return _bloomSeason;
    }
  }
}

var pineTree:Plant = new Plant("Evergreen", "N/A");
// Confirm parameters were passed correctly
trace(pineTree.leafType);
trace(pineTree.bloomSeason); 

Véase también

const identifier = value 

Especifica una constante, que es una variable a la que puede asignarse un valor una sola vez.

Puede asignar una constante con strict typing añadiendo dos puntos (:) seguidos del tipo de datos.

const MIN_AGE:int = 21;
MIN_AGE = 18; // error

const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze");
product_array.push("Flex"); // array operations are allowed
product_array = ["Other"];  // assignment is an error
trace(product_array);

Véase también

continue [label]

Salta por encima de todas las sentencias restantes en el bucle más interior e inicia la siguiente repetición del bucle como si se hubiera pasado el control hasta el final del bucle de la forma habitual. La sentencia continue no tiene ningún efecto fuera de un bucle. En bucles anidados, utilice el parámetro opcional label para omitir otros bucles además del bucle más interior.

La sentencia continue puede tener una etiqueta opcional que debe coincidir con una sentencia etiquetada exterior. El uso de una etiqueta que no coincide con la etiqueta de una sentencia exterior constituye un error de sintaxis. Las sentencias continue etiquetadas pueden utilizarse para omitir varios niveles de sentencias de bucle anidadas.

var i:int = 0;
while (i < 10) {
    if (i % 3 == 0) {
        i++;
        continue;
    }
    trace(i);
    i++;
}

En un bucle for, la sentencia continue también puede utilizarse para omitir el resto del cuerpo del bucle. En el ejemplo siguiente, si i % 3 es igual a 0, se omitirá la sentencia trace(i) :

for (var i:int = 0; i < 10; i++) {
    if (i % 3 == 0) {
        continue;
    }
    trace(i);
}

Véase también

default: statements 

Define el caso predeterminado de una sentencia switch. Las sentencias se ejecutan si el parámetro expression de la sentencia switch no equivale (mediante la operación de igualdad estricta [===]) a ninguno de los parámetros expression que siguen a las palabras claves case de una sentencia switch.

No es necesario que la sentencia switch tenga una sentencia case default. Una sentencia case default no tiene que ser necesariamente la última de la lista. Si se utiliza una sentencia default fuera de una sentencia switch, se produce un error y el script no se compila.

var dayOfWeek:int = new Date().getDay();
switch (dayOfWeek) {
    case 1 :
        trace("Monday");
        break;
    case 2 :
        trace("Tuesday");
        break;
    case 3 :
        trace("Wednesday");
        break;
    case 4 :
        trace("Thursday");
        break;
    case 5 :
        trace("Friday");
        break;
    default :
        trace("Weekend");
}

Véase también

La directiva default xml namespace establece el espacio de nombres predeterminado que debe utilizarse para objetos XML.

Si no establece default xml namespace, el espacio de nombres predeterminado es el espacio de nombres sin nombre (con el URI establecido como una cadena vacía). El ámbito de una declaración default xml namespace está dentro de un bloque de función, al igual que el ámbito de una variable.

var nsDefault1:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault1;

var x1:XML = <test1 />;
trace("x1 ns: " + x1.namespace());

scopeCheck();

var x2:XML = <test2 />;
trace("x2 ns: " + x2.namespace());

function scopeCheck(): void {

    var x3:XML = <test3 />;
    trace("x3 ns: " + x3.namespace());

    var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
    default xml namespace = nsDefault2;

    var x4:XML = <test4 />;
    trace("x4 ns: " + x4.namespace());

}

El resultado trace() de este ejemplo es el siguiente:

x1 ns: http://www.example.com/namespaces/
x3 ns:
x4 ns: http://schemas.xmlsoap.org/soap/envelope/
x2 ns: http://www.example.com/namespaces/

var nsDefault:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault;

var x1:XML = <test1 />;

trace(x1.namespace());
    // http://www.example.com/namespaces/

var x2:XML = <test2 xmlns = "http://www.w3.org/1999/XSL/Transform/" />;
trace(x2.namespace());
    // http://www.w3.org/1999/XSL/Transform/

var x3:XML = <test3 xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/" />;
trace(x3.namespace());
    // http://www.example.com/namespaces/

Véase también

do { statement(s) } while (condition)

Similar al bucle while, con la diferencia de que las sentencias se ejecutan una vez antes de la evaluación inicial de la condición. Las sentencias a continuación sólo se ejecutan si la condición da como resultado true.

Un bucle do..while garantiza que el código dentro del bucle se ejecutará al menos una vez. Aunque también puede lograr esto con un bucle while colocando una copia de las sentencias que se van a ejecutar antes de que se inicie el bucle while, muchos programadores consideran que es más fácil leer los bucles do..while.

Si la condición da siempre como resultado true, el bucle do..while es infinito. Si se introduce un bucle infinito, habrá problemas con Flash Player y finalmente se obtendrá un mensaje de advertencia o se bloqueará el reproductor. Siempre que sea posible, utilice un bucle for si sabe el número de veces que desea ejecutar el bucle. Aunque es fácil leer y depurar los bucles for, no siempre pueden sustituir a los bucles do..while.

var myVar:Number = 0;
do {
    trace(myVar);
    myVar++;
}
while (myVar < 5);
/* output:
0
1
2
3
4
*/

Véase también

dynamic class className { // class definition here }

Especifica que las instancias de una clase pueden poseer propiedades dinámicas añadidas en tiempo de ejecución. Si utiliza el atributo dynamic en una clase, puede añadir propiedades a instancias de dicha clase en tiempo de ejecución. Las clases que no están marcadas como dynamic se consideran cerradas, lo que significa que no es posible añadir propiedades a instancias de la clase.

Si una clase está cerrada (no es dinámica), los intentos de obtener o establecer propiedades en instancias de la clase dan como resultado un error. Si tiene el compilador establecido en modo estricto y especifica el tipo de datos al crear instancias, los intentos de añadir propiedades a objetos cerrados generarán un error del compilador; en caso contrario, se producirá un error de tiempo de ejecución.

Las subclases no heredan el atributo dynamic. Si amplía una clase dinámica, la subclase sólo será dinámica si declara la subclase con el atributo dynamic.

package {

    dynamic class Expando  {
    }

    class Sealed {
    }
}

var myExpando:Expando = new Expando();
myExpando.prop1 = "new";
trace(myExpando.prop1); // output: new

var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // error

Véase también

if (condition) {
	// statement(s)
}
else {
	// statement(s)
}

Especifica las sentencias que se ejecutarán si la condición de la sentencia if devuelve false. Las llaves ({}) que encierran las sentencias que va a ejecutar la sentencia else no son necesarias si sólo se va a ejecutar una sentencia.

if (age_txt.text>=18) {
    trace("welcome, user");
}
else {
    trace("sorry, junior");
    userObject.minor = true;
    userObject.accessAllowed = false;
}

if (age_txt.text>18) {
    trace("welcome, user");
}
else trace("sorry, junior");

if (score_txt.text>90) {
    trace("A");
}
else if (score_txt.text>75) {
    trace("B");
}
else if (score_txt.text>60) {
    trace("C");
}
else {
    trace("F");
}

Véase también

class className extends otherClassName {}
interface interfaceName extends otherInterfaceName {} 

Define una clase que es una subclase de otra clase. La subclase hereda todos los métodos, propiedades, funciones, etc. definidos en la superclase. Las clases marcadas como final no pueden ampliarse.

También puede utilizar la palabra clave extends para ampliar una interfaz. Una interfaz que amplía otra interfaz incluye todas las declaraciones del método de la interfaz original.

El ejemplo siguiente muestra el contenido de un archivo llamado Vehicle.as, que define la clase Vehicle:

package {
    class Vehicle {
        var numDoors:Number;
        var color:String;
        public function Vehicle(param_numDoors:Number = 2, param_color:String = null) {
            numDoors = param_numDoors;
            color = param_color;
        }
        public function start():void {
            trace("[Vehicle] start");
        }
        public function stop():void {
            trace("[Vehicle] stop");
        }
        public function reverse():void {
            trace("[Vehicle] reverse");
        }
    }
}

package {

    public class Car extends Vehicle {
        var fullSizeSpare:Boolean;
        public function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) {
            numDoors = param_numDoors;
            color = param_color;
            fullSizeSpare = param_fullSizeSpare;
        }
        public function activateCarAlarm():void {
            trace("[Car] activateCarAlarm");
        }
        public override function stop():void {
            trace("[Car] stop with antilock brakes");
        }
    }
}

var myNewCar:Car = new Car(2, "Red", true);
myNewCar.start(); // output: [Vehicle] start
myNewCar.stop(); // output: [Car] stop with anti-lock brakes
myNewCar.activateCarAlarm(); // output: [Car] activateCarAlarm

También se puede escribir una subclase de la clase Vehicle utilizando la sentencia super, que la subclase puede utilizar para acceder al constructor de la superclase. El ejemplo siguiente muestra un tercer archivo ActionScript, llamado Truck.as, también en el mismo directorio. La clase Truck utiliza super en el constructor y en el método reverse() anulado.

package {
    class Truck extends Vehicle {
        var numWheels:Number;
        public function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) {
            super(param_numDoors, param_color);
            numWheels = param_numWheels;
        }
        public override function reverse():void {
            beep();
            super.reverse();
        }
        public function beep():void {
            trace("[Truck] make beeping sound");
        }
    }
}

var myTruck:Truck = new Truck(2, "White", 18);
myTruck.reverse(); // output: [Truck] make beeping sound [Vehicle] reverse
myTruck.stop(); // output: [Vehicle] stop

Véase también

false

Valor booleano que representa el valor false. Un valor booleano puede ser true o false; lo contrario de false es true.

Cuando la asignación automática de datos convierte false en un número, pasa a ser 0; cuando convierte false en una cadena, pasa a ser "false".

Nota: la cadena "false" se convierte al valor booleano true.

var bool1:Boolean = Boolean(false);

// converts it to the number 0
trace(1 + bool1); // outputs 1

// converts it to a string
trace("String: " + bool1); // outputs String: false

El ejemplo siguiente muestra que la cadena "false" se convierte al valor booleano true:

trace(Boolean("false")); // output: true

if ("false") {
    trace("condition expression evaluated to true");
}
else {
    trace("condition expression evaluated to false");
}
// output: condition expression evaluated to true

Véase también

final function methodName() {
	// your statements here
}
final class className {}

Especifica que un método no puede ser sustituido o que una clase no puede ampliarse. Todo intento de sustituir un método o ampliar una clase marcada como final da como resultado un error.

Véase también

Define métodos de la clase Proxy. Los métodos de la clase Proxy se encuentran en su propio espacio de nombres para evitar conflictos en situaciones en las que la subclase Proxy contenga nombres de métodos de instancias que coincidan con alguno de los nombres de métodos de la clase Proxy.

Véase también

for ([init]; [condition]; [next]) {
	// statement(s)
}

Evalúa la expresión init (inicializar) una vez y, a continuación, inicia una secuencia de reproducción indefinida. La secuencia de reproducción indefinida se inicia evaluando la expresión condition. Si la expresión condition da como resultado true, se ejecuta statement y se evalúa next. La secuencia de reproducción indefinida se inicia nuevamente con la evaluación de la expresión condition.

Las llaves ({}) que encierran el bloque de sentencias que va a ejecutar la sentencia for no son necesarias si sólo se va a ejecutar una sentencia.

var my_array:Array = new Array();
for (var i:Number = 0; i < 10; i++) {
    my_array[i] = (i + 5) * 10;
}
trace(my_array); // output: 50,60,70,80,90,100,110,120,130,140 

var sum:Number = 0;
for (var i:Number = 1; i <= 100; i++) {
    sum += i;
}
trace(sum); // output: 5050

var sum:Number = 0;
for (var i:Number = 1; i <= 100; i++)
    sum += i;
trace(sum); // output: 5050

Véase también

for (variableIterant:String in object){
	// statement(s)
} 

Repite las propiedades dinámicas de un objeto o los elementos de una matriz y ejecuta statement para cada propiedad o elemento. Las propiedades de objeto no se mantienen en ningún orden determinado, por lo que las propiedades pueden aparecer en un orden aparentemente aleatorio. La sentencia for..in no enumera las propiedades fijas, como son las variables y los métodos definidos en una clase. Para obtener una lista de propiedades fijas, utilice la función describeType(), que se incluye en el paquete flash.utils.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"};
for (var prop in myObject) {
    trace("myObject."+prop+" = "+myObject[prop]);
}
/* output:
myObject.firstName = Tara
myObject.age = 27
myObject.city = San Francisco
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"};
for (var name in myObject) {
    if (typeof (myObject[name]) == "string") {
        trace("I have a string property named "+name);
    }
}
/* output:
I have a string property named city
I have a string property named firstName
*/

Véase también

for each (variableIterant in object){
	// statement(s)
} 

Repite los elementos de una colección y ejecuta statement por cada elemento. Introducida como parte de las extensiones del lenguaje E4X, la sentencia for each..in no sólo puede utilizarse para objetos XML, sino también para objetos y matrices. La sentencia for each..in repite sólo las propiedades dinámicas de un objeto, no las propiedades fijas. Una propiedad fija es aquella que se define como parte de una definición de clase. Para utilizar la sentencia for each..in con una instancia de una clase definida por el usuario, debe declarar la clase con el atributo dynamic.

A diferencia de la sentencia for..in, la sentencia for each..in repite los valores de las propiedades de un objeto en lugar de los nombres de las propiedades.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"};
for each (var item in myObject) {
    trace(item);
}
/* output:
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three");
for each(var item in myArray)
    trace(item);
/* output:
one
two
three
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"};
for each (var item in myObject) {
    if (item is String) {
        trace("I have a string property with value " + item);
    }
}

/* output:
I have a string property with value Tara
I have a string property with value San Francisco
*/

var doc:XML =
        <body>
            <p>Hello</p>
            <p>Hola</p>
            <hr />
            <p>Bonjour</p>
        </body>;
for each (var item in doc.p) {
    trace(item);
}

/* output:
Hello
Hola
Bonjour
*/

Véase también

function functionName([parameter0, parameter1,...parameterN]) : returnType{
	// statement(s)
}
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{
	// statement(s)
} 

Consta de un conjunto de sentencias que se definen para ejecutar una determinada tarea. Puede definir una función en una ubicación e invocarla o llamarla desde distintos scripts de un archivo SWF. Cuando defina una función, puede además especificar parámetros para dicha función. Los parámetros son marcadores de posición de los valores sobre los que opera la función. Puede pasar distintos parámetros a una función cada vez que la llame para poder reutilizar la misma función en situaciones diferentes.

Utilice la sentencia return en el bloque statement(s) de una función para que se genere la función o devuelva , un valor.

Sintaxis 1: puede utilizar la palabra clave function para definir una función con el nombre, los parámetros y las sentencias especificadas. Cuando un script llama a una función, se ejecutan las sentencias de la definición de la función. Se permite la creación de referencias hacia delante; en un mismo script, una función puede declararse después de llamarse. Una definición de función sustituye cualquier definición anterior de la misma función. Puede utilizar esta sintaxis donde se permita una sentencia.

Sintaxis 2: también puede utilizar function para crear una función anónima y devolver una referencia a ella. Esta sintaxis se utiliza en expresiones y es especialmente útil para instalar métodos en objetos.

Para añadir funcionalidad, puede utilizar el objeto arguments en la definición de la función. El objeto arguments suele utilizarse para crear una función que acepte un número variable de parámetros y para crear una función anónima recursiva.

function sqr(xNum:Number) {
    return Math.pow(xNum, 2);
}
var yNum:Number = sqr(3);
trace(yNum); // output: 9

var yNum:Number = sqr(3);
trace(yNum); // output: 9
function sqr(xNum:Number) {
    return Math.pow(xNum, 2);
}

Véase también

function get property() : returnType{
	// your statements here
}

Define un captador (getter), que es un método que puede leerse como una propiedad. Un captador es una función especial que devuelve el valor de una propiedad declarada con la palabra clave var o const. A diferencia de otros métodos, la llamada a un captador se realiza sin paréntesis (()), lo que hace que el captador parezca una variable.

Los captadores le permiten aplicar el principio de ocultación de información permitiéndole crear una interfaz pública para una propiedad privada. La ventaja que ofrece la ocultación de información es que la interfaz pública permanece igual aunque cambie la implementación subyacente de la propiedad privada.

Otra ventaja que presentan los captadores es que pueden sustituirse en subclases, algo que no es posible con la propiedades declaradas con var.const

Un captador puede combinarse con un definidor (setter) para crear una propiedad de sólo lectura. Para crear una propiedad de sólo lectura, cree un captador sin su correspondiente definidor. Para crear una propiedad de sólo escritura, cree un definidor sin su correspondiente captador.

package {
    public class Team {
        var teamName:String;
        var teamCode:String;
        var teamPlayers:Array = new Array();
        public function Team(param_name:String, param_code:String) {
            teamName = param_name;
            teamCode = param_code;
        }
        public function get name():String {
            return teamName;
        }
        public function set name(param_name:String):void {
            teamName = param_name;
        }
    }
}

var giants:Team = new Team("San Fran", "SFO");
trace(giants.name);
giants.name = "San Francisco";
trace(giants.name);
/* output:
San Fran San Francisco */

Cuando realiza un seguimiento de giants.name, utilice el método captador para devolver el valor de la propiedad.

Véase también

if (condition) {
	// statement(s)
}

Evalúa una condición para determinar la siguiente sentencia que debe ejecutarse. Si la condición es true, Flash Player ejecuta las sentencias que siguen a la condición entre las llaves ({}). Si la condición es false, Flash Player omite las sentencias entre llaves y ejecuta las sentencias que siguen a las llaves. Utilice la sentencia if junto con la sentencia else para crear una lógica ramificada en los scripts.

Las llaves ({}) que encierran las sentencias que va a ejecutar la sentencia if no son necesarias si sólo se va a ejecutar una sentencia.

Véase también

myClass implements interface01 [, interface02,...] 

Especifica que una clase implementa una o varias interfaces. Cuando una clase implementa una interfaz, la clase debe definir todos los métodos declarados en la interfaz. Toda instancia de una clase que implemente una interfaz se considerará miembro del tipo de datos definido por la interfaz. Como resultado, el operador is devuelve true cuando la instancia de clase es el primer operando y la interfaz el segundo; además, funcionan las coerciones de tipos desde y hacia el tipo de datos definido por la interfaz.

Nota: para utilizar esta palabra clave, debe especificar ActionScript 2.0 y Flash Player 6 o versión posterior, en la ficha Flash del cuadro de diálogo Configuración de publicación del archivo FLA. Esta palabra clave sólo se admite cuando se utiliza en archivos de script externos y no en scripts escritos en el panel Acciones.

Véase también

import packageName.className
import packageName.*

Pone las clases y paquetes definidos externamente a disposición del código. Por ejemplo, si desea utilizar la clase flash.display.Sprite en un script, debe importarla. Este requisito ha cambiado con respecto a versiones anteriores de ActionScript, en las que la directiva import era opcional.

Tras utilizar la directiva import, puede emplear el nombre de clase completo, que incluye el nombre del paquete o sólo el nombre de la clase.

import flash.display.Sprite;

// name of class only
var mySprite:Sprite = new Sprite();

// full class name
var mySprite:flash.display.Sprite = new flash.display.Sprite();

Si hay varias clases en el paquete a las que desea acceder, puede importarlas todas en una sola sentencia, como se muestra en el siguiente ejemplo:

import flash.display.*;

La directiva import importa sólo las clases, funciones y variables que residen en el nivel superior del paquete importado. Los paquetes anidados deben importarse explícitamente.

Si importa una clase pero no la utiliza en el script, la clase no se exporta como parte del archivo SWF. Eso significa que puede importar grandes paquetes sin preocuparse del tamaño del archivo SWF; el código de bytes asociado con una clase se incluye en un archivo SWF únicamente si dicha clase se utiliza realmente. Una desventaja de la importación de clases que no necesita es que aumentan las posibilidades de que se produzcan conflictos de nombres.

// On Frame 1 of a FLA:
import adobe.example.*;
var myFoo:foo = new foo();

Véase también

include "[path]filename.as"

Incluye el contenido del archivo especificado, como si los comandos del archivo formaran parte del script que realiza la llamada. La directiva include se invoca durante la compilación. Por lo tanto, si realiza modificaciones en un archivo incluido, deberá guardarlo y volver a compilar todos los archivos SWF que lo utilizan.

Véase también

 interface InterfaceName [extends InterfaceName ] {}

Define una interfaz. Las interfaces son tipos de datos que definen un conjunto de métodos; todas las clases que implementen la interfaz deberán definir los métodos.

Una interfaz es similar a una clase, pero presenta estas diferencias importantes:

• Las interfaces sólo contienen declaraciones de métodos, no su implementación. Es decir, cada clase que implementa una interfaz debe proporcionar una implementación para cada método declarado en la interfaz.
• Las definiciones de métodos de interfaz no pueden tener ningún atributo como public o private, pero los métodos implementados deben marcarse como public en la definición de la clase que implementa la interfaz.
• Una interfaz puede heredar varias interfaces mediante la sentencia extends, o mediante una clase a través de la sentencia implements.

A diferencia de ActionScript 2.0, ActionScript 3.0 permite el uso de métodos captadores y definidores en definiciones de interfaz.

Véase también

[internal] var varName
[internal] const kName
[internal] function functionName()  {
	// your statements here
}
[internal] class className{
	// your statements here
}
[internal] namespace nsName

Especifica que una clase, variable, constante o función está disponible para cualquier origen de llamada dentro del mismo paquete. Las clases, propiedades y métodos pertenecen al espacio de nombres internal de manera predeterminada.

Véase también

label: statement
label: {
    statements
}

Asocia una sentencia a un identificador al que puede hacerse referencia mediante break o continue. En bucles anidados, una sentencia break o continue que no hace referencia a una etiqueta sólo puede omitir el resto del bucle inmediato y no omite la serie completa de bucles. Sin embargo, si la sentencia que define la serie completa de bucles tiene una etiqueta asociada, una sentencia break o continue puede omitir la serie completa de bucles haciendo referencia a dicha etiqueta.

Las etiquetas también permiten salir de una sentencia de bloque. No puede colocar una sentencia break que no haga referencia a una etiqueta dentro de una sentencia de bloque a no ser que la sentencia de bloque forme parte de un bucle. Si la sentencia de bucle tiene una etiqueta asociada, puede colocar una sentencia break que haga referencia a dicha etiqueta dentro de la sentencia de bloque.

outerLoop: for (var i:int = 0; i < 10; i++) {
    for (var j:int = 0; j < 10; j++) {
        if ( (i == 8) && (j == 0)) {
            break outerLoop;
        }
        trace(10 * i + j);
    }
}
/* output:
1
2...
79
*/

El ejemplo siguiente muestra cómo utilizar una etiqueta con una sentencia de bloque. En el siguiente ejemplo, una sentencia de bloque tiene la etiqueta foo, lo que permite a la sentencia break omitir la última sentencia del bloque:

foo: {
    trace("a");
    break foo;
    trace("b");
}
// output: a

Véase también

namespace name [= uri]

Permite controlar la visibilidad de las definiciones. Entre los espacios de nombres predefinidos se encuentran public, private, protected y internal (estos espacios de nombres específicos también se conocen como "especificadores de control de acceso" y se describen en la documentación sobre "Atributos de la propiedad Class"). Si los espacios de nombre predefinidos no se ajustan a sus necesidades, puede definir un espacio de nombres personalizado.

En los siguientes pasos, se muestra cómo crear, aplicar y hacer referencia a un espacio de nombres personalizado:

• En primer lugar, defina el espacio de nombres personalizado empleando la palabra clave namespace. Por ejemplo, el código namespace version1 crea un espacio de nombres llamado version1.
• En segundo lugar, aplique el espacio de nombres a una propiedad o un método empleando su espacio de nombres personalizado en la declaración de la propiedad o el método. Por ejemplo, el código version1 myProperty:String crea una propiedad llamada myProperty que pertenece al espacio de nombres version1.
• En tercer lugar, haga referencia al espacio de nombres utilizando la palabra clave use o prefijando un identificador con el espacio de nombres. Por ejemplo, el código use namespace version1; hace referencia al espacio de nombres version1 para las posteriores líneas del código, mientras que el código version1::myProperty hace referencia al espacio de nombres version1 para la propiedad myProperty.

Véase también

native function functionName();
class className {
	native function methodName();
}

Especifica que Flash Player implementa una función o un método en código nativo. Flash Player utiliza la palabra clave native internamente para declarar funciones y métodos en la interfaz de programación de aplicaciones (API) de ActionScript. No podrá utilizar esta palabra clave en su propio código.

null

Valor especial que puede asignarse a las variables o ser devuelto por una función si no se ha proporcionado ningún dato. Puede utilizar null para representar los valores que faltan o que no tienen un tipo de datos definido.

El valor null no debe confundirse con el valor especial undefined. Cuando null y undefined se comparan con el operador de igualdad (==), se comparan como iguales. Sin embargo, cuando null y undefined se comparan con el operador de igualdad estricta (===), se comparan como no iguales.

var testArray:Array = new Array();
testArray[0] = "fee";
testArray[1] = "fi";
testArray[4] = "foo";

for (i = 0; i < 6; i++) {
    if (testArray[i] == null) {
        trace("testArray[" + i + "] == null");
    }
}

/* output:
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/

Véase también

Define métodos de la clase ObjectProxy. Los métodos de la clase ObjectProxy se encuentran en su propio espacio de nombres para evitar conflictos en situaciones en las que la subclase ObjectProxy contenga nombres de métodos de instancias que coincidan con alguno de los nombres de métodos de la clase ObjectProxy.

override function name() {
	// your statements here
}

Especifica que un método reemplaza a un método heredado. Para sustituir un método heredado, debe utilizar el atributo override y asegurarse de que el nombre, el número, el tipo de parámetros y el tipo de devolución coinciden exactamente. Es un error intentar sustituir un método sin utilizar el atributo override. Del mismo modo, es un error utilizar el atributo override si el método no tiene un método heredado correspondiente.

No puede utilizar el atributo override con ninguno de los siguientes elementos:

• Variables
• Constantes
• Métodos estáticos
• Métodos que no sean heredados
• Métodos que implementen un método de interfaz
• Métodos heredados que estén marcados como final en la superclase

Aunque no puede sustituir una propiedad declarada con var o const, puede lograr una funcionalidad similar haciendo que la propiedad de clase base sea un captador-definidor y sustituyendo los métodos definidos con get y set.

Véase también

package packageName {
    class someClassName {
    }
}

Le permite organizar el código en grupos diferenciados que otros scripts pueden importar. Debe utilizar la palabra clave package para indicar que una clase es miembro de un paquete.

Véase también

class className{
	private var varName;
	private const kName;
	private function methodName() {
		// your statements here
	}
	private namespace nsName;
}

Especifica que una variable, constante o método esté únicamente disponible para la clase que la declara o define. A diferencia de ActionScript 2.0, en ActionScript 3.0, private ya no proporciona acceso a subclases. Además, private restringe el acceso tanto en tiempo de compilación como en el de ejecución. De manera predeterminada, una variable o función está disponible para cualquier origen de llamada del mismo paquete. Utilice esta palabra clave si desea restringir el acceso a una variable o función.

Puede utilizar esta palabra clave únicamente en definiciones de clases, no en definiciones de interfaces. No puede aplicar private a una clase ni a ninguna otra definición a nivel de paquete.

class A {
  private var alpha:String = "visible only inside class A";
  public var beta:String = "visible everywhere";
}

class B extends A {
  function B() {
    alpha = "Access attempt from subclass"; // error
  }
}

Dado que alpha es una variable privada, no podrá obtener acceso a ella desde fuera de la clase A, ni siquiera desde la clase B. Los intentos de acceso a la variable privada generarán un error.

Véase también

class className{
	protected var varName;
	protected const kName;
	protected function methodName() {
		// your statements here
	}
	protected namespace nsName;
}

Especifica que una variable, constante, método o espacio de nombres esté únicamente disponible para la clase que lo define y para las subclases de dicha clase. La definición de protected en ActionScript 3.0 es similar a la definición de la versión ActionScript 2.0 de private, con la diferencia de que protected restringe el acceso tanto en tiempo de compilación como en el de ejecución. De manera predeterminada, una variable o función está disponible para cualquier origen de llamada dentro del mismo paquete. Utilice esta palabra clave si desea restringir el acceso a una variable o función.

Puede utilizar esta palabra clave únicamente en definiciones de clases, no en definiciones de interfaces. No puede aplicar private a una clase ni a ninguna otra definición a nivel de paquete.

La definición de protected en ActionScript 3.0 es más restrictiva que la de protected en el lenguaje de programación Java. En ActionScript 3.0 protected limita el acceso estrictamente a las subclases, mientras que, en Java, protected también permite el acceso a cualquier clase del mismo paquete. Por ejemplo, si una clase llamada Base contiene una propiedad marcada como protected, sólo las clases que amplíen Base podrán acceder a la propiedad protegida en ActionScript 3.0. En Java, todas las clases del mismo paquete que Base tendrán acceso a la propiedad protegida aunque la clase no sea una subclase de Base.

class A {
  private var alpha:String = "visible only inside class A";
  protected var beta:String = "visible inside class A and its subclasses";
}

class B extends A {
  public function B() {
    beta = "Access attempt from subclass succeeded";
    trace(beta);  // output: Access attempt from subclass succeeded
  }
}

Véase también

public var varName
public const kName
public function functionName()  {
	// your statements here
}
public class className {
	// your statements here
}
public namespace nsName

Especifica que una clase, variable, constante o método está disponible para cualquier origen de llamada. Las clases, variables y métodos son internos de manera predeterminada, lo que significa que sólo son visibles dentro del paquete actual. Para que una clase, una variable o un método sean visibles a todos los orígenes de llamada, deberá utilizar el atributo public.

class User {
    public var age:Number;
    public var fname:String;
} // end of class User definition

var jimmy:User = new User();
jimmy.age = 27;
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // output: 27 jimmy

Si cambia una de las variables públicas en la clase User por una variable privada, se generará un error de tiempo de compilación al intentar acceder a dicha variable fuera de la clase User.

Véase también

function functionName () {
	return [expression]
}

Provoca que la ejecución regrese inmediatamente a la función que origina la llamada. Si la sentencia return va seguida de una expresión, la expresión se evalúa y se devuelve el resultado.

Si una definición de función incluye un tipo de devolución, la sentencia return debe ir seguida de una expresión. Si no se especifica ningún tipo de devolución y la sentencia return se utiliza sola, ésta devuelve undefined.

No es posible devolver múltiples valores. Si intenta hacerlo, sólo se devolverá el último valor. En el ejemplo siguiente, se devuelve c :

return a, b, c ;

Si es necesario devolver múltiples valores, utilice una matriz u objeto en su lugar.

function sum(a:Number, b:Number, c:Number):Number {
    return (a + b + c);
}
var newValue:Number = sum(4, 32, 78);
trace(newValue); // output: 114

Véase también

function set property(newValue:*) : void{
	// your statements here
}

Define un definidor (setter), que es un método que aparece en la interfaz pública como una propiedad. Un definidor es un método especial que establece el valor de una propiedad declarada con la palabra clave var. A diferencia de otros métodos, la llamada a un definidor se realiza sin paréntesis (()), lo que hace que el definidor parezca una variable.

Los definidores le permiten aplicar el principio de ocultación de información permitiéndole crear una interfaz pública para una propiedad privada. La ventaja que ofrece la ocultación de información es que la interfaz pública permanece igual aunque cambie la implementación subyacente de la propiedad privada.

Otra ventaja que presentan los definidores es que pueden sustituirse en subclases, algo que no es posible hacer con propiedades declaradas con var.

El tipo de devolución de un definidor debe ser void o sin especificar.

Un definidor puede combinarse con un captador (getter) para crear una propiedad de lectura-escritura. Para crear una propiedad de sólo lectura, cree un captador sin su correspondiente definidor. Para crear una propiedad de sólo escritura, cree un definidor sin su correspondiente captador.

package {
    class User {
        private var userAge:Number;

        public function get age():Number {
            return userAge;
        }

        public function set age(x:Number):void {
            userAge = x;
        }
    }
}

var myUser:User = new User();
myUser.age = 25;
trace(myUser.age); // output: 25

Véase también

class someClassName{
	static var varName;
	static const kName;
	static function methodName() {
		// your statements here
	}
}

Especifica que una variable, constante o método pertenece a la clase y no las instancias de la clase.

Para acceder a un miembro de clase estático, utilice el nombre de la clase en lugar del nombre de una instancia. Por ejemplo, la clase Date tiene un método estático denominado parse(), al que sólo es posible llamar empleando la siguiente sintaxis:

Date.parse()

No es posible llamar al método parse() en una instancia de la clase Date. Por ejemplo, el siguiente código genera un error:

var myDate:Date = new Date();
			myDate.parse("Jan 01 00:00:00 2006"); // error

Puede utilizar static en definiciones de clases solamente, no en definiciones de interfaces.

Los miembros de clase estáticos no se heredan. No puede hacer referencia a un miembro de clase estático empleando el nombre de una subclase, algo que, por el contrario, sí es posible en Java o C++. Sin embargo, puede hacer referencia a una variable o un método estático dentro de una clase o subclase sin utilizar ningún calificador. Consulte el ejemplo siguiente.

No puede utilizar la sentencia super ni la palabra clave this dentro de un método estático.

class Users {
    private static var numInstances:Number = 0;
    function Users() {
        numInstances++;
    }
    static function get instances():Number {
        return numInstances;
    }
}

trace(Users.instances);
var user1:Users = new Users();
trace(Users.instances);
var user2:Users = new Users();
trace(Users.instances);

class PowerUsers extends Users{
    function PowerUsers() {
        instances++;  // unqualified reference to static property Users.instances is legal
    }
}

trace(PowerUsers.instances); // error, cannot access static property using PowerUsers class

Véase también

super([arg1,..., argN])
super.method([arg1,..., argN])

Invoca la superclase o versión principal de un método o constructor. Cuando se utiliza dentro del cuerpo de una clase constructora, la sentencia super() invoca la versión de superclase del constructor. La llamada al constructor de la superclase debe tener el número correcto de argumentos. Tenga en cuenta que siempre se llama al constructor de la superclase, con independencia de si se realiza la llamada explícitamente o no. Si no la llama explícitamente, se introduce automáticamente una llamada sin argumentos antes de la primera sentencia del cuerpo del constructor de la subclase. Esto significa que, si define una función constructora en una subclase y el constructor de la superclase tiene uno o varios argumentos, deberá llamar explícitamente al constructor de la superclase con el número correcto de argumentos o, de lo contrario, se producirá un error. Sin embargo, la llamada al constructor de la superclase no tiene que ser necesariamente la primera sentencia del constructor de la subclase, como se exigía en ActionScript 2.0.

Cuando se utiliza en el cuerpo de un método de instancia, super puede utilizarse con el operador de punto (.) para invocar la versión de superclase de un método y puede, opcionalmente, pasar argumentos (arg1... argN) al método de superclase. Esto resulta útil para crear métodos de subclase que no sólo añaden un comportamiento adicional a los métodos de superclase, sino que también invocan los métodos de superclase para que ejecuten su comportamiento original.

No se puede utilizar la sentencia super en un método estático.

Véase también

switch (expression) {
	caseClause:
	[defaultClause:]
}

Provoca que el control se transfiera a una entre varias sentencias, dependiendo del valor de una expresión. Todas las sentencias switch deberían incluir un caso predeterminado para que se ejecute si ninguna de las sentencias case coincide con la expresión. Cada sentencia case debe terminar con una sentencia break, que impide que se produzca un error de paso. Cuando se pasa de un caso al siguiente, se ejecuta el código de la siguiente sentencia case aunque dicho caso pueda no coincidir con la expresión de prueba.

var switchExpression:int = 3;

switch (switchExpression) {
    case 0:
        trace(0);
        break;
    case 1:
        trace(1);
        break;
    case 2:
        trace(2);
        break;
    default:
        trace("Not 0, 1, or 2");
}

// output: Not 0, 1, or 2

Véase también

this

Referencia al objeto que contiene el método. Cuando se ejecuta un script, la palabra clave this hace referencia al objeto que contiene el script. Dentro de un cuerpo de método, la palabra clave this hace referencia a la instancia de clase que contiene el método llamado.

// incorrect version of Simple.as
/*
dynamic class Simple {
    function callfunc() {
        func();
    }
}
*/
// correct version of Simple.as
dynamic class Simple {
    function callfunc() {
        this.func();
    }
}

var simpleObj:Simple = new Simple();
simpleObj.func = function() {
    trace("hello there");
}
simpleObj.callfunc();

Véase también

throw expression 

Genera, o emite, un error que puede controlarse o capturarse, mediante un bloque de código catch. Si un bloque catch no captura una excepción, la representación de cadena del valor emitido se envía al panel Salida. If an exception is not caught by a catch or finally block, the string representation of the thrown value is sent to the log file.

Normalmente, se emiten instancias de la clase Error o de sus subclases (consulte el apartado Ejemplo).

function checkEmail(email:String) {
    if (email.indexOf("@") == -1) {
        throw new Error("Invalid email address");
    }
}
checkEmail("someuser_theirdomain.com");

try {
    checkEmail("Joe Smith");
}
catch (e) {
    trace(e);
}
// output: Error: Invalid email address.

// Define Error subclass InvalidEmailError
class InvalidEmailAddress extends Error {
    public function InvalidEmailAddress() {
        message = "Invalid email address.";
    }
}

import InvalidEmailAddress;
function checkEmail(email:String) {
    if (email.indexOf("@") == -1) {
        throw new InvalidEmailAddress();
    }
}
try {
    checkEmail("Joe Smith");
}
catch (e) {
    trace(e);
}
// output: Error: Invalid email address.

Véase también

true

Valor booleano que representa el valor true. Un valor booleano puede ser true o false; lo contrario de true es false. Cuando la asignación automática de datos convierte true a un número, pasa a ser 1; cuando convierte true en una cadena, pasa a ser "true".

var shouldExecute:Boolean;
//...
// code that sets shouldExecute to either true or false goes here
// shouldExecute is set to true for this example:

shouldExecute = true;

if (shouldExecute == true) {
    trace("your statements here");
}

// true is also implied, so the if statement could also be written:
// if (shouldExecute) {
//         trace("your statements here");
// }

El ejemplo siguiente muestra cómo la introducción automática de datos convierte true en el número 1:

var myNum:Number;
myNum = 1 + true;
trace(myNum); // output: 2

Véase también

try {
    // try block
} finally {
    // finally block
}

try {
    // try block
} catch(error[:ErrorType1]) {
    // catch block
} [catch(error[:ErrorTypeN]) {
    // catch block
}] [finally {
    // finally block
}]

Incluye un bloque de código en el que puede producirse un error y, a continuación, responde al error. La gestión de excepciones, que se implementa mediante las sentencias try..catch..finally, son el primer mecanismo para gestionar condiciones de error de tiempo de ejecución en ActionScript 3.0. Cuando se produce un error de tiempo de ejecución, Flash Player emite una excepción, lo que significa que suspende la ejecución normal y crea un objeto especial de tipo Error. Flash Player luego pasa, o emite, el objeto de error al primer bloque catch disponible. Si no hay bloques catch disponibles, la excepción se considera una excepción no capturada. Las excepciones no capturadas provocan que se interrumpa el script.

Puede utilizar la sentencia throw para emitir excepciones explícitamente en el código. Puede emitir cualquier valor, pero lo más recomendable es emitir un objeto, ya que proporciona flexibilidad y coincide con el comportamiento de Flash Player.

Para capturar una excepción, tanto si la ha emitido Flash Player como si la emite su propio código, sitúe el código que debe emitir la excepción en un bloque try. Si alguna parte del código del bloque try emite una excepción, el control pasa al bloque catch, si existe uno, y a continuación al bloque finally, si existe uno. El bloque finally se ejecuta siempre, independientemente de que se haya emitido o no una excepción. Si el código del bloque try no emite una excepción (es decir, si el bloque try finaliza normalmente), el código del bloque catch se omite, pero el código del bloque finally sigue ejecutándose. El bloque finally se ejecuta aunque el bloque try finalice con una sentencia return.

Un bloque try debe ir seguido de un bloque catch, un bloque finally, o ambos. Un único bloque try puede tener varios bloques catch pero sólo un bloque finally. Puede anidar los bloques try tantos niveles como desee.

El parámetro error especificado en un controlador catch debe ser un identificador sencillo, como e o theException o x. Además, el parámetro puede tener un tipo asignado. Cuando se utilizan con varios bloques catch, los parámetros con tipo asignado le permiten capturar varios tipos de objetos de error emitidos desde un solo bloque try.

Si la excepción emitida es un objeto, el tipo coincidirá si el objeto emitido es una subclase del tipo especificado. Si se emite un error de un tipo específico, se ejecuta el bloque catch que controla el error correspondiente. Si se emite una excepción que no es del tipo especificado, el bloque catch no se ejecuta y la excepción se envía automáticamente fuera del bloque try a un controlador catch coincidente.

Si se emite un error en una función y ésta no incluye un controlador catch, Flash Player sale de dicha función, así como de las funciones que originen llamadas, hasta que encuentre un bloque catch. Durante este proceso, se realizan llamadas a controladores finally en todos los niveles.

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
    spr.addChild(spr);
}
catch (e:ArgumentError) {
    trace(e); // output: ArgumentError: Error #2024: An object may not be added as a child of itself.
}

class RecordSetException extends Error {
    public function RecordSetException () {
        message = "Record set exception occurred.";
    }
}

class MalformedRecord extends Error {
    public function MalformedRecord {
        message = "Malformed record exception occurred.";
    }
}

class RecordSet {
    public function sortRows() {
        var returnVal:Number = randomNum();
        if (returnVal == 1) {
            throw new RecordSetException();
        }
        else if (returnVal == 2) {
            throw new MalformedRecord();
        }
    }
    public function randomNum():Number {
        return Math.round(Math.random() * 10) % 3;
    }
}

import RecordSet;
var myRecordSet:RecordSet = new RecordSet();
try {
    myRecordSet.sortRows();
    trace("everything is fine");
}
catch (e:RecordSetException) {
    trace(e.toString());
}
catch (e:MalformedRecord) {
    trace(e.toString());
}

Véase también

use namespace ns1[, ns2,...nsN]

Provoca que los espacios de nombre especificados se añadan al conjunto de espacios de nombre abiertos. Los espacios de nombre especificados se eliminan del conjunto de espacios de nombre abiertos cuando se sale del bloque de código actual. La directiva use namespace puede aparecer en el nivel superior de un programa, una definición de paquete o una definición de clase.

Véase también

var variableName [= value1][...,variableNameN[=valueN]] 

Especifica una variable. Si declara variables en una función, las variables son locales. Se definen para la función y caducan al finalizar la llamada a la función.

Si declara variables fuera de una función, las variables estarán disponibles en toda la línea de tiempo que contiene la sentencia.

No puede declarar una variable que se encuentra en el ámbito de otro objeto como variable local.

my_array.length = 25; // ok
var my_array.length = 25; // syntax error 

Puede asignar un tipo de datos a una variable añadiendo el carácter de dos puntos seguido del tipo de datos.

Puede declarar múltiples variables en una sentencia, separando las declaraciones con comas (si bien esta sintaxis puede reducir la claridad del código):

var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";

var product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze");
product_array.push("Flex");
trace(product_array);
// output: Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

Véase también

while (condition) {
	// statement(s)
}

Evalúa una condición y, si ésta da como resultado true, ejecuta una o varias sentencias antes de volver a ejecutar el bucle para evaluar la condición nuevamente. Después de que la condición dé como resultado false, se omiten las sentencias y finaliza el bucle.

La sentencia while ejecuta la siguiente serie de pasos. Cada repetición de pasos del 1 al 4 se denomina repetición del bucle. La condición se comprueba al principio de cada repetición, tal y como se muestra en los siguientes pasos:

1. Se evalúa la expresión condition.
2. Si condition da como resultado true o un valor que se convierte al valor booleano true, como un número distinto de cero, continúe con el paso 3. En caso contrario, la sentencia while se completa y la ejecución se reanuda en la siguiente sentencia después del bucle while.
3. Ejecute el bloque de sentencias statement(s). Si se detecta una sentencia continue, se omite el resto de sentencias y se continúa con el paso 1. Si se detecta una sentencia break, la sentencia while se completa y la ejecución se reanuda en la siguiente sentencia después del bucle while.
4. Vaya al paso 1.

La reproducción indefinida suele utilizarse para ejecutar una acción mientras la variable de contador sea inferior al valor especificado. Al final de cada bucle se incrementa el contador hasta que se alcanza el valor especificado. En dicho punto, condition ya no es true y finaliza el bucle.

Las llaves ({}}) que encierran las sentencias que va a ejecutar while no son necesarias si sólo se va a ejecutar una sentencia.

var i:Number = 0;
while (i < 20) {
    trace(i);
    i += 3;
}
/* output:
0
3
6
9
12
15
18
*/

Véase también

with (object:Object) {
	// statement(s)
}

Establece el objeto predeterminado que debe utilizarse para la ejecución de una o varias sentencias, lo que, en potencia, reduce la cantidad de código que es preciso escribir.

El parámetro object se convierte en el contexto en el que se leen las propiedades, variables y funciones del parámetro statement(s). Por ejemplo, si object es my_array, y dos de las propiedades especificadas son length y concat, dichas propiedades se leen automáticamente como my_array.length y my_array.concat. En otro ejemplo, si object es state.california, se llama a todas las acciones o sentencias dentro de la sentencia with incluidas desde dentro de la instancia california.

Para buscar el valor de un identificador en el parámetro statement(s), ActionScript empieza al principio de la cadena de ámbito especificada por object y busca el identificador en cada nivel de la cadena de ámbito, en un orden específico.

La cadena de ámbito que utiliza la sentencia with para dirigirse a los identificadores empieza con el primer elemento de la siguiente lista y continúa hasta el último elemento:

• El objeto especificado en el parámetro object de la sentencia with más interna
• El objeto especificado en el parámetro object de la sentencia with más externa.
• El objeto Activation (un objeto temporal que se crea automáticamente cuando el script llama a una función que contiene las variables locales a las que se llama en la función)
• El objeto que contiene el script que se está ejecutando
• El objeto Global (objetos incorporados como Math y String)

Para establecer una variable dentro de una sentencia with debe haber declarado la variable fuera de la sentencia with o debe introducir la ruta de acceso completa a la línea de tiempo en la que desea incluir la variable. Si establece una variable en una sentencia with sin declararla, la sentencia with buscará el valor según la cadena de ámbito. Si la variable no existe ya, se establecerá el nuevo valor en la línea de tiempo desde la que se ha llamado a la sentencia with.

with (someOther_mc) {
    _x = 50;
    _y = 100;
    gotoAndStop(3);
}

someOther_mc._x = 50;
someOther_mc._y = 100;
someOther_mc.gotoAndStop(3);

La sentencia with resulta útil para acceder a múltiples elementos de una lista de cadena de ámbito simultáneamente. En el ejemplo siguiente, el objeto Math incorporado se sitúa delante de la cadena de ámbito. El establecimiento de Math como objeto predeterminado convierte los identificadores cos, sin y PI en Math.cos, Math.sin y Math.PI, respectivamente. Los identificadores a, x, y y r no son métodos ni propiedades del objeto Math, pero dado que existen en el ámbito de activación de objetos de la función polar(), se resuelven en las variables locales correspondientes.

function polar(r:Number):void {
    var a:Number, x:Number, y:Number;
    with (Math) {
        a = PI * pow(r, 2);
        x = r * cos(PI);
        y = r * sin(PI / 2);
    }
    trace("area = " + a);
    trace("x = " + x);
    trace("y = " + y);
} polar(3);
/* output:
area = 28.2743338823081
x = -3
y = 3
*/