Instructions, mots clés et directives 

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

Spécifie qu’une fonction peut accepter un nombre illimité d’arguments séparés par des virgules. La liste des arguments devient un tableau disponible dans tout le corps de la fonction. Le nom du tableau est spécifié après les caractères ... dans la déclaration des paramètres. Le paramètre peut porter un nom quelconque, sauf un mot réservé.

Si elle est utilisée avec d’autres paramètres, la déclaration de paramètres ... (rest) doit figurer en dernier paramètre spécifié. Le tableau de paramètres ... (rest) est renseigné uniquement si le nombre d’arguments transmis à la fonction est supérieur au nombre des autres paramètres.

Chaque argument figurant dans la liste d’arguments séparés par des virgules est placé dans un élément du tableau. Si vous transmettez une occurrence de la classe Array, tout le tableau est placé dans un même élément du tableau de paramètres ... (rest).

L’utilisation de ce paramètre rend l’objet arguments indisponible. Le paramètre ... (rest) apporte les mêmes fonctionnalités que le tableau arguments et la propriété arguments.length, mais il n’offre pas de fonctionnalités similaires à celles de arguments.callee. Assurez-vous que vous ne devez pas utiliser arguments.callee avant d’utiliser le paramètre ... (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);
}

Eléments de l’API associés

Définit des méthodes et propriétés des classes ActionScript essentielles correspondant à des propriétés fixes et non des propriétés de prototype. Lorsque vous définissez l’option « -as3 » du compilateur sur true (correspondant au paramètre par défaut dans Flex Builder 2), l’espace de noms AS3 est ouvert automatiquement pour toutes les classes essentielles. Par conséquent, les occurrences des classes essentielles utilisent des propriétés et méthodes fixes au lieu des versions de ces propriétés et méthodes qui sont liées à l’objet de prototype de la classe. L’utilisation de propriétés fixes permet généralement d’obtenir de meilleures performances, mais implique des problèmes de rétrocompatibilité avec la spécification de langage de la version 3 d’ECMAScript (ECMA-262).

Eléments de l’API associés

Apparaît au sein d’une boucle (for, for..in, for each..in, do..while ou while) ou dans un bloc d’instructions associées à un cas précis dans une instruction switch. Lorsqu’elle est utilisée dans une boucle, l’instruction break indique au compilateur Flash d’ignorer le reste du corps de boucle, d’interrompre l’action de boucle et d’exécuter l’instruction suivant l’instruction de boucle. Lorsqu’elle est utilisée dans une instruction switch, l’instruction break indique au compilateur Flash d’ignorer le reste des instructions de ce bloc case et de sauter jusqu’à la première instruction suivant l’instruction switch encadrante.

Dans les boucles imbriquées, l’instruction break implique d’ignorer le reste de la boucle immédiate et n’interrompt pas toute la série de boucles imbriquées. Pour sortir d’une série de boucles imbriquées, utilisez label ou try...catch..finally.

L’instruction break peut comporter une étiquette facultative devant correspondre à une instruction externe avec étiquette. L’utilisation d’une étiquette ne correspondant à aucune étiquette d’instruction externe constitue une erreur de syntaxe. Les instructions break nommées permettent de sortir de plusieurs niveaux d’instructions de boucle imbriqués, ainsi que d’instructions switch ou block. Pour obtenir un exemple, voir l’entrée concernant l’instruction 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*/

Eléments de l’API associés

case jumpTarget: statements

Définit un hyperlien cible pour l’instruction switch. Si le paramètre jumpTarget est égal au paramètre expression de l’instruction switch avec une égalité stricte (===), Flash Player exécute les instructions du paramètre statements jusqu’à atteindre une instruction break ou la fin de l’instruction switch.

Si vous utilisez l’instruction case en dehors d’une instruction switch, elle provoque une erreur et le script n’est pas compilé.

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

Eléments de l’API associés

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

Définit une classe, permettant d’instancier des objets ayant en commun des méthodes et propriétés personnalisées. Par exemple, si vous développez un système de suivi de facturation, vous pouvez créer une classe Invoice définissant toutes les méthodes et les propriétés destinées à l’ensemble des factures. Vous pouvez alors utiliser la commande new Invoice() pour créer des objets de classe Invoice.

Chaque fichier source ActionScript ne peut contenir qu’une seule classe visible aux autres scripts ou fichiers source. La classe visible en externe peut être publique ou interne et doit être définie dans une instruction de package. Si vous incluez d’autres classes dans le même fichier, elles doivent être placées en dehors de l’instruction de package et à la fin du fichier.

Le nom de la classe visible en externe doit correspondre au nom du fichier source ActionScript contenant la classe. Le nom du fichier source doit être le nom de la classe portant l’extension .as. Par exemple, si vous nommez une classe Student, le fichier définissant la classe doit porter le nom Student.as.

Les définitions de classe ne peuvent pas être imbriquées, vous ne pouvez donc pas définir des classes supplémentaires au sein d’une définition de classe.

Vous pouvez définir une méthode de constructeur, exécutée lors de chaque création d’une nouvelle instance de la classe. Le nom de la méthode de constructeur doit correspondre au nom de la classe. Si vous ne définissez aucune méthode de constructeur, un constructeur par défaut est créé automatiquement.

Pour indiquer que les objets peuvent ajouter ou consulter des propriétés dynamiques lors de l’exécution, faites précéder l’instruction de classe du mot-clé dynamic. Pour déclarer qu’une classe implémente une interface, utilisez le mot-clé implements. Pour créer des sous-classes d’une classe, utilisez le mot-clé extends (une classe ne peut étendre qu’une seule classe, mais peut implémenter plusieurs interfaces). Vous pouvez utiliser les mots-clés implements et extends dans une même instruction. Les exemples suivants illustrent des utilisations courantes des mots-clés implements et 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); 

Eléments de l’API associés

const identifier = value 

Spécifie une constante, variable ne pouvant recevoir de valeur qu’une seule fois.

Vous pouvez définir le type d’une constante de façon stricte en lui ajoutant un caractère deux points (:) suivi du type de données.

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

Eléments de l’API associés

continue [label]

Saute toutes les instructions restantes dans la boucle de plus bas niveau et commence la prochaine itération de la boucle, comme si le contrôle était passé normalement à la fin de la boucle. L’instruction continue n’a aucun effet en dehors d’une boucle. Dans les boucles imbriquées, utilisez le paramètre facultatif label pour ignorer plus que la boucle de plus bas niveau.

L’instruction continue peut comporter une étiquette facultative devant correspondre à une instruction externe avec étiquette. L’utilisation d’une étiquette ne correspondant à aucune étiquette d’instruction externe constitue une erreur de syntaxe. Les instructions continue nommées permettent de sauter plusieurs niveaux d’instructions de boucle imbriquées.

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

Eléments de l’API associés

default: statements 

Définit le cas par défaut pour une instruction switch. Les instructions sont exécutées si le paramètre expression de l’instruction switch n’est pas égal (avec l’opération d’égalité stricte [===]) à l’un des paramètres expression suivant les mots-clés case d’une instruction switch donnée.

Une instruction switch ne nécessite aucune instruction de cas default. Une instruction de cas default ne doit pas nécessairement figurer en fin de liste. Si vous utilisez une instruction default en-dehors d’une instruction switch, elle provoque une erreur et le script n’est pas compilé.

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

Eléments de l’API associés

La directive default xml namespace définit l’espace de noms par défaut à utiliser pour les objets XML.

Si vous ne définissez aucune directive default xml namespace, l’espace de noms par défaut est non nommé (avec l’URI définie sur une chaîne vide). L’étendue d’une déclaration default xml namespace est l’intérieur d’un bloc de fonction, comme l’étendue d’une 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/

Eléments de l’API associés

do { statement(s) } while (condition)

Similaire à une boucle while, sauf que les instructions sont exécutées une fois avant l’évaluation initiale de la condition. Par la suite, les instructions sont exécutées uniquement si la condition est évaluée à true.

La boucle do..while permet de s’assurer que le code de la boucle s’exécute au moins une fois. Bien que cela puisse également se faire avec une boucle while en plaçant une copie des instructions à exécuter avant le début de la boucle while, de nombreux programmeurs trouvent les boucles do..while plus faciles à lire.

Si la condition renvoie toujours true, la boucle do..while est infinie. Si vous entrez dans une boucle infinie, vous rencontrez des problèmes avec Flash Player, puis un message d’erreur s’affiche ou le lecteur se bloque. Autant que possible, utilisez une boucle for si vous connaissez le nombre d’itérations souhaitées. Bien que les boucles for soient plus faciles à lire et déboguer, elles ne sont pas totalement interchangeables avec les boucles do..while.

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

Eléments de l’API associés

dynamic class className { // class definition here }

Spécifie que les instances d’une classe peuvent disposer de propriétés dynamiques ajoutées lors de l’exécution. Si vous utilisez l’attribut dynamic sur une classe, vous pouvez ajouter des propriétés à des occurrences de cette classe lors de l’exécution. Les classes non marquées avec l’attribut dynamic sont considérées scellées, ce qui signifie qu’aucune propriété ne peut être ajoutée aux occurrences de la classe.

Si une classe est scellée (non dynamique), les tentatives de lecture ou de définition de propriétés sur les instances de classe provoquent une erreur. Si le compilateur est défini en mode strict et si vous spécifiez le type de données lors de la création d’occurrences, les tentatives d’ajout de propriétés à des objets scellés génèrent une erreur de compilateur ; sinon, il s’agit d’une erreur du moteur d’exécution.

L’attribut dynamic n’est pas hérité par les sous-classes. Si vous étendez une classe dynamique, la sous-classe n’est dynamique que si vous la déclarez avec l’attribut 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

Eléments de l’API associés

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

Spécifie les instructions à exécuter si la condition de l’instruction if retourne la valeur false. Les accolades ({}) encadrant les instructions à exécuter par l’instruction else sont inutiles s’il ne s’agit que d’une seule instruction.

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

Eléments de l’API associés

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

Définit une classe correspondant à une sous-classe d’une autre classe. La sous-classe hérite de l’ensemble des méthodes, propriétés, fonctions, etc. définies dans la superclasse. Les classes marquées avec l’attribut final ne peuvent pas être étendues.

Vous pouvez également utiliser le mot-clé extends pour étendre une interface. Une interface qui en étend une autre inclut l’ensemble des déclarations de méthode de l’interface d’origine.

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

Eléments de l’API associés

false

Valeur booléenne false. Une valeur booléenne est soit true soit false. L’opposé de false est true.

Lorsque l’affectation automatique de données à un type convertit false en nombre, la valeur devient 0. Lorsqu’elle convertit false en chaîne, elle retourne "false".

Remarque : la chaîne "false" est convertie en valeur booléenne 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

Eléments de l’API associés

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

Spécifie qu’une méthode ne peut pas être remplacée ou qu’une classe ne peut pas être étendue. Toute tentative de remplacer une méthode, ou d’étendre une classe, marquée avec l’attribut final génère une erreur.

Eléments de l’API associés

Définit les méthodes de la classe Proxy. Les méthodes de la classe Proxy figurent dans leur propre espace de noms afin d’éviter les conflits de noms lorsqu’une sous-classe Proxy contient des noms de méthode d’occurrence identiques aux noms des méthodes de classe Proxy.

Eléments de l’API associés

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

Evalue l’expression init (initialisation) une fois, puis commence une séquence de boucle. La séquence de boucle commence par l’évaluation de l’expression condition. Si l’expression condition est évaluée à true, l’instruction statement est exécutée et l’expression next est évaluée. La séquence de boucle recommence alors avec l’évaluation de l’expression condition.

Les accolades ({}) encadrant le bloc d’instructions à exécuter par l’instruction for sont inutiles s’il ne s’agit que d’une seule instruction.

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

Eléments de l’API associés

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

Effectue une itération pour chaque propriété dynamique d’un objet ou chaque élément d’un tableau et exécute l’instruction statement pour chaque propriété ou élément. Les propriétés d’objet sont conservées sans ordre particulier, elles peuvent donc apparaître dans un ordre apparemment aléatoire. Les propriétés fixes, telles que les variables et les méthodes définies dans une classe, ne sont pas énumérées par l’instruction for...in. Pour obtenir une liste de propriétés fixes, utilisez la fonction describeType() figurant dans le package 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
*/

Plus d’exemples

Eléments de l’API associés

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

Effectue une itération pour chaque élément d’une collection et exécute l’instruction statement pour chaque élément. Présentée dans le cadre des extensions de langage E4X, l’instruction for each..in peut être utilisée non seulement pour les objets XML, mais également pour les objets et les tableaux. L’instruction for each....in procède à une itération uniquement pour les propriétés dynamiques d’un objet et non pas pour les propriétés fixes. Une propriété fixe est une propriété définie comme partie d’une définition de classe. Pour utiliser l’instruction for each..in avec une occurrence de classe définie par l’utilisateur, vous devez déclarer cette classe avec l’attribut dynamic.

Contrairement à l’instruction for...in, l’instruction for each..in procède à des itérations sur les valeurs des propriétés d’un objet et non pas sur les noms de propriétés.

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

Plus d’exemples

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

Comprend un ensemble d’instructions définies pour l’exécution d’une tâche particulière. Vous pouvez définir une fonction à un emplacement, puis l’invoquer ou l’appeler depuis différents scripts dans un fichier SWF. Lors de la définition d’une fonction, vous pouvez également spécifier ses paramètres. Les paramètres sont des emplacements fictifs pour les valeurs utilisées par la fonction. Vous pouvez transmettre à une fonction des paramètres différents à chaque appel, afin de la réutiliser dans différentes situations.

Utilisez l’instruction return dans le bloc d’instructions statement(s) pour faire générer ou retourner une valeur par une fonction.

Utilisation 1 : vous pouvez utiliser le mot-clé function pour définir une fonction avec le nom, les paramètres et les instructions requis. Lorsqu’un script appelle une fonction, les instructions comprises dans la définition de la fonction sont exécutées. Les références par anticipation sont autorisées ; au sein d’un même script, une fonction peut être déclarée après son appel. Une définition de fonction remplace toute définition antérieure de la même fonction. Vous pouvez utiliser cette syntaxe à tout emplacement permettant l’utilisation d’une instruction.

Utilisation 2 : vous pouvez également utiliser function pour créer une fonction anonyme et lui renvoyer une référence. Cette syntaxe est utilisée dans les expressions ; elle est particulièrement utile pour l’installation de méthodes dans les objets.

Pour plus de fonctionnalité, vous pouvez utiliser l’objet arguments dans la définition de fonction. L’objet arguments est couramment utilisé pour créer une fonction acceptant un nombre de paramètres variable et pour créer une fonction anonyme récursive.

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

Eléments de l’API associés

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

Définit une méthode getter qui peut être lue comme une propriété. Un getter est une fonction spéciale qui retourne la valeur d’une propriété déclarée avec le mot-clé var ou const. Contrairement aux autres méthodes, un getter est appelé sans parenthèses (()), ce qui le fait ressembler à une variable.

Les méthodes getter permettent d’appliquer le principe de masquage des informations par la création d’une interface publique pour une propriété privée. L’avantage du masquage des informations est que l’interface publique reste identique même si l’implémentation sous-jacente de la propriété privée change.

Les méthodes getter présentent également l’avantage de pouvoir être remplacées dans des sous-classes, contrairement aux propriétés déclarées avec var ou const.

Un getter peut être combiné avec un setter pour former une propriété en lecture/écriture. Pour créer une propriété en lecture seule, créez un getter sans setter correspondant. Pour créer une propriété en écriture seule, créez un setter sans getter correspondant.

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

Eléments de l’API associés

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

Evalue une condition pour déterminer la prochaine instruction à exécuter. Lorsque cette condition a la valeur true, Flash Player exécute les instructions qui suivent la condition entre accolades ({}). Si la condition a la valeur false, Flash Player ignore les instructions entre accolades et exécute les instructions qui suivent ces accolades. Utilisez l’instruction if avec l’instruction else pour mettre en place une logique conditionnelle dans les scripts.

Les accolades ({}) encadrant les instructions à exécuter par l’instruction if sont facultatives s’il ne s’agit que d’une seule instruction.

Eléments de l’API associés

myClass implements interface01 [, interface02 , ...] 

Spécifie qu’une classe implémente une ou plusieurs interfaces. Lorsqu’une classe implémente une interface, la classe doit définir toutes les méthodes qui y sont déclarées. Toute occurrence d’une classe qui implémente une interface est considérée comme un membre du type de données défini par l’interface. Par conséquent, l’opérateur is retourne true lorsque l’occurrence de classe correspond au premier opérande et l’interface au deuxième. En outre, les coercitions de type depuis et vers le type de données défini par l’interface fonctionnent.

Eléments de l’API associés

import packageName.className 
import packageName.*

Rend les classes et les packages définis en externe disponibles pour le code. Par exemple, vous devez importer la classe flash.display.Sprite avant de pouvoir l’utiliser dans un script. Cette condition diffère des versions précédentes d’ActionScript, pour lesquelles la directive import était facultative.

Après avoir utilisé la directive import, vous pouvez utiliser le nom de classe complet, qui comprend le nom du package, ou simplement le nom de la classe.

 
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 le package contient plusieurs classes auxquelles vous souhaitez accéder, vous pouvez les importer toutes avec une même instruction, comme dans l’exemple suivant :

import flash.display.*;

La directive import importe uniquement les classes, les fonctions et les variables résidant au niveau supérieur du package importé. Les packages imbriqués doivent être importés de façon explicite.

Si vous importez une classe sans l’utiliser dans le script, elle n’est pas exportée avec le fichier SWF. Cela signifie que vous pouvez importer des packages volumineux sans vous préoccuper de la taille du fichier SWF. Le code en octets associé à une classe n’est inclus dans un fichier SWF que si la classe est véritablement utilisée. L’un des inconvénients de l’importation de classes superflues est l’augmentation des risques de confusion de noms.

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

include "[path]filename.as"

Comprend le contenu du fichier spécifié, comme si les commandes du fichier faisaient partie du script d’appel. La directive include est invoquée lors de la compilation. Par conséquent, si vous apportez des modifications à un fichier inclus, vous devez l’enregistrer puis recompiler tous les fichiers SWF éventuels qui l’utilisent.

 interface InterfaceName [extends InterfaceName ] {}

Définit une interface. Les interfaces sont des types de données qui définissent un ensemble de méthodes. Les méthodes doivent être définies par toute classe qui implémente l’interface.

Une interface est similaire à une classe, mais présente essentiellement les différences suivantes :

• Les interfaces contiennent uniquement des déclarations de méthodes, pas leur implémentation. Ainsi, toute classe qui implémente une interface doit fournir une implémentation pour chaque méthode déclarée dans l’interface.
• Les définitions de méthode d’interface ne peuvent pas avoir d’attributs tels que public ou private, mais les méthodes implémentées doivent être marquées comme public dans la définition de la classe qui implémente l’interface.
• Plusieurs interfaces peuvent être héritées par une interface à l’aide de l’instruction extends ou par une classe à l’aide de l’instruction implements.

Contrairement à ActionScript 2.0, ActionScript 3.0 permet l’utilisation des méthodes getter et setter dans les définitions d’interface.

Eléments de l’API associés

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

Spécifie qu’une classe, une variable, une constante ou une fonction est disponible pour tout appelant au sein du même package. Les classes, propriétés et méthodes appartiennent par défaut à l’espace de noms internal.

Eléments de l’API associés

label: statement
label: {
    statements
}

Associe une instruction à un identificateur pouvant être référencé par break ou continue. Dans les boucles imbriquées, une instruction break ou continue qui ne référence aucune étiquette peut ignorer uniquement le reste de la boucle en cours et n’ignore pas la série entière de boucles. Toutefois, si l’instruction qui définit toute la série de boucles dispose d’une étiquette associée, une instruction break ou continue peut ignorer la série entière de boucles en référençant cette étiquette.

Les étiquettes permettent également de s’échapper d’une instruction de bloc. Vous ne pouvez pas placer une instruction break sans référence à une étiquette dans une instruction de bloc, sauf si cette dernière fait partie d’une boucle. Si l’instruction de bloc dispose d’une étiquette associée, vous pouvez placer une instruction break faisant référence à cette étiquette dans l’instruction de bloc.

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

Eléments de l’API associés

namespace name [= uri]

Permet de contrôler la visibilité des définitions. Les espaces de noms prédéfinis comportent public, private, protected et internal.

La procédure suivante indique comment créer, appliquer et référencer un espace de noms :

• Tout d’abord, définissez l’espace de noms personnalisé à l’aide du mot-clé namespace. Par exemple, le code namespace version1 crée un espace de noms appelé version1.
• Ensuite, appliquez l’espace de noms à une propriété ou une méthode en utilisant l’espace de noms personnalisé dans la déclaration de propriété ou de méthode. Par exemple, le code version1 myProperty:String crée une propriété appelée myProperty appartenant à l’espace de noms version1.
• Enfin, référencez l’espace de noms à l’aide du mot-clé use ou en utilisant l’espace de noms en tant que préfixe d’identificateur. Par exemple, le code use namespace version1; référence l’espace de noms version1 pour les lignes de code suivantes et le code version1::myProperty référence l’espace de noms version1 pour la propriété myProperty.

Eléments de l’API associés

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

Permet de spécifier si une fonction ou une méthode doit être implémentée par Flash Player en code natif. Flash Player utilise le mot-clé native en interne pour déclarer des fonctions et des méthodes dans l’interface de programmation d’application (API) d’ActionScript. Ce mot-clé ne peut pas être utilisé dans votre propre code.  

null

Une valeur spéciale qui peut être affectée aux variables ou renvoyée par une fonction en l’absence de données. Vous pouvez utiliser null pour représenter les valeurs manquantes ou dont le type de données n’est pas défini.

La valeur null ne doit pas être confondue avec la valeur spéciale undefined. Lorsque les propriétés null et undefined sont comparées avec l’opérateur d’égalité (==), elles sont considérées comme égales. Lorsque les propriétés null et undefined sont comparées avec l’opérateur d’égalité stricte (===), elles sont considérées comme différentes.

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

Eléments de l’API associés

Définit les méthodes de la classe ObjectProxy. Les méthodes de la classe ObjectProxy figurent dans leur propre espace de noms afin d’éviter les conflits de noms lorsqu’une sous-classe Proxy contient des noms de méthode d’occurrence identiques aux noms des méthodes de classe Proxy.

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

Spécifie qu’une méthode remplace une méthode héritée. Pour remplacer une méthode héritée, vous devez utiliser l’attribut override et vous assurer que le nom, l’attribut de propriété de la classe, le nombre et le type des paramètres, ainsi que le type de retour concordent exactement. Toute tentative de remplacement d’une méthode sans l’attribut override constitue une erreur. De même, le fait d’utiliser l’attribut override lorsque la méthode ne dispose d’aucune méthode héritée correspondante constitue une erreur.

Vous ne pouvez pas utiliser l’attribut override avec les éléments suivants :

• Variables
• Constantes
• Méthodes statiques
• Méthodes non héritées
• Méthodes implémentant une méthode d’interface
• Méthodes héritées marquées avec l’attribut final dans la superclasse

Vous ne pouvez pas remplacer une propriété déclarée avec var ou const, mais vous pouvez obtenir une fonctionnalité similaire en transformant la propriété de la classe de base en getter/setter et en remplaçant les méthodes définies avec get et set.

Eléments de l’API associés

package packageName {
    class someClassName { 
    } 
}

Permet d’organiser le code en groupes distincts pouvant être importés par d’autres scripts. Vous devez utiliser le mot-clé package pour indiquer si une classe appartient à un package.

Eléments de l’API associés

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

Spécifie qu’une variable, une constante ou une méthode est disponible uniquement pour la classe qui la déclare ou la définit. Contrairement à ActionScript 2.0, dans ActionScript 3.0 private ne permet plus d’accéder aux sous-classes. De plus, private limite l’accès lors de la compilation et de l’exécution. Par défaut, une variable ou une fonction est disponible pour tout appelant dans le même package. Utilisez ce mot-clé pour restreindre l’accès à une variable ou une fonction.

Ce mot-clé peut être utilisé uniquement dans les définitions de classe, pas dans les définitions d’interface. Vous ne pouvez pas appliquer private à une classe ou toute autre définition au niveau du package.

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

Eléments de l’API associés

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

Spécifie qu’une variable, une constante, une méthode ou un espace de noms est disponible uniquement pour la classe qui le définit, ainsi que pour toutes ses sous-classes éventuelles. La définition de protected dans ActionScript 3.0 est similaire à la définition de la version ActionScript 2.0 de private, à la différence que protected restreint l’accès pendant la compilation et l’exécution. Par défaut, une variable ou une fonction est disponible pour tout appelant au sein du même package. Utilisez ce mot-clé pour restreindre l’accès à une variable ou une fonction.

Ce mot-clé peut être utilisé uniquement dans les définitions de classe, pas dans les définitions d’interface. Vous ne pouvez pas appliquer private à une classe ou toute autre définition au niveau du package.

La définition de protected dans ActionScript 3.0 est plus restrictive que celle de protected dans le langage de programmation Java. Dans ActionScript 3.0 protected limite strictement l’accès aux sous-classes, tandis que dans Java protected autorise également l’accès à toute classe du même package. Par exemple, si une classe nommée Base contient une propriété marquée avec l’attribut protected, dans ActionScript 3.0, seules les classes qui étendent Base peuvent accéder à la propriété protégée. Dans le langage Java, toute classe appartenant au même package que Base peut accéder à la propriété protégée, même si la classe n’est pas une sous-classe 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
  }
}

Eléments de l’API associés

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

Spécifie qu’une classe, une variable, une constante ou une méthode est disponible pour tout appelant. Les classes, les variables et les méthodes sont internes par défaut, ce qui signifie qu’elles ne sont visibles qu’à l’intérieur du package en cours. Afin de rendre une classe, une variable ou une méthode visible pour tous les appelants, vous devez utiliser l’attribut 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

Eléments de l’API associés

function functionName () {
	return [expression]
}

Renvoie immédiatement l’exécution à la fonction appelante. Si l’instruction return est suivie d’une expression, cette dernière est évaluée et le résultat est retourné.

Si une définition de fonction inclut un type de renvoi, l’instruction return doit être suivie par une expression. Si aucun type de renvoi n’est spécifié et que l’instruction return est utilisée seule, elle retourne undefined.

Vous ne pouvez pas retourner plusieurs valeurs. Dans ce cas, seule la dernière valeur est renvoyée. Dans l’exemple suivant, la valeur c est renvoyée :

return a, b, c ;

Si vous devez renvoyer des valeurs multiples, utilisez un tableau ou un objet.

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

Eléments de l’API associés

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

Définit une méthode setter, qui s’affiche dans l’interface publique en tant que propriété. Un setter est une méthode spéciale permettant de définir la valeur d’une propriété déclarée avec le mot-clé var. Contrairement aux autres méthodes, la méthode setter est appelée sans parenthèses (()), ce qui la fait ressembler à une variable.

Les méthodes setter permettent d’appliquer le principe de masquage des informations par la création d’une interface publique pour une propriété privée. L’avantage du masquage des informations est que l’interface publique reste identique même si l’implémentation sous-jacente de la propriété privée change.

Les méthodes setter présentent également l’avantage de pouvoir être remplacées dans des sous-classes, contrairement aux propriétés déclarées avec var.

Le type de retour d’une méthode setter doit être void ou non spécifié.

Un setter peut être combiné avec un getter pour former une propriété en lecture/écriture. Pour créer une propriété en lecture seule, créez un getter sans setter correspondant. Pour créer une propriété en écriture seule, créez un setter sans getter correspondant.

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

Eléments de l’API associés

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

Spécifie qu’une variable, une constante ou une méthode appartient à la classe, et non aux instances de la classe.

Pour accéder à un membre de classe statique, utilisez le nom de la classe plutôt que le nom d’une instance. Par exemple, la classe Date comporte une méthode statique appelée parse(), pouvant être appelée uniquement à l’aide de la syntaxe suivante :

Date.parse()

La méthode parse() ne peut pas être appelée pour une instance de la classe Date. Par exemple, le code suivant génère une erreur :

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

Le mot-clé static peut être utilisé uniquement dans les définitions de classe, pas dans les définitions d’interface.

Les membres de classes statiques ne sont pas hérités. Vous ne pouvez pas faire référence à un membre de classe statique à l’aide du nom d’une sous-classe, comme en langage Java ou C++. Vous pouvez toutefois faire référence à une variable ou une méthode statique appartenant à une classe ou une sous-classe, sans avoir recours à des qualificateurs. Voir l’exemple ci-dessous.

Vous ne pouvez pas utiliser l’instruction super ou le mot-clé this dans une méthode statique.

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

Invoque la version superclasse ou parent d’une méthode ou d’un constructeur. Lorsque l’instruction super() est utilisée dans le corps d’un constructeur de classe, elle invoque la version superclasse du constructeur. L’appel du constructeur de superclasse doit disposer du nombre correct d’arguments. Notez que le constructeur de superclasse est toujours appelé, que vous en ayez fait la demande explicitement ou non. Si vous ne l’appelez pas de façon explicite, un appel sans arguments est inséré automatiquement avant la première instruction dans le corps du constructeur de la sous-classe. Cela signifie que si vous définissez une fonction constructeur dans une sous-classe et que le constructeur de superclasse prend un ou plusieurs arguments, vous devez appeler le constructeur de superclasse de façon explicite avec le nombre correct d’arguments pour ne pas provoquer une erreur. L’appel au constructeur de superclasse, toutefois, ne doit pas nécessairement être la première instruction du constructeur de sous-classe, comme c’était le cas avec ActionScript 2.0.

Lorsqu’elle est utilisée dans le corps d’une méthode d’occurrence, l’instruction super peut être utilisée avec l’opérateur point (.) pour invoquer la version superclasse d’une méthode et peut éventuellement transmettre des arguments (arg1 ... argN) à la méthode de superclasse. Ceci permet de créer des méthodes de sous-classe qui non seulement ajoutent des comportements supplémentaires aux méthodes de superclasse, mais les invoquent également pour exécuter leur comportement d’origine.

Vous ne pouvez pas utiliser l’instruction super dans une méthode statique.

Eléments de l’API associés

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

Transfère le contrôle à l’une de plusieurs instructions en fonction de la valeur d’une expression. Toutes les instructions switch doivent inclure un cas par défaut exécuté si aucune des instructions case ne correspond à l’expression. Chaque instruction case doit se terminer par une instruction break, afin d’éviter les erreurs fall-through. Lorsque ce type d’erreur se produit, l’exécution du code se poursuit à la prochaine instruction case, même si elle ne correspond pas à l’expression de test.

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

Eléments de l’API associés

this

Référence à l’objet contenant une méthode. Lorsqu’un script s’exécute, le mot-clé this fait référence à l’objet contenant le script. Dans un corps de méthode, le mot-clé this fait référence à l’occurrence de classe contenant la méthode appelée.

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

Génère ou renvoie une erreur pouvant être traitée ou interceptée par un bloc de code catch. Si une exception n’est pas interceptée par un bloc catch, la chaîne représentant la valeur renvoyée est transmise au volet Sortie. Si une exception n’est pas interceptée par un bloc catch ou finally, la chaîne représentant la valeur renvoyée est transmise au fichier journal.

Généralement, le système renvoie des instances de la classe Error ou de ses sous-classes (voir la section Exemple).

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.

Plus d’exemples

Eléments de l’API associés

true

Valeur booléenne true. Une valeur booléenne est soit true soit false. L’opposé de true est false. Lorsque l’affectation automatique de données à un type convertit true en nombre, la valeur devient 1. Lorsqu’elle convertit true en chaîne, elle retourne "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

Eléments de l’API associés

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

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

Encadre un bloc de code pouvant provoquer une erreur, puis répond à l’erreur. Le traitement des exceptions, qui est implémenté à l’aide des instructions try..catch..finally, constitue le principal mécanisme de traitement des erreurs d’exécution d’ActionScript 3.0. Lorsqu’une erreur d’exécution se produit, Flash Player renvoie une exception. En d’autres termes, Flash Player suspend l’exécution normale et crée un objet spécial de type Error. Flash Player transmet ou renvoie ensuite l’objet d’erreur au premier bloc catch disponible. Si aucun bloc catch n’est disponible, l’exception est considérée comme une exception non interceptée. Ce type d’exception provoque une interruption du script.

Vous pouvez utiliser l’instruction throw pour renvoyer des exceptions de manière explicite dans le code. Vous pouvez renvoyer une valeur quelconque, mais la meilleure pratique consiste à renvoyer un objet, ce qui assure une certaine flexibilité et correspond au comportement de Flash Player.

Pour intercepter une exception renvoyée par Flash Player ou par votre propre code, placez le code susceptible de la renvoyer dans un bloc try. Si le code figurant dans le bloc try renvoie une exception, le contrôle passe au bloc catch, s’il existe, puis au bloc finally, s’il existe. Le bloc finally est toujours exécuté, qu’une exception ait été renvoyée ou non. Si le code du bloc try ne renvoie pas d’exception (si le bloc try se termine normalement), le code du bloc catch est ignoré, mais le code du bloc finally reste exécuté. Le bloc finally est exécuté même si le bloc try se termine à l’aide d’une instruction return.

Un bloc try doit être suivi d’un bloc catch, d’un bloc finally ou des deux. Un même bloc try peut comporter plusieurs blocs catch, mais un seul bloc finally. Vous pouvez imbriquer les blocs try sur autant de niveaux que nécessaire.

Le paramètre error spécifié dans un gestionnaire catch doit être un identificateur simple, tel que e, theException ou x. Le paramètre peut également disposer d’un type. Utilisés avec plusieurs blocs catch, les paramètres typés permettent d’intercepter plusieurs types d’objets d’erreur renvoyés par un même bloc try.

Si l’exception renvoyée est un objet, le type correspond lorsque l’objet renvoyé est une sous-classe du type spécifié. Si une erreur est renvoyée avec un type spécifique, le bloc catch traitant l’erreur correspondante est exécuté. Si une exception est renvoyée avec un type différent de celui spécifié, le bloc catch n’est pas exécuté et l’exception est automatiquement renvoyée en dehors du bloc try vers un gestionnaire catch correspondant.

Si une erreur est renvoyée au sein d’une fonction dépourvue de gestionnaire catch, Flash Player quitte cette fonction ainsi que toute fonction appelante, jusqu’à ce qu’il détecte un bloc catch. Pendant ce processus, les gestionnaires finally de tous les niveaux sont appelés.

Remarque : si dans un bloc try, un diffuseur d’événements appelle son gestionnaire d’événements, le bloc catch n’intercepte pas l’erreur si elle est renvoyée dans le gestionnaire d’événements. Toute erreur renvoyée peut être interceptée en écoutant 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()); 
}

Plus d’exemples

Eléments de l’API associés

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

Implique l’ajout des espaces de noms spécifiés à l’ensemble des espaces de noms ouverts. Les espaces de noms spécifiés sont retirés de l’ensemble des espaces de noms ouverts lorsque le contrôle quitte le bloc de code en cours. La directive use namespace peut figurer au niveau supérieur d’un programme, d’une définition de package ou d’une définition de classe.

Eléments de l’API associés

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

Spécifie une variable. Si vous déclarez des variables au sein d’une fonction, elles sont locales. Elles sont définies pour cette fonction et expirent à la fin de l’appel de celle-ci.

Vous ne pouvez pas déclarer une variable figurant dans l’étendue d’un autre objet en tant que variable locale.

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

Vous pouvez affecter un type de données à une constante en lui ajoutant un caractère deux points (:) suivi du type de données.

Vous pouvez déclarer plusieurs variables dans une même instruction, en séparant leurs déclarations par des virgules (bien que cette syntaxe risque de réduire la lisibilité du code) :

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

Eléments de l’API associés

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

Evalue une condition. Si elle est évaluée à true, exécute une ou plusieurs instructions avant de répéter la boucle et de réévaluer la condition. Dès que l’évaluation de la condition retourne false, les instructions sont ignorées et la boucle se termine.

L’instruction while exécute la série d’étapes suivante. Chaque répétition des étapes 1 à 4 constitue une itération de la boucle. La condition est testée au début de chaque itération, comme dans les étapes suivantes :

1. L’expression condition est évaluée.
2. Si condition est évaluée à true ou une valeur pouvant être convertie en une valeur booléenne true, telle qu’un nombre différent de zéro, passer à l’étape 3. Sinon, l’instruction while se termine et l’exécution reprend au niveau de la prochaine instruction suivant la boucle while.
3. Exécuter le bloc d’instructions statement(s). Si une instruction continue est détectée, ignorer les instructions suivantes et passer à l’étape 1. Si une instruction break est détectée, l’instruction while se termine et l’exécution reprend au niveau de la prochaine instruction suivant la boucle while.
4. Passer à l’étape 1.

Les boucles permettent habituellement d’exécuter une action tant qu’une variable de décompte est inférieure à une valeur spécifiée. Le compteur est incrémenté à la fin de chaque boucle, jusqu’à atteindre la valeur spécifiée. A ce moment, l’expression condition n’a plus la valeur true et la boucle se termine.

Les accolades ({}) encadrant les instructions à exécuter par l’instruction while sont facultatives s’il ne s’agit que d’une seule instruction.

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

Eléments de l’API associés

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

Etablit un objet par défaut à utiliser pour l’exécution d’une ou plusieurs instructions, ce qui peut permettre de réduire le volume de code à écrire.

Le paramètre object devient le contexte de lecture des propriétés, variables et fonctions du paramètre statement(s). Par exemple, si object correspond à my_array et que deux des propriétés spécifiées sont length et concat, ces propriétés sont automatiquement lues comme my_array.length et my_array.concat. Un autre exemple : si object correspond à state.california, toutes les actions et instructions contenues dans l’instruction with sont appelées depuis l’intérieur de l’occurrence california.

Pour déterminer la valeur d’un identificateur dans le paramètre statement(s), ActionScript commence au début de la chaîne d’étendue spécifiée par object et recherche l’identificateur à chaque niveau de la chaîne de domaine, dans un ordre spécifique.

La chaîne d’étendue utilisée par l’instruction with pour la résolution des identificateurs commence par le premier élément de la liste suivante et se poursuit jusqu’au dernier :

• Objet spécifié dans le paramètre object de l’instruction with de plus bas niveau.
• Objet spécifié dans le paramètre object de l’instruction with de plus haut niveau.
• Objet Activation (objet temporaire créé automatiquement lorsque le script appelle une fonction contenant les variables locales appelées dans la fonction).
• Objet contenant le script en cours d’exécution.
• Objet Global (objets intégrés, tels que Math et String).

Pour définir une variable dans une instruction with, vous devez avoir déclaré cette variable en-dehors de l’instruction with, ou vous devez entrer le chemin complet du scénario cible d’existence de la variable. Si vous définissez une variable dans une instruction with sans la déclarer, l’instruction with recherche sa valeur en fonction de la chaîne d’étendue. Si la variable n’existe pas encore, la nouvelle valeur est définie sur le scénario à l’origine de l’appel de l’instruction 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
*/