Forums d'entraide informatique - Astuces - Conseils

En règle générale, si vous importez ou exportez des fichiers ActionScript au format UTF-8,
choisissez UTF-8. Si vous importez ou exportez des fichiers dans la page de code classique de
votre système, choisissez Codage par défaut comme préférence.
Si le texte que contiennent vos scripts ne s’affiche pas correctement lorsque vous ouvrez ou
importez un fichier, modifiez la préférence de codage pour l’importation. Si vous obtenez un
avertissement lors de l’exportation de fichiers ActionScript, vous pouvez modifier la préférence de
codage pour l’exportation ou désactiver l’affichage de cet avertissement dans les préférences
ActionScript.
Pour choisir des options de codage de texte pour l’importation ou l’exportation de fichiers
ActionScript :
1 Dans la boîte de dialogue Préférences (Modifier > Préférences), cliquez sur l’onglet
ActionScript.
2 Dans la section Options d’édition, effectuez au moins une des actions suivantes :
■ Pour l’option Ouvrir/Importer, choisissez UTF-8 pour ouvrir ou importer en utilisant le
codage Unicode, ou choisissez Codage par défaut pour ouvrir ou importer en utilisant le
format de codage de la langue de votre système actuel.
■ Pour l’option Enregistrer/Exporter, choisissez UTF-8 pour enregistrer ou exporter en
utilisant le codage Unicode, ou choisissez Codage par défaut pour enregistrer ou exporter en
utilisant le format de codage de la langue de votre système actuel.
Pour activer ou désactiver le message d’avertissement de codage d’exportation :
1 Dans la boîte de dialogue Préférences (Edition > Préférences), cliquez sur l’onglet
Avertissements.
2 Activez ou désactivez l’option Avertir des conflits de codage pendant l’exportation de fichiers .as.
Attention : La commande Tester l’animation (consultez Débogage de scripts, page 71) échoue si une
partie du chemin du fichier SWF contient des caractères ne pouvant pas être représentés à l’aide du
système de codage MBCS. Par exemple, les chemins japonais dans un système anglais ne
fonctionnent pas. Toutes les zones de l’application utilisant le lecteur externe sont soumises à cette
restriction.
Terminologie
A l’instar de tout langage de programmation, ActionScript utilise une terminologie qui lui est
propre. La liste suivante présente les principaux termes ActionScript. Terminologie 29
Les actions sont des instructions qui ordonnent à un fichier SWF d’exécuter une opération
déterminée lors de sa lecture. Par exemple, gotoAndStop() envoie la tête de lecture à une image
ou une étiquette spécifique. Dans cet ouvrage, les termes action et instruction sont
interchangeables.
Une valeur booléenne est une valeur true (vraie) ou false (fausse).
Les classes sont des types de données que vous pouvez créer pour définir un nouveau type
d’objet. Pour définir une classe, utilisez le mot-clé class dans un fichier de script externe (et non
dans le script en cours de rédaction dans le panneau Actions).
Les constantes sont des éléments qui ne changent pas. Par exemple, la constante Key.TAB a
toujours la même signification : elle indique la touche Tab du clavier. Les constantes sont utiles
pour comparer des valeurs.
Les constructeurs sont des fonctions que vous utilisez pour définir les propriétés et les méthodes
d’une classe. Par définition, les constructeurs sont des fonctions au sein d’une définition de classe
qui portent le même nom que la classe. Par exemple, le code suivant définit une classe « Cercle »
et implémente une fonction constructeur :
// fichier Circle.as
class Circle {
private var radius:Number
private var circumference:Number
// constructeur
function Circle(radius:Number) {
circumference = 2 * Math.PI * radius;
}
}
Le terme constructeur est également utilisé lorsque vous créez (instanciez) un objet en fonction
d’une classe particulière. Les instructions suivantes sont des constructeurs pour la classe « Array »
intégrée et pour la classe « Circle » personnalisée :
mon_array:Array = new Array();
mon_circle:Circle = new Circle();
Les types de données décrivent le genre d’informations qu’une variable ou qu’un élément
ActionScript peut contenir. Les types de données ActionScript sont les suivants : String, Number,
Boolean, Object, MovieClip, Function, Null et Undefined. Pour plus d’informations, consultez
A propos des types de données, page 36.
Les événements sont des actions qui se produisent lors de la lecture d’un fichier SWF. Par
exemple, différents événements sont générés lorsqu’un clip est chargé, que la tête de lecture entre
dans une image, que l’utilisateur clique sur un bouton ou clip ou qu’il tape sur le clavier.
Les gestionnaires d’événement sont des actions spéciales qui gèrent les événements tels que
mouseDown ou load. Il existe deux sortes de gestionnaires d’événement ActionScript : les
méthodes de gestionnaire d’événement et les écouteurs d’événement. (Il existe également deux
gestionnaires d’événement, on() et onClipEvent(), que vous pouvez affecter directement aux
boutons et aux clips.) Dans la boîte à outils Actions, chaque objet ActionScript qui possède des
méthodes de gestionnaire d’événement ou des écouteurs d’événement est associé à une sous-
catégorie appelée Evénements ou Ecouteurs. Certaines commandes, qui peuvent être utilisées à la
fois en tant que gestionnaires d’événement et écouteurs d’événement, sont incluses dans les deux
sous-catégories. 30 Chapitre 2 :  Notions de base du langage ActionScript
Une expression est toute combinaison légale de symboles ActionScript qui représentent une
valeur. Une expression se compose d’opérateurs et d’opérandes. Par exemple, dans l’expression x +
2, x et 2 sont des opérandes et + est un opérateur.
Les fonctions sont des blocs de code réutilisables qui peuvent recevoir des paramètres et renvoyer
une valeur. Pour plus d’informations, consultez Création de fonctions, page 53.
Les identifiants sont des noms utilisés pour indiquer une variable, une propriété, un objet, une
fonction ou une méthode. Le premier caractère doit être une lettre, un trait de soulignement (_)
ou un dollar ($). Chaque caractère qui suit doit être une lettre, un chiffre, un trait de
soulignement ou un dollar. Par exemple, prénom est le nom d’une variable.
Les occurrences sont des objets qui appartiennent à une certaine classe. Chaque occurrence
d’une classe contient toutes les propriétés et les méthodes de cette classe. Par exemple, tous les
clips sont des occurrences de la classe MovieClip, vous pouvez alors utiliser n’importe quelle
méthode ou propriété de la classe MovieClip avec n’importe quelle occurrence de clip.
Les noms d’occurrence sont des noms uniques qui vous permettent de cibler des occurrences de
clip et de bouton dans les scripts. L’inspecteur des propriétés permet d’affecter des noms aux
occurrences présentes sur la scène. Par exemple, un symbole principal de la bibliothèque pourrait
s’appeler compteur et les deux occurrences de ce symbole dans le fichier SWF pourraient avoir
comme noms d’occurrence scoreJoueur1_mc et scoreJoueur2_mc. Le code suivant définit une
variable appelée score à l’intérieur de chaque occurrence de clip en utilisant le nom des
occurrences :
_root.scorePlayer1_mc.score += 1;
_root.scorePlayer2_mc.score -= 1;
Vous pouvez utiliser des suffixes spéciaux lors de l’affectation d’un nom à une occurrence, afin que
des conseils de code (consultez Utilisation de conseils de code, page 66) s’affichent lorsque vous
tapez du code. Pour plus d’informations, consultez Utilisation de suffixes pour déclencher des
conseils de code, page 64.
Les mots-clés sont des mots réservés avec une signification particulière. Par exemple, var est un
mot-clé utilisé pour déclarer des variables locales. Vous ne pouvez pas utiliser un mot-clé comme
identificateur. Par exemple, var n’est pas un nom de variable légal. Pour obtenir une liste des
mots-clés, consultez Mots-clés, page 35.
Les méthodes sont des fonctions associées à une classe. Par exemple, getBytesLoaded() est une
méthode intégrée associée à la classe MovieClip. Vous pouvez aussi créer des fonctions qui agissent
ensuite comme des méthodes pour les objets basés sur les classes intégrées ou sur les classes que
vous créez. Par exemple, dans le code suivant, clear() devient une méthode d’un objet
contrôleur que vous avez précédemment défini :
function reset(){
this.x_pos = 0;
this.x_pos = 0;
}
contrôleur.clear = reset;
contrôleur.clear();
Les objets sont des groupes de propriétés et méthodes, chaque objet ayant son propre nom et
étant une occurrence d’une classe particulière. Les objets intégrés sont prédéfinis dans le langage
ActionScript. Par exemple, l’objet intégré Date fournit des informations provenant de l’horloge
système. Syntaxe 31
Les opérateurs sont des termes qui calculent une nouvelle valeur à partir d’une ou de plusieurs
valeurs. Par exemple, l’opérateur d’addition (+) additionne deux ou plusieurs valeurs pour en
obtenir une nouvelle. Les valeurs manipulées par les opérateurs sont appelées opérandes.
Les paramètres, également appelés arguments, sont des espaces réservés qui vous permettent de
transmettre des valeurs aux fonctions. Par exemple, la fonction bienvenue() suivante, utilise
deux valeurs qu’elle reçoit dans les paramètres prénom et hobby :
function bienvenue(prénom, hobby) {
texteDeBienvenue = "Bonjour " + prénom + "Votre hobby est : " + hobby;
}
Les paquets sont des répertoires qui contiennent un ou plusieurs fichiers de classe et résident
dans un répertoire de chemin de classe désigné (consultez Compréhension du chemin de classe,
page 175).
Les propriétés sont des attributs qui définissent un objet. Par exemple, _visible est une
propriété de tous les clips qui définit si ceux-ci sont visibles ou masqués.
Les chemins cibles sont des adresses hiérarchiques de noms d’occurrences de clips, de variables et
d’objets d’un fichier SWF. Les occurrences de clips sont nommées dans l’inspecteur des propriétés
des clips correspondants. Le scénario principal porte toujours le nom _root. Vous pouvez utiliser
un chemin cible pour réaliser une action sur un clip ou pour obtenir ou définir la valeur d’une
variable. Par exemple, l’instruction suivante est le chemin cible de la variable volume dans le clip
contrôleStéréo :
_root.contrôleStéréo.volume
Pour plus d’informations sur les chemins cibles, consultez Chemins cibles absolus et relatifs dans le
guide Utilisation de Flash de l’aide.
Les variables sont des identifiants qui contiennent des valeurs de n’importe quel type de données.
Les variables peuvent être créées, modifiées et mise à jour. Vous pouvez récupérer les valeurs
qu’elles contiennent et les utiliser dans des scripts. Dans l’exemple suivant, les identifiants situés à
gauche du signe égal sont des variables :
var x = 5;
var name = "Lolo";
var c_color = new Color(mcinstanceName);
Pour plus d’informations sur les variables, consultez A propos des variables, page 43.
Syntaxe
Comme dans tout langage, ActionScript implique des règles syntaxiques à respecter pour créer des
scripts pouvant être compilés et exécutés correctement. Cette section décrit les éléments de
syntaxe ActionScript.
Hauteur de casse
Dans un langage de programmation sensible à la casse, les noms de variable qui diffèrent
uniquement par leur casse (livre et Livre) ne sont pas considérés comme identiques. Par
conséquent, il est toujours judicieux d’employer les majuscules et les minuscules selon des
conventions fixes, comme celles utilisées dans cet ouvrage, car cela permet d’identifier plus
facilement les noms des fonctions et des variables dans le code ActionScript. 32 Chapitre 2 :  Notions de base du langage ActionScript
Lorsque vous publiez des fichiers pour Flash Player 7 ou une version ultérieure, Flash implémente
la sensibilité à la casse que vous utilisiez ActionScript 1 ou ActionScript 2.0. Cela signifie que les
mots-clés, noms de classe, variables, noms de méthode etc. sont tous sensibles à la casse. Par
exemple :
// Dans un fichier ciblant Flash Player 7
// et dans ActionScript 1 ou ActionScript 2.0
//
// Définit les propriétés de deux objets différents
chat.hilite = true;
CHAT.hilite = true;
// Crée trois variables différentes
var maVar=10;
var mavar=10;
var mAvAr=10;
// Ne génère pas d’erreur
var tableau = new Array();
var date = new Date();
Cette modification a également des répercussions sur les variables externes chargées via
LoadVars.load().
En outre, la sensibilité à la casse est implémentée pour les scripts externes, tels que les scripts ou les
fichiers de classe ActionScript 2.0 que vous importez en utilisant la commande #include. Si vous
publiez des fichiers pour Flash Player 7 et avez préalablement créé des fichiers externes que vous
ajoutez à vos scripts via l’instruction #include, vous devez passer chacun d’eux en revue pour
vous assurer que la casse est correcte. Pour ce faire, ouvrez le fichier dans la Fenêtre de script (Flash
Professionnel uniquement) ou, dans un nouveau fichier FLA, réglez vos paramètres de
publication sur Flash Player 7 et copiez le contenu du fichier dans le panneau Actions. Utilisez
ensuite le bouton Vérifier la syntaxe (consultez Vérification de la syntaxe et de la ponctuation,
page 69) ou publiez votre fichier. Les erreurs dues à des conflits de noms sont signalées dans le
panneau de sortie.
Lorsque la coloration de la syntaxe est activée, les éléments du langage dont la casse est correcte
sont affichés en bleu par défaut. Pour plus d’informations, consultez Mots-clés, page 35, et Mise en
évidence de la syntaxe, page 63.
Syntaxe pointée
Dans ActionScript, un point (.) est utilisé pour indiquer les propriétés ou les méthodes associées
à un objet ou à un clip. Il est également utilisé pour identifier le chemin cible d’un clip, d’une
variable, d’une fonction ou d’un objet. Une expression en syntaxe à point commence par le nom
de l’objet ou du clip suivi d’un point et se termine par l’élément que vous souhaitez spécifier.
Par exemple, la propriété _x d’un clip indique la position sur l’axe x du clip sur la scène.
L’expression balleMC._x fait référence à la propriété _x de l’occurrence de clip balleMC.
Dans un autre exemple, envoyer est une variable définie dans le clip formulaire, qui est
imbriqué dans le clip panier. L’expression panier.formulaire.envoyer = true définit la
variable envoyer du formulaire de l’occurrence sur true.
L’expression d’une méthode d’un objet ou clip se fait selon le même schéma. Par exemple, la
méthode play() de l’occurrence de clip balle_mc déplace la tête de lecture dans le scénario de
balle_mc, comme indiqué dans l’instruction suivante :
balle_mc.play();Syntaxe 33
La syntaxe pointée utilise également deux alias spéciaux, _root et _parent. L’alias _root fait
référence au scénario principal. Vous pouvez utiliser l’alias _root pour créer un chemin cible
absolu. Par exemple, l’instruction suivante appelle la fonction constructPlateau() dans le clip
fonctions du scénario principal :
_root.fonctions.constructPlateau();
Vous pouvez utiliser l’alias _parent pour faire référence à un clip dans lequel est imbriqué l’objet
courant. Vous pouvez également utiliser _parent pour créer un chemin cible relatif. Par exemple,
si le clip chien_mc est imbriqué dans le clip animal_mc, l’instruction suivante de l’occurrence
chien_mc indique à animal_mc de s’arrêter :
_parent.stop();
Syntaxe à barre oblique
La syntaxe à barre oblique était utilisée dans Flash 3 et 4 pour indiquer le chemin cible d’un clip
ou d’une variable. Cette syntaxe est toujours supportée dans Flash Player 7, mais son utilisation
n’est pas recommandée. La syntaxe à barre oblique n’est pas supportée dans ActionScript 2.0.
Toutefois, si vous créez du contenu destiné spécialement à Flash Player 4, vous devrez utiliser la
syntaxe à barre oblique. Pour plus d’informations, consultez Utilisation de la syntaxe à barre
oblique, page 789.
Accolades
Les gestionnaires d’événement, les définitions de classe et les fonctions ActionScript sont
regroupés en blocs délimités par des accolades ({}). Vous pouvez placer l’accolade ouvrante sur la
même ligne que la déclaration ou sur la ligne suivante, comme illustré dans les exemples ci-
dessous. Pour améliorer la lisibilité du code, il est préférable de choisir un format et de s’y tenir.
//Gestionnaire d’événement
on (release) {
maDate = new Date();
moisCourant = maDate.getMonth();
}
on(release)
{
maDate = new Date();
moisCourant = maDate.getMonth();
}
// Classe
class Circle(radius) {
}
class Square(side)
{
}
//Fonction
circleArea = function(radius) {
return radius * radius * MATH.PI;
}
squareArea = function(side)
{
return side * side;
}34 Chapitre 2 :  Notions de base du langage ActionScript
Vous pouvez contrôler qu’il ne manque pas d’accolades dans vos scripts ; consultez Vérification de
la syntaxe et de la ponctuation, page 69.
Points-virgules
Une instruction ActionScript se termine par un point-virgule (, comme dans les exemples
suivants :
var colonne = dateTransmise.getDay();
var ligne    = 0;
L’omission du point-virgule final n’empêche pas Flash de compiler le script correctement.
Cependant, l’emploi de points-virgules est une bonne habitude à prendre lors de la rédaction de
scripts.
Parenthèses
Lorsque vous définissez une fonction, placez les paramètres entre parenthèses :
function maFonction (nom, âge, lecteur){
// entrez votre code ici
}
Lorsque vous appelez une fonction, incluez tous les paramètres transmis à la fonction entre
parenthèses, comme suit :
maFonction ("Steve", 10, true);
Vous pouvez également utiliser les parenthèses pour supplanter l’ordre de priorité d’ActionScript
ou pour faciliter la lecture des instructions ActionScript. Pour plus d’informations, consultez
Priorité et associativité des opérateurs, page 47.
Les parenthèses servent également à évaluer une expression située à gauche d’un point dans la
syntaxe pointée. Par exemple, dans l’instruction suivante, les parenthèses obligent à l’évaluation de
new Color(this) et à la création d’un objet Color :
onClipEvent(enterFrame){
(new Color(this)).setRGB(0xffffff);
}
Si vous n’utilisez pas de parenthèses, vous devez ajouter une instruction pour évaluer l’expression :
onClipEvent(enterFrame){
maCouleur = new Color(this);
maCouleur.setRGB(0xffffff);
}
Vous pouvez contrôler qu’il ne manque pas de parenthèses dans vos scripts ; consultez Vérification
de la syntaxe et de la ponctuation, page 69.
Commentaires
Il est vivement recommandé d’utiliser des commentaires pour ajouter des notes aux scripts. Les
commentaires sont particulièrement utiles pour consigner vos intentions et transmettre des
informations à d’autres développeurs (si vous travaillez en équipe ou si vous fournissez des
échantillons). Même un script simple est plus facile à comprendre si vous l’annotez lors de sa
création.
Pour indiquer qu’une ligne ou portion de ligne est un commentaire, faites-la précéder de deux
barres obliques(//):Syntaxe 35
on (release) {
// créer un nouvel objet Date
maDate = new Date();
moisCourant = maDate.getMonth();
// convertir le chiffre du mois en son nom
nomDuMois = calcMois(moisCourant);
année = maDate.getFullYear();
dateDuJour = maDate.getDate();
}
Lorsque la coloration de la syntaxe est activée (consultez Mise en évidence de la syntaxe, page 63),
les commentaires apparaissent en gris, par défaut. Les commentaires peuvent avoir n’importe
quelle longueur sans que cela affecte la taille du fichier exporté. Ils ne suivent aucune règle de
syntaxe ou de mots-clés relative à ActionScript.
Si vous souhaitez appliquer un commentaire à une portion complète de script, intégrez-le dans un
bloc de commentaire plutôt que de devoir ajouter // au début de chaque ligne. Cette technique
est plus simple et plus pratique, surtout lorsque vous souhaitez tester uniquement certaines parties
d’un script en en commentant de grandes parties.
Pour créer un bloc de commentaire, entrez /* au début du commentaire, puis */ à la fin. Par
exemple, lorsque le script suivant est exécuté, le code intégré dans le bloc de commentaire n’est pas
exécuté :
// Le code ci-dessous est exécuté
var x:Number = 15;
var y:Number = 20;
// Le code ci-dessous ne s’exécute pas
/*
on (release) {
// créer un nouvel objet Date
maDate = new Date();
moisCourant = maDate.getMonth();
// convertir le chiffre du mois en son nom
nomDuMois = calcMois(moisCourant);
année = maDate.getFullYear();
dateDuJour = maDate.getDate();
}
*/
// Le code ci-dessous est exécuté
var nom:String = "Je m’appelle";
var âge:Number = 20;
Mots-clés
ActionScript réserve certains mots à des usages spécifiques au sein du langage et vous ne pouvez
pas vous en servir comme identifiants (noms de variable, de fonction, d’étiquette, etc.). Le tableau
suivant répertorie tous les mots-clés ActionScript :
break case classe continue
default delete dynamic else
extends for function get
if implements import in
instanceof interface intrinsic new
private public return set36 Chapitre 2 :  Notions de base du langage ActionScript
Constantes
Une constante est une propriété dont la valeur ne varie jamais.
Par exemple, les constantes BACKSPACE, ENTER, QUOTE, RETURN, SPACE et TAB sont des propriétés
de l’objet Key et font référence aux touches du clavier. Pour savoir si un utilisateur appuie sur la
touche Entrée, vous pourriez utiliser l’instruction suivante :
if(Key.getCode() == Key.ENTER) {
alert = "Etes-vous prêt(e) ?";
controlMC.gotoAndStop(5);
}
A propos des types de données
Un type de données décrit le genre d’informations qu’une variable ou qu’un élément ActionScript
peut contenir. Il existe deux sortes de types de données intégrées dans Flash : primitives et de
référence. Les données primitives (chaîne, nombre et booléen) ont une valeur constante et
peuvent donc contenir la valeur réelle de l’élément qu’elles représentent. Les données de référence
(clip et objet) possèdent des valeurs qui peuvent changer et contiennent donc des références à la
valeur réelle de l’élément. Les variables contenant des données primitives ont un comportement
différent de celles contenant des références dans certaines situations. Pour plus d’informations,
consultez Utilisation des variables dans un programme, page 45. Il existe également deux types
spéciaux de données : null et undefined.
Dans Flash, tout objet intégré qui n’est pas une donnée primitive, ni une donnée de clip, telle que
Array ou Math, est une donnée d’objet.
Chaque type de données possède ses propres règles et est décrit sous les rubriques suivantes :
• String, page 37
• Number, page 37
• Boolean, page 38
• Objet, page 38
• MovieClip, page 38
• Null, page 39
• Undefined, page 39
Lorsque vous déboguez des scripts, vous pouvez avoir besoin de déterminer le type de données
d’une expression ou d’une variable pour comprendre pourquoi elle se comporte de telle manière.
Vous pouvez effectuer cette opération avec l’opérateur typeof (consultez Définition du type de
données d’un objet, page 39).
Vous pouvez convertir un type de données en un type différent en utilisant l’une des fonctions de
conversion suivantes : Array(), Boolean(), Number, Objet(), String. 
static switch this typeof
var void while withA propos des types de données 37
String
Une chaîne est une séquence de caractères (lettres, chiffres et signes de ponctuation, par exemple).
Vous insérez des chaînes dans une instruction ActionScript en les plaçant entre des guillemets
droits simples ou doubles. Les chaînes sont traitées comme des caractères et non comme des
variables. Par exemple, dans l’instruction suivante, "L7" est une chaîne :
groupePréféré = "L7";
Vous pouvez utiliser l’opérateur d’addition (+) pour concaténer, ou joindre, deux chaînes.
ActionScript traite les espaces au début ou à la fin d’une chaîne comme faisant partie de la chaîne.
L’expression suivante contient un espace après la virgule :
salutations = "Bonjour, " + prénom;
Pour inclure un guillemet dans une chaîne, il faut le faire précéder d’une barre oblique inverse (\).
Cette opération s’appelle échapper un caractère. D’autres caractères ne peuvent pas être représentés
dans ActionScript sans l’emploi de séquences d’échappement particulières. Le tableau suivant
répertorie l’ensemble des caractères d’échappement d’ActionScript:
Number
Le type de données Number correspond à un nombre à virgule flottante à double précision. Vous
pouvez manipuler les nombres avec les opérateurs arithmétiques d’addition (+), de soustraction (-),
de multiplication (*), de division (/), de modulo (%), d’incrémentation (++) et de
décrémentation (--). Vous pouvez également utiliser des méthodes des classes intégrées Math et
Number pour manipuler les nombres. L’exemple suivant utilise la méthode sqrt() (racine carrée)
pour renvoyer la racine carrée de 100 : 
Math.sqrt(100);
Pour plus d’informations, consultez Opérateurs numériques, page 48.
Séquence
d’échappement
Caractère
\b Caractère de retour arrière (ASCII 8)
\f Caractère de changement de page (ASCII 12)
\n Caractère de changement de ligne (ASCII 10)
\r Caractère de retour chariot (ASCII 13)
\t Caractère de tabulation (ASCII 9)
\" Guillemet droit double
\’ Guillemet droit simple
\\ Barre oblique inverse
\000 - \377 Un octet spécifié en octal
\x00 - \xFF Un octet spécifié en hexadécimal
\u0000 - \uFFFF Un caractère Unicode 16 bits spécifié en hexadécimal38 Chapitre 2 :  Notions de base du langage ActionScript
Boolean
Une valeur booléenne est soit true (vraie), soit false (fausse). ActionScript convertit également
les valeurs true et false en 1 et 0 lorsque cela est nécessaire. Les valeurs booléennes sont le plus
souvent utilisées dans les instructions ActionScript effectuant des comparaisons pour contrôler le
déroulement d’un script. Par exemple, dans le script suivant, le fichier SWF est lu si la variable
motDePasse est vraie (true):
onClipEvent(enterFrame){
if (nomDutilisateur == true && motDePasse == true){
play();
}
}
Consultez Utilisation de fonctions intégrées, page 53, et Opérateurs logiques, page 49.
Objet
Un objet est une collection de propriétés. Chaque propriété possède un nom et une valeur. La
valeur d’une propriété peut être de n’importe quel type de données Flash, même un type de
données Object. Cela vous permet d’arranger les objets les uns dans les autres, ou de les imbriquer.
Pour spécifier les objets et leurs propriétés, vous devez utiliser l’opérateur point (.). Par exemple,
dans le code suivant, heuresTravaillées est une propriété de statsHebdo, qui est une propriété
de personnel :
personnel.statsHebdo.heuresTravaillées
Vous pouvez utiliser les objets ActionScript intégrés pour localiser et manipuler certains types
d’informations spécifiques. Par exemple, l’objet Math possède des méthodes qui effectuent des
opérations mathématiques sur les nombres que vous leur transmettez. Cet exemple utilise la
méthode sqrt() :
racineCarrée = Math.sqrt(100);
L’objet ActionScript MovieClip possède des méthodes qui vous permettent de contrôler les
occurrences de symbole de clip sur la scène. Cet exemple utilise les méthodes play() et
nextFrame() :
nomDoccurrenceMC.play();
nomDoccurrenceMC2.nextFrame();
Vous pouvez aussi créer des objets personnalisés pour organiser les informations dans votre
application Flash. Pour ajouter de l’interactivité à votre application avec ActionScript, vous aurez
besoin d’un certain nombre d’informations : un nom d’utilisateur, la vitesse d’une balle, les noms
des objets contenus dans un panier, le nombre d’images chargées, le code postal de l’utilisateur et
la dernière touche utilisée, par exemple. La création d’objets personnalisés vous permet
d’organiser ces informations dans des groupes, de simplifier la rédaction et de réutiliser vos scripts.
MovieClip 
Les clips sont des symboles qui peuvent lire des effets animés dans une application Flash. Ils sont
le seul type de données faisant référence à un élément graphique. Le type de données MovieClip
vous permet de contrôler les symboles de clip au moyen des méthodes de la classe MovieClip.
Vous appelez les méthodes en utilisant l’opérateur point (.), comme ci-dessous :
mon_mc.startDrag(true);
parent_mc.getURL("http://www.macromedia.com/support/" + produit);Affectation de types de données aux éléments 39
Null
Le type de données nul ne possède qu’une valeur, null. Cette valeur signifie en fait « pas de
valeur », c’est-à-dire une absence de données. La valeur null peut être utilisée dans diverses
situations. En voici quelques exemples :
• Pour indiquer qu’une variable n’a pas encore reçu de valeur.
• Pour indiquer qu’une variable ne contient plus de valeur.
• En tant que valeur de retour d’une fonction, afin d’indiquer qu’aucune valeur n’a pu être
retournée par la fonction.
• En tant que paramètre d’une fonction, afin d’indiquer qu’un paramètre est omis.
Undefined
Le type de données undefined ne possède qu’une valeur, undefined, et est utilisé pour les
variables auxquelles aucune valeur n’a été affectée.
Définition du type de données d’un objet
Lors du test et du débogage de vos programmes, des problèmes liés aux types de données peuvent
se produire. Dans ce cas, il peut être souhaitable de déterminer le type de données d’un objet.
Pour ce faire, utilisez l’opérateur typeof, comme dans l’exemple suivant :
trace(typeof(nomDeVariable));
Pour plus d’informations sur le test et le débogage, consultez le Chapitre 3, Rédaction et débogage
de scripts, page 57.
Affectation de types de données aux éléments
Flash affecte automatiquement les types de données aux éléments de langage suivants, comme
indiqué dans la section suivante, Typage des données automatique :
• Variables
• Paramètres transmis à une fonction, à une méthode ou à une classe
• Valeurs renvoyées d’une fonction ou d’une méthode
• Objets créés comme sous-classes de classes existantes
Vous pouvez également affecter explicitement des types de données aux éléments, ce qui peut vous
aider à éviter ou diagnostiquer certaines erreurs dans vos scripts. Pour plus d’informations,
consultez Typage strict des données, page 40.
Typage des données automatique
Dans Flash, il n’est pas nécessaire de définir explicitement un élément comme contenant un
nombre, une chaîne ou un autre type de données. Flash détermine le type de données d’un
élément lorsque celui est affecté :
var x = 3;
Dans l’expression var x = 3, Flash évalue l’élément à droite de l’opérateur et détermine qu’il
s’agit du type de données nombre. Une affectation ultérieure pourra changer le type de x. Par
exemple, l’instruction x = "bonjour" change le type de x en chaîne. Une variable à laquelle
aucune valeur n’a été affectée est du type undefined.40 Chapitre 2 :  Notions de base du langage ActionScript
ActionScript convertit automatiquement les types de données lorsqu’une expression le nécessite.
Par exemple, lorsque vous transmettez une valeur à l’action trace(), trace() convertit
automatiquement la valeur en chaîne et l’envoie au panneau de sortie. Dans les expressions avec
opérateurs, ActionScript convertit les types de données en fonction des besoins, par exemple, lors
de l’utilisation dans une chaîne, l’opérateur + s’attend à ce que l’autre opérande soit une chaîne.
"Suivant : le numéro " + 7
ActionScript convertit le chiffre 7 en chaîne "7" et l’ajoute à la fin de la première chaîne, ce qui
aboutit à la chaîne suivante :
"Suivant : le numéro 7"
Typage strict des données
ActionScript 2.0 vous permet de déclarer explicitement le type d’objet d’une variable lorsque vous
la créez, ce qui est appelé typage strict. Les incompatibilités de type de données déclenchent des
erreurs de compilation, le typage strict vous permet donc d’éviter d’affecter un type de données
incorrect à une variable existante. Pour affecter un type de données spécifique à un élément,
spécifiez son type à l’aide d’une syntaxe utilisant le mot-clé var ainsi que deux points :
// typage strict de variable ou objet
var x:Number = 7;
var anniversaire:Date = new Date();
// typage strict de paramètres
function welcome(firstName:String, age:Number){
}
// typage strict de paramètre et de valeur renvoyée
function square(x:Number):Number {
var squared = x*x;
return squared;
}
Etant donné que vous devez utiliser le mot-clé var pour le typage strict des variables, vous ne
pouvez pas définir strictement le type d’une variable globale (consultez Domaine et déclaration de
variables, page 44). 
Vous pouvez typer des objets en fonction des classes intégrées (Button, Date, MovieClip, etc.) et
des classes et interfaces que vous créez. Par exemple, vous avez un fichier qui s’appelle Etudiant.as
dans lequel vous avez défini une classe Etudiant, vous pouvez spécifier que les objets que vous
créez sont de type Etudiant :
var étudiant:Student = new Student();
Vous pouvez également spécifier que les objets sont de type Function ou Void.
L’utilisation du typage strict vous empêche d’affecter, par inadvertance, un type de valeur
incorrect à un objet. Flash recherche les incompatibilités de type au moment de la compilation.
Par exemple, supposons que vous tapez ce qui suit :
// dans le fichier de classe Etudiant.as
class Etudiant {
var status:Boolean; // propriété des objets Etudiant
}
// dans un script
var étudiantMarieLago:Student = new Student();
étudiantMarieLago.status = "inscrite";Affectation de types de données aux éléments 41
Lorsque Flash compile ce script, une erreur « Incompatibilité de types » se produit.
Un des autres avantages du typage strict des données réside dans le fait que Flash MX 2004 affiche
automatiquement des conseils de code pour les objets intégrés que vous typez strictement. Pour
plus d’informations, consultez Typage strict des objets pour déclencher des conseils de code, page 64.
Les fichiers publiés à l’aide d’ActionScript 1 ne respectent pas les affectations de typage strict des
données lors de la compilation. Ainsi, l’affectation du mauvais type de valeur à une variable que
vous avez strictement typée ne génère pas d’erreur de compilation.
var x:String = "abc"
x = 12 ; // aucune erreur dans ActionScript 1, erreur de compatibilité de type
dans ActionScript 2
Ceci est dû au fait que lorsque vous publiez un fichier pour ActionScript 1, Flash interprète une
instruction telle que var x:String = "abc" comme une syntaxe à barre oblique et non comme
un typage strict. (ActionScript 2.0 ne supporte pas la syntaxe à barre oblique.) Il peut alors en
résulter un objet affecté à une variable de type erroné. Le compilateur autorise alors que des appels
de méthodes illégaux et que des références de propriété non définies passent sans être signalés.
Ainsi, si vous implémentez le typage strict de données, assurez-vous de publier les fichiers pour
ActionScript 2.0.
Attribution d’objets
ActionScript 2.0 vous permet d’attribuer un type de données à un autre. L’opérateur d’attribution
utilisé par Flash se présente sous la forme d’un appel de fonction et concorde avec la coercition
explicite, telle qu’elle est définie dans la norme ECMA-262 version 4. L’attribution vous permet
d’affirmer qu’un objet est d’un type spécifique de telle sorte que, lors de la vérification du type, le
compilateur considère que l’objet est doté de propriétés absentes du type d’origine. Ceci peut
s’avérer utile, par exemple, lors de l’itération sur un tableau d’objets pouvant être de types
différents.
Dans les fichiers publiés pour Flash Player 7 ou une version ultérieure, les instructions
d’attribution qui échouent à l’exécution renvoient null. Dans les fichiers publiés pour Flash
Player 6, les attributions ayant échouées ne sont pas supportées à l’exécution.
La syntaxe d’attribution est type(élément) : le compilateur doit se comporter comme si le type
de données de élément était type. L’attribution est essentiellement un appel de fonction, et
l’appel de fonction renvoi null si l’attribution échoue. Si l’attribution réussit, l’appel de fonction
renvoie l’objet original. Toutefois, le compilateur ne génère pas d’erreurs d’incompatibilité de type
lorsque vous attribuez des éléments à des types de données que vous avez créés dans des fichiers de
classe externes, même si l’attribution échoue à l’exécution.
// dans Animal.as
class Animal {}
// dans Chien.as
class Chien extends Animal { function aboie (){} }
// dans Chat.as
class Chat extends Animal { function miaule (){} }
// dans le fichier FLA
var spot:Chien = new Chien();   42 Chapitre 2 :  Notions de base du langage ActionScript
var temp:Chat = Chat (spot);  // affirme qu’un objet Chien est de type Chat
temp.miaou(); // n’a aucun effet et n’entraîne pas d’erreur de compilation non
plus
Dans cette situation, vous avez indiqué au compilateur que temp est un objet Chat, et le
compilateur suppose donc que temp.miaou() est une instruction légale. Toutefois, le compilateur
ne sait pas que l’attribution échouera (c’est-à-dire que vous avez essayé d’attribuer un objet Chien
à un type Chat), et aucune erreur de compilation ne se produit. Si vous incorporez une
vérification dans votre script de manière à vous assurer que l’attribution réussit, vous pouvez
trouver des erreurs d’incompatibilité de types à l’exécution.
var spot:Chien = new Chien();
var temp:Chat = Chat (spot);
trace(temp);  //affiche null à l’exécution
Vous pouvez attribuer une expression à une interface. Si l’expression est un objet qui implémente
l’interface, ou si elle possède une classe de base qui implémente l’interface, l’objet est renvoyé.
Sinon, null est renvoyé.
L’exemple suivant montre les résultats de l’attribution de types d’objet intégrés. Comme le montre
la première ligne du bloc with(results), une attribution illégale (dans le cas présent,
l’attribution d’une chaîne à un clip) renvoie null. Comme le montrent les deux dernières lignes,
l’attribution vers null ou undefined renvoie undefined.
var mc:MovieClip;
var tab:Array;
var bool:Boolean;
var num3:Number;
var obj:Object;
var str:String;
_root.createTextField("results",2,100,100,300,300);
with(results){
text = "type MovieClip : "+(typeof MovieClip(str));     // renvoie null
text += "\ntype object : "+(typeof Object(str));        // renvoie object
text += "\ntype Array : "+(typeof Array(num3));         // renvoie object
text += "\ntype Boolean : "+(typeof Boolean(mc));       // renvoie boolean
text += "\ntype String : "+(typeof String(mc));         // renvoie string
text += "\ntype Number : "+(typeof Number(obj));        // renvoie number
text += "\ntype Function : "+(typeof Function(mc));     // renvoie object
text += "\ntype null : "+(typeof null(arr));            // renvoie undefined
text += "\ntype undefined : "+(typeof undefined(obj));  // renvoie undefined
}
//Résultats dans le panneau de sortie
type MovieClip : null
type object : objet
type Array : object
type Boolean : boolean
type String : string
type Number : number
type Function : object
type null : undefined
type undefined : undefined
Vous ne pouvez pas supplanter les types de données primitifs tels que Boolean, Date et Number
par un opérateur d’attribution du même nom. A propos des variables 43
A propos des variables
Une variable est un conteneur qui stocke des informations. Le conteneur reste toujours le même,
c’est le contenu qui peut varier. La modification de la valeur d’une variable pendant la lecture du
fichier SWF permet d’enregistrer les informations relatives aux actions de l’utilisateur,
d’enregistrer les valeurs modifiées pendant la lecture du fichier SWF ou d’évaluer si une condition
est true ou false.
Il est toujours judicieux d’affecter une valeur connue à une variable que vous définissez pour la
première fois. Cette opération, appelée initialisation de la variable, est souvent effectuée dans la
première image du fichier SWF. Elle facilite le suivi et la comparaison de la valeur de la variable
pendant la lecture du fichier SWF.
Les variables peuvent contenir tous les types de données (consultez A propos des types de données,
page 36). Le type de données contenu dans une variable affecte la façon dont est modifiée la
valeur de la variable lorsqu’elle est affectée à un script.
Les types d’informations standard que vous pouvez stocker dans une variable sont les URL, les
noms d’utilisateur, les résultats d’opérations mathématiques, le nombre de fois qu’un événement
s’est produit ou si un bouton a été actionné. Chaque fichier SWF et chaque occurrence de clip
dispose d’un jeu de variables, dont la valeur est indépendante des variables figurant dans d’autres
fichiers SWF ou clips.
Pour tester la valeur d’une variable, utilisez l’action trace() pour envoyer la valeur au panneau de
sortie. Par exemple, trace(heuresTravaillées) envoie la valeur de la variable
heuresTravaillées au panneau de sortie en mode de test. Vous pouvez également vérifier et
définir les valeurs des variables dans le débogueur en mode de test. Pour plus d’informations,
consultez Utilisation de l’instruction trace, page 82, et Affichage et modification de variables,
page 74.
Affectation d’un nom à une variable
Le nom des variables doit suivre les règles suivantes :
• Il doit s’agir d’un identifiant (consultez Te rmi n o l o g i e, page 28).
• Il ne peut pas s’agir d’un mot-clé ni d’un littéral ActionScript, tel que true, false, null ou
undefined.
• Il doit être unique dans son domaine (consultez Domaine et déclaration de variables, page 44).
Par ailleurs, n’utilisez pas les éléments du langage ActionScript comme noms de variable : cela
donnerait lieu à des erreurs de syntaxe ou à des résultats inattendus. Si vous appelez une variable
String, par exemple, puis tentez de créer un objet String au moyen de new String(), le nouvel
objet n’est pas défini.
bonjour_str = new String();
trace(bonjour_str.length); // renvoie 0
String = "bonjour"; // Attribution du nom d’une classe intégrée à une variable
bonjour_str = new String();
trace(bonjour_str.length); // renvoie undefined
L’éditeur ActionScript prend en charge les conseils de code pour les classes intégrées et pour les
variables basées sur ces classes. Si vous souhaitez obtenir des conseils de code pour un type d’objet
particulier affecté à une variable, vous pouvez définir strictement le type de cette dernière ou la
nommer en utilisant un suffixe spécial. 44 Chapitre 2 :  Notions de base du langage ActionScript
Par exemple, supposons que vous tapez ce qui suit :
var membres:Array = new Array();
membres.
Dès que vous tapez le point (.), Flash affiche la liste des méthodes et propriétés disponibles pour
les objets Array. Pour plus d’informations, consultez Rédaction de code qui déclenche des conseils de
code, page 64.
Domaine et déclaration de variables
Le domaine d’une variable fait référence au domaine dans lequel la variable est connue et peut être
référencée. Il existe trois types de domaine de variable dans ActionScript :
• Les variables locales sont disponibles dans le corps de la fonction dans lequel elles sont déclarées
(délimité par des accolades).
• Les variables de scénario sont disponibles pour tout script dans ce scénario.
• Les variables globales et les fonctions sont visibles par tout scénario et domaine du document.
Remarque : Les classes ActionScript 2.0 que vous créez supportent des domaines de variables
publics, privés et statiques. Pour plus d’informations, consultez Contrôle de l’accès des membres,
page 170, et Création des membres de classe, page 172.
Les variables locales
Pour déclarer des variables locales, utilisez l’instruction var dans le corps de la fonction. Une
variable locale a un domaine limité au bloc et expire à la fin du bloc. Une variable locale qui n’est
pas déclarée dans un bloc expire à la fin de son script.
Par exemple, les variables i et j sont souvent utilisées comme compteurs de boucles. Dans
l’exemple suivant, i est utilisée comme variable locale et existe uniquement dans la fonction
constructJours() :
function constructJours() {
var i;
for( i = 0; i < tableauDeMois[month]; i++ ) {
_root.Jours.attachMovie( "affichageDesJours", i, i + 2000 );
_root.Jours[i].num = i + 1;
_root.Jours[i]._x = colonne * _root.Jours[i]._width;
_root.Jours[i]._y = ligne * _root.Jours[i]._height;
colonne = colonne + 1;
if (colonne == 7 ) {
colonne = 0;
ligne = ligne + 1;
}
}
}
Les variables locales permettent aussi d’empêcher les conflits de noms, qui peuvent donner lieu à
des erreurs dans une application. Par exemple, si vous créez la variable locale nom, vous pouvez
l’utiliser pour stocker un nom d’utilisateur dans un contexte et une occurrence de clip dans un
autre. Ces variables fonctionnant dans des domaines distincts, il n’y a pas de risques de conflits.A propos des variables 45
Il est toujours judicieux d’utiliser des variables locales dans le corps d’une fonction pour que celle-
ci puisse agir en tant que partie de code indépendante. Une variable locale n’est modifiable qu’au
sein de son propre bloc de code. Si une expression d’une fonction utilise une variable globale, un
élément extérieur peut modifier sa valeur, ce qui modifierait la fonction.
Vous pouvez affecter un type de données à une variable locale lorsque vous la définissez, ce qui
vous évite d’affecter un type de données erroné à une variable existante. Pour plus d’informations,
consultez Typage strict des données, page 40.
Les variables de scénario
Les variables de scénario sont disponibles pour tout script dans le scénario. Pour déclarer les
variables de scénario, initialisez-les sur n’importe quelle image du scénario. Veillez à initialiser la
variable avant de tenter d’y accéder dans un script. Si, par exemple, vous placez le code varx =
10 ; sur l’image 20, un script associé à une image précédant l’image 20 n’aura pas accès à cette
variable.
Les variables globales
Les variables et les fonctions globales sont visibles par tout scénario et domaine du document.
Pour créer une variable globale, faites précéder son nom de l’identifiant _global et n’utilisez pas
la syntaxe var =. Par exemple, le code suivant crée la variable globale monNom :
var _global.monNom = "George"; // erreur de syntaxe
_global.monNom = "George";
Toutefois, si vous initialisez une variable locale portant le même nom qu’une variable globale,
vous n’avez pas accès à cette dernière dans le domaine de la variable locale :
_global.compteur = 100;
compteur++;
trace(compteur); // affiche 101
function count(){
for( var compteur = 0; compteur <= 10 ; compteur++ ) {
trace(compteur); // affiche 0 à 10
}
}
count();
compteur++;
trace(compteur); // affiche 102
Utilisation des variables dans un programme
Vous devez déclarer une variable dans un script avant de pouvoir l’utiliser dans une expression. Si
vous utilisez une variable non déclarée, comme dans l’exemple suivant, elle prend la valeur NaN ou
undefined, et votre script est susceptible de générer des résultats inattendus :
var squared = x*x;
trace(squared); // NaN
var x = 6;
Dans l’exemple ci-dessous, l’instruction déclarant la variable x doit être placée en premier de sorte
que squared puisse être remplacée par une valeur.
var x = 6;
var squared = x*x;
trace(squared); // 3646 Chapitre 2 :  Notions de base du langage ActionScript
La même chose se produit lorsque vous transmettez une valeur non définie à une méthode ou à
une fonction :
getURL(onSiteWeb); // aucune action
var monSiteWeb = "http://www.macromedia.com";
var monSiteWeb = "http://www.macromedia.com";
getURL(monSiteWeb); // le navigateur affiche www.macromedia.com
Vous pouvez changer plusieurs fois la valeur d’une variable dans un script. Le type de données
contenu dans la variable affecte les conditions et le moment où la variable sera modifiée. Les types
primitifs de données, comme les chaînes et les nombres, sont transmis par valeur. Cela signifie que
le contenu réel de la variable est transmis à la variable.
Dans l’exemple suivant, x est défini sur 15 et cette valeur est copiée dans y. Lorsque x devient 30
à la ligne 3, la valeur de y reste 15 étant donné que y ne va pas chercher sa valeur dans x ; elle
contient la valeur de x qu’elle a reçu à la ligne 2.
var x = 15;
var y = x;
var x = 30;
Dans un autre exemple, la variable valeurEntrée contient une valeur primitive, 3, la valeur réelle
étant donc transmise à la fonction sqrt() et la valeur renvoyée étant 9 :
function sqrt(x){
return x * x;
}
var valeurEntrée = 3;
var Sortie = sqrt(valeurEntrée);
La valeur de la variable valeurEntrée ne change pas.
Le type de données objet peut contenir tant d’informations complexes qu’une variable de ce type
ne contient pas la valeur réelle, mais contient une référence à la valeur. Cette référence est un
« alias » qui désigne le contenu de la variable. Lorsque la variable a besoin de connaître sa valeur, la
référence demande le contenu et renvoie la réponse sans transférer la valeur à la variable.
Le code suivant est un exemple de transmission par référence :
var monTableau = ["tom", "josie"];
var nouveauTableau = monTableau;
monTableau[1] = "jack";
trace(nouveauTableau);
Le code ci-dessus crée un objet Array appelé monTableau qui contient deux éléments. La variable
nouveauTableau est créée et reçoit une référence à monTableau. La modification du deuxième
élément de monTableau affecte toutes les variables qui y font référence. L’action trace() envoie
tom, jack au panneau de sortie.
Dans l’exemple suivant, monTableau contient un objet Array qui est transmis à la fonction
tableauNul() par référence. La fonction tableauNu()l change le contenu du tableau en
monTableau.
function tableauNul(leTableau){
var i;
for (i=0; i < leTableau.length; i++) {
leTableau[i] = 0;
}
} Utilisation d’opérateurs pour manipuler les valeurs des expressions 47
var monTableau = new Array();
monTableau[0] = 1;
monTableau[1] = 2;
monTableau[2] = 3;
tableauNul(monTableau);
La fonction tableauNul() accepte un objet Array comme paramètre et définit tous les éléments
de ce tableau sur 0. Elle peut modifier ce tableau car il est transmis par référence.
Utilisation d’opérateurs pour manipuler les valeurs des
expressions
Une expression est une instruction que Flash pourra évaluer et qui renvoie une valeur. Pour créer
une expression, vous pouvez associer des opérateurs et des valeurs ou appeler une fonction.
Les opérateurs sont des caractères qui spécifient comment combiner, comparer ou modifier les
valeurs d’une expression. Les éléments sur lesquels les opérateurs agissent sont appelés opérandes.
Par exemple, dans l’instruction suivante, l’opérateur + additionne la valeur d’un littéral numérique
à la valeur de la variable truc; truc et 3 sont les opérandes :
truc + 3
Cette section décrit des règles générales au sujet de types courants d’opérateurs, de la priorité des
opérateurs et de leur associativité. Pour plus d’informations sur chaque opérateur, de même que
sur les opérateurs spéciaux n’appartenant pas à ces catégories, consultez les entrées du
Chapitre 12, Dictionnaire ActionScript Présentation, page 211.
Priorité et associativité des opérateurs
Lorsque deux opérateurs ou plus sont utilisés dans la même instruction, certains opérateurs sont
prioritaires par rapport à d’autres. ActionScript suit une hiérarchie précise pour déterminer les
opérateurs à exécuter en premier. Par exemple, une multiplication est toujours effectuée avant une
addition, les éléments entre parenthèses restant cependant prioritaires sur la multiplication. Donc,
sans parenthèses, ActionScript effectue la multiplication en premier, comme dans l’exemple
suivant :
total = 2 + 4 * 3;
Le résultat est 14.
Mais si l’addition est mise entre parenthèses, ActionScript effectue l’addition en premier :
total = (2 + 4) * 3;
Le résultat est 18.
Lorsque deux ou plusieurs opérateurs possèdent le même ordre de priorité, leur associativité
détermine l’ordre dans lequel ils sont exécutés. L’associativité peut aller de la gauche vers la droite,
comme de la droite vers la gauche. Par exemple, l’opérateur de multiplication a une associativité
gauche-droite et les deux instructions suivantes sont donc équivalentes :
total = 2 * 3 * 4;
total = (2 * 3) * 4;
Un tableau de tous les opérateurs, de leur ordre de priorité et de leur associativité, apparaît à
l’Annexe B, Priorité et associativité des opérateurs, page 779.48 Chapitre 2 :  Notions de base du langage ActionScript
Opérateurs numériques
Les opérateurs numériques additionnent, soustraient, multiplient, divisent et effectuent d’autres
opérations arithmétiques.
L’emploi le plus courant de l’opérateur d’incrémentation est i++ au lieu de l’opérateur i = i+1,
qui est plus long. L’opérateur d’incrémentation peut s’utiliser avant ou après une opérande. Dans
l’exemple suivant, âge est incrémenté en premier, puis à nouveau testé contre le nombre 30 :
if (++âge >= 30)
Dans l’exemple suivant, âge est incrémenté à la suite du test :
if (âge++ >= 30)
Le tableau suivant répertorie les opérateurs numériques d’ActionScript :
Opérateurs de comparaison
Les opérateurs de comparaison comparent les valeurs des expressions et renvoient une valeur
booléenne (true ou false). Ces opérateurs sont surtout utilisés dans les boucles et les
instructions conditionnelles. Dans l’exemple suivant, si la variable score correspond à 100, un
fichier SWF spécifique est chargé ; sinon, c’est un autre fichier SWF qui est chargé :
if (score > 100){
loadMovieNum("gagnant.swf", 5);
} else {
loadMovieNum("perdant.swf", 5);
}
Le tableau suivant répertorie les opérateurs de comparaison d’ActionScript :
Opérateur Opération effectuée
+ Addition
* Multiplication
/ Division
% Modulo (reste de division)
- Soustraction
++ Incrémentation
-- Décrémentation
Opérateur Opération effectuée
< Inférieur à
> Supérieur à
<= Inférieur ou égal à
>= Supérieur ou égal àUtilisation d’opérateurs pour manipuler les valeurs des expressions 49
Opérateurs de chaîne
L’opérateur + agit de manière spéciale sur les chaînes : il en concatène les deux opérandes. Par
exemple, les instructions suivantes additionnent "Félicitations," et "Donna !":
"Félicitations, " + "Donna !"
Le résultat est "Félicitations, Donna !". Si un seul opérande de l’opérateur + est une chaîne,
Flash convertit l’autre opérande en chaîne.
Les opérateurs de comparaison >, >=, < et <= agissent également de manière particulière sur les
chaînes. Ces opérateurs comparent deux chaînes pour déterminer celle qui apparaît en premier
dans l’ordre alphabétique. Les opérateurs de comparaison ne comparent des chaînes que si les
deux opérandes sont des chaînes. Si un seul opérande est une chaîne, ActionScript convertit les
deux opérandes en nombres et effectue une comparaison numérique.
Opérateurs logiques
Les opérateurs logiques comparent des valeurs booléennes (true et false) et renvoient une
troisième valeur booléenne. Par exemple, si les deux opérandes sont true, l’opérateur logique
AND (&&) renvoie true. Si l’un des opérandes, ou les deux, est true, l’opérateur logique OR (||)
renvoie false. Les opérateurs logiques sont souvent utilisés en complément des opérateurs de
comparaison pour déterminer la condition d’une action if. Par exemple, dans le script suivant, si
les deux expressions sont true, l’action if est exécutée :
if (i > 10 && _framesloaded > 50){
play();
}
Le tableau suivant répertorie les opérateurs logiques d’ActionScript :
Opérateurs au niveau du bit
Les opérateurs au niveau du bit manipulent (en interne) les nombres à virgule flottante pour les
transformer en entiers 32 bits. L’opération exacte effectuée dépend de l’opérateur, mais toutes les
opérations au niveau du bit évaluent chaque bit d’un entier 32 bits séparément pour calculer une
nouvelle valeur.
Le tableau suivant répertorie les opérateurs au niveau du bit d’ActionScript :
Opérateur Opération effectuée
&& AND logique
|| OR logique
! NOT logique
Opérateur Opération effectuée
& AND au niveau du bit
| OR au niveau du bit
^ XOR au niveau du bit
~ NOT au niveau du bit
<< Décalage gauche50 Chapitre 2 :  Notions de base du langage ActionScript
Opérateurs d’égalité
Vous pouvez utiliser l’opérateur d’égalité (= pour déterminer si les valeurs ou les identités de
deux opérandes sont égales. Cette comparaison renvoie une valeur booléenne (true ou false). Si
les opérandes sont des chaînes, des nombres ou des valeurs booléennes, ils sont comparés par
valeur. Si les opérandes sont des objets ou des tableaux, ils sont comparés par référence.
Une erreur courante consiste à utiliser l’opérateur d’affectation pour contrôler l’égalité. Par
exemple, le code suivant compare x à 2 :
if (x == 2)
Dans ce même exemple, l’expression x = 2 est incorrecte, car elle ne compare pas les opérandes,
mais affecte la valeur 2 à la variable x.
L’opérateur d’égalité stricte (== est semblable à l’opérateur d’égalité, à une différence
(importante) près : l’opérateur d’égalité stricte n’effectue pas de conversion de type. Si les deux
opérandes sont de types différents, l’opérateur d’égalité stricte renvoie false. L’opérateur
d’inégalité stricte (!= renvoie l’inverse de l’opérateur d’égalité stricte.
Le tableau suivant répertorie les opérateurs d’égalité d’ActionScript :
Opérateurs d’affectation
Vous pouvez utiliser l’opérateur d’affectation ( pour affecter une valeur à une variable, comme
par exemple :
var motDePasse = "Sk8tEr";
Vous pouvez également utiliser l’opérateur d’affectation pour affecter plusieurs variables dans la
même expression. Dans l’instruction suivante, la valeur a est affectée aux variables b, c et d :
a = b = c = d;
Vous pouvez aussi utiliser des opérateurs d’affectation composés pour combiner des opérations.
Les opérateurs composés agissent sur les deux opérandes, puis affectent la nouvelle valeur au
premier. Par exemple, les deux instructions suivantes sont équivalentes :
x += 15;
x = x + 15;
L’opérateur d’affectation peut également être utilisé au milieu d’une expression, comme illustré ci-
dessous :
// s’il ne s’agit pas de vanille, afficher un message.
>> Décalage droit
>>> Décalage droit avec remplissage par zéros
Opérateur Opération effectuée
== Egalité
=== Egalité stricte
!= Inégalité
!== Inégalité stricte
Opérateur Opération effectuéeUtilisation d’opérateurs pour manipuler les valeurs des expressions 51
if ((goût =goûtGlace()) != "vanille") {
trace ("Le goût est " + flavor + ", pas la vanille.");
}
Ce code équivaut au code suivant, qui est quelque peu plus long :
goût = goûtGlace();
if (goût != "vanille") {
trace ("Le goût est " + flavor + ", pas la vanille.");
}
Le tableau suivant répertorie les opérateurs d’affectation d’ActionScript :
Opérateurs point et accès tableau
Vous pouvez utiliser les opérateurs point (.) et accès tableau ([]) pour accéder aux propriétés des
objets ActionScript intégrés ou personnalisés, telles que celles d’un clip.
L’opérateur point utilise le nom d’un objet dans sa partie gauche et le nom d’une propriété ou
d’une variable dans sa partie droite. Le nom de propriété ou de variable ne peut pas être une
chaîne ni une variable évaluée comme une chaîne ; il doit s’agir d’un identifiant. Les exemples
suivants utilisent l’opérateur point :
année.mois = "juin";
année.mois.jour = 9;
Les opérateurs point et accès tableau jouent le même rôle, mais l’opérateur point prend un
identifiant comme propriété alors que l’opérateur d’accès tableau évalue son contenu comme nom
et accède ensuite à la valeur de cette propriété nommée. Par exemple, les expressions suivantes
accèdent à la même variable vitesse dans le clip fusée :
fusée.vitesse;
fusée["vitesse"];
Opérateur Opération effectuée
= Affectation
+= Addition et affectation
-= Soustraction et affectation
*= Multiplication et affectation
%= Modulo et affectation
/= Division et affectation
<<= Décalage gauche au niveau du bit et affectation
>>= Décalage droit au niveau du bit et affectation
>>>= Décalage droit avec remplissage par zéros et affectation
^= XOR au niveau du bit et affectation
|= OR au niveau du bit et affectation
&= AND au niveau du bit et affectation52 Chapitre 2 :  Notions de base du langage ActionScript
Vous pouvez utiliser l’opérateur d’accès tableau pour définir et récupérer dynamiquement les
noms et les variables des occurrences. Par exemple, dans le code suivant, l’expression insérée dans
l’opérateur [] est évaluée et le résultat de cette évaluation est utilisé comme nom de la variable à
récupérer du clip nom :
nom["mc" + i]
Vous pouvez également utiliser la fonction eval() , comme dans l’exemple ci-dessous :
eval("mc" + i)
L’opérateur d’accès tableau peut également être utilisé dans la partie gauche d’une instruction
d’affectation. Cela vous permet de définir dynamiquement les noms d’objet, de variable et
d’occurrence, comme dans l’exemple suivant :
nom[index] = "Gary";
Pour créer des tableaux multidimensionnels dans ActionScript, vous construisez un tableau dont
les éléments sont également des tableaux. Pour accéder aux éléments d’un tableau
multidimensionnel, vous pouvez imbriquer l’opérateur accès tableau en lui-même, comme illustré
ci-après :
var Echiquier = new Array();
for (var i=0; i<8; i++) {
Echiquier.push(new Array(8));
}
function récupContenuPosition(ligne, colonne){
Echiquier[ligne][colonne];
}
Vous pouvez contrôler qu’il ne manque pas d’opérateurs [] dans vos scripts ; consultez
Vérification de la syntaxe et de la ponctuation, page 69.

Débogage d’un fichier SWF à partir d’un emplacement distant
Vous pouvez déboguer un fichier SWF à distance au moyen de la version autonome, de la version
ActiveX ou du module de Flash Player. Lors de l’exportation d’un fichier SWF, vous pouvez
activer le débogage dans le fichier et créer un mot de passe de débogage. Le débogueur n’est pas
activé si vous n’activez pas le débogage.
Pour que seuls certains utilisateurs puissent exécuter vos fichiers SWF dans le débogueur de Flash
Player, vous pouvez les publier avec un mot de passe de débogage. Tout comme dans JavaScript ou
HTML, les utilisateurs peuvent consulter les variables côté client dans ActionScript. Pour stocker
les variables de façon sécurisée, vous devez les envoyer à une application côté serveur au lieu de les
stocker dans votre fichier. Cependant, en tant que développeur Flash, vous ne voudrez peut-être
pas révéler d’autres secrets professionnels, tels que des structures de clips. Vous pouvez donc
utiliser un mot de passe de débogage pour protéger votre travail.
Lorsque vous exportez, publiez ou testez une animation, Flash crée un fichier SWD contenant des
informations de débogage. Pour effectuer le débogage à distance, vous devez placer le fichier
SWD dans le répertoire du serveur qui contient le fichier SWF.
Pour permettre le débogage à distance d’une animation Flash :
1 Choisissez Fichier > Paramètres de publication.
Liste hiérarchique Code
Barre d’état Liste d’observationDébogage de scripts 73
2 Sous l’onglet Flash de la boîte de dialogue Paramètres de publication, activez l’option Débogage
autorisé.
3 Pour définir un mot de passe, entrez-le dans le champ Mot de passe.
Une fois un mot de passe défini, personne ne peut télécharger d’informations vers le débogueur
sans entrer ce mot de passe. Cependant, aucun mot de passe n’est requis si vous ne remplissez
pas le champ correspondant.
4 Fermez la boîte de dialogue Paramètres de publication, puis choisissez l’une des commandes
suivantes :
■ Contrôle > Déboguer l’animation
■ Fichier > Exporter l’animation
■ Fichier > Paramètres de publication > Publier
Flash crée un fichier de débogage portant l’extension .swd et l’enregistre conjointement avec le
fichier SWF. Le fichier SWD contient des informations qui vous permettent d’utiliser des
points d’arrêt et de faire défiler le code pas à pas.
5 Placez le fichier SWD dans le répertoire du serveur qui contient le fichier SWF.
Si le fichier SWD ne se trouve pas dans ce répertoire, vous pouvez toujours effectuer le
débogage à distance, mais le débogueur ignore les points d’arrêt et il vous est impossible de
faire défiler le code pas à pas.
6 Dans Flash, choisissez Fenêtre > Panneaux de développement > Débogueur.
• Dans le débogueur, dans le menu contextuel Options (dans le coin supérieur droit du
panneau), choisissez Activer le débogage à distance.
Pour activer le débogueur à distance :
1 Ouvrez l’application auteur Flash.
2 Dans un navigateur ou dans le lecteur autonome, ouvrez le fichier SWF publié à partir de son
emplacement distant.
La boîte de dialogue Débogage à distance apparaît.74 Chapitre 3 :  Rédaction et débogage de scripts
Si cette boîte de dialogue ne s’affiche pas, cela signifie que Flash n’a pas trouvé le fichier SWD.
Dans ce cas, cliquez sur le fichier SWF avec le bouton droit de la souris (Windows) ou en
appuyant sur la touche Ctrl (Macintosh) pour afficher un menu contextuel, et choisissez
Débogueur.
3 Dans la boîte de dialogue Débogage à distance, sélectionnez Hôte local ou Autre machine :
■ L’option Hôte local est utilisée si le lecteur de débogage et l’application auteur Flash se
trouvent sur le même ordinateur.
■ Optez pour Autre machine si le lecteur de débogage et l’application auteur Flash ne se
trouvent pas sur le même ordinateur. Entrez l’adresse IP de l’ordinateur qui exécute
l’application auteur Flash.
4 Lorsqu’une connexion est établie, une boîte de dialogue s’affiche et vous invite à entrer un mot
de passe. Entrez le mot de passe de débogage si vous en avez défini un.
La liste hiérarchique du fichier SWF apparaît dans le débogueur.
Affichage et modification de variables
L’onglet Variables du débogueur affiche les noms et valeurs des variables globales et de scénario du
fichier SWF. Si vous modifiez la valeur d’une variable dans cet onglet, vous pouvez constater la
modification dans le fichier SWF au cours de son exécution. Par exemple, pour tester la détection
de collision dans un jeu, vous pouvez entrer la valeur de la variable afin de positionner une balle à
l’emplacement correct près d’un mur.
L’onglet Locales du débogueur affiche les noms et les valeurs des variables locales disponibles
lorsque le fichier SWF s’est arrêté à un point d’arrêt ou n’importe où ailleurs dans une fonction
définie par l’utilisateur.
Pour afficher une variable :
1 Sélectionnez le clip contenant la variable de la liste.
Pour afficher les variables globales, sélectionnez le clip _global dans la liste.
2 Cliquez sur l’onglet Variables.Débogage de scripts 75
La liste hiérarchique est automatiquement mise à jour au cours de la lecture du fichier SWF. Un
clip supprimé du fichier SWF au niveau d’une image spécifique est également supprimé (avec sa
variable et son nom de variable) de la liste hiérarchique du débogueur. Toutefois, si vous marquez
une variable pour la liste d’observation (consultez Utilisation de la liste d’observation, page 75),
cette variable n’est pas supprimée.
Pour modifier la valeur d’une variable :
• Double-cliquez sur la valeur et entrez-en une nouvelle.
La valeur ne peut pas être une expression. Par exemple, vous pouvez utiliser "Bonjour", 3523 ou
"http://www.macromedia.com", et vous ne pouvez pas utiliser x + 2 ou eval("nom:" +i). La
valeur peut être une chaîne (n’importe quelle valeur comprise entre guillemets, un nombre ou une
valeur booléenne (true ou false).
Remarque : Pour afficher la valeur d’une expression dans le panneau de sortie en mode de test
d’animation, utilisez l’instruction trace. Pour plus d’informations, consultez Utilisation de l’instruction
trace, page 82.
Utilisation de la liste d’observation
Pour facilement contrôler un ensemble de variables critiques, vous pouvez marquer celles qui
doivent apparaître dans la liste d’observation. Cette liste affiche le chemin d’accès absolu de la
variable et de la valeur. Vous pouvez également entrer une nouvelle valeur de variable dans la liste
d’observation, comme dans le volet Variables.
Si vous ajoutez une variable locale à la liste d’observation, sa valeur ne s’affiche que lorsque le
lecteur est arrêté sur une ligne de code ActionScript au niveau de laquelle cette variable est utilisée.
Toutes les autres variables s’affichent pendant la lecture du fichier SWF. Si le débogueur ne trouve
pas la valeur de la variable, elle est répertoriée comme « undefined ».76 Chapitre 3 :  Rédaction et débogage de scripts
La liste d’observation ne peut afficher que les variables, et non les propriétés ou les fonctions.
Variables marquées pour la liste d’observation et variables dans la liste d’observation
Pour ajouter des variables à la liste d’observation, effectuez l’une des opérations suivantes :
• Sous l’onglet Variables ou Locales, cliquez sur une variable sélectionnée avec le bouton droit de
la souris (Windows) ou en appuyant sur la touche Ctrl (Macintosh), puis choisissez
Observateur dans le menu contextuel. Un point bleu apparaît en regard de la variable.
• Sous l’onglet Observateur, cliquez sur une variable sélectionnée avec le bouton droit de la
souris (Windows) ou en appuyant sur la touche Ctrl (Macintosh), puis choisissez Ajouter dans
le menu contextuel. Entrez le chemin cible du nom de variable et sa valeur dans les champs.
Pour retirer des variables de la liste d’observation :
• Sous l’onglet Observateur, cliquez sur une variable sélectionnée avec le bouton droit de la
souris (Windows) ou en appuyant sur la touche Ctrl (Macintosh), puis choisissez Supprimer
dans le menu contextuel.
Affichage et modification des propriétés de clip
L’onglet Propriétés du débogueur affiche toutes les valeurs de propriétés des clips sur la scène.
Vous pouvez modifier une valeur et constater l’effet de la modification sur le fichier SWF lors de
son exécution. Certaines propriétés de clip sont en lecture seule et ne peuvent pas être modifiées.
Pour afficher les propriétés d’un clip dans le débogueur :
1 Sélectionnez un clip dans la liste.Débogage de scripts 77
2 Cliquez sur l’onglet Propriétés du débogueur.
Pour modifier la valeur d’une propriété :
• Double-cliquez sur la valeur et entrez-en une nouvelle.
La valeur ne peut pas être une expression. Par exemple, vous pouvez entrer 50 ou "goutteDeau"
mais pas x + 50. La valeur peut être une chaîne (n’importe quelle valeur comprise entre
guillemets, un nombre ou une valeur booléenne (true ou false). Vous ne pouvez pas entrer de
valeurs d’objets ou tableaux (par exemple, {id: "rogue"} ou [1, 2, 3]) dans le débogueur.
Pour plus d’informations, consultez Opérateurs de chaîne, page 49 et Utilisation d’opérateurs pour
manipuler les valeurs des expressions, page 47.
Remarque : Pour afficher la valeur d’une expression dans le panneau de sortie en mode de test
d’animation, utilisez l’instruction trace. Pour plus d’informations, consultez Utilisation de l’instruction
trace, page 82.
Définition et suppression de points d’arrêt
Un point d’arrêt vous permet d’interrompre un fichier SWF en cours de lecture dans Flash Player
à une ligne précise de code ActionScript. Vous pouvez utiliser les points d’arrêt pour tester
d’éventuels endroits problématiques du code. Par exemple, si vous avez rédigé un jeu
d’instructions if..else if et que vous ne pouvez pas déterminer laquelle est en cours
d’exécution, vous pouvez ajouter un point d’arrêt avant ces instructions et les faire défiler une par
une dans le débogueur.
Vous pouvez définir des points d’arrêt dans le panneau Actions ou dans le débogueur. (Pour
définir des points d’arrêt dans des scripts externes, vous devez utiliser le débogueur.) Les points
d’arrêt définis dans le panneau Actions sont enregistrés dans le document Flash (fichier FLA). Les
points d’arrêt définis dans le débogueur ne sont pas enregistrés dans le fichier FLA et ne sont
valides que pour la session de débogage en cours. 78 Chapitre 3 :  Rédaction et débogage de scripts
Pour définir ou supprimer un point d’arrêt dans le panneau Actions, effectuez l’une des
opérations suivantes :
• Cliquez dans la marge gauche. La présence d’un point rouge indique un point d’arrêt.
• Cliquez sur le bouton Options de débogage, situé au-dessus de la fenêtre de script.
• Cliquez avec le bouton droit (Windows) ou en appuyant sur la touche Contrôle (Macintosh)
pour afficher le menu contextuel et choisissez Définir un point d’arrêt, Supprimer le point
d’arrêt ou Supprimer tous les points d’arrêt.
• Appuyez sur Ctrl+Maj+B (Windows) ou sur Commande+Maj+B (Macintosh).
Remarque : Dans les versions précédentes de Flash, un clic dans la marge gauche de la fenêtre de
script sélectionnait la ligne de code. Désormais il permet d’ajouter ou de supprimer un point d’arrêt.
Pour sélectionner une ligne de code, cliquez en appuyant sur la touche Ctrl (Windows) ou
Commande (Macintosh).
Pour définir ou supprimer des points d’arrêt dans le débogueur, effectuez l’une des
opérations suivantes :
• Cliquez dans la marge gauche. La présence d’un point rouge indique un point d’arrêt.
• Cliquez sur le bouton Basculer le point d’arrêt ou Supprimer tous les points d’arrêt, au-dessus
de l’affichage du code.
• Cliquez avec le bouton droit (Windows) ou en appuyant sur la touche Contrôle (Macintosh)
pour afficher le menu contextuel et choisissez Définir un point d’arrêt, Supprimer le point
d’arrêt ou Supprimer tous les points d’arrêt.
• Appuyez sur Ctrl+Maj+B (Windows) ou sur Commande+Maj+B (Macintosh).
Lorsque Flash Player est interrompu à un point d’arrêt, vous pouvez entrer dans une ligne de
code, l’ignorer ou en sortir. Un point d’arrêt fixé dans un commentaire ou sur une ligne vide du
panneau Actions est ignoré.
Défilement de lignes de code
Flash Player est mis en pause lorsque vous commencez une session de débogage. Si vous définissez
des points d’arrêt dans le panneau Actions, vous pouvez tout simplement cliquer sur le bouton
Continuer pour lire le fichier SWF jusqu’à ce qu’il rencontre un de ces points. Par exemple, dans le
code suivant, supposons qu’un point d’arrêt a été défini dans un bouton sur la ligne maFonction():
on(press) {
maFonction();
}
Lorsque vous cliquez sur le bouton, le point d’arrêt est atteint et Flash Player s’interrompt. Vous
pouvez ensuite intervenir afin d’amener le débogueur à la première ligne de maFonction(), là où
elle a été définie dans le document. Vous pouvez également faire défiler toute la fonction ou la
quitter.
Si vous n’avez pas défini de points d’arrêt dans le panneau Actions, vous pouvez utiliser le menu
de passage aux autres éléments du débogueur pour sélectionner n’importe quel script de
l’animation. Vous pouvez ensuite y ajouter des points d’arrêt. Après avoir ajouté des points d’arrêt,
vous devez cliquer sur le bouton Continuer pour lancer l’animation. Le débogueur s’arrête
lorsqu’il atteint le point d’arrêt. Débogage de scripts 79
Lorsque vous faites défiler les lignes de code, les valeurs des variables et des propriétés changent
dans la liste d’observation ainsi que dans les onglets Variables, Locales et Propriétés. Une flèche
jaune sur le côté gauche de la fenêtre de code du débogueur indique la ligne sur laquelle le
débogueur s’est arrêté. Utilisez les boutons suivants, placés en haut de la fenêtre de code :
Le bouton Pas à pas détaillé fait avancer le débogueur (indiqué par la flèche jaune) dans une
fonction. Le bouton Pas à pas détaillé ne peut être utilisé qu’avec les fonctions définies par
l’utilisateur.
Dans l’exemple suivant, si vous placez un point d’arrêt à la ligne 7 et que vous cliquez sur Pas à pas
détaillé, le débogueur passe à la ligne 2, et un nouveau clic sur ce bouton passe à la ligne 3. Un clic
sur Pas à pas détaillé pour des lignes ne comportant pas de fonction définie par l’utilisateur fait
avancer le débogueur sur une ligne de code. Par exemple, si vous effectuez un arrêt à la ligne 2 et
que vous choisissez Pas à pas détaillé, le débogueur passe à la ligne 3, comme dans l’exemple
suivant :
1 function maFonction() {
2 x = 0;
3 y = 0;
4 }
5
6 mover = 1;
7 maFonction();
8 mover = 0;
Le bouton Sortir du pas à pas fait sortir le débogueur d’une fonction. Le bouton Sortir du pas à
pas ne fonctionne que si vous êtes actuellement arrêté(e) sur une fonction définie par l’utilisateur.
Il déplace la flèche jaune sur la ligne suivant celle au niveau de laquelle cette fonction a été
appelée. Dans l’exemple ci-dessus, si vous placez un point d’arrêt à la ligne 3 et que vous cliquez
sur Sortir du pas à pas, le débogueur passe à la ligne 8. Un clic sur Sortir du pas à pas sur une ligne
qui ne se trouve pas dans une fonction définie par l’utilisateur équivaut à cliquer sur Continuer.
Par exemple, si vous vous arrêtez à la ligne 6 et que vous cliquez sur Sortir du pas à pas, le lecteur
continue à exécuter le script jusqu’à ce qu’il rencontre un point d’arrêt.
Le bouton Pas à pas principal fait avancer le débogueur sur une ligne de code. Le bouton Pas à
pas principal déplace la flèche jaune sur la ligne suivante du script et ignore les fonctions définies
par l’utilisateur. Dans l’exemple ci-dessus, si vous êtes arrêté(e) à la ligne 7 et que vous cliquez sur
Pas à pas principal, vous passez directement à la ligne 8 et maFonction() est ignorée.
Le bouton Continuer quitte la ligne au niveau de laquelle le lecteur est arrêté et continue la
lecture jusqu’à ce qu’un point d’arrêt soit atteint.
Arrêter le débogage
Basculer le point d’arrêt
Supprimer tous les points d’arrêt
Continuer
Pas à pas principal
Pas à pas détaillé
Sortir du pas à
pas80 Chapitre 3 :  Rédaction et débogage de scripts
Le bouton Interrompre le débogage désactive le débogueur sans arrêter la lecture du fichier SWF
dans Flash Player.
Utilisation du panneau de sortie
En mode de test d’animation, le panneau de sortie affiche des informations facilitant le dépannage
de votre fichier SWF. Certaines informations, telles que les erreurs de syntaxe, sont
automatiquement affichées. Vous pouvez afficher d’autres informations à l’aide des commandes
Lister les objets et Lister les variables. (Consultez Liste des objets d’un fichier SWF, page 80 et Liste
des variables d’un fichier SWF , page 81.)
Si vous utilisez l’instruction trace dans vos scripts, vous pouvez envoyer des informations
spécifiques au panneau de sortie au cours de l’exécution du fichier SWF. Il peut s’agir de notes
relatives à l’état du fichier SWF ou à la valeur d’une expression. Pour plus d’informations, consultez
Utilisation de l’instruction trace, page 82.
Pour afficher le panneau de sortie, choisissez Fenêtre > Panneaux de développement > Sortie ou
appuyez sur la touche F2.
Remarque : Si un script comporte des erreurs de syntaxe, le panneau de sortie apparaît
automatiquement lorsque vous vérifiez la syntaxe ou que vous testez votre fichier SWF.
Pour utiliser le contenu du panneau de sortie, utilisez le menu d’options (dans le coin supérieur
droit).
Liste des objets d’un fichier SWF
En mode de test d’animation, la commande Lister les objets affiche le niveau, l’image, le type
d’objet (forme, clip ou bouton), les chemins cible et les noms d’occurrences de clips, boutons et
champs de texte dans une liste hiérarchique. Cela est particulièrement utile pour rechercher le
chemin cible et le nom de l’occurrence corrects. Contrairement au débogueur, la liste n’est pas
automatiquement mise à jour au cours de la lecture du fichier SWF ; vous devez choisir la
commande Lister les objets chaque fois que vous voulez envoyer les informations au panneau de
sortie. 
La commande Lister les objets ne dresse pas la liste de tous les objets de données ActionScript.
Dans ce contexte, un objet est considéré comme une forme ou un symbole sur la scène.
Pour afficher une liste d’objets d’une animation :
1 Si l’animation n’est pas en cours d’exécution en mode de test d’animation, choisissez Contrôle >
Tester l’animation. Utilisation du panneau de sortie 81
2 Choisissez Déboguer > Lister les objets.
La liste des objets actuellement sur la scène s’affiche dans le panneau de sortie, comme illustré
dans l’exemple suivant :
Level #0: Image=1 Etiquette="Scene_1"
  Bouton: Cible="_level0.monBouton"
    Forme:
  Clip: Image=1 Cible="_level0.monClip"
    Forme:
  Modifier le texte: Cible="_level0.monChampDeTexte" Texte="Ceci est un
exemple."
Liste des variables d’un fichier SWF 
En mode de test, la commande Lister les variables affiche la liste de toutes les variables actuelles
que contient le fichier SWF. Cela est particulièrement utile pour rechercher la variable cible et le
nom de la variable corrects. Contrairement au débogueur, la liste n’est pas automatiquement mise
à jour au cours de la lecture du fichier SWF ; vous devez choisir la commande Lister les variables
chaque fois que vous voulez envoyer les informations au panneau de sortie.
La commande Lister les variables affiche également les variables globales déclarées au moyen de
l’identifiant _global. Les variables globales sont affichées en haut de la liste produite par l’option
Lister les variables, dans une section nommée « Variables globales ». Chacune d’entre elles est
précédée de la mention _global.
En outre, la commande Lister les variables affiche des propriétés de type lecture/définition, des
propriétés créées par la méthode Objet.addProperty() et qui appellent des méthodes get ou
set. Une propriété lecture/définition est affichée à côté des autres propriétés de l’objet auquel elle
appartient. Pour distinguer aisément ces propriétés des variables ordinaires, la valeur d’une
propriété lecture/définition porte le préfixe [obtenir/placer]. La valeur affichée pour une
propriété lecture/définition est déterminée par l’évaluation de la fonction get de la propriété.
Pour afficher la liste des variables d’un fichier SWF :
1 Si le fichier SWF n’est pas en cours d’exécution en mode de test, choisissez Contrôle > Tester
l’animation.
2 Choisissez Déboguer > Lister les variables.
La liste de toutes les variables qui figurent actuellement dans le fichier SWF s’affiche dans le
panneau de sortie, comme illustré dans l’exemple suivant :
Variables globales :
  Variable _global.MonTableauDeGlobales = [objet 1] [
    0:1,
    1:2,
    2:3
  ]
Level #0:
  Variable _level0.$version = "WIN 6,0,0,101"
  Variable _level0.VariableNormale = "Gary"
  Variable _level0.UnObjet = [objet 1] {
    maPropriété: [obtenir/placer] 3.14159
  }82 Chapitre 3 :  Rédaction et débogage de scripts
Affichage des propriétés de champ de texte pour le débogage
Pour obtenir des informations de débogage sur les objets du champ de texte, vous pouvez utiliser
la commande Déboguer > Lister les variables en mode tester l’animation. Le panneau de sortie
utilise les conventions suivantes pour l’affichage des objets TextField : 
• Si une propriété est introuvable sur l’objet, elle ne s’affiche pas.
• Pas plus de quatre propriétés s’affichent sur une ligne.
• Une propriété possédant une valeur de chaîne est affichée sur une ligne séparée.
• Si d’autres propriétés sont définies pour l’objet après le traitement des propriétés intégrées, elles
s’ajoutent à l’affichage selon les règles des deuxième et troisième points précédents.
• Les propriétés de couleur s’affichent sous forme de nombres hexadécimaux (0x00FF00).
• Les propriétés sont affichées dans l’ordre suivant : variable, text, htmlText, html,
textWidth, textHeight, maxChars, borderColor, backgroundColor, textColor, border,
background, wordWrap, password, multiline, selectable, scroll, hscroll, maxscroll,
maxhscroll, bottomScroll, type, embedFonts, restrict, length, tabIndex, autoSize.
La commande Déboguer > Lister les objets en mode test répertorie les objets du champ de texte.
Si un nom d’occurrence est spécifié pour un champ de texte, le panneau de sortie affiche le
chemin cible complet, y compris le nom d’occurrence sous la forme suivante :
Target = "target path"
Utilisation de l’instruction trace
L’utilisation de l’instruction trace dans un script vous permet d’envoyer des informations au
panneau de sortie. Par exemple, lors du test d’une animation ou séquence, vous pouvez envoyer
des notes de programmation spécifiques au panneau ou afficher des résultats spécifiques lorsque
vous cliquez sur un bouton ou en lisez une image. L’instruction trace est similaire à l’instruction
JavaScript alert.   
Lorsque vous utilisez l’instruction trace dans un script, vous pouvez utiliser des expressions en
tant que paramètres. La valeur d’une expression s’affiche dans le panneau de sortie en mode de
test, comme illustré dans l’exemple suivant :
L’instruction trace renvoie des valeurs qui sont affichées dans le panneau de sortie.Mise à jour de Flash Player pour le test 83
onClipEvent (enterFrame) {
trace("onClipEvent enterFrame " + enterFrame++)
}
Mise à jour de Flash Player pour le test
Vous pouvez télécharger la version la plus récente de Flash Player à partir du site du centre de
support Macromedia à l’adresse www.macromedia.com/support/flash afin de l’utiliser pour tester
vos fichiers SWF. 84 Chapitre 3 :  Rédaction et débogage de scriptsPARTIE II
Gestion des événements et création d’interactivité
Certains événements, tels que les clics de souris ou les pressions exercées sur les touches, peuvent
être générés par l’utilisateur. D’autres peuvent être le résultat de certains autres processus, tels que
le chargement d’un fichier XML sur le réseau. Le premier chapitre de cette section décrit les
différents types d’événements dans Macromedia Flash et explique comment les traiter dans
ActionScript. Le deuxième chapitre explique comment appliquer ces principes pour créer des
présentations, des applications et des animations interactives simples.
Chapitre 4: Gestion d’événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Chapitre 5: Création d’interactivité avec ActionScript  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
PARTIE II87
CHAPITRE 4
Gestion d’événements
Un événement est une occurrence logicielle ou matérielle qui requiert une réponse d’une
application Macromedia Flash. Par exemple, un événement tel qu’un clic de souris ou une
pression sur une touche est appelé événement utilisateur, puisqu’il résulte d’une interaction directe
avec l’utilisateur. Un événement généré automatiquement par Flash Player, tel que l’apparence
initiale d’un clip sur la scène, est appelé événement système, car il n’est pas généré directement par
l’utilisateur.
Pour que votre application réagisse à des événements, vous devez utiliser des gestionnaires
d’événement (code ActionScript associé à un objet et à un événement particuliers). Par exemple,
lorsqu’un utilisateur clique sur un bouton sur la scène, la tête de lecture peut passer à l’image
suivante. De même, à l’issue du chargement d’un fichier XML sur le réseau, le contenu du fichier
peut s’afficher dans un champ de texte.
ActionScript propose différentes méthodes de gestion des événements : méthodes de gestionnaire
d’événement, des écouteurs d’événement, et des gestionnaires d’événement de bouton et de clip.
Utilisation de méthodes de gestionnaire d’événement
Une méthode de gestionnaire d’événement est une méthode de classe invoquée lorsqu’un
événement se produit sur une occurrence de cette classe. Par exemple, la classe Button définit un
gestionnaire d’événement onPress, invoqué lorsque l’utilisateur clique avec le bouton de la souris
sur un objet Button. Contrairement aux autres méthodes de classe, vous n’invoquez pas
directement un gestionnaire d’événement ; Flash Player l’invoque automatiquement lorsque
l’événement approprié se produit.
Par défaut, les méthodes de gestionnaire d’événement ne sont pas définies : lorsqu’un événement
particulier se produit, son gestionnaire d’événement correspondant est invoqué, mais votre
application ne répond pas davantage à l’événement. Pour qu’elle réponde à l’événement, définissez
une fonction au moyen de l’instruction function et affectez-la au gestionnaire d’événement
approprié. La fonction que vous avez affectée au gestionnaire d’événement est ensuite
automatiquement invoquée lorsque l’événement se produit.
Un gestionnaire d’événement se compose de trois éléments : l’objet auquel l’événement
s’applique, le nom de la méthode de gestionnaire d’événement de l’objet et la fonction que vous
avez affectée au gestionnaire d’événement. L’exemple suivant illustre la structure de base d’un
gestionnaire d’événement.
object.eventMethod = function () {88 Chapitre 4 :  Gestion d’événements
// Votre code, répondant à l’événement
}
Par exemple, supposons que vous avez un bouton suivant_btn sur la scène. Le code suivant
affecte au gestionnaire d’événement onPress du bouton une fonction qui permet de faire avancer
la tête de lecture jusqu’à l’image suivante dans le scénario.
suivant_btn.onPress = function ()
nextFrame();
}
Dans le code ci-dessus, la fonction nextFrame() est affectée directement à onPress. Vous pouvez
également affecter une référence de fonction (nom) à une méthode de gestionnaire d’événement
et définir la fonction ultérieurement.
// Assigne une référence de fonction à la méthode de gestionnaire d’événement
onPress du bouton
suivant_btn.onPress = goNextFrame;
// Définit la fonction doSubmit()
function goNextFrame() {
nextFrame();
}
Notez que vous affectez la référence de fonction et non la valeur renvoyée de la fonction au
gestionnaire d’événement onPress.
// Incorrect !
suivant_btn.onPress = goNextFrame();
// Correct.
suivant_btn.onPress = goNextFrame;
Certains gestionnaires d’événement reçoivent des paramètres transmis qui donnent des
informations sur l’événement qui s’est produit. Par exemple, le gestionnaire d’événement
TextField.onSetFocus est invoqué lorsqu’une occurrence de champ de texte parvient au focus
clavier. Ce gestionnaire d’événement reçoit une référence à l’objet de champ de texte qui avait
précédemment le focus clavier.
Par exemple, le code suivant insère du texte dans le champ de texte qui vient juste de perdre le
focus clavier.
nomDutilisateur_txt.onSetFocus = function(oldFocus_txt) {
ancienFocus_txt.text = "Je viens de perdre le focus clavier";
}
Les classes ActionScript suivantes définissent des gestionnaires d’événement : Button,
ContextMenu, ContextMenuItem, Key, LoadVars, LocalConnection, Mouse, MovieClip,
MovieClipLoader, Selection, SharedObject, Sound, Stage, TextField, XML et XMLSocket. Pour
plus d’informations sur les gestionnaires d’événement qu’elles proposent, consultez les entrées
correspondantes dans le Chapitre 12, Dictionnaire ActionScript Présentation, page 211.
Vous pouvez également affecter des fonctions à des gestionnaires d’événement pour des objets que
vous créez lors de l’exécution. Le code suivant, par exemple, crée une nouvelle occurrence de clip
(nouveauClip_mc) et affecte une fonction au gestionnaire d’événement onPress du clip.
_root.attachMovie("idDeSymbole", "nouveauClip_mc", 10);
nouveauClip_mc.onPress = function () {
trace("Vous m’avez pressé");
}
Pour plus d’informations, consultez Création de clips à l’exécution, page 130.Utilisation des écouteurs d’événement 89
Utilisation des écouteurs d’événement
Les écouteurs d’événement permettent à un objet, appelé objet d’écoute, de recevoir des
événements générés par un autre objet, appelé objet diffuseur. L’objet diffuseur enregistre l’objet
d’écoute afin de recevoir des événements générés par le diffuseur. Par exemple, vous enregistrez un
objet de clip pour recevoir des notifications onResize de la scène, ou une occurrence de bouton
peut recevoir des notifications onChanged d’un objet de champ de texte. Vous pouvez enregistrer
plusieurs objets d’écoute pour recevoir des événements d’un seul diffuseur, et vous pouvez
enregistrer un seul objet d’écoute pour recevoir des événements de plusieurs diffuseurs.   
Les écouteurs d’événement utilisent le même modèle que les gestionnaires d’événement (consultez
Utilisation de méthodes de gestionnaire d’événement, page 87), à deux différences près :
• L’objet auquel vous affectez le gestionnaire d’événement n’est pas l’objet qui émet l’événement.
• Appelez une méthode spéciale de l’objet diffuseur, addListener(), qui enregistre l’objet
d’écoute pour recevoir ses événements.
Pour utiliser les écouteurs d’événement, créez un objet d’écoute avec une propriété qui porte le
même nom que l’événement en cours de création par l’objet diffuseur. Affectez ensuite une
fonction à l’écouteur d’événement qui répond en quelque sorte à l’événement. Enfin, appelez
addListener() sur l’objet qui diffuse l’événement, en lui transmettant le nom de l’objet
d’écoute. Le code suivant présente le modèle d’écouteur d’événement.
objetDecoute.eventName = function(){
// votre code
};
objetDiffuseur.addListener(listenerObject);
L’objet d’écoute spécifié peut être tout objet, tel qu’une occurrence de bouton ou de clip sur la
scène ou une occurrence de n’importe quelle classe ActionScript. Le nom de l’événement est un
événement qui se produit sur objetDiffuseur, qui ensuite diffuse l’événement à objetDecoute.
Vous pouvez enregistrer plusieurs écouteurs sur un diffuseur d’événement.
L’exemple suivant illustre comment utiliser l’écouteur d’événement Selection.onSetFocus pour
créer un gestionnaire de focus simple pour un groupe de champs de saisie de texte. Dans ce cas, la
bordure du champ de texte qui reçoit le focus clavier est activée (affichée) et la bordure du champ
de texte qui a perdu le focus est désactivée.
Pour créer un gestionnaire de focus simple avec des gestionnaires d’événement :
1 En utilisant l’outil Texte, créez un champ de texte sur la scène.
2 Sélectionnez le champ de texte et, dans l’Inspecteur des propriétés, choisissez Entrée dans le
menu contextuel Type de texte, puis choisissez l’option Afficher la bordure autour du texte.
3 Créez un autre champ de saisie de texte, sous le premier.
Assurez-vous que l’option Afficher la bordure autour du texte n’est pas activée pour ce champ
de texte. Si nécessaire, continuez à créer des champs de saisie de texte.
4 Sélectionnez l’image 1 dans le scénario et ouvrez le panneau Actions (Fenêtre > Panneaux de
développement > Actions).
5 Pour créer un objet qui écoute les notifications de focus d’une classe Selection, entrez le code
suivant dans le panneau Actions :
var ecouteurDeFocus = new Object();
ecouteurDeFocus.onSetFocus = function(ancienFocus_txt, nouveauFocus_txt) {
ancienFocus_txt.border = false;90 Chapitre 4 :  Gestion d’événements
nouveauFocus_txt.border = true;
}
Ce code crée un nouvel objet ActionScript (générique) appelé focusListener. Cet objet
définit pour lui-même une propriété onSetFocus, à laquelle il affecte une fonction. La
fonction prend en compte deux paramètres : une référence au champ de texte qui a perdu le
focus et une référence au champ de texte qui a reçu le focus. La fonction définit la propriété
border du champ de texte qui a perdu le focus à false et la propriété border du champ de
texte qui a reçu le focus à true.
6 Pour enregistrer l’objet focusListener pour recevoir des événements de l’objet Selection,
ajoutez le code suivant au panneau Actions :
Selection.addListener(focusListener);
7 Testez l’animation (Contrôle > Tester l’animation), cliquez dans le premier champ de texte, puis
appuyez sur Tab pour passer d’un champ à l’autre.
Pour désenregistrer un objet d’écoute de sorte qu’il ne reçoive plus d’événements, appelez la
méthode removeListener() de l’objet diffuseur, en lui transmettant le nom de l’objet d’écoute.
objetDiffuseur.removeListener(listenerObject);
Les écouteurs d’événement sont disponibles pour les objets des classes ActionScript suivantes :
Key, Mouse, MovieClipLoader, Selection, TextField, et Stage. Pour obtenir une liste des écouteurs
d’événement disponibles pour chaque classe, consultez les entrées de ces classes dans le
Chapitre 12, Dictionnaire ActionScript Présentation, page 211.
Utilisation de gestionnaires d’événement de bouton et de clip
Vous pouvez associer des gestionnaires d’événement directement à une occurrence de bouton ou
de clip au moyen des gestionnaires onClipEvent() et on(). Le gestionnaire onClipEvent()
traite les événements de clips alors que le gestionnaire on() traite ceux des boutons. Vous pouvez
également utiliser on() avec des clips pour créer des clips qui reçoivent des événements de
bouton. Pour plus d’informations, consultez Création de clips avec états de bouton, page 91.
Pour utiliser le gestionnaire on() ou onClipEvent(), associez-le directement à une occurrence
d’un bouton ou d’un clip sur la scène et spécifiez l’événement que vous souhaitez gérer pour cette
occurrence. Par exemple, le gestionnaire d’événement on() suivant est exécuté lorsque l’utilisateur
clique sur le bouton auquel il est associé.
on(press) {
trace("Merci de m’avoir pressé.");
}
Vous pouvez spécifier deux événements, voire plus, pour chaque gestionnaire on(), séparés par
des virgules. Le code ActionScript dans un gestionnaire est exécuté lorsque l’un des événements
spécifiés par le gestionnaire se produit. Par exemple, le gestionnaire on() suivant, associé à un
bouton, est exécuté lorsque le pointeur de la souris passe au-dessus puis en dehors du bouton.
on(rollOver, rollOut) {
trace("Vous êtes passé au-dessus ou en dehors");
}
Vous pouvez associer plusieurs gestionnaires à un objet si vous souhaitez exécuter différents scripts
lorsque différents événements se produisent. Par exemple, vous pouvez associer les gestionnaires
onClipEvent() suivants à la même occurrence de clip. Le premier est exécuté au premier
chargement du clip (ou lorsque celui-ci apparaît sur la scène), le second est exécuté lorsque le clip
est vidé de la scène.Création de clips avec états de bouton 91
onClipEvent(load) {
trace("chargé");
}
onClipEvent (unload) {
trace("vidé");
}
Pour obtenir la liste complète des événements pris en charge par les gestionnaires d’événement
on() et onClipEvent(), consultez on(), page 577 et onClipEvent(), page 578.
La gestion d’événement avec on() et onClipEvent() ne provoque pas de conflit avec la gestion
d’événement via des méthodes de gestionnaire d’événement que vous définissez. Imaginons par
exemple que votre fichier SWF comporte un bouton associé à un gestionnaire on(press) qui
déclenche la lecture du fichier SWF. Ce même bouton possède également une méthode onPress,
pour laquelle vous définissez une fonction qui indique une rotation à un objet sur la scène.
Lorsque l’utilisateur clique sur le bouton, la lecture du fichier SWF commence et l’objet tourne
sur lui-même. Selon vos préférences, vous pouvez utiliser on() et onClipEvent(), des méthodes
de gestionnaire d’événement ou ces deux types de gestion d’événement. Toutefois, le domaine des
variables et des objets dans les gestionnaires on() et onClipEvent() n’est pas le même que celui
du gestionnaire d’événement et des écouteurs d’événement. Pour plus d’informations, consultez
Domaine du gestionnaire d’événement, page 92.
Vous pouvez associer onClipEvent() et on() uniquement à des occurrences de clips qui ont été
placées sur la scène au cours de la programmation. Il est impossible d’associer onClipEvent() ou
on() à des occurrences de clips créées à l’exécution (avec la méthode attachMovie, par exemple).
Pour associer des gestionnaires d’événement à des objets créés à l’exécution, utilisez des méthodes
de gestionnaire d’événement ou des écouteurs d’événement. Pour plus d’informations, consultez
Utilisation de méthodes de gestionnaire d’événement, page 87 et Utilisation des écouteurs d’événement,
page 89. 
Création de clips avec états de bouton
Lorsque vous associez un gestionnaire on() à un clip ou que vous affectez une fonction à l’un des
gestionnaires d’événement souris MovieClip pour une occurrence de clip, le clip répond à des
événements souris de la même façon qu’un bouton. Vous pouvez également créer des états de
bouton automatiques (Haut, Dessus et Abaissé) dans un clip, en ajoutant les étiquettes d’image
_up, _over et _down au scénario du clip.
Lorsque l’utilisateur déplace la souris au-dessus d’un clip ou qu’il clique sur ce dernier, la tête de
lecture passe à l’image avec l’étiquette d’image appropriée. Pour désigner la zone active qu’utilise
un clip, utilisez la propriété hitArea de la classe MovieClip.
Pour créer des états de bouton dans un clip :
1 Sélectionnez, dans le scénario d’un clip, une image à utiliser comme état de bouton (Haut,
Dessus ou Abaissé).
2 Entrez une étiquette d’image dans l’inspecteur des propriétés(_up, _over ou _down).
3 Pour ajouter d’autres états de bouton, répétez les étapes 1 et 2.
4 Pour que votre clip réponde aux événements souris, effectuez l’une des opérations suivantes :
■ Associez un gestionnaire d’événement on() à l’occurrence du clip, comme indiqué dans
Utilisation de gestionnaires d’événement de bouton et de clip, page 90.92 Chapitre 4 :  Gestion d’événements
■ Affectez une fonction à l’un des gestionnaires d’événement souris de l’objet du clip
(onPress, onRelease, etc.), comme indiqué dans Utilisation de méthodes de gestionnaire
d’événement, page 87.
Domaine du gestionnaire d’événement
Le domaine, ou contexte, des variables et commandes que vous déclarez et exécutez dans un
gestionnaire d’événement varie selon le type de gestionnaire d’événement que vous utilisez :
gestionnaires d’événement ou écouteurs d’événement, gestionnaires on() et onClipEvent().
Les fonctions affectées aux méthodes de gestionnaire d’événement et aux écouteurs d’événement
(comme toutes les fonctions ActionScript que vous rédigez) définissent un domaine de variable
locale, contrairement aux gestionnaires on() et onClipEvent().
Par exemple, soit les deux gestionnaires d’événement suivants : le premier est un gestionnaire
d’événement onPress associé à un clip appelé clip_mc, le second est un gestionnaire on() associé
à la même occurrence de clip.
// Associé au scénario de clip parent de clip_mc :
clip_mc.onPress = function () {
var couleur; // variable de fonction locale
couleur = "bleu";
}
// gestionnaire on() associé à clip_mc :
on(press) {
var couleur; // aucun domaine de variable locale
couleur = "bleu";
}
Bien que les deux gestionnaires d’événement contiennent le même code, les résultats sont
différents. Dans le premier cas, la variable couleur est locale par rapport à la fonction définie
pour onPress. Dans le second, dans la mesure où le gestionnaire on() ne définit pas de domaine
de variable locale, la variable a un domaine limité au scénario du clip clip_mc.
Dans le cas des gestionnaires d’événement on() associés à des boutons, plutôt qu’à des clips, le
domaine des variables (à l’instar des appels de fonction et de méthode) est limité au scénario qui
contient l’occurrence de bouton.
Le gestionnaire d’événement on() suivant, par exemple, génère différents résultats selon qu’il est
associé à un clip ou à un bouton. Dans le premier exemple, l’appel de la fonction play() lance la
tête de lecture du scénario qui contient le bouton ; dans le second, l’appel de la fonction play()
démarre le scénario du clip auquel le gestionnaire est associé.
// Associé à un bouton
on(press) {
play(); // exécute le scénario parent
}
// Associé à un clip
on(press) {
play(); // exécute le scénario du clip
}
Autrement dit, lorsqu’il est associé à un objet de bouton, l’appel de la méthode play() s’applique
au scénario qui contient le bouton, c’est-à-dire au scénario parent du bouton. En revanche,
lorsque ce même gestionnaire est associé à un objet de clip, la méthode play() s’applique au clip
qui contient le gestionnaire.Domaine du mot-clé « this » 93
Dans la définition d’une fonction de gestionnaire d’événement ou d’écouteur d’événement, la
fonction play() s’appliquerait au scénario contenant la définition. Imaginons par exemple que la
fonction de gestionnaire d’événement MovieClip.onPress suivante soit déclarée dans le scénario
contenant l’instance de clip monClip.
// Fonction définie dans le scénario du clip :
monClip.onPress = function () {
play(); // exécute le scénario contenant la définition de la fonction
}
Pour exécuter le clip qui définit le gestionnaire d’événement onPress, vous devez faire
explicitement référence à ce clip à l’aide du mot-clé this, comme suit :
monClip.onPress = function () {
this,play(); // exécute le scénario du clip qui définit le gestionnaire
onPress
}
Domaine du mot-clé « this »
Le mot-clé this fait référence à l’objet dans le domaine en cours d’exécution. Selon le type de
technique de gestionnaire d’événement que vous utilisez, this renvoie à différents objets.
Dans une fonction de gestionnaire d’événement ou d’écouteur d’événement, this fait
référence à l’objet qui définit la méthode du gestionnaire d’événement ou de l’écouteur
d’événement. Dans le code suivant, par exemple, this renvoie à monClip.
// gestionnaire d’événement onPress() associé à _level0.monClip :
monClip.onPress = function () {
trace(this); // affiche "_level0.monClip"
}
Dans un gestionnaire on() associé à un clip, this renvoie au clip auquel le gestionnaire on()
est associé.
// Associé au clip "monClip"
on(press) {
trace(this); // affiche "_level0.monClip"
}
Dans un gestionnaire on() associé à un bouton, this renvoie au scénario qui contient le
bouton.
// Associé à un bouton du scénario principal
on(press) {
trace(this); // affiche "_level0"
}94 Chapitre 4 :  Gestion d’événements95
CHAPITRE 5
Création d’interactivité avec ActionScript
Dans une animation simple, Macromedia Flash Player lit les scènes et les images du fichier SWF
de façon séquentielle. Dans un fichier SWF interactif, votre public utilise le clavier et la souris
pour atteindre les différentes parties du fichier SWF, pour déplacer des objets, entrer des
informations dans des formulaires et effectuer bien d’autres opérations interactives.   
Utilisez ActionScript pour créer des scripts qui indiquent à Flash Player l’action à exécuter
lorsqu’un événement survient. Certains événements pouvant déclencher un script se produisent
lorsque la tête de lecture atteint une image, qu’un clip est chargé ou purgé, ou que l’utilisateur
clique sur un bouton ou appuie sur une touche.
Les scripts peuvent prendre la forme d’une commande unique (pour ordonner la fin de la lecture
d’un fichier SWF, par exemple) ou d’une série de commandes et d’instructions (pour évaluer une
condition avant d’effectuer une action, par exemple). De nombreuses commandes ActionScript
sont simples et permettent de créer des contrôles de base pour un fichier SWF. D’autres actions
exigent une certaine connaissance des langages de programmation et sont destinées à un
développement avancé.
A propos des événements et de l’interaction
Chaque clic de souris ou pression sur une touche entraîne la génération d’un événement. Ces
types d’événements portent généralement le nom d’événements utilisateur, car ils sont générés en
réponse à une action de l’utilisateur final. Vous pouvez utiliser ActionScript pour répondre à ces
événements ou les gérer. Par exemple, lorsqu’un utilisateur clique sur un bouton, il peut être
intéressant d’envoyer la tête de lecture vers une autre image du fichier SWF ou de charger une
nouvelle page dans le navigateur.
Dans un fichier SWF, les boutons, clips et champs de texte génèrent tous des événements auxquels
vous pouvez répondre. ActionScript offre trois manières de gérer les événements : les méthodes
des gestionnaires d’événement, les écouteurs d’événements et les gestionnaires on() et
onClipEvent(). Pour plus d’informations sur les événements et les gestionnaires d’événement,
consultez le Chapitre 4, Gestion d’événements, page 87.
Contrôle de la lecture d’un fichier SWF
Les fonctions ActionScript suivantes vous permettent de contrôler la tête de lecture dans le
scénario et de charger une nouvelle page web dans une fenêtre de navigateur :96 Chapitre 5 :  Création d’interactivité avec ActionScript
• Les fonctions gotoAndPlay() et gotoAndStop() envoient la tête de lecture vers une image ou
une scène. Ce sont des fonctions générales que vous pouvez appeler à partir de tout script. Vous
pouvez également utiliser les méthodes MovieClip.gotoAndPlay() et
MovieClip.gotoAndStop() pour naviguer dans le scénario d’un objet clip spécifique.
• Les actions play() et stop() entraînent la lecture et l’arrêt des animations.
• L’action getURL() permet d’atteindre une URL différente.
Déplacement vers une image ou une scène
Pour atteindre une image ou une scène spécifique du fichier SWF, vous pouvez utiliser les
fonctions globales gotoAndPlay() ou gotoAndStop() ou les méthodes équivalentes
gotoAndPlay() et gotoAndStop() de la classe MovieClip. Chaque fonction ou méthode vous
permet de spécifier l’image de la scène en cours à atteindre. Si le document contient plusieurs
scènes, vous pouvez en plus spécifier celle qui est concernée.
L’exemple suivant utilise la fonction globale gotoAndPlay() dans le gestionnaire d’événement
onRelease d’un objet bouton pour envoyer la tête de lecture du scénario contenant le bouton
vers l’image 10.
jump_btn.onRelease = function () {
gotoAndPlay(10);
}
Dans l’exemple suivant, la méthode MovieClip.gotoAndStop() envoie le scénario d’un clip
nommé categories_mc vers l’image 10 puis s’arrête. Lorsque vous utilisez les méthodes
MovieClip gotoAndPlay() et gotoAndStop(), vous devez indiquer l’occurrence à laquelle elles
s’appliquent.
jump_btn.onPress = function () {
categories_mc.gotoAndStop(10);
}
Lecture et arrêt de clips
Sauf indication contraire, une fois démarré, un fichier SWF exécute toutes les images du scénario.
Vous pouvez arrêter ou démarrer un fichier SWF à l’aide des fonctions globales play() et stop()
ou des méthodes MovieClip équivalentes. Ainsi, la fonction ou la méthode stop() vous permet
d’arrêter un fichier SWF à la fin d’une scène avant de passer à la scène suivante. Une fois un
fichier SWF arrêté, il doit être redémarré au moyen de play().
Vous pouvez utiliser les fonctions play() et stop() ou les méthodes MovieClip pour contrôler le
scénario principal ou le scénario de tout clip ou de tout fichier SWF chargé. Le clip que vous
souhaitez contrôler doit posséder un nom d’occurrence et être présent dans le scénario.
Le gestionnaire on(press) suivant associé à un bouton lance la tête de lecture dans le fichier
SWF ou le clip contenant l’objet bouton.
// Associé à une occurrence de bouton
on (press) {
// Lit le scénario contenant le bouton
play();
}Création d’interactivité et d’effets visuels 97
Ce même code donnerait un résultat différent s’il était associé à un clip plutôt qu’à un bouton.
Lorsqu’elles sont associées à un objet bouton, les instructions faites dans un gestionnaire on()
sont par défaut appliquées au scénario contenant le bouton. En revanche, lorsqu’elles sont
associées à un clip, les instructions définies dans un gestionnaire on() sont appliquées au clip
contenant le gestionnaire.
Le gestionnaire on() suivant, par exemple, arrête le scénario du clip auquel il est associé, et non le
scénario contenant le clip.
on (press) {
stop();
}
Il en va de même pour les gestionnaires onClipEvent() associés à des clips. Le code suivant, par
exemple, arrête le scénario du clip contenant le gestionnaire onClipEvent() lors du premier
chargement du clip ou de sa première apparition sur la scène.
onClipEvent(load) {
stop();
}
Déplacement vers une URL différente
Pour ouvrir une page web dans une fenêtre de navigateur ou pour transmettre des données à une
autre application sur une URL définie, utilisez la fonction globale getURL() ou la méthode
MovieClip.getURL(). Vous pouvez, par exemple, lier un bouton à un nouveau site web ou
envoyer des variables de scénario à un script CGI pour traitement comme s’il s’agissait d’un
formulaire HTML. Vous pouvez également spécifier une fenêtre cible, exactement comme pour le
ciblage d’une fenêtre à l’aide d’une balise d’ancrage HTML (<a></a>).
Par exemple, le code suivant ouvre la page d’accueil macromedia.com dans une fenêtre de
navigateur vide lorsque l’utilisateur clique sur l’occurrence de bouton homepage_btn.
homepage_btn.onRelease = function () {
getURL("http://www.macromedia.com", _blank);
}
Vous pouvez également envoyer des variables avec l’URL, en utilisant GET ou POST. Cette
opération est utile si la page que vous chargez provient d’un serveur d’applications, telle une page
ColdFusion Server (CFM), et attend la réception de variables. Supposons par exemple que vous
souhaitiez charger une page CFM nommée addUser.cfm qui attend deux variables de formulaire,
name et age. Pour ce faire, vous pouvez créer un clip nommé variables_mc qui définit ces deux
variables de la façon suivante :
variables_mc.name = "Francois";
variables_mc.age = 32;
Le code suivant charge ensuite addUser.cfm dans une fenêtre de navigateur vide, puis transmet
variables_mc.name et variables_mc.age à la page CFM dans l’en-tête POST.
variables_mc.getURL("addUser.cfm", "_blank", "POST");
Pour plus d’informations, consultez getURL(), page 394.
Création d’interactivité et d’effets visuels
Pour créer de l’interactivité et d’autres effets visuels, vous devez comprendre les techniques
suivantes : 98 Chapitre 5 :  Création d’interactivité avec ActionScript
• Création d’un pointeur de souris personnalisé
• Obtention de la position de la souris
• Capture des pressions sur les touches
• Définition des valeurs des couleurs
• Création de commandes audio
• Détection des collisions
• Création d’un outil de dessin de ligne simple
Création d’un pointeur de souris personnalisé
Un pointeur de souris standard est la représentation visuelle par le système d’exploitation de la
position de la souris de l’utilisateur. Si vous remplacez le pointeur de souris standard par un
pointeur réalisé dans Flash, vous pouvez intégrer plus étroitement les mouvements de la souris de
l’utilisateur dans le fichier SWF. L’exemple de cette section utilise un pointeur personnalisé qui
ressemble à une grande flèche. Cependant, la puissance de cette fonctionnalité réside dans la
possibilité de donner au pointeur n’importe quelle apparence (par exemple, un ballon de football
qui doit franchir la ligne de but ou un rouleau de tissu que l’utilisateur tire au-dessus d’un canapé
afin de modifier sa couleur).
Pour créer un pointeur personnalisé, vous devez créer son clip sur la scène. Ensuite, dans
ActionScript, masquez le pointeur standard et associez le clip aux mouvements du curseur
personnalisé. Pour masquer le pointeur standard, utilisez la méthode Mouse.hide() de la classe
Mouse intégrée. Pour utiliser un clip comme pointeur personnalisé, utilisez startDrag()
l’action.
Pour créer un pointeur personnalisé :
1 Créez un clip à utiliser comme pointeur et placez une occurrence du clip sur la scène.
2 Sélectionnez l’occurrence de clip sur la scène.
3 Sélectionnez Fenêtre > Panneaux de développement > Actions pour ouvrir le panneau Actions
si ce dernier n’est pas déjà visible.
4 Tapez ce qui suit dans le panneau Actions :
onClipEvent(load) {
Mouse.hide();
startDrag(this, true);
}
onClipEvent(mouseMove) {
updateAfterEvent();
}
Le premier gestionnaire onClipEvent() masque le pointeur de la souris lors de la première
apparition du clip sur la scène. Le second gestionnaire appelle updateAfterEvent() chaque
fois que l’utilisateur déplace la souris.
La fonction updateAfterEvent() actualise l’écran dès que l’événement spécifié s’est produit,
sans attendre le dessin de l’image suivante, ce qui correspond au comportement par défaut.
Pour plus d’informations, consultez updateAfterEvent(), page 734.
5 Sélectionnez Contrôle > Tester l’animation pour tester votre pointeur personnalisé.Création d’interactivité et d’effets visuels 99
Les boutons fonctionnent encore lorsque vous utilisez un pointeur personnalisé. Il est conseillé de
placer le pointeur personnalisé sur le calque supérieur du scénario, de sorte qu’il s’affiche au
premier plan, par-dessus les boutons et autres objets, lorsque vous le déplacez dans le fichier SWF.
De plus, l’extrémité d’un pointeur personnalisé est le point d’alignement du clip que vous utilisez
comme pointeur. Pour qu’elle corresponde à une partie spécifique du clip, définissez donc les
coordonnées du point d’alignement de façon à ce qu’ils coïncident avec ce point.
Pour plus d’informations sur les méthodes de la classe Mouse, consultez l’entrée correspondante
dans le Chapitre 12, Dictionnaire ActionScript Présentation, page 211.
Obtention de la position de la souris
Vous pouvez utiliser les propriétés _xmouse et _ymouse pour déterminer la position du pointeur
de la souris (curseur) dans un fichier SWF. Chaque scénario possède une propriété _xmouse et
_ymouse qui renvoie l’emplacement de la souris dans son système de coordonnées. La position est
toujours donnée par rapport au point d’alignement. Dans le scénario principal (_level0), le
point d’alignement se trouve dans le coin supérieur gauche.
Les propriétés _xmouse et _ymouse dans le scénario principal et dans le scénario d’un clip
Les procédures suivantes représentent deux manières d’obtenir la position de la souris.
Pour obtenir la position actuelle de la souris dans le scénario principal :
1 Créez deux champs de texte dynamiques et nommez-les x_pos et y_pos.
2 Sélectionnez Fenêtre > Panneaux de développement > Actions pour ouvrir le panneau Actions
si ce dernier n’est pas déjà visible.
3 Pour renvoyer la position de la souris dans le scénario principal, ajoutez le code suivant à une
image du fichier SWF _level0 :
x_pos = _root._xmouse;
y_pos = _root._ymouse;
Les variables x_pos et y_pos sont utilisées en tant que conteneurs pour stocker les valeurs des
positions de la souris. Vous pouvez utiliser ces variables dans n’importe quel script de votre
document. Dans le gestionnaire onClipEvent() suivant, les valeurs de x_pos et y_pos sont mises
à jour à chaque fois que l’utilisateur déplace la souris.
onClipEvent(mouseMove) {
x_pos = _root._xmouse;100 Chapitre 5 :  Création d’interactivité avec ActionScript
y_pos = _root._ymouse;
}
Pour obtenir la position actuelle de la souris dans un clip :
1 Créez un clip.
2 Sélectionnez l’occurrence de clip sur la scène. Utilisez l’inspecteur des propriétés pour le
nommer monClip.
3 Sélectionnez Fenêtre > Panneaux de développement > Actions pour ouvrir le panneau Actions
si ce dernier n’est pas déjà visible.
4 Utilisez le nom de l’occurrence de clip pour renvoyer la position de la souris dans le scénario
principal.
Par exemple, vous pouvez placer l’instruction suivante dans tout scénario du fichier SWF
_level0 pour renvoyer la position _ymouse dans l’occurrence monClip :
x_pos = _root.monClip._xmouse
y_pos = _root.monClip._ymouse
Le code renvoie les positions _xpos et _ypos de la souris par rapport au point d’alignement.
5 Sélectionnez Contrôle > Tester l’animation pour tester l’animation.
Vous pouvez également déterminer la position de la souris dans un clip en utilisant les propriétés
_xmouse et _ymouse dans un événement de clip, comme illustré dans le code suivant :
onClipEvent(enterFrame){
xmousePosition = this._xmouse;
ymousePosition = this._ymouse;
}
Pour plus d’informations sur les propriétés _xmouse et _ymouse, consultez MovieClip._xmouse,
page 537 et MovieClip._ymouse, page 538.
Capture des pressions sur les touches
Vous pouvez utiliser les méthodes de la classe intégrée Key pour détecter la dernière touche sur
laquelle l’utilisateur a appuyé. La classe Key ne requiert aucune fonction constructeur ; appelez
simplement ses méthodes sur la classe même, comme illustré dans l’exemple suivant :
Key.getCode();
Vous pouvez obtenir des codes virtuels ou des valeurs ASCII (American Standard Code for
Information Interchange) des pressions sur les touches :
• Pour obtenir le code réel de la dernière touche enfoncée par l’utilisateur, utilisez la méthode
getCode().
• Pour obtenir la valeur ASCII de la dernière touche enfoncée par l’utilisateur, utilisez la
méthode getAscii().
Un code est affecté à chaque touche physique du clavier. Ainsi, la touche Flèche gauche est
associée au code virtuel 37. L’utilisation d’un code vous permet de vous assurer que les
commandes de votre fichier SWF sont les mêmes sur chaque clavier, quelle que soit la langue ou
la plate-forme utilisée.
Des valeurs ASCII sont affectées aux 127 premiers caractères de chaque jeu de caractères. Les
valeurs ASCII fournissent des informations sur un caractère affiché à l’écran. Par exemple, la lettre
« A » et la lettre « a » ont des valeurs ASCII différentes. Création d’interactivité et d’effets visuels 101
Pour décider des touches que vous allez utiliser et déterminer leurs codes, utilisez l’une des
approches suivantes :
• La liste des codes de touches est publiée dans Annexe C, Touches du clavier et valeurs de code
correspondantes, page 781.
• Utilisez une constante de classe Key. (Dans la boîte à outils Actions, cliquez sur la catégorie
Classes intégrées, sur Animation, sur Touche et sur Constantes.)
• Affectez le gestionnaire onClipEvent() suivant à un clip, puis choisissez Contrôle > Tester
l’animation et appuyez sur la touche souhaitée.
onClipEvent(keyDown) {
trace(Key.getCode());
}
Le code de la touche s’affiche dans le panneau de sortie.
Les méthodes de classe Key sont fréquemment placées dans un gestionnaire d’événement. Dans
l’exemple suivant, l’utilisateur déplace la voiture à l’aide des touches de direction.  La méthode
Key.isDown() indique si la touche enfoncée est la flèche orientée vers la droite, la gauche, le haut
ou le bas. Le gestionnaire d’événement, onEnterFrame, détermine la valeur de
Key.isDown(codeDeTouche) à partir des instructions if. En fonction de la valeur, il indique à
Flash Player de mettre à jour la position de la voiture et d’afficher la direction.
La saisie avec les touches du clavier entraîne le déplacement de la voiture.102 Chapitre 5 :  Création d’interactivité avec ActionScript
La procédure suivante indique comment capturer les pressions sur les touches pour déplacer un
clip vers le haut, le bas, à gauche ou à droite de la scène, en fonction de la touche fléchée utilisée
(haut, bas, gauche ou droite). Le clip est confiné dans une zone arbitraire d’une largeur de
400 pixels et d’une hauteur de 300 pixels. Par ailleurs, un champ de texte indique le nom de la
touche enfoncée.
Pour créer un clip activé via le clavier :
1 Sur la scène, créez un clip qui se déplacera en réponse aux touches fléchées du clavier.
Dans cet exemple, le nom de l’occurrence de clip est voiture.
2 Sur la scène, créez un champ de texte dynamique qui sera mis à jour en fonction de la direction
de la voiture. Utilisez l’inspecteur des propriétés pour lui donner le nom d’occurrence
display_txt.
Remarque : Ne confondez pas le nom des variables avec celui des occurrences. Pour plus
d’informations, consultez A propos des noms d’occurrence et de variable de champ de texte,
page 140.
3 Sélectionnez l’image 1 dans le scénario et, le cas échéant, choisissez Fenêtre > Panneaux de
développement > Actions pour ouvrir le panneau Actions.
4 Pour déterminer la distance parcourue par la voiture à l’écran après chaque pression sur une
touche, définissez une variable distance et fixez sa valeur initiale à 10.
var distance = 10;
5 Pour créer le gestionnaire d’événement du clip voiture qui vérifie quelle touche de direction
(gauche, droite, bas ou haut) est enfoncée, ajoutez le code suivant au panneau Actions :
voiture.onEnterFrame = function() {
}
6 Ajoutez une instruction with au corps du gestionnaire onEnterFrame et spécifiez voiture
comme objet de l’instruction with.
Le code devrait avoir cette forme :
var distance = 10;
voiture.onEnterFrame = function() {
    with (voiture) {
    }
}
7 Pour vérifier si la touche de direction vers la droite est enfoncée et déplacer le clip voiture en
conséquence, ajoutez du code au corps de l’instruction with. Le code devrait avoir cette forme :
distance = 10;
voiture.onEnterFrame = function() {
with (voiture) {
if (Key.isDown(Key.RIGHT)) {
_x += distance;
if (_x >= 400) {
_x = 400;
}
_root.display_txt.text = "Droite";
}
}
}Création d’interactivité et d’effets visuels 103
Si la touche fléchée vers la droite est enfoncée, la propriété _x de la voiture est augmentée de la
valeur spécifiée dans la variable distance. L’instruction if suivante teste si la valeur de la
propriété _x du clip est supérieure ou égale à 400 (if(_x >=400)) ; si tel est le cas, sa position
est fixée à 400. De plus, le mot Droite doit apparaître dans le fichier SWF.
8 Adaptez ce code pour vérifier si les autres touches de direction (gauche, haut ou bas) ont été
enfoncées. Le code devrait avoir cette forme :
var distance = 10;
voiture.onEnterFrame = function() {
with (voiture) {
if (Key.isDown(Key.RIGHT)) {
_x += distance;
if (_x >= 400) {
_x = 400;
}
_root.display_txt.text = "Droite";
} else if (Key.isDown(Key.LEFT)) {
_x -= distance;
if (_x < 0) {
_x = 0;
}
_root.display_txt.text = "Gauche";
} else if (Key.isDown(Key.UP)) {
_y -= distance;
if (_y < 0) {
_y = 0 ;
}
_root.display_txt.text = "Haut";
} else if (Key.isDown(Key.DOWN)) {
_y += distance;
if (_y > 300) {
_y = 300;
}
_root.display_txt.text = "Bas";
}
}
}
9 Choisissez Contrôle > Tester l’animation pour tester le fichier.