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

<