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

Spécifie les instructions à exécuter si la condition de l'instruction if renvoie false. Les accolades ({}) qui entourent les instructions à exécuter avec l'instruction else sont facultatives si une seule instruction doit s'exécuter.

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

Voir aussi

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

Définit une classe qui est une sous-classe d'une autre classe. La sous-classe hérite de toutes les méthodes, propriétés, fonctions, etc. qui sont définies dans la super-classe. Les classes qui portent la mention final ne peuvent pas être étendues.

Vous pouvez également utiliser le mot-clé extends pour étendre une interface. Toute interface qui étend une autre interface reprend toutes les déclarations de méthode de l'interface d'origine.

L'exemple suivant affiche le contenu d'un fichier intitulé Vehicle.as, qui définit la classe Vehicle :

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

package {

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

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

Vous pouvez également écrire une sous-classe pour la classe Vehicle à l'aide de l'instruction super. La sous-classe pourra l'utiliser pour accéder au constructeur de la super-classe. L'exemple suivant affiche un troisième fichier ActionScript, intitulé Truck.as, toujours dans le même répertoire. La classe Truck utilise super dans le constructeur et dans la méthode reverse() bloquée.

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

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

Voir aussi

false

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

Lorsque le typage automatique de données convertit false en nombre, il renvoie 0. Lorsqu'il convertit false en chaîne, il renvoie "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

L'exemple suivant montre que la chaîne "false" est convertie en valeur booléenne true :

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

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

Voir aussi

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

Permet de spécifier qu'une méthode ne peut pas être remplacée ou qu'une classe ne peut pas être étendue. Toute tentative de remplacement d'une méthode ou d'extension d'une classe avec la mention final renvoie une erreur.

Voir aussi

Définit les méthodes de la classe Proxy. Les méthodes de la classe Proxy figurent dans leur propre espace de nom pour prévenir les risques de confusion lorsque vos sous-classes Proxy contiennent des noms de méthode d'occurrence identiques aux noms des méthodes de classe Proxy.

Voir aussi

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

Evalue l'expression init (initialiser) une fois, puis amorce une séquence de bouclage. La séquence de bouclage commence par évaluer l'expression condition. Si l'expression condition renvoie true, statement est exécuté et next est évalué. La séquence de bouclage reprend par l'évaluation de l'expression condition.

Les accolades ({}) qui entourent le bloc d'instructions à exécuter avec l'instruction for sont facultatives si une seule instruction doit s'exécuter.

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

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

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

Voir aussi

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

Répète en boucle les propriétés dynamiques d'un objet ou d'éléments de tableau, puis exécute l'instruction statement pour chaque propriété ou élément. Les propriétés des objets n'étant pas conservées dans un ordre particulier, elles peuvent apparaître aléatoirement. 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 la liste des propriétés fixes, utilisez la fonction describeType(), qui figure 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]); 
} 
/* output:
myObject.firstName = Tara 
myObject.age = 27 
myObject.city = San Francisco
*/

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

Voir aussi

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

Procède à une itération sur les éléments d'une collection et exécute statement pour chaque élément. L'instruction for each..in a été introduite dans le cadre des extensions de langage E4X et peut être utilisée non seulement pour les objets XML, mais encore 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 les propriétés fixes. Une propriété fixe est une propriété qui est définie dans le cadre 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); 
} 
/* output:
Tara
27
San Francisco
*/

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

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

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

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

/* output:
Hello
Hola
Bonjour
*/

Voir aussi

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

Comprend un ensemble d'instructions que vous définissez pour effectuer une certaine tâche. Vous pouvez définir une fonction à un emplacement et l'appeler à partir de différents scripts dans un fichier SWF. Lorsque vous définissez une fonction, vous pouvez également lui attribuer des paramètres. Les paramètres sont des espaces réservés pour les valeurs sur lesquelles la fonction agit. A chaque appel, vous pouvez transmettre des paramètres différents à une fonction de façon à pouvoir l'utiliser dans différentes situations.

Utilisez l'instruction return dans le bloc statement(s) d'une fonction pour lui faire générer ou renvoyer une valeur.

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 figurant dans sa définition s'exécutent. Les références anticipées sont autorisées. Dans un même script, une fonction peut être déclarée après son appel. Chaque définition de fonction remplace toute définition précédente de la même fonction. Vous pouvez utiliser cette syntaxe dans tous les cas où une instruction est autorisée.

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 des expressions et est particulièrement pratique pour l'installation de méthodes dans les objets.

Pour bénéficier de fonctionnalités supplémentaires, utilisez l'objet arguments dans la définition de votre fonction. Certaines utilisations courantes de l'objet arguments créent une fonction qui accepte un nombre variable de paramètres et créent une fonction anonyme récursive.

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

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

Voir aussi

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

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

Les méthodes de lecture permettent d'appliquer le principe de dissimulation des informations en créant une interface publique pour une propriété privée. L'avantage de la dissimulation des informations est que l'interface publique reste telle quelle, même si la propriété privée sous-jacente change.

Un autre avantage des méthodes de lecture est qu'elles peuvent être remplacées dans des sous-classes, tandis que les propriétés déclarées avec var ou const sont irremplaçables.

Une méthode de lecture peut être combinée avec une méthode de définition pour former une propriété en lecture/écriture. Pour créer une propriété en lecture/écriture, créez une méthode de lecture sans méthode de définition correspondante. Pour créer une propriété en lecture seule, créez une méthode de définition sans méthode de lecture correspondante.

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

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

Lorsque vous surveillez giants.name, vous utilisez une méthode de lecture pour renvoyer la valeur de cette propriété.

Voir aussi

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

Evalue une condition pour déterminer la prochaine instruction à exécuter. Lorsque cette condition est true, Flash Player exécute les instructions qui suivent la condition entre accolades ({}). Si la condition est 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.

Les accolades ({}) qui entourent les instructions à exécuter avec l'instruction if sont facultatives si une seule instruction doit s'exécuter.

Voir aussi

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 de 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 renvoie 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.

Remarque : Pour utiliser ce mot-clé, vous devez spécifier ActionScript 2.0 et Flash Player 6 ou une version plus récente dans l'onglet Flash de la boîte de dialogue Paramètres de publication de votre fichier FLA. Ce mot-clé n'est pris en charge que lorsqu'il est utilisé dans des fichiers de script externes, et non pas dans les scripts écrits dans le panneau Actions.

Voir aussi

import packageName.className 
import packageName.*

Rend les classes et les packages définis en externe disponibles pour votre 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();

Lorsque le package contient plusieurs classes auxquelles vous souhaitez accéder, vous pouvez les importer avec une seule instruction, comme dans l'exemple suivant :

import flash.display.*;

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

Si vous importez une classe, mais ne l'utilisez pas dans votre script, elle n'est pas exportée avec le fichier SWF. Ceci signifie que vous pouvez importer des packages volumineux sans vous soucier de la taille du fichier SWF. Le pseudo-code binaire associé à une classe n'est inclus dans un fichier SWF que si cette classe est véritablement utilisée. L'un des inconvénients de l'importation de classes superflues est que vous augmentez les risques de confusion des noms.

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

Voir aussi

include "[path]filename.as"

Inclut le contenu du fichier spécifié, comme si les commandes du fichier faisaient partie du script d'appel. La directive include est appelée lors de la compilation. Cela signifie que si vous apportez des modifications à un fichier inclus, vous devez l'enregistrer, puis recompiler tous les fichiers SWF qui l'utilisent.

Voir aussi

 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 les classes qui implémentent l'interface.

Une interface est similaire à une classe. Les différences fondamentales sont regroupées ci-dessous :

• Les interfaces contiennent uniquement les déclarations des 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. Par contre, les méthodes implémentées doivent être marquées comme public dans la définition de la classe qui implémente l'interface.
• Des interfaces multiples peuvent être héritées par une interface à l'aide de l'instruction extends ou à l'aide d'une classe avec l'instruction implements.