Sentencias, palabras clave y directivas 

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 un conjunto que está disponible en todo el cuerpo de la función. El nombre del conjunto 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. El conjunto del parámetro ... (rest) se llena de valores solo 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 del conjunto. Si pasa una instancia de la clase Array, todo el conjunto se colocará en un único elemento del conjunto del parámetro ... (rest).

El uso de este parámetro hace que el objeto arguments no esté disponible. Aunque el parámetro ... (rest) ofrece la misma funcionalidad que el conjunto 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"); // 100,130,two
			trace(average(4, 7, 13));     // 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);
}

Elementos de API relacionados

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 (que es la configuración predeterminada en Flex Builder), 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).

Elementos de API relacionados

Aparece en un bucle (for, for..in, for each..in, do..while o while) o dentro de un bloque de sentencias asociadas a un caso concreto en 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 a continuación de 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 solo 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++; 
} 
/*
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

Elementos de API relacionados

case jumpTarget: statements

Define el destino del salto para la sentencia switch. Si el parámetro jumpTarget es igual que el parámetro expression de la sentencia switch que utiliza igualdad estricta (===), Flash Player ejecutará sentencis 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 guion no se compila.

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

Elementos de API relacionados

[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 solo 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 solo puede ampliar una clase pero puede implementar varias interfaces.) Puede utilizar las palabras clave implements y extends en una sola sentencia. En el siguiente ejemplo 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); 

Elementos de API relacionados

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

Elementos de API relacionados

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

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

Elementos de API relacionados

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 determinada 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 la sentencia default fuera de una sentencia switch, se produce un error y el guion 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"); 
}

Elementos de API relacionados

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 será el espacio de nombres sin nombre asignado (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 = ;
trace("x1 ns: " + x1.namespace());
			
scopeCheck();	

var x2:XML = ;
trace("x2 ns: " + x2.namespace());
		
function scopeCheck(): void {
	
	var x3:XML = ;
	trace("x3 ns: " + x3.namespace());
				
	var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
	default xml namespace = nsDefault2;
		    
	var x4:XML = ;
	trace("x4 ns: " + x4.namespace());

}

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

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

var x2:XML = ;
trace(x2.namespace());
	// http://www.w3.org/1999/XSL/Transform/

var x3:XML = ;
trace(x3.namespace());
	// http://www.example.com/namespaces/

Elementos de API relacionados

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 solo 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 en todas las circunstancias.

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

Elementos de API relacionados

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 solo 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); // new

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

Elementos de API relacionados

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

Especifica las sentencias que se ejecutarán si la condición en la sentencia if devuelve false. Las llaves ({}) que encierran las sentencias que va a ejecutar la sentencia else no son necesarias si solo 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"); 
}

Elementos de API relacionados

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.

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(); // [Vehicle] start 
myNewCar.stop(); // [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // [Car] activateCarAlarm

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(); // [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // [Vehicle] stop

Elementos de API relacionados

false

Valor booleano que representa el valor false. Un valor Boolean es true o false; lo opuesto a 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

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

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

Elementos de API relacionados

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.

Elementos de API relacionados

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.

Elementos de API relacionados

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, statement se ejecuta 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 solo 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); // 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); // 5050

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

Elementos de API relacionados

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

Repite las propiedades dinámicas de un objeto o los elementos de un conjunto 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. Las propiedades fijas, como son las variables y los métodos definidos en una clase, no las enumera la sentencia for..in. 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]); 
} 
/*
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); 
	} 
}
/*
I have a string property named city
I have a string property named firstName
*/

Elementos de API relacionados

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

Repite los elementos de una colección y ejecuta statement por cada elemento. Se introduce como parte de las extensiones del lenguaje E4X, la sentencia for each..in se puede utilizar no solo para objetos XML, sino también para objetos y conjuntos. La sentencia for each..in repite solo 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); 
} 
/*
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
	trace(item); 
/*
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); 
	} 
}

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

var doc:XML = 
		
			
Hello
			
Hola
			

			
Bonjour
		;
for each (var item in doc.p) {
	trace(item);
}

/*
Hello
Hola
Bonjour
*/

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 guiones 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 devolver 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); // 9

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

Elementos de API relacionados

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 o const.

Un captador puede combinarse con un definidor (setter) para crear una propiedad de solo lectura. Para crear una propiedad de solo lectura, cree un captador sin su correspondiente definidor. Para crear una propiedad de solo 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); 
/*
San Fran San Francisco */

Elementos de API relacionados

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 hay entre llaves ({}), a continuación de la condición. 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 solo se va a ejecutar una sentencia.

Elementos de API relacionados

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.

Elementos de API relacionados

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, podrá utilizar el nombre completo de la clase, que incluye el nombre del paquete, o solo 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 solo 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();

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.

 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 solo 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.

Elementos de API relacionados

[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.

Elementos de API relacionados

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 al texto puede omitir el resto del bucle inmediato, no toda la serie de bucles anidados. Sin embargo, si la sentencia que define toda la serie de bucles tiene texto asociado, una sentencia break o continue puede omitir toda la serie de bucles haciendo referencia a dicho texto.

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);
	}
}
/*
1
2
...
79
*/

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

Elementos de API relacionados

namespace name [= uri]

Permite controlar la visibilidad de las definiciones. Algunos de los espacios de nombres predefinidos son public, private, protected e internal.

El siguiente paso muestra cómo crear, aplicar y hacer referencia a un espacio de nombres:

• 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 líneas siguientes de código, y el código version1::myProperty hace referencia al espacio de nombres version1 para la propiedad myProperty.

Elementos de API relacionados

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

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

Elementos de API relacionados

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 garantizar que el nombre, el atributo de la propiedad de la clase, el número y el tipo de parámetros y 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.

Elementos de API relacionados

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.

Elementos de API relacionados

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

Elementos de API relacionados

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, solo 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);  // Access attempt from subclass succeeded
  }
}

Elementos de API relacionados

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 solo 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); // 27 jimmy

Elementos de API relacionados

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, esta devuelve undefined.

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

return a, b, c ;

Si es necesario devolver múltiples valores, utilice un conjunto 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); // 114

Elementos de API relacionados

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 setter 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 solo lectura, cree un captador sin su correspondiente definidor. Para crear una propiedad de solo 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); // 25

Elementos de API relacionados

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

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 solo 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.

Elementos de API relacionados

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

// Not 0, 1, or 2

Elementos de API relacionados

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

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. Si un bloque catch o finally no captura una excepción, la representación de cadena del valor emitido se envía al archivo de registro.

Normalmente, se emiten instancias de la clase Error o de sus subclases (véase 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); 
}
// 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);
}
// Error: Invalid email address.

Elementos de API relacionados

true

Valor booleano que representa el valor true. Un valor Boolean es true o false; lo opuesto a true es false. Cuando la introducción automática de datos convierte true en 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");
// }

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

Elementos de API relacionados

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, es el mecanismo principal de gestión de condiciones de error en tiempo de ejecución en ActionScript 3.0. Cuando se produce un error en tiempo de ejecución, Flash Player emite una excepción, es decir, Flash Player desactiva 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) y, después, al bloque finally (si existe). El bloque finally se ejecuta siempre, independientemente de que se haya emitido o no una excepción. Si el código dentro del bloque try no emite ninguna excepción (esto es, si el bloque try finaliza correctamente), el código del bloque catch se omite, pero el código del bloque finally sí se ejecuta. 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 incluir múltiples bloques catch pero solo 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 simple 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 clasificados por tipos 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 esta no incluye un controlador catch, Flash Player abandona esta función y cualquier otra que realice llamadas hasta que encuentra un bloque catch. Durante este proceso, se realizan llamadas a controladores finally en todos los niveles.

Nota: Si en un bloque try hay un distribuidor de eventos que llama al controlador de eventos, el bloque catch no detecta el error si se inicia en el controlador de eventos. Cualquier error generado a partir de ese momento se puede detectar mediante LoaderInfo.uncaughtErrorEvents

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
	spr.addChild(spr);
}
catch (e:ArgumentError) {
	trace (e); // 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()); 
}

Elementos de API relacionados

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.

Elementos de API relacionados

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.

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); 
// Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

Elementos de API relacionados

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

Evalúa una condición y, si esta 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 en el valor booleano true, por ejemplo, un número distinto de cero, vaya al paso 3. De lo contrario, se completa la sentencia while y se reanuda la ejecución en la sentencia que hay a continuación del bucle while.
3. Ejecute las sentencias del bloque. 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 la sentencia while no son necesarias si solo se va a ejecutar una sentencia.

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

Elementos de API relacionados

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, cualquier acción o sentencia dentro de la sentencia with se llama 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 en 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.

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);
/* 
area = 28.2743338823081 
x = -3 
y = 3
*/