Formation à ActionScript 2.0 dans Flash


Télécharger Formation à ActionScript 2.0 dans Flash

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Learning ActionScript 2.0 in Flash FORMATION À ACTIONSCRIPT™ 2.0
DANS FLASH®

© 2007 Adobe Systems Incorporated. Tous droits réservés.
Formation à ActionScript 2.0 dans Flash® 
Si le présent guide est fourni avec un logiciel régi par un contrat d’utilisateur final, ce guide ainsi que le logiciel décrit, sont 
fournis sous licence et peuvent être utilisés ou copiés uniquement selon les clauses et conditions de la licence. A moins d’une 
autorisation expresse accordée par cette licence, aucune partie du présent guide ne peut être reproduite, stockée dans un système 
d’interrogation ou transmise, sous quelque forme ou par quelque moyen que ce soit (électronique, mécanique, par enregistrement 
ou autre) sans l’autorisation écrite préalable d’Adobe Systems Incorporated. Veuillez noter que le contenu du présent guide est 
protégé par la loi sur les droits d’auteur, même s’il n’est pas distribué avec un logiciel régi par un contrat de licence utilisateur 
final. 
Les informations contenues dans le présent guide sont fournies à titre purement informatif ; elles sont susceptibles d’être 
modifiées sans préavis et ne doivent pas être interprétées comme étant un engagement de la part d’Adobe Systems Incorporated. 
Adobe Systems Incorporated n’accepte aucune responsabilité quant aux erreurs ou inexactitudes pouvant être contenues dans le 
présent guide. 
Veuillez noter que les illustrations et images existantes que vous souhaiterez éventuellement inclure dans votre projet sont 
susceptibles d’être protégées par les lois sur les droits d’auteur. L’inclusion non autorisée de tels éléments dans vos nouveaux 
travaux peut constituer une violation des droits du propriétaire. Veuillez vous assurer que vous obtenez toute autorisation 
nécessaire auprès du détenteur du copyright.
Toute référence à des noms de sociétés dans les modèles types n’est utilisée qu’à titre d’exemple et ne fait référence à aucune 
société réelle.
Adobe®, Flash®, FlashHelp®, Flash® Player, JRun™, Macromedia® et Shockwave® sont des marques commerciales ou des marques déposées d’Adobe 
Systems Incorporated aux Etats-Unis et/ou dans d’autres pays.
Macintosh® est une marque commerciale d’Apple Computer, Inc., déposée aux Etats-Unis et dans d’autres pays. Windows® est 
une marque commerciale ou une marque déposée de Microsoft Corporation aux Etats-Unis et/ou dans d’autres pays. Toutes les 
autres marques citées appartiennent à leurs propriétaires respectifs.
Certaines parties de ce produit contiennent du code utilisé sous licence de Nellymoser. (). 
Technologie de compression et décompression vidéo Sorenson Spark™ utilisée sous licence de 
Sorenson Media, Inc.
La vidéo de Flash CS3 est optimisée par la technoogie vidéo On2 TrueMotion. © 1992-2005 On2 Technologies, Inc. Tous droits 
réservés. .
Adobe Systems Incorporated, 345 Park Avenue, San Jose, Californie 95110, Etats-Unis. A l’attention des utilisateurs du 
Gouvernement des Etats-Unis. Ce logiciel et sa documentation sont des « articles commerciaux », conformément à la définition 
de ce terme dans le document 48 C.F.R. §2.101, comprenant d’une part un « logiciel informatique commercial » et d’autre part 
une « documentation de logiciel informatique commercial », conformément à la définition de ces termes dans le document 
48 C.F.R. §12.212 ou 48 C.F.R. §227.7202, si approprié. Conformément aux documents 48 C.F.R. §12.212 ou 48 C.F.R. 
§§227.7202-1 à 227.7202-4, si approprié, le logiciel informatique commercial et la documentation de logiciel informatique 
commercial sont accordés sous licence aux tilisateurs du Gouvernement des Etats-Unis (a) uniquement en tant que produits 
commerciaux et (b) uniquement avec les droits accordés à tous les autres utilisateurs selon les termes et conditions mentionnés 
dans le présent contrat. Droits non publiés réservés dans le cadre des lois sur les droits d’auteur en vigueur aux Etats-Unis. Adobe 
Systems Incorporated, 345 Park Avenue, San Jose, CA 95110-2704, Etats-Unis. A l’attention des utilisateurs du Gouvernement 
des Etats-Unis, Adobe s’engage à respecter la législation relative à l’égalité des chances y compris, le cas échéant, les dispositions 
du décret 11246, tel qu’amendé, à la section 402 de la loi sur l’assistance aux vétérans du Vietnam (Vietnam Era Veterans 
Readjustment Assistance Act) de 1974 (38 USC 4212), et à la section 503 de la loi sur la réadaptation (Rehabilitation Act) de 
1973, telle qu’amendée, et la réglementation des articles 41 CFR, alinéas 60-1 à 60-60, 60-250 et 60-741. La clause relative à 
l’égalité des chances et les règlements énoncés dans la phrase précédente doivent être compris comme tels lorsqu’il y est fait 
référence.

Table des matières
Introduction  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Ressources supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Chapitre 1 : Nouveautés du langage ActionScript de Flash . . . . . 19
installés localement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  29
Chapitre 2 : A propos d’ActionScript . . . . . . . . . . . . . . . . . . . . . . . 31
Présentation d’ActionScript et de Flash Player  . . . . . . . . . . . . . . . . . .  34
Chapitre 3 : Données et types de données  . . . . . . . . . . . . . . . . .  35
Attribution  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
de la syntaxe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Présentation des instructions  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .109
3

Présentation des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Chapitre 5 : Fonctions et méthodes . . . . . . . . . . . . . . . . . . . . . . . .171
Fonctionnement des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Chapitre 6 : Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Utilisation des classes intégrées  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .274
Chapitre 7 : Héritage  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Utilisation du polymorphisme dans une application. . . . . . . . . . . . . .  290
Chapitre 8 : Interfaces  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  295
Exemple : Création d’une interface complexe . . . . . . . . . . . . . . . . . . . .307
Chapitre 9 : Gestion d’événements  . . . . . . . . . . . . . . . . . . . . . . .  311
Création de clips avec des états de bouton . . . . . . . . . . . . . . . . . . . . . .326
4
Table des matières

Utilisation de la classe Delegate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331
Chapitre 10 : Utilisation des clips  . . . . . . . . . . . . . . . . . . . . . . . .  335
Initialisation des propriétés de classe. . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Chapitre 11 : Utilisation du texte et des chaînes . . . . . . . . . . . . .  367
Présentation des chaînes et de la classe String  . . . . . . . . . . . . . . . . . 443
Chapitre 12 : Animation, Filtres et Dessins  . . . . . . . . . . . . . . . .  463
A propos des modes de fondu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
Table des matières
5

de découpe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
Chapitre 13 : Création d’interactivité avec ActionScript  . . . . .  557
Structure d’un exemple de script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .585
Chapitre 14 : Utilisation des images, du son et de la vidéo  . . .  589
Création d’animation de progression pour les fichiers média  . . . . . .623
Chapitre 15 : Utilisation de données externes . . . . . . . . . . . . . . . 631
A propos de l’API externe  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .665
Chapitre 16 : Fonctionnement de la sécurité . . . . . . . . . . . . . . . .675
les fichiers SWF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
6
Table des matières

de programmation pour ActionScript 2.0. . . . . . . . . . . . . . . . . . . 715
Mise en forme de la syntaxe ActionScript. . . . . . . . . . . . . . . . . . . . . . .  750
Annexe A : Messages d’erreur. . . . . . . . . . . . . . . . . . . . . . . . . . .  759
Annexe B : Opérateurs Flash 4 déconseillés . . . . . . . . . . . . . . .  765
correspondantes  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .767
antérieures de Flash Player  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .773
Flash Player 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  774
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .777
ActionScript 1.0  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  787
Index  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791
Table des matières
7

8
Table des matières

Introduction
Adobe Flash CS3 Professional est l’outil préféré des professionnels pour la création de contenu 
Web percutant. Le langage ActionScript permet de rendre les applications Flash plus 
interactives, qu’il s’agisse de simples fichiers SWF animés ou d’applications Internet plus 
complexes. Vous pouvez très bien utiliser Flash sans ActionScript. Toutefois, si l’interactivité 
des utilisateurs est un critère important ou si vous souhaitez utiliser des objets autres que ceux 
intégrés dans Flash (boutons et clips) ou créer des applications plus complexes à partir de 
fichiers SWF, il est probable que vous aurez recours à ActionScript.
Pour plus d’informations, voir les sections suivantes :
Public visé  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  9
Mise à jour des fichiers XML Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  10
Configuration système requise  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  10
Présentation de la documentation  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Ressources supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  14
Public visé
Ce manuel suppose que vous avez déjà installé Flash et savez comment utiliser l’interface 
 devez également savoir comment placer des objets sur la scène et les 
manipuler dans l’environnement de programmation de Flash. Si vous avez déjà utilisé un 
langage de programmation, vous vous sentirez en terrain connu avec ActionScript. 
Cependant, si vous êtes novice en programmation, les bases d’ActionScript sont faciles à 
apprendre. Commencez par les commandes de base, puis abordez progressivement les 
éléments plus complexes. Vous pouvez donc accroître l’interactivité de vos fichiers sans avoir à 
apprendre (ou à écrire) beaucoup de code.
9

Configuration système requise
La configuration système requise par ActionScript 2.0 est identique à celle de Flash.
Flash CS3 Professional introduit ActionScript 3.0. Flash Player 9 et ActionScript 3.0 sont les 
paramètres de publication par défaut de Flash. Ce manuel fournit des informations sur 
l’utilisation d’ActionScript 2.0 avec Flash. Vous devez modifier les paramètres de publication 
de vos fichiers Flash sur Flash Player 9 et ActionScript 2.0. Si vous ne modifiez pas ces 
paramètres, les explications et les exemples de code qui figurent dans la documentation 
risquent de ne pas fonctionner correctement. Si vous développez des applications pour les 
versions précédentes de Flash Player, reportez-vous à là des versions antérieures de Flash Player », à la page 773.
Mise à jour des fichiers XML Flash 
Il est essentiel de disposer en permanence des fichiers Flash XML les plus récents. Adobe 
introduit parfois de nouvelles fonctionnalités dans les versions secondaires de Flash Player. 
Lorsque ce type de version est disponible, vous devez mettre votre version de Flash à jour. 
Sinon, le compilateur de Flash risque de générer des erreurs si vous utilisez de nouvelles 
propriétés ou méthodes non disponibles dans la version de Flash Player livrée avec votre 
installation Flash.
Par exemple, Flash Player 7 (7.0.19.0) contient une nouvelle méthode pour l’objet System, 
System.security.loadPolicyFile. Pour accéder à cette méthode, vous devez utiliser le 
programme d’installation des mises à jour de Flash Player. Sinon, le compilateur Flash affiche 
des erreurs.
N’oubliez pas que vous pouvez installer Player Updater même si ce programme a plusieurs 
versions d’avance sur votre version de Flash. Ainsi, vous bénéficiez des fichiers XML 
nécessaires sans rencontrer d’erreurs de compilation lorsque vous publiez des documents 
destinés à des versions plus anciennes de Flash Player. Certaines nouvelles méthodes ou 
propriétés sont disponibles pour les anciennes versions. Le fait de disposer des fichiers XML 
réduit le risque d’erreurs de compilation lorsque vous tentez d’accéder à d’anciennes méthodes 
ou propriétés.
10
Introduction

Présentation de la documentation
Ce manuel passe en revue les principes généraux de la syntaxe ActionScript et explique 
comment utiliser ce langage pour intervenir sur différents types d’objet. Pour plus 
d’informations sur la syntaxe et l’utilisation de chaque élément, consultez le Guide de référence 
du langage ActionScript 2.0

Pour plus d’informations, voir les sections suivantes :
?
« Présentation du manuel Formation à ActionScript 2.0 », à la page 11
?
« Présentation des fichiers d’exemple », à la page 15
?
« Terminologie utilisée dans ce manuel », à la page 13
?
« Copie et collage de code », à la page 14
Présentation du manuel Formation à 
ActionScript 2.0
La liste suivante récapitule le contenu du manuel :
?
Chapitre 1, « Nouveautés du langage ActionScript de Flash », décrit les nouvelles 
fonctions d’ActionScript, les modifications apportées au module de compilation et 
débogage, ainsi que le nouveau modèle de programmation du langage ActionScript 2.0.
?
Chapitre 2, « A propos d’ActionScript », définit le langage ActionScript et explique 
comment choisir la version d’ActionScript à utiliser.
?
Chapitre 3, « Données et types de données », décrit la terminologie et les concepts de base 
sur les données, les types de données et les variables. Vous aurez recours à ces concepts tout 
au long du manuel.
?
et les concepts de base du langage ActionScript. Vous aurez recours à ces concepts tout au 
long du manuel.
?
Chapitre 5, « Fonctions et méthodes », explique comment écrire différents types de 
fonctions et de méthodes et comment les utiliser dans votre application.
?
Chapitre 6, « Classes », explique comment créer des classes et des objets personnalisés dans 
ActionScript. Ce chapitre affiche également la liste des classes intégrées dans ActionScript 
et offre un bref aperçu de leur application pour accéder aux fonctions puissantes du code 
ActionScript.
?
Chapitre 7, « Héritage », décrit l’héritage dans le langage ActionScript et explique 
comment étendre des classes personnalisées ou intégrées.
Présentation de la documentation
11

?
Chapitre 8, « Interfaces », explique comment créer et utiliser les interfaces dans 
ActionScript.
?
Chapitre 9, « Gestion d’événements », décrit les différentes façons de gérer les 
événements : méthodes de gestionnaire d’événement, écouteurs d’événement et 
gestionnaires d’événement de bouton et de clip.
?
Chapitre 10, « Utilisation des clips », décrit les clips et le code ActionScript qui permet de 
les contrôler.
?
Chapitre 11, « Utilisation du texte et des chaînes », décrit les différentes façons mises à 
votre disposition pour contrôler le texte et les chaînes dans Flash et comprend des 
informations sur la mise en forme du texte et de l’anti-aliasing avancé.
?
Chapitre 12, « Animation, Filtres et Dessins », explique comment créer des images et des 
animations à base de code, ajouter des filtres aux objets et dessiner à l’aide d’ActionScript.
?
Chapitre 13, « Création d’interactivité avec ActionScript », décrit des méthodes simples de 
création d’applications plus interactives, ce qui inclut le contrôle de la lecture des fichiers 
SWF, la création de pointeurs personnalisés et la création de contrôles audio.
?
Chapitre 14, « Utilisation des images, du son et de la vidéo », spécifie comment importer 
des fichiers de supports externes, tels que des images bitmap, des fichiers MP3, des fichiers 
FLV (Flash Video) et autres fichiers SWF dans vos applications Flash. Ce chapitre 
explique également comment utiliser la vidéo dans vos applications et comment créer des 
animations de chargement avec barre de progression.
?
Chapitre 15, « Utilisation de données externes », indique comment traiter les données des 
sources externes en utilisant des scripts côté serveur ou client dans vos applications. 
Ce chapitre explique comment intégrer des données dans vos applications.
?
Chapitre 16, « Fonctionnement de la sécurité », explique comment la sécurité est mise en 
oeuvre dans Flash Player, en ce qui concerne l’utilisation locale de fichiers SWF sur votre 
disque dur. Ce chapitre décrit également les problèmes de sécurité inter-domaines et 
explique comment charger des données à partir de serveur ou à travers des domaines.
?
2.0 », détaille les meilleures pratiques d’utilisation de Flash et d’écriture de code 
ActionScript. Ce chapitre dresse également la liste des conventions de codage normalisées, 
notamment en matière d’appellation des variables, et d’autres conventions.
?
Annexe A, « Messages d’erreur », dresse la liste des messages d’erreur que le compilateur 
Flash est susceptible de générer.
?
Annexe B, « Opérateurs Flash 4 déconseillés », dresse la liste de tous les opérateurs Flash 4 
déconseillés et leur associativité.
12
Introduction

?
Annexe C, « Touches du clavier et valeurs de code correspondantes », répertorie toutes les 
touches d’un clavier standard et les valeurs de code ASCII correspondantes utilisées pour 
identifier les touches dans ActionScript.
?
fournit des consignes pour la syntaxe des scripts en fonction de la version de Flash Player 
ciblée.
?
Annexe E, « Programmation orientée objet avec ActionScript 1.0 », fournit des 
informations sur l’utilisation du modèle d’objet ActionScript 1.0 pour écrire des scripts.
Ce manuel explique comment utiliser le langage ActionScript. Pour plus d’informations sur 
les éléments de langage, consultez le Guide de référence du langage ActionScript 2.0.
Conventions typographiques
Ce manuel utilise les conventions typographiques suivantes :
?
La police de code indique le code ActionScript.
?
La police de code en gras, généralement utilisée dans les procédures, signale le code 
à modifier ou à ajouter au code déjà inséré dans votre fichier FLA. Dans certains cas, elle 
peut signaler le code à examiner.
?
Le texte en gras indique des données à saisir dans l’interface utilisateur, telles que le nom 
d’un fichier ou d’une occurrence.
?
Le texte en italique indique un terme nouveau défini dans la suite du texte. Dans un 
chemin de fichier, il peut indiquer une valeur à remplacer (par exemple par le nom d’un 
répertoire de votre propre disque dur).
Terminologie utilisée dans ce manuel
Ce manuel emploie les termes suivants :
?
Vous fait référence au programmeur qui développe un script ou une application.
?
L’utilisateur désigne la personne qui exécute vos scripts et applications.
?
La compilation correspond à la phase de publication, d’exportation, de test ou de débogage 
de votre document. 
?
L’exécution représente le moment auquel votre script s’exécute dans Flash Player. 
Présentation de la documentation
13

Copie et collage de code 
Vous devez faire particulièrement attention aux caractères spéciaux lorsque vous collez des 
éléments ActionScript du panneau Aide vers votre fichier FLA ou ActionScript. Parmi les 
caractères spéciaux figurent des guillemets spéciaux (également appelés guillemets anglais ou 
guillemets typographiques). Ces caractères ne sont pas interprétés par l’éditeur ActionScript. 
Par conséquent, votre code renvoie une erreur si vous tentez de les compiler dans Flash.
Vous pouvez déterminer que vos guillemets sont des caractères spéciaux si leur code couleur 
n’est pas correct. En d’autres termes, si toutes vos chaînes ne changent pas de couleur dans 
l’éditeur de code, vous devez remplacer les caractères spéciaux par des guillemets droits 
classiques. Si vous tapez un guillemet simple ou double directement dans l’éditeur 
ActionScript, utilisez toujours un guillemet droit. Le compilateur (lors du test ou de la 
publication d’un fichier SWF) renvoie une erreur et indique si votre code comporte le 
mauvais type de caractère (guillemets spéciaux ou guillemets anglais).
REMARQUE
Vous pouvez également rencontrer des guillemets spéciaux lorsque vous collez des 
éléments ActionScript à partir d’autres emplacements, tels qu’une page Web ou un 
document Microsoft Word.
Veillez à respecter les sauts de ligne lorsque vous copiez et collez du code. Si vous collez du 
code à partir de différents emplacements, les sauts de la ligne de code peuvent être situés au 
mauvais endroit. Assurez-vous que le code couleur de votre syntaxe est correct dans l’éditeur 
ActionScript si vous pensez que les sauts de ligne peuvent poser problème. Si vous le 
souhaitez, comparez votre code du panneau Actions à celui du panneau Aide pour voir s’ils 
correspondent. Essayez d’activer le retour à la ligne dans l’éditeur ActionScript pour vous aider 
à résoudre l’excédent de sauts de ligne dans votre code (sélectionnez Affichage > Retour à la 
ligne dans la fenêtre de script ou Retour à la ligne dans le menu déroulant du panneau 
Actions).
Ressources supplémentaires
En plus de ce manuel sur ActionScript, vous pouvez consulter des manuels sur d’autres sujets 
liés à Flash, tels que les composants et Adobe Flash Lite. Vous pouvez accéder à chaque 
manuel dans le panneau Aide (Aide > Aide de Flash), en consultant le Sommaire par défaut. 
Cliquez sur le bouton Effacer pour faire apparaître chaque manuel disponible. Pour plus 
d’informations, consultez la section la page 17. 
14
Introduction

Pour plus d’informations sur les autres ressources disponibles, consultez les sections suivantes :
?
« Présentation des fichiers d’exemple », à la page 15
?
« Emplacement des fichiers PDF et de la documentation imprimée », à la page 15
?
« Présentation de LiveDocs », à la page 16
?
« Ressources en ligne supplémentaires », à la page 17
?
« Documentation se rapportant à d’autres sujets », à la page 17
Présentation des fichiers d’exemple 
De nombreux fichiers d’exemple basés sur ActionScript sont installés avec Flash. Ces fichiers 
montrent comment le code fonctionne dans un fichier FLA. Ils constituent généralement un 
outil d’apprentissage utile. Les chapitres de ce manuel font souvent référence à ces fichiers 
mais nous vous recommandons également de consulter le dossier de fichiers d’exemple de 
votre disque dur. 
Parmi les fichiers d’exemple figurent des fichiers d’application FLA qui utilisent des 
fonctionnalités Flash installées avec Flash. Ces applications ont été conçues pour présenter les 
fonctionnalités des applications Flash aux nouveaux développeurs et illustrer le contexte de ces 
fonctions pour les développeurs plus expérimentés. 
Pour des exemples de fichiers source axés sur le code ActionScript, reportez-vous à la page des 
exemples Flash à l’adresse  Téléchargez et 
décompressez le fichier zip Exemples et naviguez jusqu’au dossier ActionScript2.0 afin 
d’accéder aux exemples. Pour des fichiers exemples axés sur les composants, vous pouvez 
naviguer jusqu’au dossier ComponentsAS2.
Emplacement des fichiers PDF et de la 
documentation imprimée
Si vous préférez lire la documentation sur copie papier, les versions PDF de chaque manuel 
d’aide sont disponibles en téléchargement. Accédez à 
;et sélectionnez le produit qui vous intéresse. 
Vous pouvez consulter ou télécharger le PDF ou accéder à la version LiveDocs du manuel.
Généralement, vous pouvez également acquérir la version imprimée de la documentation. 
Pour obtenir des informations à jour, accédez au site contenant la documentation.
Ressources supplémentaires
15

Présentation de LiveDocs 
Vous pouvez accéder à la documentation à partir du panneau Aide mais également sur le site 
Web LiveDocs. Ce site contient toutes les pages d’aide de Flash ainsi que des commentaires 
qui précisent, actualisent ou rectifient des parties de la documentation. Pour afficher la page 
équivalente sur le site Web LiveDocs, il suffit de cliquer sur Commentaires sur LiveDocs au 
bas d’une page du panneau Aide. Accédez à  pour consulter la liste 
de toute la documentation disponible au format LiveDocs.
Le site Web LiveDocs est surveillé par des rédacteurs techniques. L’un des avantages de 
LiveDocs réside dans la possibilité de consulter des commentaires qui clarifient la 
documentation ou qui corrigent des problèmes rencontrés après la publication d’un logiciel. 
LiveDocs n’est pas un endroit où soumettre des demandes d’assistance. Par exemple, vous ne 
pouvez pas poser de questions au sujet de code que vous ne parvenez pas à faire fonctionner, ni 
commenter des problèmes de logiciel ou d’installation, ni demander comment créer quelque 
chose avec Flash. LiveDocs est un endroit destiné à fournir des réactions au sujet de la 
documentation (par exemple si vous remarquez une phrase ou un paragraphe qui mériterait 
d’être clarifié).
Lorsque vous cliquez sur le bouton permettant d’ajouter un commentaire dans LiveDocs, 
vous verrez plusieurs remarques relatives au type de commentaires admis sur le système. 
Lisez attentivement ces instructions, faute de quoi vous risquez de voir votre commentaire 
supprimé du site Web. 
Si vous voulez poser une question au sujet de Flash, posez-la dans les forums Web d’Adobe : 
;Les forums Web sont le meilleur endroit où poser vos 
questions, car ils sont consultés par de nombreux employés d’Adobe, des volontaires de 
l’équipe Adobe, des gestionnaires et membres de groupes d’utilisateurs Adobe, voire des 
rédacteurs techniques. 
Les ingénieurs ne contrôlent pas le système LiveDocs mais ils surveillent la liste de souhaits 
pour Flash. Si vous pensez avoir découvert un bogue dans votre logiciel ou si vous souhaitez 
demander une amélioration de Flash, veuillez remplir le formulaire approprié à l’adresse 
suivante :  Si vous soumettez votre découverte de bogue ou votre 
demande d’amélioration sur LiveDocs, elle ne sera pas officiellement ajoutée à la base de 
données des bogues. Si vous voulez qu’un ingénieur tienne compte de votre bogue ou de votre 
demande, vous devez utiliser la liste de souhaits.
N’oubliez pas de faire attention aux caractères spéciaux et aux sauts de ligne lorsque vous 
collez du texte à partir d’Internet, y compris à partir de LiveDocs. Adobe a tout mis en oeuvre 
pour supprimer tous les caractères spéciaux des exemples de code mais si vous avez encore des 
difficultés lors du collage du code, consultez la sectiola page 14.
16
Introduction

Ressources en ligne supplémentaires
De nombreuses ressources en ligne offrent une abondance d’instructions, d’aides et de 
procédures qui vous guideront dans votre découverte de Flash. Consultez régulièrement les 
sites Web suivants pour être informé(e) des mises à jour :
Le Pôle de développement Adobe () est régulièrement actualisé 
et propose les informations les plus récentes sur Flash, ainsi que des conseils d’utilisateurs 
expérimentés, des rubriques avancées, des exemples, des astuces, des didacticiels en plusieurs 
parties et d’autres mises à jour. Consultez régulièrement ce site Web pour vous tenir au 
courant des nouveautés de Flash et tirer le meilleur parti de votre logiciel.
Le Centre de support Adobe Flash () fournit des 
TechNotes, des mises à jour de la documentation et des liens vers des ressources 
supplémentaires dans la communauté Flash.
Le site Web des blogs Adobe () fournit la liste des blogs des 
employés et de la communauté Adobe (également appelés Weblogs). 
Les forums Adobe () offrent de nombreuses 
discussions sur des questions spécifiques relatives à Flash, à vos applications ou au langage 
ActionScript. Ces forums sont surveillés par des volontaires de l’équipe Adobe et également 
régulièrement consultés par des employés d’Adobe. Si vous ne savez pas à qui vous adresser ou 
comment résoudre un problème, commencez par consulter un forum Flash.
La Communauté Adobe () héberge 
régulièrement des MacroChats, séries de présentations en direct sur divers sujets et menées par 
les employés ou les membres de la communauté Adobe. Consultez régulièrement le site Web 
pour être informé(e) des mises à jour.
Documentation se rapportant à d’autres sujets
Les manuels suivants fournissent des informations supplémentaires sur des sujets 
généralement associés à ActionScript 2.0 :
?
Pour plus d’informations sur les éléments qui composent le langage ActionScript, 
consultez le Guide de référence du langage ActionScript 2.0.
?
Pour plus d’informations sur l’utilisation de l’environnement de programmation de Flash, 
consultez la section Comment utiliser l’Aide.
?
Pour en savoir plus sur l’utilisation des composants, consultez la section Utilisation des 
composants ActionScript 2.0
.
Ressources supplémentaires
17

18
Introduction

CHAPITRE 1 
Nouveautés du langage 
1
ActionScript de Flash
Adobe Flash CS3 Professional bénéficie de plusieurs améliorations qui vous permettront 
d’écrire aisément des scripts fiables à l’aide du langage ActionScript. Ces améliorations, 
décrites dans le présent chapitre, portent notamment sur de nouveaux éléments de langage 
(consultez la section la page 23), des outils d’édition améliorés (consultez la section ActionScript », à la page 28), des changements dans les modèles de sécurité et sur d’autres 
améliorations apportées à cet outil de programmation dans ActionScript. 
Pour plus d’informations, consultez les sections suivantes :
Nouveau dans ActionScript 2.0 et Flash Player 9.x. . . . . . . . . . . . . . . . . . . . . . . . . . .  19
Nouveau dans ActionScript 2.0 et Flash Player 8  . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Modifications du modèle de sécurité pour les fichiers SWF installés localement . . . .  29
Nouveau dans ActionScript 2.0 et Flash 
Player 9.x
Flash Player 9.x permet à un utilisateur d’activer et de désactiver le mode plein écran de Flash 
Player. Les éléments suivants prennent en charge cette nouvelle fonctionnalité :
?
Propriété Stage.displayState
?
Gestionnaire d’événements Stage.onFullScreen
?
Paramètre allowFullScreen contenu dans les balises HTML object et embed
Pour plus d’informations, consultez le Guide de référence du langage ActionScript 2.0.
Flash Player 9.x introduit également un nouvel événement FileReference, 
onUploadCompleteData. Cet événement peut être appelé après réception d’un chargement 
réussi par le serveur. Pour plus d’informations sur cet élément, consultez le Guide de référence 
du langage ActionScript 2.0
.
19

Nouveau dans ActionScript 2.0 et Flash 
Player 8
Depuis son introduction il y a quelques années de cela, le langage ActionScript n’a cessé de se 
développer. A chaque nouvelle version de Flash, de nouveaux mots-clés, objets, méthodes et 
autres éléments de langage ont été ajoutés à ActionScript. Des améliorations s’articulant 
autour d’ActionScript sont également apportées aux environnements de programmation de 
Flash 8. Flash Basic 8 et Flash Professional 8 présentent plusieurs nouveaux éléments de 
langage dédiés aux fonctionnalités fiables, tels que les filtres et les modes de fondu, et le 
développement d’applications, comme par exemple l’intégration JavaScript 
(ExternalInterface) et le fichier d’entrée/sortie (FileReference et FileReferenceList). 
Cette section présente une vue d’ensemble des éléments de langage et des classes 
d’ActionScript qui sont nouveaux ou modifiés dans Flash 8, ainsi que les améliorations de 
l’outil de programmation qui s’articulent autour d’ActionScript. Pour obtenir une liste de 
suppléments spécifiques dans ActionScript 2.0, consultlangage ActionScript de Flash Player 8 », à la page 23. Pour pouvoir utiliser ces nouveautés 
dans vos scripts, vous devez cibler Flash Player 8 lors de la publication des documents.
Flash Basic 8 et Flash Professional 8 comprennent les fonctions nouvelles suivantes (sauf avis 
contraire) :
?
Les améliorations de l’éditeur ActionScript vous permettent de faire apparaître des 
éléments cachés dans vos scripts. Pour plus d’informations, consultez la section « Affichage 
des caractères masqués » dans le guide Utilisation de Flash.
?
Les options de débogage sont désormais disponibles dans la fenêtre Script, ainsi que le 
panneau Actions, pour les fichiers ActionScript.
?
Le répertoire de configuration qui comprend des fichiers XML et des fichiers de classe a 
été réorganisé. Voir la section « Dossiers de configuration installés avec Flash » dans le 
guide Utilisation de Flash pour plus de détails.
?
Vous pouvez régler une préférence pour recharger les fichiers de script modifiés lorsque 
vous travaillez sur une application, ce qui vous évite de travailler avec des versions de 
fichiers script plus anciennes et d’écraser des fichiers script plus récents. Pour plus 
d’informations, consultez la section « Définition des préférences d’ActionScript » dans le 
guide Utilisation de Flash.
?
La fonctionnalité de la fenêtre Script est disponible dans Flash. Ainsi, vous pouvez 
maintenant créer un fichier ActionScript dans l’un ou l’autre programme.
20
Nouveautés du langage ActionScript de Flash

?
L’Assistant de Script (similaire au mode normal dans des éditions plus anciennes de Flash) 
vous aide à coder sans besoin de comprendre la syntaxe. Pour plus d’informations, 
consultez la section « Présentation du mode Assistant de script » dans le guide Utilisation 
de Flash
.
?
En cours d’exécution, vous pouvez charger de nouveaux types de fichiers image, y compris 
des images JPEG progressives et des fichiers GIF et PNG non-animés. Si vous chargez un 
fichier animé, la première image de l’animation apparaît. 
?
Vous pouvez assigner des identifiants de liaison à des fichiers bitmap et des fichiers audio 
stockés dans la Bibliothèque, ainsi vous pouvez associer des images à la scène ou travailler 
avec ces éléments dans des bibliothèques partagées. 
?
La mémoire cache bitmap vous permet d’améliorer la performance de vos applications en 
cours d’exécution en mettant sous mémoire cache une représentation bitmap de vos 
occurrences. Vous pouvez utiliser le code ActionScript pour accéder à cette propriété. 
Pour plus d’informations, voir performances », à la page 474.
?
La mise à l’échelle à 9 niveaux vous permet de redimmensionner les occurrences de clips 
sans élargir les traits du contour du clip. Vous pouvez utiliser le code ActionScript pour 
accéder à cette fonctionnalité dans Flash. Pour plus d’informations, voir mise à l’échelle à 9 découpes dans ActionScript », à la page 554. Pour plus d’informations 
sur l’accès à la mise à l’échelle à 9 niveaux dans l’outil de programmation, consultez le 
guide Utilisation de Flash.
?
Vous pouvez maintenant ajouter des informations sur les métadonnées à vos fichiers FLA 
dans la boîte de dialogue Propriétés du document. Vous pouvez ajouter un nom et une 
description à votre fichier FLA en utilisant la boîte de dialogue pour une meilleure 
visibilité de recherche en ligne. 
?
Le panneau Chaînes a été amélioré et inclut désormais une prise en charge multiligne dans 
le champ Chaîne et dans le fichier de langue XML. Pour plus d’informations, voir 
« panneau », à la page 445.
?
Un nouveau nettoyeur de mémoire a été intégré dans Flash Player, qui utilise un nettoyeur 
incrémentiel pour améliorer les performances. 
?
Le rendement de création d’applications accessibles a été amélioré. Avec Flash Player 8, les 
développeurs n’ont plus besoin d’ajouter tous les objets à l’index de tabulation pour que le 
contenu soit lu correctement avec un lecteur d’écran. Pour plus d’informations sur les 
index de tabulation, consultez les entrées tabIndex (propriété Button.tabIndex), 
tabIndex (propriété MovieClip.tabIndex) et tabIndex (propriété 
TextField.tabIndex) dans le Guide de référence du langage ActionScript 2.0.
Nouveau dans ActionScript 2.0 et Flash Player 8
21

?
Flash Player a amélioré la sécurité des fichiers locaux pour plus de sécurité lors de 
l’exécution de fichiers SWF sur votre disque dur. Pour plus d’informations sur la sécurité 
des fichiers locaux, consultez « Sécurité des fichiers locaux et Flash Player », à la page 677.
?
En utilisant le code ActionScript, aidez-vous de l’API de dessin pour contrôler le style de 
traits que vous dessinez. Pour plus d’informations sur les nouveaux styles de lignes, 
consultez la section « Utilisation de styles de ligne », à la page 543.
?
En utilisant le code ActionScript, aidez-vous de l’API de dessin pour créer des dégradés 
plus complexes avec lesquels vous remplissez des formes. Pour plus d’informations sur les 
remplissages de dégradés, consultez la section complexes », à la page 542.
?
Utilisez le code ActionScript pour appliquer plusieurs filtres à des objets sur la scène (tels 
que des occurrences de clips). Pour plus d’informations sur les filtres et sur ActionScript, 
consultez la section « Utilisation des filtres avec ActionScript », à la page 499.
?
Utilisez FileReference et FileReferenceList API pour télécharger des fichiers sur un serveur. 
Pour plus d’informations, voir la page 643.
?
Utilisez le code ActionScript pour accéder à de nouveaux moyens avancés d’application et 
de manipulation des couleurs. Pour plus d’informations, consultez les sections 
« Définition des valeurs de couleurs », à la page 568 et ColorTransform 
(.ColorTransform) dans le Guide de référence du langage ActionScript 2.0.
?
De nombreuses améliorations ont été apportées au traitement de texte, y compris de 
nouvelles options, propriétés et paramètres dans les classes de champ de texte et de format 
de texte. Pour plus d’informations, consultez les sections TextField et TextFormat du 
Guide de référence du langage ActionScript 2.0.
?
Utilisez le code ActionScript pour accéder aux fonctionnalités avancées d’anti-aliasing. 
Pour plus d’informations, voir la page 395. 
?
Vous pouvez supprimer les fichiers ASO quand vous testez votre application. Sélectionnez 
Contrôle > Supprimer les fichiers ASO ou Contrôle > Supprimer les fichiers ASO et tester 
le clip dans l’outil de programmation. Pour plus d’informations, consultez la section 
« Utilisation des fichiers ASO », à la page 259.
Pour obtenir une liste de classes, d’éléments de langage, de méthodes et de propriétés 
spécifiques ajoutées à ActionScript 2.0 dans Flash 8, consultez la section « Définition des 
préférences d’ActionScript » dans le guide Utilisation de Flash.
22
Nouveautés du langage ActionScript de Flash

Nouveautés dans le langage ActionScript de Flash 
Player 8
Les classes et les éléments de langage qui suivent sont des nouveautés ou prises en charge dans 
Flash Player 8.
Les classes suivantes sont des nouveautés d’ActionScript 2.0 dans Flash 8 :
?
La classe BevelFilter (du paquet flash.filters) vous permet d’ajouter des effets de biseau aux 
objets.
?
La classe BitmapData (du paquet flash.display) vous permet de créer des images bitmap 
transparentes ou opaques dimensionnées de manière arbitraire et de les manipuler à votre 
guise lors de l’exécution.
?
La classe BitmapFilter (du paquet flash.display) est une classe de base pour les effets de 
filtres.
?
La classe BlurFilter vous permet d’appliquer un effet visuel de flou aux objets dans Flash.
?
La classe ColorMatrixFilter (du paquet flash.filters) vous permet de transformer les 
couleurs ARGB et les valeurs alpha. 
?
La classe ColorTransform (du paquet ) vous permet de régler les valeurs des 
couleurs dans un clip. La classe Color est déconseillée et doit être remplacée par la classe 
ColorTransform.
?
La classe ConvolutionFilter (du paquet flash.filters) vous permet d’appliquer des effets de 
filtre de convolution matricielle. 
?
La classe DisplacementMapFilter (du paquet flash.filters) vous permet d’utiliser des 
valeurs de pixel depuis un objet BitmapData pour déplacer un objet.
?
La classe DropShadowFilter (du paquet flash.filters) vous permet d’ajouter des projections 
d’ombres à des objets.
?
La classe ExternalInterface (du paquet flash.external) vous permet de communiquer en 
utilisant ActionScript avec le conteneur Flash Player (le système supportant l’application 
Flash, par exemple une page HTML utilisant JavaScript ou une application de bureau).
?
La classe FileReference (du paquet ) vous permet de charger et télécharger des 
fichiers entre l’ordinateur d’un utilisateur et le serveur.
?
La classe FileReference (du paquet ) vous permet de sélectionner un ou plusieurs 
fichiers à charger.
?
La classe GlowFilter (du paquet flash.filters) vous permet d’ajouter des effets de brillance à 
des objets.
?
La classe GradientBevelFilter (du paquet flash.filters) vous permet d’ajouter des effets de 
biseaux dégradés à des objets.
Nouveau dans ActionScript 2.0 et Flash Player 8
23

?
La classe GradientGlowFilter (du paquet flash.filters) vous permet d’ajouter des effets de 
brillance dégradée à des objets.
?
La classe IME (de la classe System) vous permet de manipuler directement l’IME (Input 
Method Editor) du système d’exploitation sous lequel l’application Flash Player s’exécute 
sur l’ordinateur client. 
?
La classe Locale (du paquet ) vous permet de contrôler la façon dont le texte 
multilingue s’affiche dans un fichier SWF.
?
La classe Matrix (du paquet ) représente une matrice de transformation qui 
détermine la façon de mapper des points d’un espace de coordonnées à l’autre.
?
La classe Point (du paquet ) représente un emplacement dans un système de 
coordonnées à deux dimensions ( x est l’axe horizontal et y représente l’axe vertical).
?
La classe Rectangle (du paquet ) vous permet de créer et de modifier des objets 
rectangles.
?
La classe TextRenderer (du paquet ) permet d’exploiter la fonction d’anti-aliasing 
avancé des polices incorporées. 
?
La classe Transform (du paquet ) rassemble des données sur les transformations 
de couleurs et coordonne les manipulations que vous appliquez à un objet MovieClip.
REMARQUE
Une prise en charge officielle a été ajouté à la classe AsBroadcaster dans Flash 8.
Les nouveautés dans les éléments de langage, les méthodes et les fonctions dans les classes 
existantes d’ActionScript comprennent notamment :
?
La fonction globale showRedrawRegions permet au débogueur de détourer les zones de 
l’écran qui sont redessinées (c’est-à-dire des zones obsolètes qui sont mises à jour). 
La fonction permet à l’utilisateur de montrer ce qui a été redessiné, mais ne vous permet 
pas de redessiner les zones.
?
La propriété blendMode de la classe Button, qui règle le mode de fondu pour 
l’occurrence de bouton.
?
La propriété cacheAsBitmap de la classe Button, qui vous permet de cacher l’objet en tant 
que représentation bitmap interne de l’occurrence.
?
La propriété filters de la classe Button, qui est un tableau indexé contenant chacun des 
objets filtre associés au bouton.
?
La propriété scale9Grid de la classe Button, qui est la zone rectangulaire définissant les 
neuf zones de redimensionnement du bouton.
24
Nouveautés du langage ActionScript de Flash

?
La propriété hasIME de la classe System.capabilities, qui indique si le système possède 
un IME.
?
La propriété getUTCYear de la classe Date, qui renvoie l’année de l’objet Date spécifié, 
conformément à l’heure locale.
?
La méthode isAccessible() de la classe Key retourne une valeur booléenne qui indique 
si d’autres fichiers SWF peuvent accéder à la dernière touche enfoncée, en fonction des 
restrictions de sécurité.
?
Le programme de traitement d’événement onHTTPStatus de la classe LoadVars retourne 
le code d’état qui est retourné par le serveur (par exemple, la valeur 404 pour impossible 
de trouver la page). Pour plus d’informations, consultez HTTPStatus (gestionnaire 
LoadVars.onHTTPStatus) dans le Guide de référence du langage ActionScript 2.0.
?
La méthode attachBitmap() de la classe MovieClip, qui associe une image bitmap à un 
clip. Pour plus d’informations, consultez la section BitmapData 
(flash.display.BitmapData) dans le Guide de référence du langage ActionScript 2.0.
?
La méthode beginBitmapFill() de la classe MovieClip, qui remplit un clip avec une 
image bitmap.
?
Les paramètres de spreadMethod, interpolationMethod et de focalPointRatio de la 
méthode beginGradientFill()de la classe MovieClip. Cette méthode remplit une zone 
de dessin avec une image bitmap et le bitmap peut être répété ou former une mosaïque 
afin de remplir la zone. 
?
La propriété blendMode de la classe MovieClip, qui règle le mode de fondu pour 
l’occurrence.
?
La propriété cacheAsBitmap de la classe MovieClip, qui vous permet de cacher l’objet en 
tant qu’une représentation bitmap interne de l’occurrence.
?
La propriété filters dans la classe MovieClip, qui est un tableau indexé contenant 
chacun des objets filtre associés à l’occurrence.
?
La méthode getRect() de la classe MovieClip, qui renvoie les propriétés aux valeurs de 
coordonnées minimales et maximales de l’occurrence donnée.
?
La méthode lineGradientStyle() de la classe MovieClip, qui spécifie un style de ligne 
dégradée que Flash utilise lors du dessin d’un chemin.
?
Les paramètres pixelHinting, noScale, capsStyle, jointStyle et miterLimit de la 
méthode lineStyle()de la classe MovieClip. Ces paramètres spécifient les types de styles 
de lignes que vous pouvez utiliser en dessinant des lignes.
?
La propriété opaqueBackground de la classe MovieClip, qui règle la couleur de l’arrière-
plan opaque (non transparent) du clip à la couleur spécifiée par une valeur RVB 
hexadécimale.
Nouveau dans ActionScript 2.0 et Flash Player 8
25

?
La propriété scale9Grid de la classe MovieClip, qui est la zone rectangulaire définissant 
les neuf zones de redimensionnement de l’occurrence.
?
La propriété scrollRect de la classe MovieClip, qui vous permet de parcourir 
rapidement le contenu d’un clip et d’ouvrir une fenêtre capable d’afficher davantage de 
contenu.
?
La propriété transformation de la classe MovieClip, qui vous permet des réglages se 
rapportant à la matrice d’un clip, à la transformation des couleurs et aux limites des pixels. 
Pour plus d’informations, consultez Transform (.Transform) dans le Guide 
de référence du langage ActionScript 2.0
.
?
Le paramètre statut de MovieClipLoader. Le programme de traitement d’événements 
onLoadComplete renvoie le code de statut qui est ramené depuis le serveur (par exemple, 
la valeur 404 pour impossible de trouver la page). Pour plus d’informations, consultez 
onLoadComplete (écouteur d’événement MovieClipLoader.onComplete) dans le 
Guide de référence du langage ActionScript 2.0.
?
Le programme de traitement d’événements onLoadError de la classe MovieClipLoader 
est appelé lorsque le chargement d’un fichier chargé avec MovieClipLoader.loadClip() 
a échoué.
?
Le paramètre secure de la méthode SharedObject.getLocal() détermine si l’accès à cet 
objet partagé est restreint aux fichiers SWF acheminés à travers une connexion HTTPS. 
Pour plus d’informations, consultez getLocal (méthode SharedObject.getlocal) 
dans le Guide de référence du langage ActionScript 2.0.
?
La propriété de type sandbox de la classe System.security indique le type de sandbox de 
sécurité dans lequel le SWF appelant fonctionne. Pour plus d’informations, consultez la 
section sandboxType (propriété security.sandboxType) du Guide de référence du 
langage ActionScript 2.0
.
?
La propriété antiAliasType de la classe TextField, qui règle le type d’anti-aliasiang 
avancé que vous utilisez pour l’occurrence TextField.
?
La propriété filters de la classe TextField, qui est un tableau indexé contenant chacun 
des objets filtre associés à la zone de texte.
?
La propriété gridFitType de la classe TextField, qui règle le type de grille que vous 
utilisez pour l’occurrence. Pour plus d’informations sur les grilles et sur 
TextField.gridFitType, consultez la section gridFitType (propriété 
TextField.gridFitType) dans le Guide de référence du langage ActionScript 2.0.
?
La propriété sharpness de la classe TextField, qui règle le type de définition des bords de 
glyphes pour l’occurrence zone de texte. Vous devez régler la méthode antiAliasType() 
en mode avancé si vous utilisez cette propriété.
26
Nouveautés du langage ActionScript de Flash

?
La propriété thickness de la classe TextField, qui règle l’épaisseur des bords de glyphes 
pour l’occurrence zone de texte. Vous devez régler la méthode antiAliasType() en mode 
avancé si vous utilisez cette propriété.
?
La valeur justify pour la propriété align de la classe TextFormat, qui vous permet de 
justifier un paragraphe donné.
?
La propriété indent de la classe TextFormat, qui vous permet d’utiliser des valeurs 
négatives.
?
La propriété kerning de la classe TextFormat, qui vous permet d’activer ou de désactiver 
le crénage pour l’objet TextFormat.
?
La propriété leading de la classe TextFormat, qui vous permet d’utiliser un lignage 
négatif, afin que l’espace entre les lignes soit inférieur à la hauteur de texte. Ceci vous 
permet de placer des lignes de texte proches les unes des autres dans vos applications. 
?
La propriété letterSpacing de la classe TextFormat, qui vous permet de spécifier la taille 
de l’espace uniformément réparti entre les caractères.
?
La propriété _alpha de la classe Video, qui est le montant spécifié de transparence pour 
l’objet vidéo.
?
La propriété _height de la classe Video, qui indique la hauteur de l’occurrence vidéo.
?
La propriété _name de la classe Video, qui indique le nom de l’occurrence vidéo.
?
La propriété _parent de la classe Video, qui indique l’occurrence de clip ou l’objet qui 
contient l’occurrence vidéo.
?
La propriété _rotation de la classe Video, qui vous permet de régler le mouvement de 
rotation de l’occurrence vidéo en degrés.
?
La propriété _visible de la classe Video, qui vous permet de régler la visibilité d’une 
occurrence vidéo.
?
La propriété _width de la classe Video, qui vous permet de régler la largeur de 
l’occurrence vidéo.
?
La propriété _x de la classe Video, qui vous permet de régler les coordonnées x de 
l’occurrence vidéo.
?
La propriété _xmouse de la classe Video, qui vous permet de régler les coordonnées x de la 
position du pointeur de la souris.
?
La propriété _xscale de la classe Video, qui vous permet de régler le pourcentage de 
redimensionnement horizontal de l’occurrence vidéo.
?
La propriété _y de la classe Video, qui vous permet de régler les coordonnées y de 
l’occurrence vidéo.
?
La propriété _ymouse de la classe Video, qui vous permet de régler les coordonnées y de la 
position du pointeur de la souris.
Nouveau dans ActionScript 2.0 et Flash Player 8
27

?
La propriété _yscale de la classe Video, qui vous permet de régler le pourcentage de 
redimensionnement vertical de l’occurrence vidéo.
?
Le programme de traitement d’événement onHTTPStatus de la classe XML retourne le 
code de statut qui est revenu du serveur (par exemple, la valeur 404 pour impossible de 
trouver la page). Pour plus d’informations, consultez la section onHTTPStatus 
(gestionnaire XML.onHTTPStatus) du Guide de référence du langage ActionScript 2.0.
?
La propriété localName de la classe XMLNode, qui renvoie le nom complet de l’objet 
noeud XML (y compris le préfixe et le nom local).
?
La propriété namespaceURIde la classe XMLNode, qui lit l’URI de l’espace de nom 
résultant du préfixe du nœud XML. Pour plus d’informations, consultez la section 
namespaceURI (propriété XMLNode.namespaceURI) du Guide de référence du langage 
ActionScript 2.0

?
La propriété prefix de la classe XMLNode, qui lit le préfixe du nom du nœud.
?
La méthode getNamespaceForPrefix() de la classe XMLNode, qui renvoie le nom 
d’espace URI se rapportant au préfixe spécifié pour le nœud.
?
La méthode getPrefixForNamespace de la classe XMLNode, qui renvoie le préfixe se 
rapportant à un nom d’espace URI donné pour le nœud.
À propos des éléments de langage déconseillés
Certains éléments de langage sont déconseillés dans Flash Player 8. Pour obtenir une liste des 
éléments de langage déconseillés et des méthodes de remplacement à utiliser dans Flash 
Player 8, consultez les sections suivantes dans le Guide de référence du langage ActionScript 2.0 :
?
Classes déconseillées
?
Fonctions déconseillées
?
Propriétés déconseillées
?
Opérateurs déconseillés
Modifications de l’éditeur ActionScript
L’éditeur ActionScript dans le panneau Actions et dans la fenêtre Script a subi différentes 
mises à jour afin d’être plus fiable et plus simple à utiliser que dans les versions antérieures de 
l’outil. Cette section récapitule toutes ces modifications.
Affichage des caractères masqués
Pour activer ou désactiver l’affichage des caractères 
masqués, vous pouvez désormais utiliser le menu d’options contextuel de la fenêtre de script, 
du panneau Débogueur et du panneau de sortie. Pour plus d’informations sur cette 
fonctionnalité, consultez le guide Utilisation de Flash.
28
Nouveautés du langage ActionScript de Flash

L’Assistant de script a été ajouté au panneau Actions
Dans les versions antérieures de 
Flash, vous pouviez travailler dans le panneau Actions soit en mode normal dans lequel vous 
complétiez des options et des paramètres pour créer du code, soit en mode expert dans lequel 
vous ajoutiez des commandes directement dans la fenêtre de script. Ces options n’étaient plus 
disponibles dans Flash MX 2004 ou Flash MX Professional 2004. Flash Basic 8 et Flash 
Professional 8 permettent cependant d’utiliser le mode d’Assistant de script, semblable (mais 
plus fiable) au mode normal. Pour plus d’informations et obtenir un didacticiel sur l’Assistant 
Script, consultez le guide Utilisation de Flash
Rechargement des fichiers modifiés
Vous pouvez recharger les fichiers script modifiés 
lorsque vous travaillez sur une application. Un message d’avertissement apparaît pour vous 
inviter à recharger les fichiers script modifiés qui sont liés à l’application sur laquelle vous 
travaillez. Cette fonctionnalité est particulièrement profitable aux équipes qui travaillent sur 
des applications en même temps, car elle vous évite de travailler avec des scripts périmés ou 
d’écraser des versions plus récentes d’un script. Si un fichier de script a été déplacé ou 
supprimé, un message d’avertissement apparaît et vous rappelle d’enregistrer les fichiers selon 
les besoins. Pour plus d’informations, consultez la section « Définition des préférences 
d’ActionScript » dans le guide Utilisation de Flash.
Modifications du modèle de sécurité pour 
les fichiers SWF installés localement
Flash Player 9.x prend également en charge une nouvelle balise HTML, allowNetworking. 
Pour plus d’informations, consultez le chapitre Sécurité du manuel Programmation avec 
ActionScript 3.0
.
Flash Player 8 a introduit un nouveau modèle de sécurité améliorée dans lequel les 
applications Flash et les fichiers SWF sur un ordinateur local peuvent communiquer par 
Internet sur le système de fichiers local plutôt que de passer par un serveur Internet à distance. 
Lors de la programmation d’une application Flash, il faut indiquer si un fichier SWF est 
autorisé à communiquer avec un réseau ou un système de fichiers local.
REMA
Dans le cadre de cette section, un fichier SWF local est un fichier SWF installé 
localement sur l’ordinateur d’un utilisateur, et non pas obtenu via un site Web, et qui ne 
R
comprend pas de fichiers de projections (EXE).
Q
UE
Modifications du modèle de sécurité pour les fichiers SWF installés localement
29

Dans les versions antérieures de Flash Player, les fichiers SWF locaux pouvaient interagir avec 
d’autres fichiers SWF et charger des données depuis un ordinateur à distance ou local sans 
effectuer de réglages de sécurité. Dans Flash Player 8 et les versions ultérieures, un fichier 
SWF ne peut pas établir de connexion entre le système de fichiers local et le réseau 
(tel qu’Internet) dans une même application sans effectuer de réglage de sécurité. Ceci est 
pour votre sécurité ; c’est ainsi qu’un fichier SWF ne peut pas lire de fichiers sur votre disque 
dur, puis envoyer le contenu de ces fichiers sur Internet.
Cette restriction de sécurité affecte un contenu déployé localement, qu’il soit patrimonial 
(un fichier FLA créé dans une version antérieure de Flash) ou qu’il ait été créé dans Flash 8 et 
ses versions ultérieures. En utilisant l’outil Flash MX 2004 ou une version antérieure, vous 
pouviez tester une application Flash qui s’exécutait localement et accédait également à 
Internet. Dans Flash Player 8 et les versions ultérieures, cette application demande désormais 
à l’utilisateur l’autorisation de communiquer avec Internet.
Quand vous testez un fichier sur votre disque dur, plusieurs étapes permettent de déterminer 
si le fichier est un document local fiable (sûr) ou potentiellement incertain (dangereux). 
Si vous créez le fichier dans l’environnement autorisé Flash (par exemple, quand vous 
sélectionnez Contrôle > Tester le clip), votre fichier est considéré comme fiable parce qu’il se 
trouve dans l’environnement de test.
Dans la version Flash Player 7 et les versions antérieures, les fichiers SWF locaux étaient 
autorisés à accéder au réseau et au système de fichiers local. Dans Flash Player 8 et les versions 
ultérieures, les fichiers SWF locaux peuvent disposer de trois niveaux d’autorisation :
?
Accès au système de fichiers local uniquement (niveau par défaut). Le fichier SWF local 
peut lire le système de fichiers local et les chemins de réseau de la convention UNC, mais 
il ne peut pas communiquer avec Internet.
?
Accès au réseau uniquement. Le fichier SWF local ne peut accéder qu’au réseau 
(tel qu’Internet) et pas au système de fichiers local sur lequel il est installé.
?
Accès au système de fichiers local et au réseau. Le fichier SWF local peut lire le système de 
fichiers local sur lequel il est installé, lire et écrire sur les serveurs qui lui accordent une 
autorisation et peut inter-coder d’autres fichiers SWF du réseau ou du système de fichiers 
local qui l’y autorisent.
Pour plus de détails sur chaque niveau d’autorisation, consultez la sectionfichiers locaux et Flash Player », à la page 677.
Des retouches légères ont également été apportées à System.security.allowDomain et des 
améliorations à System.security.allowInsecureDomain. Pour plus d’informations sur la 
sécurité des fichiers locaux, consultez le Chapitre 16, « Fonctionnement de la sécurité »
30
Nouveautés du langage ActionScript de Flash

CHAPITRE 2
A propos d’ActionScript
2
Les fonctionnalités de programmation orientée objet (OOP) d’ActionScript 2.0 reposent sur 
la norme ECMAScript 4 Draft Proposal en cours de développement par ECMA TC39-TG1 
(voir le site ). Dans la mesure où la proposition 
de la ECMA-4 n’est pas encore une norme établie car elle est encore en cours d’élaboration, 
ActionScript 2.0 ne l’applique pas de façon stricte.
ActionScript 2.0 prend en charge tous les éléments standard du langage ActionScript. Il vous 
permet simplement d’écrire des scripts plus proches des normes utilisées par d’autres langages 
orientés objet, tels que Java. ActionScript 2.0 intéressera principalement les développeurs 
Flash de niveau intermédiaire ou expert qui créent des applications nécessitant 
l’implémentation de classes et de sous-classes. ActionScript 2.0 vous permet également de 
déclarer le type d’objet d’une variable au moment de sa création (consulteztypes de données et typage strict », à la page 45) et améliore considérablement les erreurs de 
compilateur (consultez l’Annexe A, « Messages d’erreur », à la page 759).
Les points principaux à connaître sur ActionScript 2.0 sont les suivants :
?
Les scripts utilisant ActionScript 2.0 pour définir des classes ou des interfaces doivent être 
enregistrés en tant que fichiers de script externes, avec une seule classe définie par script. 
Les classes et les interfaces ne peuvent donc pas être définies dans le panneau Actions.
?
Vous pouvez importer des fichiers de classe individuels de façon implicite (en les 
enregistrant dans un emplacement spécifié par des chemins de recherche généraux ou de 
niveau document et en les utilisant dans un script) ou de façon explicite (en utilisant la 
commande import). Vous pouvez importer des lots de fichiers (collections de fichiers de 
classe placés dans un répertoire) en utilisant des caractères génériques.
?
Les applications développées avec ActionScript 2.0 sont prises en charge par Flash Player 6 
et les versions ultérieures. 
ATT
Le paramètre de publication par défaut des nouveaux fichiers créés dans Flash 9 est 
E
ActionScript 3.0. Si vous envisagez de modifier un fichier FLA existant à l’aide 
NTIO
d’ActionScript 1.0 ou ActionScript 2.0 pour utiliser la syntaxe ActionScript 2.0, 
vérifiez que le fichier FLA indique bien ActionScript 2.0 dans ses paramètres de 
N
publication. Si ce n’est pas le cas, votre fichier ne sera pas compilé correctement, 
même si Flash ne génère pas d’erreurs de compilation.
31

Pour plus d’informations sur l’utilisation d’ActionScript 2.0 dans la rédaction de programmes 
orientés objet dans Flash, consultez le Chapitre 6, « Classes », à la page 197. 
Bien qu’Adobe recommande d’utiliser ActionScript 3.0, vous pouvez continueer à utiliser la 
syntaxe ActionScript 1.0 et ActionScript 2.0.
Présentation d’ActionScript
Les fonctions principales d’ActionScript 2.0 sont regroupées ci-dessous :
Modèle familier de programmation orientée objet (OOP)
ActionScript 2.0 offre un 
modèle connu de tous pour la création de programmes orientés objet. ActionScript 2.0 met en 
oeuvre plusieurs concepts et mots-clés orientés objet, tels que class, interface et packages qui 
vous sembleront familiers si vous avez déjà programmé en Java.
Le modèle OOP d’ActionScript 2.0 est une « formalisation syntaxique » de la méthode de 
chaînage de prototype utilisée dans les précédentes versions de Flash pour créer des objets et 
établir une relation d’héritage. Avec ActionScript 2.0, vous pouvez créer des classes 
personnalisées et étendre les classes intégrées de Flash.
Typage strict des données 
ActionScript 2.0 vous permet également de spécifier 
explicitement les types de données pour les variables et pour les paramètres et les renvois des 
fonctions. Par exemple, le code suivant déclare une variable appelée userName de type chaîne 
(type de données ActionScript intégré ou classe). 
var userName:String = "";
Avertissements et messages d’erreur du compilateur
Les deux précédentes fonctions 
(modèle OOP et typage strict des données) permettent à l’outil de programmation et au 
compilateur de générer des avertissements et messages d’erreur qui vous aident à localiser les 
bogues de vos applications dans Flash plus rapidement qu’auparavant.
Lorsque vous utilisez ActionScript 2.0, assurez-vous que les paramètres de publication du 
fichier FLA spécifient ActionScript 2.0 (le paramètre par défaut pour Flash Player 9 est 
ActioScript 3.0). En outre, si vous ouvrez un ancien fichier FLA qui utilise ActionScript 1.0 et 
que vous le modifiez en langage ActionScript 2.0, vous devez régler les paramètres de 
publication du fichier FLA sur ActionScript 2.0. Sinon, votre fichier FLA ne sera pas compilé 
correctement et aucune erreur ne sera générée. 
32
A propos d’ActionScript

Différences entre ActionScript 1.0 et 
ActionScript 2.0 
Lorsque vous démarrez avec un document ou une application dans Flash, vous devez 
déterminer le mode d’organisation des fichiers qui lui sont associés. Vous pouvez utiliser des 
classes dans certains projets, comme lorsque vous créez des applications ou des fichiers FLA 
complexes, bien que certains documents excluent l’utilisation de classes. Ainsi, de nombreux 
exemples courts de cette documentation n’ont pas recours à des classes. L’utilisation de classes 
pour stocker des fonctionnalités n’est pas la meilleure solution ni la plus facile pour les petites 
applications ou les fichiers FLA simples. Il est généralement plus efficace de placer du code 
ActionScript dans le document. Essayez alors de placer l’ensemble du code sur le scénario et 
sur le moins d’images possible. Evitez de placer du code sur ou dans les occurrences (telles que 
les boutons ou les clips) dans un fichier FLA.
Lorsque vous créez un petit projet, il est souvent plus difficile d’utiliser des classes ou des 
fichiers de code externes pour organiser le code ActionScript que d’ajouter ce code au sein du 
fichier FLA. Il est parfois plus facile de regrouper l’ensemble du code ActionScript au sein du 
fichier FLA que de le placer dans une classe à importer. Cela ne signifie pas que vous devez 
nécessairement utiliser ActionScript 1.0. Vous pouvez décider de placer votre code dans le 
fichier FLA à l’aide d’ActionScript 2.0 avec son typage strict des données et ses nouvelles 
méthodes et propriétés. ActionScript 2.0 propose également une syntaxe qui applique les 
normes des autres langages de programmation. Le langage devient alors plus aisé et plus utile à 
apprendre. Par exemple, il vous sera plus facile de vous familiariser avec ActionScript si vous 
connaissez déjà un autre langage reposant sur les mêmes normes de structure et de syntaxe. 
De même, vous pourrez appliquer les connaissances que vous allez acquérir à d’autres langages 
de programmation. ActionScript 2.0 vous permet de bénéficier d’une approche orientée objet 
pour développer des applications en utilisant un ensemble supplémentaire d’éléments de 
langage, ce qui peut être avantageux pour le développement de votre application.
Dans certains cas, il n’est pas possible de choisir la version d’ActionScript à utiliser. Si vous 
créez un fichier SWF destiné à une ancienne version de Flash Player, telle qu’une application 
pour périphérique mobile, choisissez ActionScript1.0 pour sa compatibilité.
Néanmoins, quelle que soit la version d’ActionScript, vous devez appliquer les meilleures 
pratiques. La plupart de ces pratiques, telles qu’un usage cohérent des majuscules, la saisie 
automatique, l’amélioration de la lisibilité, l’exclusion de mots clés pour les noms d’occurrence 
et l’application d’une convention d’appellation cohérente s’appliquent aux deux versions.
Si vous prévoyez de mettre à jour votre application avec les versions suivantes de Flash ou si 
vous devez la développer et créer du code plus complexe, utilisez ActionScript 2.0 et les classes 
afin de faciliter la mise à jour et la modification de vos applications.
Différences entre ActionScript 1.0 et ActionScript 2.0
33

Présentation d’ActionScript et de 
Flash Player 
Si vous compilez un fichier SWF contenant du code ActionScript 2.0 dont l’option 
Paramètres de publication est définie sur Flash Player 6 et ActionScript 1.0, votre code reste 
valable tant qu’il n’utilise pas les classes ActionScript 2.0. Le code n’est pas sensible à la casse 
tandis que Flash Player l’est. Cependant, si vous compilez votre fichier SWF avec l’option 
Paramètres de publication définie sur Flash Player 7 ou 8 et ActionScript 1.0, Flash impose le 
respect de la casse.
Annotations de type de données (types de données strictes) sont imposées sur un au moment 
de la compilation pour Flash Player 7 et versions ultérieures quand les paramètres de 
publication sont définis sur ActionScript 2.0.
ActionScript 2.0 compile en pseudo-code ActionScript 1.0 lorsque vous publiez vos 
applications, et vous pouvez ainsi cibler Flash Player 6 et versions ultérieures lorsque vous 
travaillez avec ActionScript 2.0.
34
A propos d’ActionScript

CHAPITRE 3
Données et types de 
3
données
Ce chapitre est le premier d’une longue série qui décrit les concepts fondamentaux 
d’ActionScript. Pour apprendre à créer des applications complexes, vous vous exercerez à 
l’utilisation des techniques de base de la programmation. Dans ce chapitre, vous apprendrez 
également à manipuler les données des fichiers FLA et à identifier les données compatibles 
avec vos applications. Dans le chapitre suivant, langage et de la syntaxe », vous découvrirez les instructions des formulaires et la syntaxe 
d’ActionScript. Ensuite, le Chapitre 5, « Fonctions et méthodes » présente l’utilisation des 
fonctions et des méthodes dans le langage ActionScript. 
Pour plus d’informations sur les données et les types de données, consultez les sections 
suivantes :
A propos des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Présentation des types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Présentation des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  51
Organisation des données dans des objets  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Attribution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  77
A propos des données 
Le terme données fait référence aux nombres, chaînes de caractères et autres informations qui 
sont manipulés au sein de Flash. Lorsque vous créez des applications ou des sites Internet, la 
manipulation d’un certain nombre de données est inévitable. Vous utilisez également des 
données pour créer des graphiques sophistiqués et des animations générées par des scripts. 
Dans ce cas, vous devez manipuler les valeurs utilisées pour appliquer vos effets spéciaux. 
Vous pouvez définir des données en variables dans Flash ou les charger à partir de fichiers 
externes ou de sites utilisant XML, des services Web, des classes ActionScript intégrées, etc. 
Vous pouvez stocker les données dans une base de données, puis les représenter sous 
différentes formes dans un fichier SWF. Cela comprend l’affichage des informations dans des 
champs de texte ou des composants et l’affichage des images dans des occurrences de clip.
35

Les types de données les plus utilisés sont les suivants : chaînes (série de caractères, telles que 
des noms et des phrases), nombres, objets (tels que des clips), valeurs booléennes (true et 
false), etc. Dans ce chapitre, vous apprendrez également à reconnaître les différents types de 
données dans Flash et à les utiliser.
Pour plus d’informations sur les types de données, consultez la section de données », à la page 36. Pour plus d’informations sur les variables, consultez la section 
« Présentation des variables », à la page 51.
Présentation des types de données
Le type de données décrit une information et les sortes d’opération qu’elles peuvent subir. 
Vous stockez les données dans des variables. Vous utilisez les types de données lors de la 
création des variables, des occurrences d’objets et des définitions de fonctions pour attribuer le 
type de données que vous manipulez. Lorsque vous écrivez du code ActionScript, vous utilisez 
de nombreux types de données différents.
ActionScript 2.0 définit plusieurs types de données fréquemment utilisés. Les types de 
données décrivent le genre de valeur qu’une variable ou qu’un élément ActionScript peut 
contenir. Après l’affectation de son type de données, une variable ne peut contenir qu’une 
valeur correspondant à ce type. Pour plus d’informations sur les variables, consultez la section 
« Présentation des variables », à la page 51.
ActionScript dispose de nombreux types de données de base que vous utiliserez fréquemment 
dans vos applications. Pour plus d’informations, consultez le tableau de la section données complexes et primitifs », à la page 37.
ActionScript dispose également de classes de base, telles que Array et Date, qui sont 
considérées comme des types de données complexes ou de référence. Pour plus d’informations 
sur les types de données complexes ou de référence, consultez la complexes et primitifs », à la page 37. De plus, tous les types de données et les classes sont 
intégralement définis dans le Guide de référence du langage ActionScript de Flash.
Vous pouvez également créer des classes personnalisées pour vos applications. Toute classe 
définie par une déclaration est également considérée comme un type de données. Pour plus 
d’informations sur les classes intégrées ou de base, consultez la section classes de niveau supérieur et intégrées », à la page 263. Pour plus d’informations sur la 
création de classes personnalisées, consultez le Chapitre 6, « Classes », à la page 197.
Dans ActionScript 2.0, vous pouvez affecter des types de données aux variables lorsque vous 
les déclarez. Les types de données que vous affectez peuvent être de type de base ou peuvent 
représenter une classe personnalisée que vous avez créée. Pour plus d’informations, voir 
« Affectation des types de données et typage strict », à la page 45. 
36
Données et types de données

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 son comportement. Vous pouvez 
effectuer cette opération avec les opérateurs instanceof et typeof (consultez la section 
« Identification du type de données », à la page 50). 
Lors de l’exécution, vous pouvez convertir un type de données en un autre en utilisant l’une 
des fonctions de conversion suivantes : Array(), Boolean(), Number(), Object(), 
String(). 
Pour un exemple du fichier , qui vous explique comment utiliser des types de 
données dans une application, consultez la page des exemples Flash à l’adresse 
;Téléchargez et décompressez le fichier zip Exemples 
et naviguez jusqu’au dossier ActionScript2.0/DataTypes afin d’accéder à l’exemple.
Types de données complexes et primitifs
Les valeurs des différents types de données se divisent en deux catégories principales : primitive 
et complexe
Une valeur primitive (ou type de données primitif ) est une valeur stockée par ActionScript au 
niveau d’abstraction le plus bas, ce qui signifie que les opérations qu’elles subissent sont 
généralement plus rapides et plus importantes que celles effectuées sur les types de données 
complexes. Les types de données suivants définissent tous un ensemble de valeurs primitives : 
Boolean, null, Number, String et undefined.  
Une valeur complexe (ou type de données complexe) est une valeur non primitive qui fait 
référence aux valeurs primitives. Elles sont souvent appelées types de données de référence
Les valeurs complexes appartiennent au type de données Objet ou à un type de données basé 
sur le type de données Objet. Les types de données qui définissent des ensembles de valeurs 
complexes comprennent Array, Date, Error, Function et XML. Pour plus d’informations sur 
ces types de données complexes, consultez les entrées correspondantes dans le Guide de 
référence du langage ActionScript 2.0

Les variables contenant des données primitives ont un comportement différent de celles 
contenant des données complexes dans certaines situations. Pour plus d’informations, voir 
« Utilisation des variables dans un projet », à la page 72. 
Présentation des types de données
37

ActionScript dispose des types de données de base suivants que vous pouvez utiliser 
fréquemment dans vos applications : 
Type de 
Description
données
Boolean
Primitive. Le type booléen est composé de deux valeurs : true et false. 
Les variables de ce type ne prennent en charge aucune autre valeur. 
La valeur par défaut d’une variable booléenne qui a été déclarée mais 
non initialisée est false. Pour plus d’informations, voir données Boolean », à la page 39.
MovieClip
Complexe. Le type de données MovieClip vous permet de contrôler les 
symboles de clip au moyen des méthodes de la classe MovieClip. 
Pour plus d’informations, la page 40.
null
Primitive. Ce type de données ne contient que la valeur null. Cette 
valeur signifie « pas de valeur », c’est-à-dire une absence de données. 
Vous pouvez affecter la valeur null dans de nombreuses situations 
pour indiquer qu’une propriété ou une variable n’a pas reçu de valeur. 
Il s’agit du type de données par défaut pour toutes les classes qui 
définissent des types de données complexes. La classe Objet est la 
seule exception à cette règle, car elle est undefined par défaut. Pour plus 
d’informations, voir « Type de données Null », à la page 42.
Number
Primitive. Ce type de données peut représenter des entiers, des entiers 
non signés et des nombres en virgule flottante. Pour stocker un nombre 
en virgule flottante, vous devez y insérer une virgule. Sans virgule, le 
nombre est considéré comme un entier. Le type de données Numérique 
peut stocker des valeurs allant de Number.MAX_VALUE (très élevées) à 
Number.MIN_VALUE (très basses). Pour plus d’informations, consultez le 
Guide de référence du langage ActionScript 2.0 et la section données Number », à la page 42.
Object
Complexe. Ce type de données est défini par la classe Object. La classe 
Object sert de base pour toutes les définitions de classe dans 
ActionScript. Elle vous permet d’organiser les objets les uns dans les 
autres (objets imbriqués). Pour plus d’informations, voir données Object », à la page 43.
String
Primitive. Ce type de données représente une séquence de caractères 
16 bits qui peuvent comprendre des lettres, des chiffres et des 
caractères de ponctuation. Les chaînes sont stockées sous forme de 
caractères Unicode, au format UTF-16. Toute opération effectuée sur la 
valeur d’une chaîne renvoie une nouvelle occurrence de la chaîne. 
Pour plus d’informations, voir « Type de données String », à la page 44.
38
Données et types de données

Type de 
Description
données
undefined
Primitive. Ce type de données contient une valeur : undefined. Il s’agit de 
la valeur par défaut des occurrences de la classe Object. Seule la valeur 
undefined peut être affectée aux variables qui appartiennent à la classe 
Object. Pour plus d’informations, vola page 45.
Void
Complexe. Ce type de données contient une seule valeur : void. 
Vous l’utilisez pour désigner les fonctions qui ne renvoient aucune 
valeur. Void est un type de données complexe qui fait référence au type 
de données Void primitif. Pour plus d’informations, voir données Void », à la page 45.
Pour un exemple du fichier , consultez la page des exemples Flash à l’adresse 
;Téléchargez et décompressez le fichier zip Exemples 
et naviguez jusqu’au dossier ActionScript2.0/DataTypes afin d’accéder à l’exemple.
Type de données 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. 
L’exemple suivant illustre le chargement d’un fichier texte dans un fichier SWF. Il affiche un 
message dans le panneau de sortie si le chargement du fichier texte échoue ou les paramètres 
s’il réussit. Pour plus d’informations, consultez les commentaires de l’exemple de code.
var my_lv:LoadVars = new LoadVars();
//success est une valeur booléenne
my_lv.onLoad = function(success:Boolean) {
//si le paramètre success est true, suivre monthNames
if (success) {
trace(my_lv.monthNames);
//si le paramètre success est false, suivre un message
} else {
trace("unable to load text file");
}
};
("");
Présentation des types de données
39

L’exemple suivant permet de s’assurer que les utilisateurs entrent des valeurs dans deux 
occurrences de composant TextInput. Deux variables booléennes sont créées, 
userNameEntered et isPasswordCorrect. Si ces deux variables renvoient la valeur true, un 
message de bienvenue est affecté à la variable de type chaîne titleMessage.
// Ajoute deux composants TextInput, un composant Label et 
// un composant Button sur la scène.
// Application de typage strict aux trois occurrences de composant.
var userName_ti:mx.controls.TextInput;
var password_ti:mx.controls.TextInput;
var submit_button:mx.controls.Button;
var welcome_lbl:mx.controls.Label;
//Masquer l’étiquette
welcome_lbl.visible = false;
// Crée un objet écouteur utilisé avec le composant Button.
// Lorsque vous cliquez sur le composant Button, le programme recherche 
// un nom d’utilisateur et un mot de passe.
var btnListener:Object = new Object();
btnListener.click = function(evt:Object) {
// Vérifie que l’utilisateur a saisi au moins un caractère dans TextInput
// occurrences et renvoie une valeur booléenne true/false.
var userNameEntered:Boolean = (.length > 0);
var isPasswordCorrect:Boolean = ( == "vertigo");
if (userNameEntered && isPasswordCorrect) {
var titleMessage:String = "Welcome " + + "!";
= titleMessage;
//afficher l’étiquette
welcome_lbl.visible = true;
}
};
submit_button.addEventListener("click", btnListener);
Pour plus d’informations, reportez-vous la page 185 et à « Présentation des opérateurs logiques », à la page 163.
Type de données 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. 
N’utilisez pas de constructeur pour appeler les méthodes de la classe MovieClip. Vous pouvez 
créer une instance de clip sur la scène ou créer une instance de façon dynamique. Vous pouvez 
alors appeler les méthodes de la classe MovieClip avec l’opérateur point (.).
40
Données et types de données

Manipulation des clips sur la scène
L’exemple suivant appelle les méthodes startDrag() 
et getURL() pour différentes occurrences de clip placées sur la scène :    
my_mc.startDrag(true);
parent_mc.getURL("; + product);
Le deuxième exemple renvoie la largeur d’un clip appelé my_mc et situé sur la scène. L’instance 
cible doit être un clip et la valeur renvoyée doit être une valeur numérique.
function getMCWidth(target_mc:MovieClip):Number {
return target_mc._width;
}
trace(getMCWidth(my_mc));
Création dynamique de clips
La création dynamique de clips à l’aide d’ActionScript évite 
de devoir les créer manuellement sur la scène ou de les associer à partir de la bibliothèque. 
Par exemple, vous pouvez créer une galerie d’images à partir d’un grand nombre d’images de 
vignettes à organiser sur la scène. L’utilisation de MovieClip.createEmptyMovieClip() 
permet de créer une application de bout en bout avec ActionScript.
Pour créer un clip de façon dynamique, utilisez MovieClip.createEmptyMovieClip(), 
comme indiqué dans l’exemple suivant :
// Crée un clip parent pour le conteneur.
this.createEmptyMovieClip("image_mc", 9);
// Charge une image dans image_mc.
image_mc.loadMovie("");
Le deuxième exemple crée un clip appelé square_mc qui utilise l’API de dessin pour dessiner 
un rectangle. Les gestionnaires d’événement et les méthodes startDrag() et stopDrag() de 
la classe MovieClip sont ajoutés pour permettre à l’utilisateur de faire glisser le rectangle.
this.createEmptyMovieClip("square_mc", 1);
square_mc.lineStyle(1, 0x000000, 100);
square_mc.beginFill(0xFF0000, 100);
square_mc.moveTo(100, 100);
square_mc.lineTo(200, 100);
square_mc.lineTo(200, 200);
square_mc.lineTo(100, 200);
square_mc.lineTo(100, 100);
square_mc.endFill();
square_mc.onPress = function() {
this.startDrag();
};
square_mc.onRelease = function() {
this.stopDrag();
};
Pour plus d’informations, consultez le Chapitre 10, « Utilisation des clips », à la page 335 et 
l’entrée Clip du Guide de référence du langage ActionScript 2.0.
Présentation des types de données
41

Type de données Null
Ce type de données ne peut contenir qu’une valeur, null. Cette valeur signifie en fait pas de 
valeur
 et symbolise l’absence de données. Vous pouvez affecter la valeur null dans de 
nombreuses situations pour indiquer qu’une propriété ou une variable n’a pas encore reçu de 
valeur. Par exemple, vous pouvez affecter la valeur null dans les situations suivantes : 
?
Pour indiquer qu’une variable existe, mais n’a pas encore reçu de valeur ;
?
Pour indiquer qu’une variable existe, mais 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.
Plusieurs méthodes et fonctions renvoient null si aucune valeur n’a été définie. L’exemple 
suivant démontre comment utiliser null pour vérifier si les champs du formulaire ont le 
focus :
if (Selection.getFocus() == null) {
trace("no selection");
}
Type de données Number
Ce type numérique correspond à un nombre à virgule flottante à double précision. La valeur 
minimum d’un objet Number est d’environ 5e-324. Sa valeur maximum est d’environ 
1,79E+308.
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 (--). Pour plus d’informations, vnumériques », à la page 157.
Vous pouvez également utiliser des méthodes des classes intégrées Math et Number pour 
manipuler les nombres. Pour plus d’informations sur les méthodes et les propriétés de ces 
classes, consultez les entrées Math et Number du Guide de référence du langage 
ActionScript 2.0
.
L’exemple suivant utilise la méthode sqrt() (racine carrée) de la classe Math pour renvoyer la 
racine carrée de 100 : 
(100);
L’exemple suivant suit un entier compris entre 10 et 17 (inclusivement) : 
var bottles:Number = 0;
bottles = 10 + Math.floor(Math.random() * 7);
trace("There are " + bottles + " bottles");
42
Données et types de données

L’exemple suivant mesure le pourcentage du clip intro_mc chargé et le représente sous forme 
d’entier :
var percentLoaded:Number = Math.round((intro_mc.getBytesLoaded() / 
intro_mc.getBytesTotal()) * 100);
Type de données Object
Un objet correspond à un ensemble de propriétés. Une propriété est un attribut qui décrit 
l’objet. Par exemple, la transparence d’un objet (tel qu’un clip) est un attribut qui décrit son 
apparence. Donc, _alpha (transparence) est une propriété. 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 de type 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, hoursWorked est une propriété de weeklyStats, qui est 
une propriété de employee : 
employee.weeklyStats.hoursWorked
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() :
();
mc2InstanceName.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 de nombreuses informations : un nom d’utilisateur, son âge et son numéro de 
téléphone, la vitesse d’une balle, les noms des articles contenus dans un panier d’achat, le 
nombre d’images chargées ou la dernière touche utilisée sur le clavier, 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.
Le code ActionScript suivant affiche un exemple d’utilisation des objets personnalisés pour 
organiser les informations. Il crée un nouvel objet appelé user et trois propriétés, name, age et 
phone, qui sont de types chaîne et numérique.
var user:Object = new Object();
= "Irving";
 = 32;
user.phone = "555-1234";
Pour plus d’informations, voir « Exemple : Ecriture de classes personnalisées », à la page 238.
Présentation des types de données
43

Type de données 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 (").
L’un des moyens les plus courants consiste à associer une chaîne à une variable. Par exemple, 
dans l’instruction suivante, "L7" est une chaîne associée à la variable favoriteBand_str : 
var favoriteBand_str:String = "L7";
Vous pouvez utiliser l’opérateur d’addition (+) pour concaténer, ou réunir, 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 : 
var greeting_str:String = "Welcome, " + firstName;
Pour inclure un guillemet dans une chaîne, faites-le précéder d’une barre oblique inversée (\). 
Cette opération s’appelle application d’une séquence d’échappement à 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 : 
Séquence 
Caractère
d’échappement
\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écimal
Comme sous Java, les chaînes sont inaltérables dans ActionScript. Toute opération modifiant 
une chaîne renvoie une nouvelle chaîne.
La classe String est une classe intégrée du code ActionScript. Pour plus d’informations sur les 
méthodes et les propriétés de la classe String, reportez-vous à l’entrée String dans le Guide de 
référence du langage ActionScript 2.0
.
44
Données et types de données

Type de données undefined
Ce type de données n’a qu’une seule valeur, undefined. Il est affecté automatiquement à une 
variable qui n’a reçu aucune valeur, que se soit du code ou de l’interaction de l’utilisateur. 
La valeur undefined est affectée automatiquement. Contrairement à null, vous ne pouvez 
pas l’affecter à une variable ou une propriété. Ce type de données permet de vérifier si la 
variable est définie ou non. Vous pouvez alors écrire du code qui ne s’exécute que lorsque 
l’application est en cours d’exécution, comme indiqué dans l’exemple suivant :
if (init == undefined) {
trace("initializing app");
init = true;
}
Si votre application comporte plusieurs images, le code ne s’exécute pas une deuxième fois 
parce que la variable init n’est plus « undefined ».
Type de données Void
Ce type de données n’a qu’une seule valeur, void. Il est utilisé dans la définition des fonctions 
pour indiquer qu’elles ne renvoient pas de valeurs, comme indiqué dans l’exemple suivant : 
//Crée une fonction renvoyant le type Void
function displayFromURL(url:String):Void {}
Affectation des types de données et typage strict
Dans Flash, les variables vous permettent de stocker des valeurs dans votre code. Vous pouvez 
déclarer explicitement le type d’objet d’une variable lorsque vous la créez. Cette opération est 
appelée le typage strict.
Si vous ne déclarez pas de façon explicite qu’un élément contient un nombre, une chaîne ou 
tout autre type de donnée, lors de l’exécution du script Flash Player tente d’identifier le type 
de données de cet élément lorsqu’il est affecté. Si vous affectez une valeur à une variable 
comme indiqué dans l’exemple suivant, lors de l’exécution du script, Flash Player évalue 
l’élément situé à droite de l’opérateur et détermine qu’il est de type numérique :
var x = 3;
Dans la mesure où x n’a pas été déclaré par typage strict, le compilateur ne peut pas 
déterminer son type. Ainsi, pour le compilateur, la variable x peut être de n’importe quel type. 
(Voir la section « Affectation d’un type de données », à la page 47.) Une affectation ultérieure 
pourra changer le type de x. Par exemple, l’instruction x = "hello" change le type de x en 
String.
Présentation des types de données
45

ActionScript convertit toujours les types de données primitifs (tels que Boolean, Number, 
String, null ou undefined) automatiquement lorsqu’une expression en a besoin et que les 
variables ne sont pas déclarées par typage strict.
Le typage strict des données offre plusieurs avantages lors de la compilation. La déclaration 
des types de données (typage strict) permet de prévenir et de diagnostiquer les erreurs de votre 
code au moment de sa compilation. Pour déclarer une variable par typage strict, utilisez le 
format suivant :
var variableName:datatype;
REMARQUE
Le typage strict des variables est parfois appelé typage fort.
Comme les incompatibilités de type de données déclenchent des erreurs de compilation, le 
typage strict facilite le débogage lors de la compilation et permet donc d’éviter d’affecter un 
type de données incorrect à une variable existante. Lors de la programmation, le typage strict 
des données active les conseils de code dans l’éditeur ActionScript (mais vous devez toujours 
utiliser les suffixes de nom d’occurrence pour les éléments visuels).
L’utilisation du typage strict vous empêche d’affecter, par inadvertance, un type de valeur 
incorrect à une variable. Flash vérifie les erreurs de typage lors de la compilation. En cas de 
type de valeur incorrect, il affiche un message d’erreur. Ainsi, l’application du typage strict 
permet de s’assurer que vous ne tentez pas d’accéder à des propriétés ou des méthodes qui ne 
font pas partie d’un type d’objet. Le typage strict permet également de bénéficier 
automatiquement des conseils de code proposés par l’éditeur d’ActionScript pour les objets. 
Pour plus d’informations sur la création de variables, consultevariables », à la page 51. Pour plus d’informations sur l’appellation des variables, consultez la 
section « A propos de l’appellation des variables », à la page 57. Pour plus d’informations sur 
l’affectation des types de données et sur les types appropriés, consultez la section d’un type de données », à la page 47. 
Pour un exemple du fichier , qui vous explique comment utiliser des types de 
données dans une application, consultez la page des exemples Flash à l’adresse 
;Téléchargez et décompressez le fichier zip Exemples 
et naviguez jusqu’au dossier ActionScript2.0/DataTypes afin d’accéder à l’exemple.
46
Données et types de données

Affectation d’un type de données
Vous devez affecter des types de données chaque fois que vous définissez une variable, que 
vous la déclariez à l’aide d’un mot-clé var, que vous créiez un argument de fonction ou que 
vous définissiez un type de retour de fonction ou une variable à utiliser dans une boucle for 
ou . Pour affecter un type de données, utilisez la syntaxe à deux points : le nom de la 
variable est suivi de deux points, puis du type de données :  
var my_mc:MovieClip;
Les types de données offrent de nombreuses possibilités : des types natifs, tels que Number, 
String, Boolean, jusqu’aux classes intégrées de Flash Player 8, telles que BitmapData, 
FileReference ou même les classes personnalisées écrites par vos soins ou par d’autres 
développeurs. Les types de données les plus courants que vous devrez définir sont les types 
intégrés, tels que Number, String, Boolean, Array ou Object qui apparaissent dans les 
exemples de code suivants.
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, comme illustré ci-dessous :
// Typage strict de variable ou d’objet
var myNum:Number = 7;
var birthday: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(myNum:Number):Number {
  var squared:Number = myNum * myNum;
  return squared;
}
Vous pouvez déclarer le type des objets en fonction des classes intégrées (Button, Date, etc.) et 
des classes et interfaces que vous créez. Dans l’exemple suivant, si vous avez un fichier qui 
s’appelle  dans lequel vous avez défini une classe Student, vous pouvez spécifier que 
les objets que vous créez sont de type Student :
var myStudent:Student = new Student();
Présentation des types de données
47

Par exemple, supposons que vous tapiez le code suivant :
// dans le fichier de classe
class Student {
  public var status:Boolean; // Propriété des objets Student
}
// Dans le fichier FLA
var studentMaryLago:Student = new Student();
studentMaryLago.status = "enrolled"; /* Incompatibilité de types dans 
l’instruction d’affectation : type String présent au lieu du type 
Boolean. */
Lorsque Flash compile ce script, une erreur d’incompatibilité de types est générée, car le 
fichier SWF s’attend à une valeur booléenne.
Si vous écrivez une fonction sans type de renvoi, vous pouvez déclarer le type de renvoi Void 
pour cette fonction. Ou, si vous créez un raccourci vers une fonction, vous pouvez affecter le 
type de données Function à la nouvelle variable. Pour indiquer le type Function ou Void pour 
les objets, inspirez-vous de l’exemple suivant :
function sayHello(name_str:String):Void {
trace("Hello, " + name_str);
}
sayHello("world"); // Hello, world
var greeting:Function = sayHello;
greeting("Augustus"); // Hello, Augustus
Un des autres avantages du typage strict des données réside dans le fait que Flash affiche 
automatiquement des conseils de code pour les objets intégrés que vous déclarez par typage 
stricte. Pour plus d’informations, voir la page 45.
Les fichiers publiés avec ActionScript 1.0 ne respectent pas le typage strict des données lors de 
la compilation. Par conséquent, l’attribution d’un type de valeur incorrect à une variable que 
vous avez typée de façon stricte ne génère pas d’erreur de compilation. 
var myNum:String = "abc";
myNum = 12;
/* Aucune erreur dans ActionScript 1.0, mais incompatibilité dans 
ActionScript 2.0 */
Ceci est dû au fait que lorsque vous publiez un fichier pour ActionScript 1.0, Flash interprète 
une instruction telle que var myNum:String = "abc" comme une syntaxe à barre oblique et 
non comme un typage strict. (ActionScript 2.0 ne prend pas en charge la syntaxe à barre 
oblique.) Il peut alors en résulter un objet affecté à une variable de type erroné. 
Le compilateur ignore alors les appels de méthodes non valides et les références de propriété 
non définies. 
48
Données et types de données

Les fichiers publiés à l’aide d’ActionScript 2.0 peuvent utiliser le typage des données en 
option. Ainsi, si vous implémentez le typage strict dans votre code, assurez-vous de définir vos 
paramètres de publication sur ActionScript 2.0. Vous pouvez définir les paramètres de 
publication, ainsi que la version d’ActionScript à utiliser pour la publication de vos fichiers, 
soit à partir du menu principal (Fichier > Paramètres de publication), soit en cliquant sur le 
bouton Paramètres dans l’inspecteur des propriétés (assurez-vous qu’aucune occurrence n’est 
sélectionnée). Pour utiliser une version spéciale d’ActionScript ou de Flash Player, ouvrez 
l’onglet Flash dans la boîte de dialogue Paramètres de publication, puis sélectionnez la version 
ActionScript désirée dans le menu contextuel.
Pour plus d’informations sur la vérification des types de données, consultez la section 
« Vérification du type de données », à la page 49.
Vérification du type de données
Cette opération consiste à vérifier que le type d’une variable est compatible avec une 
expression. Flash vérifie donc que le type que vous indiquez pour une variable convient aux 
valeurs que vous affectez à celle-ci. Pour plus d’informations sur le typage strict et l’affectation 
des types de données, consultez les sectiostrict », à la page 45 et « Affectation d’un type de données », à la page 47. 
La vérification des types peut être effectuée lors de la compilation ou de l’exécution. Si vous 
utilisez le typage strict des données, le type est vérifié lors de la compilation. ActionScript 
étant un langage typé dynamiquement, ActionScript peut également vérifier le type à 
l’exécution.
Par exemple, le code suivant n’indique aucun type de données pour le paramètre xParam. 
A l’exécution, vous utilisez ce paramètre pour stocker une valeur numérique Number, puis une 
valeur de chaîne de caractères String. La fonction dynamicTest() utilise ensuite l’opérateur 
typeof pour connaître le type du paramètre, String ou Number.
function dynamicTest(xParam) {
if (typeof(xParam) == "string") {
var myStr:String = xParam;
trace("String: " + myStr);
} else if (typeof(xParam) == "number") {
var myNum:Number = xParam; 
trace("Number: " + myNum);

}
dynamicTest(100);
dynamicTest("one hundred");
Présentation des types de données
49

Vous n’avez pas besoin de déclarer explicitement le type de ces données dans votre code 
ActionScript. Le compilateur d’ActionScript vous permet d’utiliser des propriétés et 
d’invoquer des méthodes qui n’existent pas au moment de la compilation. Ainsi, vous pouvez 
créer des propriétés ou affecter des méthodes dynamiquement au moment de l’exécution. 
La flexibilité offerte par la vérification dynamique du type de données implique l’utilisation de 
propriétés et de méthodes inconnues au moment de la compilation. Le code étant moins 
restrictif, cette flexibilité est avantageuse dans certains cas de programmation. Par exemple, le 
code suivant crée une fonction nommée runtimeTest() qui appelle une méthode et renvoie 
une propriété, toutes deux inconnues du compilateur. Ce code ne générera aucune erreur lors 
de la compilation. Cependant, si la propriété ou la méthode est inaccessible à l’exécution, une 
erreur se produira à ce moment-là. 
function runtimeTest(myParam) {
myParam.someMethod();
return myParam.someProperty; 
}
Identification du type de données
Lors du test et du débogage de vos programmes, des problèmes liés aux types de données 
peuvent se produire. Ou, si vous utilisez des variables non explicitement associées à un type de 
données, il sera plus pratique de connaître le type d’une variable donnée. Avec ActionScript, 
vous pouvez identifier le type de données d’un élément. Vous pouvez utiliser l’opérateur 
typeof pour récupérer des informations sur les données.
Cependant, n’oubliez pas que cet opérateur ne renvoie pas d’informations sur la classe d’une 
occurrence.
L’exemple suivant présente l’utilisation de l’opérateur typeof pour renvoyer la nature de 
l’objet à identifier :
// Crée une nouvelle occurrence de la classe LoadVars.
var my_lv:LoadVars = new LoadVars();
/* L’opérateur typeof n’indique pas la classe, il spécifie uniquement que 
myLV est un objet. */
var typeResult:String = typeof(my_lv);
trace(typeResult); // Objet
50
Données et types de données

Dans cet exemple, vous créez une nouvelle variable String nommée myName, puis vous la 
convertissez en type Number :
var myName:String = new String("17");
trace(myName instanceof String); // true
var myNumber:Number = new Number(myName);
trace(myNumber instanceof Number); // true
Pour plus d’informations sur ces opérateurs, reportez-vous à l’opérateur typeof et 
l’opérateur instanceof dans le Guide de référence du langage ActionScript 2.0. Pour plus 
d’informations sur le test et le débogage, consultez le guide Utilisation de Flash. Pour plus 
d’informations sur les héritages et les interfaces, consultezpage 281. Pour plus d’informations sur les classes, consultez lepage 197.
Présentation des variables
Une variable est un conteneur qui stocke des informations. Le code suivant montre une 
variable dans ActionScript :
var myVariable:Number = 10;
Cette variable contient une valeur numérique. L’utilisation de :Number dans le code précédent 
affecte le type de valeur que la variable contient, opération appelée typage des données
Pour plus d’informations sur le typage des données, consultez les sections types de données et typage strict », à la page 45 et la page 47.   
Le conteneur (représenté par le nom de variable) est toujours le même dans tout votre code 
ActionScript, mais son contenu (sa valeur) peut évoluer. Vous pouvez changer plusieurs fois la 
valeur d’une variable dans un script. 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 vraie ou fausse (true ou false). La variable devra peut-être être 
continuellement mise à jour pendant la lecture du fichier SWF, par exemple lorsque le score 
d’un joueur change dans un jeu Flash. Les variables sont indispensables pour créer et gérer les 
interactions de l’utilisateur dans un fichier SWF.
Présentation des variables
51

Il est toujours judicieux d’affecter une valeur à une variable lors de sa première déclaration. 
L’affectation d’une valeur initiale est appelée initialisation de la variable. Cette opération est 
souvent effectuée sur l’Image 1 du scénario ou depuis la classe qui est chargée au début de la 
lecture du fichier SWF. Il existe différentes sorte de variables qui sont affectées par domaine. 
Pour plus d’informations sur les différentes sortes de variables et sur les domaines, consultez la 
section « Variables et domaine », à la page 62.
CO
L’initialisation d’une variable facilite le suivi et la comparaison de sa valeur pendant la 
NS
lecture du fichier SWF.
EI
L
REMARQUE
Flash Player 7 et ses versions ultérieures n’évaluent pas les variables non initialisées de 
la même manière que Flash Player 6 et ses versions précédentes. Si vous avez écrit des 
scripts pour Flash Player 6 et prévoyez d’écrire ou porter des scripts pour Flash Player 7 
ou une version plus récente, vous devez comprendre ces différences pour éviter un 
comportement inattendu. 
Les variables peuvent contenir différents types de données. Pour plus d’informations, 
consultez la section « Présentation des types de données », à la page 36. Le type de données 
d’une variable influence la façon dont sa valeur est modifiée par un script.
Les types d’informations le plus souvent stockés dans une variable sont les URL (String), les 
noms d’utilisateur (String), les résultats d’opérations mathématiques (Number), le nombre 
d’occurrences d’un événement (Number) ou si un bouton a été actionné (Boolean). Chaque 
fichier SWF et chaque occurrence d’objet (tel qu’un 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’instruction trace() pour envoyer la valeur au 
panneau de sortie. La valeur apparaît ensuite dans le panneau de sortie lorsque vous testez le 
fichier SWF dans l’environnement de test. Par exemple, trace(hoursWorked) envoie la 
valeur de la variable hoursWorked au panneau de sortie dans l’environnement de test. 
Vous pouvez également vérifier et définir les valeurs des variables avec le débogueur dans 
l’environnement de test.
Pour plus d’informations sur les variables, consultez les sections suivantes :
?
« Déclaration des variables », à la page 53
?
« Affectation des valeurs », à la page 53
?
« A propos de l’appellation des variables », à la page 57
?
« Utilisation des variables dans une application », à la page 58
?
« Variables et domaine », à la page 62
?
« A propos des valeurs par défaut », à la page 53
52
Données et types de données

?
« A propos des opérateurs et des variables », à la page 56
?
« Chargement des variables », à la page 67
?
« Utilisation des variables dans un projet », à la page 72
Déclaration des variables
Vous pouvez déclarer les variables sur une image du scénario, directement dans un objet ou 
dans un fichier de classe externe.
Définissez les variables à l’aide du mot-clé var et respectez leurs conventions d’appellation. 
Comme dans l’exemple suivant, vous pouvez déclarer une variable nommée firstName :
var firstName:String;
Lorsque vous déclarez une variable, vous lui affectez un type de données. Dans le cas présent, 
vous affectez le type String à la variable firstName. Pour plus d’informations sur l’affectation 
du type de données, consultez le la page 45.
A propos des valeurs par défaut
La valeur par défaut est le contenu d’une variable avant que vous définissiez sa valeur. 
Vous initialisez une variable lorsque vous lui affectez sa première valeur. Si vous déclarez une 
variable sans définir sa valeur, cette variable est non initialisée. La valeur par défaut d’une 
variable non initialisée est undefined. Pour plus d’informations sur la création et l’utilisation 
des variables, consultez la section « Présentation des variables », à la page 51. 
Affectation des valeurs
Vous pouvez définir une valeur comme contenu actuel d’une variable. Cette valeur peut être 
composée de chaînes, nombres, tableaux, objets, XML, dates ou même de classes 
personnalisées que vous créez. N’oubliez pas que vous déclarez les variables dans Flash à l’aide 
du mot-clé var. Lorsque vous déclarez une variable, vous lui affectez également un type de 
données. Vous pouvez également lui attribuer une valeur tant que celle-ci correspond au type 
de données affecté à la variable.
L’exemple suivant présente la création d’une variable nommée catName :
var catName:String;
Présentation des variables
53

Après la déclaration de la variable, vous pouvez lui affecter une valeur. La ligne de code 
ActionScript précédente doit être suivie de cette ligne :
catName = "Pirate Eye";
REMARQ
Pirate Eye étant une chaîne (String), sa valeur doit être entre guillemets. 
UE
Cet exemple affecte la valeur de Pirate Eye à la variable catName. Lorsque vous déclarez la 
variable, vous pouvez également lui attribuer une valeur immédiatement et non 
ultérieurement comme dans les exemples précédents. Vous pouvez définir la variable catName 
lors de sa déclaration, comme dans l’exemple suivant :
var catName:String = "Pirate Eye";
Si vous souhaitez afficher la valeur de la variable catName dans l’environnement de test, 
utilisez l’instruction trace(). Cette instruction envoie la valeur au panneau de sortie. 
Vous pouvez suivre l’évolution de la valeur de la variable catName et vérifier si les guillemets 
sont absents dans son contenu actuel à l’aide du code ActionScript suivant :
var catName:String = "Pirate Eye";
trace(catName); // Pirate Eye
N’oubliez pas que la valeur affectée doit être compatible avec le type de données déclaré 
(String dans le cas présent). Si par la suite vous tentez d’affecter un nombre à la variable 
catName, par exemplecatName = 10, l’erreur suivante apparaîtra dans le panneau de sortie 
lors du test du fichier SWF :
Type mismatch in assignment statement: found Number where String is 
required.
Cette erreur indique que vous avez tenté d’affecter un type de données incorrect à une variable 
définie.
Lorsque vous affectez une valeur numérique à une variable, les guillemets ne sont pas 
nécessaires, comme le montre le code suivant :
var numWrinkles:Number = 55;
Pour modifier la valeur de numWrinkles ultérieurement dans votre code, affectez une nouvelle 
valeur à l’aide du code ActionScript suivant :
numWrinkles = 60;
Lorsque vous réaffectez la valeur d’une variable existante, il n’est pas nécessaire d’utiliser le 
mot-clé var ni de définir le type de données de la variable (dans le cas présent, Number).
54
Données et types de données

Si la valeur est numérique ou booléenne (true ou false), les guillemets sont inutiles. 
Des exemples de valeurs numériques et booléennes sont présentés dans le fragment de code 
suivant :
var age:Number = 38;
var married:Boolean = true;
var hasChildren:Boolean = false;
Dans l’exemple précédent, la variable age contient la valeur d’un entier (non décimal), 
bien que vous puissiez utiliser une valeur décimale ou à virgule flottante telle que 38,4. 
Les variables booléennes (telles que married ou hasChildren) ont deux valeurs possibles, 
true et false.
Si vous souhaitez créer un tableau et lui affecter des valeurs, le format est légèrement différent, 
comme dans le code suivant : 
var childrenArr:Array = new Array("Pylon", "Smithers", "Gil");
Il existe une autre syntaxe (abrégée) pour créer un tableau à l’aide des opérateurs d’accès 
tableau, qui utilisent les parenthèses ([]). Vous pouvez réécrire l’exemple précédent comme 
suit :
var childrenArr:Array = ["Pylon", "Smithers", "Gil"];
Pour plus d’informations sur la création de tableaux et leurs opérateurs d’accès, consultez les 
sections « Présentation des tableaux », à la page 132cibler une occurrence », à la page 86.
De même, vous pouvez créer un nouvel objet appelé myObj. Pour créer un objet, utilisez l’une 
des méthodes suivantes. La première méthode (et la plus longue) pour créer un tableau avec 
du code est la suivante :
var myObj:Object = new Object();
myObj.firstName = "Steve";
= 50;
myObj.childrenArr = new Array("Mike", "Robbie", "Chip");
La seconde méthode (la plus courte) pour créer le tableau myObj avec du code est la suivante :
var myObj:Object = {firstName:"Steve", age:50, childrenArr:["Mike", 
"Robbie", "Chip"]};
Présentation des variables
55

Comme le montre cet exemple, le choix de la méthode courte permet d’économiser beaucoup 
de saisie et de temps, particulièrement lorsque vous définissez des occurrences d’objets. Il est 
important de bien connaître cette syntaxe de rechange car vous la rencontrerez en travaillant 
avec d’autres équipes ou dans du code ActionScript écrit par des tiers sur Internet ou dans les 
livres spécialisés.
REMARQUE
Toutes les variables n’ont pas besoin d’être définies explicitement. Certaines variables 
sont créées automatiquement par Flash pour vous. Par exemple, pour connaître les 
dimensions de la scène, vous pouvez utiliser les valeurs des deux variables prédéfinies 
suivantes : Stage.width et Stage.height.
A propos des opérateurs et des variables
Les symboles mathématiques présents dans le code peuvent prêter à confusion. 
Dans ActionScript, ces symboles sont appelés des opérateurs. Les opérateurs calculent une 
nouvelle valeur à partir d’une ou plusieurs valeurs et vous les utilisez pour affecter une valeur à 
une variable dans votre code. Vous utilisez l’opérateur d’égalité (=) pour affecter une valeur à 
une variable :
var username:String = "Gus";
L’opérateur d’addition (+) est un autre exemple, utilisé pour ajouter des valeurs numériques 
entre elles et produire ainsi une nouvelle valeur. Si vous utilisez l’opérateur + avec des valeurs 
de chaînes (string), les chaînes seront concaténées. Les valeurs manipulées avec des opérateurs 
sont appelées opérandes.
Pour affecter une valeur à une variable, vous utilisez un opérateur. Par exemple, le script 
suivant utilise l’opérateur d’affectation pour donner la valeur 7 à la variable numChildren :
var numChildren:Number = 7;
Si vous devez modifier la valeur de la variable numChildren, utilisez le code suivant :
numChildren = 8;
REMAR
Le mot-clé var n’est pas nécessaire car la variable a déjà été définie.
Q
UE
Pour plus d’informations sur l’utilisation des opérateurs dans le code ActionScript, consultez 
la section « Présentation des opérateurs », à la page 145.
56
Données et types de données

A propos de l’appellation des variables 
Prenez soin de bien choisir les noms que vous attribuez aux variables car, bien que leur choix 
soit entièrement libre, certaines règles doivent être respectées. Le nom des variables doit suivre 
les règles suivantes :
?
Toute variable doit être un identifiant. 
REMARQUE
Les identifiants sont des noms de variable, de propriété, d’objet, de fonction ou de 
méthode. Le premier caractère des identifiants doit être une lettre, un trait de 
soulignement (_) ou un signe dollar ($). Chaque caractère qui suit peut être une lettre, 
un chiffre, un trait de soulignement ou un dollar.
?
Une variable ne peut pas être un mot-clé, ni un littéral ActionScript, tel que true, false, 
null ou undefined. Pour plus d’informations sur les littéraux, consultez la section 
« Présentation des littéraux », à la page 99.
?
Toute variable doit être unique dans son domaine (consultez la section domaine », à la page 62).
?
Le nom d’une variable ne doit pas correspondre à un élément du langage ActionScript, tel 
qu’un nom de classe.
Si vous ne respectez pas ces règles lors de l’attribution des noms de variables, des erreurs de syntaxe 
ou des résultats inattendus risquent de se produire. Dans l’exemple suivant, si vous nommez une 
variable new, lorsque vous testez votre document, Flash générera une erreur de compilation :
// Ce code fonctionne comme prévu.
var helloStr:String = new String();
trace(helloStr.length); // 0
// Mais si une variable porte le même nom qu’une classe intégrée .
var new:String = "hello"; // erreur : identifiant attendu
var helloStr:String = new String();
trace(helloStr.length); // non défini
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 que vous avez affecté à une variable, vous pouvez définir strictement le type 
de cette dernière. Les conseils de code fournissent des astuces de syntaxe sous forme d’info-
bulles et un menu contextuel qui accélère votre rédaction du code.
Par exemple, vous tapez le code suivant :
var members:Array = new Array();
members.
Dès que vous tapez le point (.) dans le panneau Actions, Flash affiche la liste des méthodes et 
propriétés disponibles pour les objets Array.
Pour connaître les conventions de codage pour l’appellation des variables, consultez la section 
« Appellation des variables », à la page 720.
Présentation des variables
57

Utilisation des variables dans une application
Dans cette section, vous utilisez des variables dans des fragments de code ActionScript. 
Vous devez déclarer et initialiser une variable dans un script avant de pouvoir l’utiliser dans 
une expression. Les expressions sont des combinaisons d’opérandes et d’opérateurs qui 
représentent une valeur. Par exemple, dans l’expression i+2, i et 2 sont des opérandes et + est 
un opérateur.
Si vous n’initialisez pas une variable avant de l’utiliser dans une expression, elle reste indéfinie 
et risque de provoquer des résultats inattendus. Pour plus d’informations sur la syntaxe des 
expressions, consultez la page 81.
Si vous utilisez une variable indéfinie comme dans l’exemple suivant, elle prend la valeur NaN 
dans Flash Player 7 et les versions ultérieures, et votre script est susceptible de générer des 
résultats inattendus :
var squared:Number = myNum * myNum;
trace(squared); // NaN
var myNum:Number = 6;
Dans l’exemple suivant, l’instruction déclarant et initialisant la variable myNum est placée en 
premier, pour que squared puisse être remplacé par une valeur :
var myNum:Number = 6;
var squared:Number = myNum * myNum;
trace(squared); // 36
La même chose se produit lorsque vous transmettez une valeur non définie à une méthode ou 
à une fonction, comme dans l’exemple suivant.
Comparaison de variables définies et non définies transférées à une fonction 
1.
Faites glisser un composant Button du panneau Composants sur la scène.
2. Ouvrez l’inspecteur des propriétés et tapez bad_button dans la zone de texte Nom de 
l’occurrence.
3. Tapez le code suivant dans l’image 1 du scénario.
// Ne fonctionne pas
function badClickListener(evt:Object):Void {
getURL(targetUrl);
var targetUrl:String = "";
}
bad_button.addEventListener("click", badClickListener);
4. Sélectionnez Contrôle > Tester l’animation, et remarquez que le bouton ne fonctionne pas 
(la page Web ne s’ouvre pas).
5. Faites glisser un composant Button sur la scène. Sélectionnez le bouton.
58
Données et types de données

6. Ouvrez l’inspecteur des propriétés et tapez good_button dans le champ de texte Nom de 
l’occurrence.
7. Ajoutez le code ActionScript suivant à l’image 1 du scénario (à la suite du précédent code 
ActionScript ajouté) :
// Fonctionne
function goodClickListener(evt:Object):Void {
var targetUrl:String = "";
getURL(targetUrl);
}
good_button.addEventListener("click", goodClickListener);
8. Sélectionnez Contrôle > Tester l’animation, puis cliquez sur le second bouton ajouté à la 
scène. 
Ce bouton fonctionne correctement et ouvre la page Web.
Le type de données contenu dans une variable affecte les conditions et le moment où sa valeur 
sera modifiee. Les types de données primitifs, tels que les chaînes et les chiffres, sont transmis 
par valeur 
: la valeur actuelle de la variable est reprise, et non pas une référence à cette valeur. 
Parmi les exemples de type de données complexes, on trouve Array et Object.
Dans l’exemple suivant, vous définissez myNum sur 15 et copiez la valeur dans otherNum. 
Lorsque vous modifiez myNum en 30 (à la ligne 3 du code), la valeur de otherNum demeure 15 
car otherNum ne regarde pas dans myNum pour connaître sa valeur. La variable otherNum 
contient la valeur de myNum qu’elle a reçue (à la ligne 2 du code).
Utilisation des variables dans votre code ActionScript 
1.
Créez un document Flash, puis enregistrez-le sous le nom de .
2. Sélectionnez l’image 1 du scénario, puis tapez le code suivant dans le panneau Actions :
var myNum:Number = 15;
var otherNum:Number = myNum;
myNum = 30;
trace(myNum); // 30
trace(otherNum); // 15
Lorsque vous modifiez myNum en 30 (à la ligne 3 du code), la valeur de otherNum demeure 
15 car otherNum ne regarde pas dans myNum pour connaître sa valeur. La variable 
otherNum contient la valeur de myNum qu’elle a reçue (à la ligne 2 du code).
3. Choisissez Contrôle > Tester l’animation pour voir les valeurs affichées dans le panneau 
de sortie.
Présentation des variables
59

4. Maintenant, ajoutez le code ActionScript suivant après celui ajouté à l’étape 2 :
function sqr(myNum:Number):Number {
myNum *= myNum;
return myNum;
}
var inValue:Number = 3;
var outValue:Number = sqr(inValue);
trace(inValue); // 3
trace(outValue); // 9
Dans ce code, la variable inValue contient une valeur primitive, 3, la valeur est donc 
transmise à la fonction sqr() et la valeur renvoyée est 9. La valeur de la variable inValue 
ne change pas, bien que la valeur de myNum change dans la fonction.
5. Choisissez Contrôle > Tester l’animation pour voir les valeurs affichées dans le panneau de 
sortie.
Le type de données Object peut contenir tant d’informations complexes qu’une variable de ce 
type ne contient pas de valeur réelle, mais 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.
Pour plus d’informations sur le transfert d’une variable par référence, consultez la section 
« Transfert d’une variable par référence », à la page 60.
Transfert d’une variable par référence
Les types de données Array et Object contenant une référence à une valeur au lieu de leur 
valeur réelle, soyez prudent lorsque vous travaillez avec des tableaux et des objets. 
L’exemple suivant montre comment transmettre un objet par référence. Lorsque vous créez 
une copie du tableau, vous créez en réalité une copie de la référence (ou alias) au contenu du 
tableau. Lorsque vous modifiez le contenu du second tableau, vous modifiez à la fois le 
contenu du premier et du second tableau car ils pointent tous les deux vers la même valeur.
Transmission d’un objet par référence
1.
Sélectionnez Fichier > Nouveau puis Document Flash pour créer un fichier FLA et 
l’enregistrer sous le nom de .
2. Sélectionnez l’image 1 du scénario, puis tapez le code suivant dans le panneau Actions :
var myArray:Array = new Array("tom", "josie");
var newArray:Array = myArray;
myArray[1] = "jack";
trace(myArray); // tom,jack
trace(newArray); // tom,jack
60
Données et types de données

3. Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Ce code crée un objet Array appelé myArray qui contient deux éléments. Vous créez la 
variable newArray et transmettez une référence à myArray. Lorsque vous modifiez le 
deuxième élément de myArray en jack, cela affecte toutes les variables qui y font 
référence. L’instruction trace() envoie tom,jack au panneau Sortie.
REMARQUE
Flash utilise un index basé sur zéro, ce qui signifie que 0 est le premier élément du 
tableau, 1 le deuxième, etc.
Dans l’exemple suivant, myArray contient un objet Array que vous transmettez à la fonction 
zeroArray() par référence. 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.
Transmission d’un tableau par référence 
1.
Sélectionnez Fichier > Nouveau puis Document Flash pour créer un fichier FLA et 
l’enregistrer sous le nom de .
2. Ajoutez le code ActionScript suivant à l’image 1 du scénario :
function zeroArray (theArr:Array):Void {
  var i:Number;
  for (i = 0; i < theArr.length; i++) {
    theArr[i] = 0;
  }
}
var myArr:Array = new Array();
myArr[0] = 1;
myArr[1] = 2;
myArr[2] = 3;
trace(myArr); // 1,2,3
zeroArray(myArr);
trace(myArr); // 0,0,0
3. Choisissez Contrôle > Tester l’animation pour tester votre code ActionScript.
La première instruction trace() de ce code ActionScript affiche le contenu original du 
tableau myArray (1,2,3). Après votre appel de la fonction zeroArray() et votre transfert 
d’une référence au tableaumyArray, toutes les valeurs du tableau sont écrasées et définies sur 
zéro. La prochaine instruction trace() affiche le nouveau contenu original du tableau 
myArray (0,0,0). Le tableau ayant été transmis par référence et non par valeur, il est inutile 
de renvoyer le contenu actualisé du tableau provenant de la fonction zeroArray().
Pour plus d’informations sur les tableaux, consultez la section la page 132.
Présentation des variables
61

Variables et domaine
Le domaine d’une variable fait référence au domaine dans lequel la variable est connue 
(définie) et peut être référencée. Il peut s’agir d’un certain scénario ou d’une fonction, ou 
d’une application entière. Pour plus d’informations sur le domaine, consultez la section 
« Domaine et ciblage », à la page 91.
Lorsque vous développez des applications Flash avec ActionScript, la compréhension du 
domaine des variables est capitale. Le domaine indique non seulement où et quand vous 
pouvez faire référence aux variables, mais également la durée d’existence de chaque variable 
dans l’application. Lorsque vous définissez des variables dans le corps d’une fonction, elles 
cessent d’exister dès que la fonction spécifiée se termine. Si vous tentez de faire référence à des 
objets dans un domaine incorrect ou à des variables qui ont expiré, vous obtenez des erreurs 
dans vos documents Flash, ce qui entraîne des comportements inattendus ou des défaillances 
de fonctionnalité.
Il existe trois types de domaine de variable dans ActionScript :
?
Variables globales et fonctions sont visibles par tout scénario et domaine du document. 
Toute variable globale est donc définie dans chaque zone de votre code.
?
Variables de scénario sont disponibles pour tous les scripts de ce scénario.
?
Variables locales sont disponibles dans le corps de la fonction dans lequel elles sont 
déclarées (délimité par des accolades). Les variables locales sont donc définies dans une 
seule partie de votre code.
Pour consulter les recommandations sur l’utilisation des domaines et des variables, consultez 
le Chapitre 4, « Domaine et ciblage », à la page 91.
REMARQUE
Les classes ActionScript  2.0 que vous créez prennent en charge les domaines de 
variables publics, privés et statiques. Pour plus d’informations, vomembres de classe », à la page 224classes », à la page 249.
Vous ne pouvez pas typer les variables globales de façon stricte. Pour obtenir plus 
d’informations et une solution de rechange, consultez la la page 63.
62
Données et types de données

Variables globales
Les variables et les fonctions globales sont visibles par tout scénario et domaine du document. 
Pour déclarer (ou 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 myName : 
var _global.myName = "George"; // Syntaxe incorrecte pour la variable
// globale
_global.myName = "George"; // Syntaxe correcte pour la variable globale
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, comme indiqué 
dans l’exemple suivant :
_global.counter = 100; // Déclare une variable globale
trace(counter); // Accède à la variable globale et affiche 100
function count():Void {
for (var counter:Number = 0; counter <= 2; counter++) { // Variable
// locale
trace(counter); // Accède à la variable locale et affiche de 0 à 2
}
}
count();
trace(counter); // Accède à la variable globale et affiche 100
Cet exemple indique uniquement que la variable globale n’est pas accessible dans le domaine 
de la fonction count(). Toutefois, vous pouvez y accéder si vous lui ajoutez le préfixe 
_global. Par exemple, vous pouvez y accéder si vous ajoutez le préfixe _global au compteur, 
comme dans le code suivant :
trace(_global.counter);
Vous ne pouvez pas affecter des types de données stricts aux variables créées dans le domaine 
_global puisque vous devez utiliser le mot-clé var lorsque vous affectez un type de données. 
Par exemple, vous ne pourriez pas faire :
:String = "foo";  //erreur de syntaxe
var :String = "foo"; //erreur de syntaxe
Le Sandbox de Flash Player version 7 et ses versions suivantes applique des restrictions 
concernant l’accès de variables globales à partir de fichiers SWF chargés à partir de domaines 
de sécurité distincts. Pour plus d’informations, consultez la sécurité », à la page 675.
Présentation des variables
63

Variables de scénario
Les variables de scénario sont disponibles pour tout script dans ce scénario. Pour déclarer des 
variables de scénario, utilisez l’instruction var et initialisez-les dans chaque image du scénario. 
Cette image et toutes les suivantes peuvent accéder à la variable, comme le montre l’exemple 
suivant. 
Pour utiliser des variables de scénario dans un document :
1.
Créez un document Flash et nommez-le .
2. Ajoutez le code ActionScript suivant à l’image 1 du scénario :
var myNum:Number = 15; /* initialisé dans l’image 1, donc accessible à 
toutes les images */
3. Sélectionnez l’image 20 du scénario.
4. Sélectionnez Insertion > Scénario > Image-clé vide.
5. La nouvelle image-clé sélectionnée, tapez le code ActionScript suivant dans le panneau 
Actions :
trace(myNum);
6. Choisissez Contrôle > Tester l’animation pour tester le nouveau document.
La valeur 15 apparaît dans le panneau de sortie au bout d’une seconde environ. Les 
documents Flash fonctionnant en boucle par défaut, la valeur 15 apparaît continuellement 
dans le panneau de sortie chaque fois que la tête de lecture atteint l’image 20 dans le 
scénario. Pour interrompre la boucle, ajoutez stop(); après l’instruction trace().
Vous devez déclarer toute variable de scénario avant d’y accéder dans un script. Par exemple, si 
vous placez le code var myNum:Number = 15; dans l’image 20, aucun des scripts joints aux 
images précédentes ne peut accéder à myNum et sont indéfinis au lieu de contenir la valeur 15.
Variables locales  
Lorsque vous utilisez l’instruction var dans un bloc de fonction, vous déclarez des variables 
locales
. Lorsque vous déclarez une variable locale dans un bloc de fonction (également appelé 
définition de fonction), elle est définie dans le domaine de ce bloc et expire à la fin du bloc. 
La variable locale n’existe donc que dans cette fonction.
Par exemple, si vous déclarez une variable nommée myStr dans une fonction appelée 
localScope, cette variable ne sera pas disponible en dehors de cette fonction.
function localScope():Void {
var myStr:String = "local";
}
localScope();
trace(myStr); // Non défini, car myStr n’est pas définie globalement
64
Données et types de données

Si le nom utilisé pour votre variable locale est déjà déclaré en tant que variable de scénario, la 
définition locale prévaut sur celle du scénario pendant que la variable locale est dans le 
domaine. La variable de scénario persiste hors de la fonction. Par exemple, le code suivant crée 
une variable de scénario de type chaîne appelée str1, puis une variable locale du même nom 
dans la fonction scopeTest(). L’instruction trace placée dans la fonction génère la 
définition locale de la variable, tandis que celle qui est placée hors de la fonction génère la 
définition de scénario de la variable.
var str1:String = "Timeline";
function scopeTest():Void {
var str1:String = "Local";
trace(str1); // Locale
}
scopeTest();
trace(str1); // Scénario
Dans l’exemple suivant, vous constatez que certaines variables n’existent que pour les besoins 
d’une fonction spécifique et qu’elles peuvent générer des erreurs si vous y faites référence hors 
du domaine de cette fonction.
Utilisation des variables locales dans une application
1.
Créez un nouveau document Flash.
2. Ouvrez le panneau Actions (Fenêtre > Actions) et ajoutez le code ActionScript suivant dans 
l’image 1 du scénario :
function sayHello(nameStr:String):Void {
var greetingStr:String = "Hello, " + nameStr;
trace(greetingStr);
}
sayHello("world"); // Hello, world
trace(nameStr); // non défini
trace(greetingStr); // non défini
3. Choisissez Contrôle > Tester l’animation pour tester le document. 
Flash affiche la chaîne « Hello, world » dans le panneau de sortie et undefined pour les 
valeurs des variables nameStr et greetingStr car elles ne sont plus disponibles dans ce 
domaine. Vous pouvez faire référence à nameStr et greetingStr uniquement lors de 
l’exécution de la fonction sayHello. Dès que cette fonction se termine, ces variables 
cessent d’exister.
Présentation des variables
65

Les variables i et j sont souvent utilisées comme compteurs de boucles. Dans l’exemple 
suivant, vous utilisez i comme variable locale qui existe uniquement dans la fonction 
initArray() :
var myArr:Array = new Array();
function initArray(arrayLength:Number):Void {
  var i:Number;
  for(i = 0; i < arrayLength; i++) {
    myArr[i] = i + 1;
  }
}
trace(myArr); // <vide>
initArray(3);
trace(myArr); // 1,2,3
trace(i); // non défini
REMARQUE
Il n’est pas rare de rencontrer la syntaxe suivante pour une boucle for : for (var 
i:Number = 0; i < arrayLength; i++) { }.
Cet exemple affiche la valeur undefined dans l’environnement de test Flash car la variable i 
n’est pas définie dans le scénario principal. Elle existe uniquement dans la fonction 
initArray().
Vous pouvez également utiliser des variables locales pour empêcher les conflits de noms, qui 
peuvent donner lieu à des résultats inattendus dans votre application. Par exemple, si vous 
utilisez age comme variable locale, elle vous permet de stocker l’âge d’une personne dans un 
contexte et celui d’un enfant de la personne dans un autre contexte. Dans ce cas, aucun conflit 
ne se produit car ces variables sont utilisées dans des domaines distincts.
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. Vous ne pouvez modifier une 
variable locale que dans son bloc de code. Si une expression d’une fonction utilise une variable 
globale, du code ou des événements extérieurs peuvent modifier sa valeur, ce qui modifierait la 
fonction. 
Vous pouvez affecter un type de données à une variable locale lorsque vous la déclarez, ce qui 
vous évite d’affecter un type de données erroné à une variable existante. Pour plus 
d’informations, voir « Affectation des types de données et typage strict », à la page 45.
66
Données et types de données

Chargement des variables
Dans les sections suivantes, vous allez charger des variables depuis le serveur de différentes 
manières ou dans un document depuis une chaîne d’URL ou FlashVars (qui permet de 
transférer des variables dans Flash) dans votre code HTML. Ces pratiques présentent les 
méthodes différentes d’utilisation des variables hors d’un fichier SWF.
Pour plus d’informations sur le chargement des variables (telles que des paires nom/valeur), 
consultez le Chapitre 15, « Utilisation de données externes », à la page 631.
Vous pouvez utiliser des variables de différentes manières dans un fichier SWF, selon vos 
besoins. Pour plus d’informations, voir les sections suivantes :
?
« Utilisation de variables depuis l’URL », à la page 67
?
« Utilisation de FlashVars dans une application », à la page 70 
?
« Chargement des variables depuis un serveur », à la page 71
Utilisation de variables depuis l’URL
Lorsque vous développez une application ou un exemple simple dans Flash, vous pourriez 
souhaiter faire passer des valeurs entre une page HTML et votre document Flash. Les valeurs 
transmises portent parfois le nom de chaîne de requête ou variables de code URL. Les variables 
d’URL s’avèrent très pratiques pour créer un menu dans Flash par exemple. Vous pouvez 
initialiser le menu pour afficher la navigation appropriée par défaut ou vous pouvez créer une 
visionneuse dans Flash et définir l’image à afficher par défaut sur le site Web. 
Utilisation des variables d’URL dans un document
1.
Créez un document Flash et appelez-le .
2. Sélectionnez Fichier > Enregistrer sous, puis enregistrez le document sur votre ordinateur.
3. Sélectionnez l’image 1 du scénario, puis ajoutez le code suivant dans le panneau Actions :
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
= _level0.myURL;
4. Choisissez Contrôle > Tester l’animation pour tester le fichier SWF dans Flash Player. 
Le champ de texte contient la valeur undefined. Pour vous assurer que les variables sont 
bien définies, vous devez vérifier leur présence dans Flash. Pour ce faire, vérifiez leurs 
valeurs qui doivent être non définies.
Présentation des variables
67

5. Pour vérifier si une variable est définie, modifiez le code ActionScript que vous avez ajouté 
dans le panneau Actions) à l’étape 3 pour qu’il ressemble au code suivant. Ajoutez le code 
qui apparaît en gras :
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
if (_level0.myURL == undefined) {
= "myURL is not defined";
} else {
= _level0.myURL;
}
Lorsque vous publiez votre document Flash, un document HTML est créé par défaut dans 
le même répertoire que le fichier SWF. Si un fichier HTML n’a pas été créé, sélectionnez 
Fichier > Paramètres de publication, et assurez-vous d’avoir sélectionné HTML dans 
l’onglet Formats. Puis, republiez votre document.
Le code suivant montre les lignes HTML dans le document qui sont responsables de 
l’imbrication d’un document Flash dans une page HTML. Examinez bien ce code HTML 
pour comprendre le fonctionnement des variables d’URL dans l’étape suivante 
(qui consiste à ajouter du code pour les variables d’URL).
<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" 
codebase="
#version=8,0,0,0" width="550" height="400" 
id="urlvariables" align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="" />
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="" quality="high" bgcolor="#ffffff" 
width="550" height="400" name="urlvariables" align="middle" 
allowScriptAccess="sameDomain" type="application/x-shockwave-flash" 
pluginspage="; />
</object>
6. Pour faire passer des variables du document HTML généré à votre document Flash, vous 
pouvez les ajouter à la suite du chemin d’accès et du nom de fichier (). 
Ajoutez le texte en gras au fichier HTML généré sur votre ordinateur.
<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" 
codebase="
#version=8,0,0,0" width="550" height="400" 
id="urlvariables" align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="?myURL=http://
" />
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="
quality="high" bgcolor="#ffffff" width="550" height="400" 
name="urlvariables" align="middle" allowScriptAccess="sameDomain" 
type="application/x-shockwave-flash" pluginspage="http://
; />
</object>
68
Données et types de données

7. Si vous souhaitez transmettre plusieurs variables dans Flash, vous devez séparer les paires 
nom/valeur par un caractère esperluette (&). Récupérez le code suivant à l’étape 6 : 

Remplacez-le par le texte suivant :
&myTitle=adobe+News+Aggregator
N’oubliez pas que vous devez modifier de la même manière les deux balises object et 
embed pour garantir la cohérence sur tous les navigateurs. Vous remarquerez que les mots 
sont séparés par des signes +, car les valeurs sont du code URL et que le signe + représente 
un espace vide. 
REMARQUE
Pour connaître la liste des caractères spéciaux de code URL les plus courants, 
consultez la TechNote Flash, text file.
L’esperluette (&) servant de délimiteur pour différentes paires nom/valeur, des résultats 
inattendus risquent de se produire lorsque les valeurs que vous transmettez en 
contiennent. Etant donné la nature des paires nom/valeur et de l’analyse, si vous faites 
passer les valeurs suivantes dans Flash,
?name=PB+&+J&flavor=strawberry+rhubarb
Flash créera les variables (et les valeurs) suivantes dans le domaine racine :
'name': 'PB ' (note space at end of value)
' J': '' (note space at beginning of variable name and an empty value)
'flavor': 'strawberry rhubarb'
Pour éviter cela, vous devez remplacer l’esperluette (&) dans la paire nom/valeur par son 
équivalent en code URL (%26).
8. Ouvrez le document et localisez le code suivant :
&myTitle=Adobe+News+Aggregator
Remplacez-le par le code suivant :
?myURL=PB+%26+J&flavor=strawberry+rhubarb
9. Enregistrez le code HTML modifié et testez de nouveau votre document Flash. 
Vous constatez que Flash crée les paires nom/valeur suivantes.
'name': 'PB & J'
'flavor': 'strawberry rhubarb'
REMARQUE
Tous les navigateurs prennent en charge les chaînes d’une longueur allant jusqu’à 
64 Ko (65 535 octets). Un paramètre FlashVars doit être affecté aux deux balises 
object et embed pour que votre code fonctionne dans tous les navigateurs.
Présentation des variables
69

Utilisation de FlashVars dans une application
L’emploi de FlashVars pour faire passer des variables dans Flash est similaire à l’emploi d’URL 
dans le code HTML. Avec FlashVars, au lieu d’être à la suite du nom de fichier, les variables 
sont transmises dans une balise param distincte, ainsi que dans une balise embed. 
Utilisation de FlashVars dans un document
1.
Créez un document Flash et appelez-le .
2. Sélectionnez Fichier > Paramètres de publication et assurez-vous d’avoir sélectionné 
HTML, puis cliquez sur OK pour fermer la boîte de dialogue.
3. Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
if (_level0.myURL == undefined) {
= "myURL is not defined";
} else {
= _level0.myURL;
}
REMARQUE
Par défaut, le code HTML publie dans le même emplacement que . 
4. Sélectionnez Fichier > Publier pour publier les fichiers SWF et HTML.
5. Accédez au répertoire contenant les fichiers publiés (celui où vous avez enregistré le fichier 
dans votre disque dur), puis ouvrez le document HTML ( 
par défaut) dans un éditeur HTML, tel que Dreamweaver ou Notepad.
6. Ajoutez le code qui apparaît en gras ci-dessous pour que votre document HTML ressemble 
au code suivant :
<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" 
codebase="
#version=8,0,0,0" width="550" height="400" id="myflashvars" 
align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="" />
<param name="FlashVars" value=";>
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="" FlashVars="; 
quality="high" bgcolor="#ffffff" width="550" height="400" 
name="myflashvars" align="middle" allowScriptAccess="sameDomain" 
type="application/x-shockwave-flash" pluginspage="http://
; />
</object>
70
Données et types de données

Ce code fait passer une seule variable appelée myURL, qui contient la chaîne
. Lors du chargement du fichier SWF, une propriété 
appelée myURL est créée dans le domaine _level0. L’un des avantages de l’emploi de 
FlashVars ou de l’URL réside dans la disponibilité immédiate des variables dans Flash dès 
le chargement du fichier SWF. Ainsi, il est inutile d’écrire des fonctions supplémentaires 
pour vérifier le chargement des variables, ce qui serait obligatoire si vous les chargiez à 
l’aide de LoadVars ou XML.
7. Enregistrez vos modifications du document HTML, puis fermez-le.
8. Double-cliquez sur le fichier pour tester l’application. 
Le texte , une variable du fichier HTML, apparaît 
dans le fichier SWF.
REMARQUE
Tous les navigateurs prennent en charge les chaînes d’une longueur allant jusqu’à 
64 Ko (65535 octets). Un paramètre FlashVars doit être affecté aux deux balises 
object et embed pour que votre code fonctionne dans tous les navigateurs. 
Chargement des variables depuis un serveur
Il existe plusieurs méthodes pour charger des variables dans Flash à partir de sources externes 
(telles que des fichiers texte, des documents XML, etc.). Pour plus d’informations sur le 
chargement des variables (y compris des paires nom/valeur), consult« Utilisation de données externes », à la page 631. 
Dans Flash, la classe LoadVars permet de charger facilement des variables, comme le montre 
l’exemple suivant. 
Chargement des variables depuis un serveur
1.
Créez un document Flash.
2. Sélectionnez l’image 1 du scénario, puis ajoutez le code ActionScript suivant dans le 
panneau Actions :
var my_lv:LoadVars = new LoadVars();
my_lv.onLoad = function(success:Boolean):Void {
if (success) {
trace(this.dayNames); // Sunday,Monday,Tuesday,
} else {
trace("Error");
}
}
("");
Ce code charge un fichier texte depuis un serveur distant et analyse ses paires nom/valeur. 
CO
Téléchargez ou affichez le fichier texte (
NS
) dans un navigateur si vous souhaitez savoir comment les variables sont 
EI
mises en forme.
L
Présentation des variables
71

3. Choisissez Contrôle > Tester l’animation pour tester le document.
Si le chargement réussi, l’événement complete est appelé et le panneau de sortie affiche la 
valeur de la variable dayNames. Si le chargement du fichier texte échoue, l’argument 
success est défini sur false et le panneau de sortie affiche le texte Error.
Utilisation des variables dans un projet
Lorsque vous développez des animations ou des applications avec Flash, il est très rare que 
vous n’ayez besoin d’aucune variable. Par exemple, si vous créez un système d’ouverture de 
session, vous aurez besoin de variables pour valider le nom d’utilisateur et le mot de passe ou 
vérifier leur remplissage. 
Pour plus d’informations sur le chargement des variables (telles que des paires nom/valeur), 
consultez le Chapitre 15, « Utilisation de données externes », à la page 631.
Dans l’exemple suivant, vous utilisez des variables pour stocker le chemin d’une image que 
vous chargez avec la classe Loader, une pour l’occurrence de la classe Loader et deux fonctions 
sont appelées selon le résultat, satisfaisant ou non, du chargement du fichier.
Utilisation des variables dans un projet
1.
Créez un document Flash, puis enregistrez-le sous le nom de .
2. Sélectionnez l’image 1 du scénario, puis ajoutez le code ActionScript suivant dans le 
panneau Actions :
/* Spécifie une image par défaut au cas où aucune valeur n’est transmise 
par FlashVars. */
var imgUrl:String = "
";
if (_level0.imgURL != undefined) {
// Si une image a été désignée, la valeur par défaut est remplacée.
imgUrl = _level0.imgURL;
}
this.createEmptyMovieClip("img_mc", 10);
var mclListener:Object = new Object();
mclListener.onLoadInit = function(target_mc:MovieClip):Void {
target_mc._x = (Stage.width - target_mc._width) / 2;
target_mc._y = (Stage.height - target_mc._height) / 2;
}
mclListener.onLoadError = function(target_mc:MovieClip):Void {
target_mc.createTextField("error_txt", 1, 0, 0, 100, 20);
target_mc.error_txt.autoSize = "left";
= "Error downloading specified image;\n\t" + 
target_mc._url;
}
var myMCL:MovieClipLoader = new MovieClipLoader();
myMCL.addListener(mclListener);
myMCL.loadClip(imgUrl, img_mc);
72
Données et types de données

La première ligne du code désigne l’image à charger dynamiquement dans votre document 
Flash. Ensuite, vous vérifiez si une nouvelle valeur a été spécifiée pour imgURL à l’aide de 
paramètres FlashVars ou de variables de code URL. Dans l’affirmative, l’URL de l’image 
par défaut est remplacée par la nouvelle valeur. Pour plus d’informations sur l’utilisation 
des variables d’URL, consultez la section la page 67. Pour plus d’informations sur FlashVars, consultez la section FlashVars dans une application », à la page 70.
Les deux lignes de code suivantes définissent l’occurrence de MovieClip et un objet 
écouteur pour la future occurrence de MovieClipLoader. L’objet écouteur du 
MovieClipLoader définit deux gestionnaires d’événement, onLoadInit et onLoadError. 
Ces gestionnaires sont invoqués lorsque le chargement et l’initialisation de l’image sur la 
scène ont réussi, ou quand le chargement a échoué. Ensuite, vous créez une occurrence de 
MovieClipLoader et vous utilisez la méthode addListener() pour ajouter l’objet 
écouteur défini préalablement au MovieClipLoader. Pour finir, l’image est téléchargée et 
déclenchée par votre appel de la méthode MovieClipLoader.loadClip(), qui désigne le 
fichier de l’image à charger et le clip qui doit la recevoir.
3. Choisissez Contrôle > Tester l’animation pour tester le document.
Comme vous testez le document Flash dans l’outil de programmation, aucune valeur de 
imgUrl n’est transmise par FlashVars ni avec l’URL. Par conséquent, l’image par défaut 
s’affiche.
4. Enregistrez le document Flash, puis sélectionnez Fichier > Publier pour publier le fichier 
sous forme de document SWF et HTML.
REMARQUE
Assurez-vous que les deux options Flash et HTML sont bien sélectionnées dans la 
boîte de dialogue Paramètres de publication. Choisissez Fichier > Paramètres de 
publication et cliquez sur l’onglet Formats. Sélectionnez ensuite les deux options.
5. Si vous testez votre document dans l’outil de Flash (Contrôle > Tester l’animation) ou dans 
un navigateur local (Fichier > Aperçu avant publication > HTML), vous constaterez que 
l’image se centre elle-même verticalement et horizontalement sur la scène.
Présentation des variables
73

6. Modifiez le document HTML généré dans un éditeur (tel que Dreamweaver ou Notepad), 
puis modifiez le code HTML par défaut pour qu’il corresponde au texte suivant :
<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" 
codebase="
#version=8,0,0,0" width="550" height="400" id="imgloader" 
align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="" />
<param name="FlashVars" value="
">
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="" quality="high" FlashVars="imgURL=http://
" bgcolor="#ffffff" 
width="550" height="400" name="imgloader" align="middle" 
allowScriptAccess="sameDomain" type="application/x-shockwave-flash" 
pluginspage="; />
</object>
7. Testez le document HTML pour examiner les changements. L’image spécifiée dans le code 
HTML apparaît dans le fichier SWF.
Pour modifier cet exemple afin d’utiliser vos propres images, modifiez la valeur FlashVars 
(chaîne entre guillemets).
Organisation des données dans des objets
Vous êtes probablement habitué(e) à manipuler les objets placés sur la scène. Supposons par 
exemple que vous avez un objet MovieClip sur la scène, qui contient lui-même d’autres clips. 
Les champs de texte, les clips et les boutons sont souvent considérés comme des objets dès 
qu’ils sont déposés sur la scène. 
Dans ActionScript, les objets sont des collections de propriétés et de méthodes. Chaque objet 
possède son propre nom et est une occurrence d’une classe donnée. Les objets intégrés 
proviennent de classes qui sont prédéfinies dans ActionScript. Par exemple, la classe intégrée 
Date fournit des informations provenant de l’horloge système de l’ordinateur de l’utilisateur. 
Vous pouvez utiliser la classe LoadVars pour charger des variables dans votre fichier SWF.
74
Données et types de données

Vous pouvez également créer des objets et des classes avec du code ActionScript. Vous pouvez 
créer un objet destiné à stocker une collection de données, telles que le nom, l’adresse et le 
numéro de téléphone d’une personne. Vous pouvez créer un objet destiné à stocker des 
informations sur les couleurs d’une image. L’organisation des données dans des objets permet 
de tenir vos documents Flash bien ordonnés. Pour des informations d’ordre général sur la 
création d’une classe personnalisée destinée à stocker une collection de méthodes et de 
propriétés, Pour des informations détaillées sur les classes intégrées et personnalisées, consultez le 
Chapitre 6, « Classes », à la page 197.
Il existe plusieurs manières de créer un objet dans ActionScript. L’exemple suivant crée des 
objets simples de deux manières différentes, puis passe en boucle sur leur contenu. 
Création d’objets simples dans Flash
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Sélectionnez l’image 1 du scénario et, dans le panneau Actions, tapez le code ActionScript 
suivant :
// Première méthode
var firstObj:Object = new Object();
firstObj.firstVar = "hello world";
firstObj.secondVar = 28;
firstObj.thirdVar = new Date(1980, 0, 1); // 1er janvier 1980
Ce code, qui constitue une méthode pour créer un objet simple, crée une nouvelle 
occurrence d’objet et définit quelques propriétés dans cet objet.
3. Maintenant, tapez le code ActionScript suivant après celui ajouté à l’étape 2.
// Deuxième méthode
var secondObj:Object = {firstVar:"hello world", secondVar:28, 
thirdVar:new Date(1980, 0, 1)};
Voici une autre manière de créer un objet. Les deux objets sont semblables. Le code ci-
dessus crée un nouvel objet et initialise certaines propriétés sous forme courte.
4. Pour passer en boucle sur chacun des objets précédents et afficher leur contenu, ajoutez le 
code ActionScript suivant sur l’image 1 du scénario (à la suite du code déjà saisi) :
var i:String;
for (i in secondObj) {
trace(i + ": " + secondObj[i]);
}
Organisation des données dans des objets
75

5. Choisissez Contrôle > Tester l’animation pour voir le texte suivant dans le panneau de 
sortie :
firstVar: hello world
secondVar: 28
thirdVar: Tue Jan 1 00:00:00 GMT-0800 1980
REMARQUE
Il se peut que les variables n’apparaissent pas nécessairement dans cet ordre dans le 
panneau de sortie. Vous ne pouvez pas garantir l’ordre lorsque vous utilisez une 
boucle  ; le lecteur renvoie le contenu d’un objet dans un ordre imprévisible.
Vous pouvez également utiliser des tableaux pour créer des objets. Au lieu d’avoir une série de 
variables telles que firstname1, firstname2 et firstname3 pour représenter une collection 
de variables, vous pouvez fabriquer un tableau contenant les mêmes données. Cette technique 
est présentée ci-après.
Utilisation d’un tableau pour créer un objet 
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Sélectionnez l’image 1 du scénario et, dans le panneau Actions, tapez le code ActionScript 
suivant :
var usersArr:Array = new Array();
({firstname:"George"});
({firstname:"John"});
({firstname:"Thomas"});
L’organisation des variables dans des tableaux et des objets présente l’avantage de faciliter 
le passage en boucle sur les variables et l’affichage de leurs valeurs, comme le montre 
l’étape suivante.
3. Tapez le code ActionScript suivant après celui ajouté à l’étape 2.
var i:Number;
for (i = 0; i < usersArr.length; i++) {
trace(usersArr[i].firstname); // George, John, Thomas
}
4. Choisissez Contrôle > Tester l’animation pour voir le texte suivant dans le panneau 
de sortie :
George
John
Thomas
76
Données et types de données

L’exemple suivant présente une autre méthode de passage en boucle sur les objets. Ici, un objet 
est créé et survolé répétitivement à l’aide d’une boucle  et chaque propriété apparaît 
dans le panneau de sortie :
var myObj:Object = {var1:"One", var2:"Two", var3:18, var4:1987};
var i:String;
for (i in myObj) {
trace(i + ": " + myObj[i]);
}
// Résultats suivants :
/*
    var1: One
    var2: Two
    var3: 18
    var4: 1987
*/
Pour plus d’informations sur les boucles, consultez le for », à la page 126. Pour plus d’informations sur les boucles , consultez la section 
« Utilisation des boucles  », à la page 127. Pour plus d’informations sur les objets, 
consultez la section Chapitre 6, « Classes », à la page 197.
Attribution 
ActionScript 2.0 vous permet d’attribuer un type de données à un autre. Cette opération 
signifie que vous convertissez la valeur que l’objet ou la variable contient en un type différent.
Les résultats de cette attribution dépendent des types de données impliqués. Pour changer le 
type de données d’un objet, vous mettez le nom de l’objet entre parenthèses (()) et le faites 
précéder du nom du nouveau type. Par exemple, le code suivant prend une valeur booléenne 
et la transforme en entier numérique.
var myBoolean:Boolean = true;
var myNumber:Number = Number(myBoolean);
Pour plus d’informations sur l’attribution, consultez les sections suivantes :
?
« Attribution des objets », à la page 78
Attribution
77

Attribution des objets
La syntaxe de l’attribution est type(élément) : le compilateur doit se comporter comme si le 
type de données de l’élément était type. L’attribution est avant tout un appel de fonction qui 
renvoie null si l’attribution échoue lors de l’exécution (dans les fichiers publiés pour Flash 
Player version 7 ou plus récente). L’exécution des fichiers publiés pour Flash Player 6 n’est pas 
prise en charge en cas d’échec de l’attribution. Si l’attribution réussit, l’appel de fonction 
renvoie l’objet original. Cependant, le compilateur ne peut pas déterminer si une attribution 
échoue lors de l’exécution et ne génère pas d’erreurs de compilation dans ces cas. 
Le code suivant illustre cette situation :
// Les classes Cat et Dog sont des sous-classes de la classe Animal
function bark(myAnimal:Animal) {
var foo:Dog = Dog(myAnimal);
();
}
var curAnimal:Animal = new Dog();
bark(curAnimal); // Fonctionne
curAnimal = new Cat();
bark(curAnimal); // Ne fonctionne pas
Dans cet exemple, vous avez indiqué au compilateur que foo est un objet Dog, et le 
compilateur suppose donc que () est une instruction autorisée. Toutefois, le 
compilateur ne sait pas que l’attribution échouera (c’est-à-dire que vous avez tenté d’attribuer 
un objet Cat au type Animal), et aucune erreur de compilation ne se produit. Toutefois, 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’attribution à l’exécution, comme le montre 
l’exemple suivant.
function bark(myAnimal:Animal) {
  var foo:Dog = Dog(myAnimal);
  if (foo) {
    ();
  }
}
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’attribution réussit. Sinon, l’attribution échoue.
RE
L’attribution de valeurs Null ou non définies renvoie undefined.
M
A
R
Q
UE
78
Données et types de données

Vous pouvez remplacer les types de données primitifs qui disposent d’une fonction de 
conversion globale correspondante par un opérateur d’attribution du même nom. C’est 
pourquoi les fonctions de conversion globales sont prioritaires par rapport aux opérateurs 
d’attribution. Par exemple, vous ne pouvez pas attribuer Array dans la mesure où la fonction 
de conversion Array() est prioritaire par rapport à l’opérateur d’attribution. 
Cet exemple définit deux variables de chaîne (firstNum et secondNum), qui s’ajoutent l’une à 
l’autre. Résultat initial : les nombres sont concaténés au lieu d’être ajoutés car ils sont de type 
String. La deuxième instruction trace convertit les deux nombres en type de données Number 
avant d’exécuter l’addition qui donne le résultat correct. La conversion des données est 
importante lorsque vous manipulez des données chargées à l’aide de XML ou FlashVars, 
comme le montre l’exemple suivant :
var firstNum:String = "17";
var secondNum:String = "29";
trace(firstNum + secondNum); // 1729
trace(Number(firstNum) + Number(secondNum)); // 46
Pour plus d’informations sur les fonctions de conversion des données, consultez l’entrée de 
chaque fonction de conversion dans le Guide de référence du langage ActionScript 2.0 
Fonction Array, fonction Boolean, fonction Number, fonction Object et fonction 
String.
Attribution
79

80
Données et types de données

CHAPITRE 4
Eléments fondamentaux du 
4
langage et de la syntaxe
L’apprentissage de la syntaxe et des instructions d’ActionScript revient à apprendre à associer 
des mots pour construire des phrases, à rassembler ensuite au sein de paragraphes. Le langage 
ActionScript atteint ce niveau de simplicité. Par exemple, en français, une phrase se termine 
par un point, tandis que les instructions de code ActionScript se terminent par un point-
virgule. En langage ActionScript, vous pouvez taper une instruction stop() pour 
interrompre la lecture en boucle d’une occurrence de clip ou d’un fichier SWF. Vous pouvez 
également écrire des milliers de lignes de code pour mettre au point une application bancaire 
interactive. ActionScript peut donc accomplir des tâches très simples ou très complexes.
Dans le Chapitre 3, « Données et types de données », vous allez découvrir comment 
ActionScript manipule les données et comment les mettre en forme dans votre code. 
Ce chapitre décrit la rédaction d’instructions dans ActionScript avec la syntaxe appropriée. 
Il contient un grand nombre de petits blocs de code et quelques exemples qui présentent les 
concepts de base de ce langage. Les chapitres suivants contiennent des exemples de code plus 
longs et de plus en plus complexes qui combinent et simplifient à la fois les bases présentées 
dans ce chapitre.
Les règles générales décrites dans cette section s’appliquent à l’ensemble du code ActionScript. 
La plupart des termes ActionScript font également l’objet de règles individuelles. Pour en 
savoir plus sur les règles qui s’appliquent à un terme particulier, reportez-vous à l’entrée 
correspondante du Guide de référence du langage ActionScript 2.0
Les nouveaux utilisateurs peuvent éprouver des difficultés à créer des programmes 
ActionScript de façon élégante. Pour plus de détails sur l’application des règles décrites dans 
cette section, consultez le programmation pour ActionScript 2.0 », à la page 715.
REMARQUE
Dans ce chapitre, vous allez ajouter du code ActionScript directement dans une image 
du scénario. Dans les chapitres suivants, vous utiliserez des classes pour isoler votre 
code ActionScript du fichier FLA.
81

Pour plus d’informations sur l’utilisation des concepts de base du langage et de la syntaxe 
ActionScript, consultez les sections suivantes :
Présentation de la syntaxe, des instructions et des expressions . . . . . . . . . . . . . . . . 82
Syntaxe à points et chemins cibles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Eléments de ponctuation  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Présentation des constantes et des mots-clés  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Présentation des instructions  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Présentation des tableaux  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Présentation des opérateurs  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Présentation de la syntaxe, des 
instructions et des expressions
Le langage ActionScript est composé de classes intégrées. Pour formuler vos instructions de 
sorte que le code puisse être compilé et exécuté correctement dans Flash, il est nécessaire 
d’utiliser la syntaxe ActionScript appropriée. Ici, le terme syntaxe fait référence à la grammaire 
et à l’orthographe du langage de programmation. Le compilateur ne pouvant pas interpréter la 
syntaxe incorrecte, des erreurs ou des avertissements apparaissent dans le panneau de sortie 
lorsque le document est testé dans l’environnement de test. La syntaxe est donc un ensemble 
de règles et de consignes qui vous aide à rédiger correctement votre code ActionScript.
Une instruction est une action spécifique que vous demandez au fichier FLA d’exécuter. 
Par exemple, vous pouvez utiliser une instruction conditionnelle pour déterminer si quelque 
chose est vrai ou existe. Vous pouvez ensuite exécuter les actions spécifiées, telles que des fonctions 
ou des expressions, selon si la condition est vraie ou non. L’instruction if est une instruction 
conditionnelle qui évalue une condition afin de déterminer la prochaine action du code. 
// instruction if
if (condition) {
  // instructions ;
}
Pour plus d’informations sur les instructions, consultez la instructions », à la page 109.
Une expression diffèr d’une instruction et désigne toute combinaison valable de symboles 
ActionScript représentant une valeur. Les expressions ont des valeurs alors que les valeurs et les 
propriétés ont des types. Une expression peut être composée d’opérateurs et d’opérandes, de 
valeurs, de fonctions et de procédures, et suit les règles de priorité et d’association 
d’ActionScript. En général, Flash Player interprète l’expression et renvoie une valeur que vous 
pouvez utiliser dans votre application.
82
Eléments fondamentaux du langage et de la syntaxe

Par exemple, le code suivant est une expression : 
x + 2
Dans l’expression précédente, x et 2 sont des opérandes et + est un opérateur. Pour plus 
d’informations sur les opérateurs et les opérandes, consultez la sectionopérateurs », à la page 145. Pour plus d’informations sur les objets et les propriétés, consultez 
la section « Type de données Object », à la page 43.
La mise en forme de votre code ActionScript conditionne également la facilité de sa 
maintenance. Par exemple, il est extrêmement difficile de comprendre la logique d’un fichier 
FLA qui ne comporte ni indentation ni commentaire, ou dont le formatage et les conventions 
d’appellation sont incohérents. Lorsque les blocs ActionScript (tels que les boucles et les 
instructions if ) sont placés en retrait, le code est plus facile à lire et à déboguer en cas 
d’anomalie. Pour plus d’informations sur la mise en forme du code ActionScript, consultez la 
section « Mise en forme de la syntaxe ActionScript », à la page 750. Ces sections contiennent 
également des exemples de mise en forme appropriée du code ActionScript.
Pour plus d’informations sur les concepts de base du langage et de la syntaxe, consultez les 
sections suivantes :
?
« Différences entre ActionScript et JavaScript »
?
« Respect de la casse »
Différences entre ActionScript et JavaScript 
ActionScript est analogue au langage de programmation JavaScript. Pour utiliser le code 
ActionScript, la connaissance de JavaScript n’est pas indispensable, mais elle en facilite 
considérablement l’apprentissage. 
Cet ouvrage n’a pas pour but d’enseigner la programmation générale. Il existe de nombreuses 
sources qui fournissent des informations complémentaires sur les concepts de programmation 
généraux et sur le langage JavaScript. 
?
La spécification ECMAScript (ECMA-262) édition 3 est issue de JavaScript et sert de 
norme internationale pour le langage JavaScript. ActionScript est basé sur cette 
spécification. Pour plus d’informations, consultez le site 

?
Le site Java Technology propose des didacticiels sur la programmation orientée objet 
() qui portent essentiellement sur 
le langage Java, mais permettent de comprendre les concepts qui s’appliquent également à 
ActionScript.
Présentation de la syntaxe, des instructions et des expressions
83

Les principales différences qui existent entre ActionScript et JavaScript sont les suivantes :
?
ActionScript ne prend pas en charge les objets spécifiques aux navigateurs que sont les 
documents, fenêtres et ancres, par exemple.
?
ActionScript ne prend pas entièrement en charge tous les objets JavaScript intégrés.
?
ActionScript ne prend pas en charge certaines constructions syntaxiques JavaScript, telles 
que les étiquettes d’instructions.
?
Dans ActionScript, la fonction eval() ne peut effectuer que des références aux variables.
?
ActionScript 2.0 prend en charge plusieurs fonctionnalités qui ne figurent pas dans la 
spécification ECMA-262, telles que les classes et le typage fort. Un grand nombre de ces 
fonctionnalités sont modélisées d’après la spécification ECMAScript (ECMA-262) édition 
3 (voir ).
?
ActionScript ne prend pas en charge les expressions régulières ayant recours à l’objet 
RegExp, contrairement à Adobe Central, qui prend en charge cet objet. Pour plus 
d’informations sur Adobe Central, consultez le site 
Respect de la casse 
Lorsque vous rédigez du code ActionScript pour Flash Player 7 et ses versions ultérieures, 
votre code respecte la casse. Cela signifie que les variables dont la casse diffère sont considérées 
comme différentes. Le code ActionScript suivant illustre cette particularité :
// Combinaison de majuscules/minuscules
var firstName:String = "Jimmy";
// Tout en minuscules
trace(firstname); // non défini
Vous pouvez également écrire :
// Dans un fichier destiné à Flash Player 8
// et avec ActionScript 1.0 ou 2.0
//
// Définit les propriétés de deux objets différents
cat.hilite = true;
CAT.hilite = true;
// Crée trois variables différentes
var myVar:Number = 10;
var myvar:Number = 10;
var mYvAr:Number = 10;
RE
Il n’est pas conseillé de différencier les variables, ou tout autre identifiant, uniquement 
M
A
par le changement de la casse. Pour plus d’informations sur l’appellation des variables, 
R
consultez le Chapitre 17, « Recommandations et conventions de programmation pour 
Q
UE
ActionScript 2.0 », à la page 715.
84
Eléments fondamentaux du langage et de la syntaxe

Lorsque vous publiez pour les anciennes versions de Flash Player (version 6 et antérieures), le 
logiciel recherche la chaîne Jimmy dans le panneau de sortie. Flash Player 7 et les versions 
ultérieures étant sensibles à la casse, firstName et firstname sont deux variables distinctes 
(avec ActionScript 1.0 ou 2.0). Ce concept est essentiel. Si vous avez créé des fichiers FLA 
pour Flash Player 6 ou une version antérieure en utilisant indifféremment la casse dans vos 
variables, des problèmes risquent de survenir lors de la conversion du fichier ou de 
l’application pour une version plus récente de Flash Player.
Il est donc fortement conseillé d’adopter des conventions cohérentes en matière d’utilisation 
des majuscules/minuscules, comme celles employées dans ce manuel. Vos variables, vos classes 
et les noms de vos fonctions seront ainsi plus simples à distinguer. Ne vous contentez pas de 
changer la casse pour différencier deux identifiants. Modifiez plutôt le nom de l’occurrence, 
de la variable ou de la classe, pas seulement sa casse. Pour plus d’informations sur les 
conventions de codage, consultez programmation pour ActionScript 2.0 », à la page 715. 
Le respect de la casse peut avoir un impact considérable lorsque vous travaillez avec un service 
Web qui utilise ses propres règles pour l’appellation des variables et la casse des variables 
renvoyées par le serveur au fichier SWF. Par exemple, si vous utilisez un service Web 
ColdFusion, les noms de propriété provenant d’une structure ou d’un objet peuvent rester en 
majuscules, comme FIRSTNAME. Vous devez conserver la même casse dans Flash pour ne pas 
provoquer de résultats imprévus.
REMARQUE
Le respect de la casse affecte également les variables externes que vous chargez dans 
un fichier SWF, par exemple celles qui sont chargées avec ().
La différentiation des majuscules et des minuscules est implémentée pour les scripts externes, 
tels que les fichiers de classe ActionScript 2.0, les scripts importés avec la commande #include 
et les scripts d’un fichier FLA. Si vous subissez des erreurs lors de l’exécution et exportez vos 
données vers plusieurs versions de Flash Player, vous devez vérifier les scripts externes et les 
scripts des fichiers FLA pour vous assurer qu’ils appliquent les mêmes majuscules.
Cette différentiation est implémentée au niveau de chaque fichier SWF. Lorsqu’une application 
Flash Player 8 stricte (qui respecte la casse) appelle un fichier SWF Flash Player 6 non strict, le 
code ActionScript exécuté dans ce dernier ne respecte pas la casse. Par exemple, si vous utilisez 
loadMovie() pour charger un fichier SWF Flash Player 6 dans un fichier SWF Flash Player 8, 
celui de la version 6 ne tient pas compte des majuscules, contrairement à celui de la version 8.
Lorsque la coloration de la syntaxe est activée, les éléments du langage dont la casse est 
correcte apparaissent en bleu par défaut. Pour plus d’informations, voir mots réservés », à la page 109. 
Présentation de la syntaxe, des instructions et des expressions
85

Syntaxe à points et chemins cibles
Dans ActionScript, un opérateur point (.) (syntaxe à point) est utilisé pour accéder aux 
propriétés ou méthodes associées à un objet ou à une occurrence de la scène. Il est également 
utilisé pour identifier le chemin cible d’une occurrence (telle qu’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. La rédaction des expressions en 
syntaxe à point est décrite dans les sections suivantes.
Pour contrôler un clip, un fichier SWF chargé ou un bouton, vous devez spécifier un chemin 
cible
. Les chemins cibles sont des adresses hiérarchiques de noms d’occurrences de clips, de 
variables et d’objets dans un fichier SWF. Pour spécifier le chemin cible d’un clip ou d’un 
bouton, vous devez lui affecter un nom d’occurrence. Pour nommer une occurrence de clip, 
sélectionnez-la et saisissez son nom dans l’inspecteur Propriétés. Il est également possible de 
nommer l’occurrence dans le code si vous la créez avec ActionScript. Vous pouvez utiliser le 
chemin cible pour affecter une action à un clip ou pour obtenir ou définir la valeur d’une 
variable ou propriété.
Pour plus d’informations sur la nomination d’une occurrence et l’utilisation de la syntaxe à 
point pour cibler une occurrence, consultez les sections suivantes :
?
 « Utilisation de la syntaxe à point pour cibler une occurrence », à la page 86. 
?
« Domaine et ciblage », à la page 91
?
« Utilisation du bouton Chemin cible », à la page 93
?
« Syntaxe à barre oblique », à la page 93
Pour plus d’informations sur les objets et les propriétés, consultez la section Object », à la page 43.
Utilisation de la syntaxe à point pour cibler une 
occurrence
Pour rédiger un code ActionScript qui contrôle une occurrence, telle qu’un clip, ou manipule 
les éléments d’un fichier SWF chargé, vous devez indiquer son nom et son adresse dans le 
code, c’est-à-dire son chemin cible. Pour cibler (ou faire référence à) des objets dans un fichier 
SWF, vous utilisez la syntaxe à point (également appelée notation avec point). Par exemple, 
vous devez cibler une occurrence de clip ou de bouton avant de pouvoir lui appliquer une 
action. La syntaxe à point vous aide à créer le chemin vers l’occurrence cible. Ce chemin vers 
l’occurrence ciblée est parfois appelé chemin cible.
86
Eléments fondamentaux du langage et de la syntaxe

La hiérarchie des fichiers FLA est particulière. Vous pouvez créer des occurrences sur la scène 
ou utiliser ActionScript. Vous pouvez même créer des occurrences à l’intérieur d’autres 
occurrences ou en imbriquer au sein de plusieurs autres occurrences. Tant que vous la 
nommez, vous pouvez manipuler n’importe quelle occurrence.
Les occurrences sont nommées par l’attribution d’un nom d’occurrence, que vous pouvez 
spécifier de deux manières différentes (présentées ci-dessous) :
?
Manuellement en sélectionnant l’occurrence et en saisissant son nom dans l’inspecteur 
Propriétés (lorsque l’occurrence est sur la scène).
?
Dynamiquement avec ActionScript. Dans ce cas, vous créez l’occurrence avec 
ActionScript et lui affectez un nom dès sa création.
Pour affecter un nom d’occurrence à l’occurrence dans l’inspecteur de propriétés, tapez un 
nom dans la zone de texte Nom de l’occurrence.
Vous pouvez également attribuer un nom d’occurrence à un objet créé à l’aide d’ActionScript. 
Comme le montre le code suivant, cette opération peut être très simple :
this.createEmptyMovieClip("pic_mc", this.getNextHighestDepth());
pic_mc.loadMovie("");
Ce code crée un nouveau clip et lui affecte le nom d’occurrence pic_mc. Vous pouvez ensuite 
manipuler l’occurrence pic_mc à l’aide du code, par exemple en y chargeant une image, 
comme l’illustre le code précédent.
Pour plus d’informations sur l’utilisation des domaines, consultez les sections ciblage », à la page 91 et « Variables et domaine », à la page 62. 
Ciblage d’une occurrence
Pour qu’une occurrence fonctionne dans votre fichier SWF, vous devez la cibler, puis lui 
indiquer quoi faire, par exemple lui affecter une action à exécuter ou modifier ses propriétés. 
En général, il est nécessaire de définir l’emplacement de cette occurrence dans le fichier SWF 
(par exemple le scénario dans lequel elle se trouve ou l’occurrence dans laquelle elle est 
imbriquée) par la création d’un chemin cible. N’oubliez pas que vous avez fourni la plupart 
des occurrences via leurs noms d’occurrence dans votre fichier FLA, puis ajouté du code dans 
le fichier FLA qui utilise ces noms. Dans ce cas, vous ciblez cette occurrence particulière, puis 
lui indiquez une action à exécuter (par exemple déplacer la tête de lecture ou ouvrir une page 
Web). Pour plus d’informations sur les objets et les propriétés, consultez la section données Object », à la page 43. 
Syntaxe à points et chemins cibles
87

Pour cibler une occurrence :
1.
Choisissez Fichier > Nouveau, puis sélectionnez un document Flash.
2. Choisissez Fichier > Enregistrer sous et nommez le fichier .
3. A l’aide de l’outil Ovale, tracez une forme sur la scène. Dessinez un ovale de taille et de 
couleur quelconques.
4. Utilisez l’outil Sélection pour sélectionner l’ovale sur la scène. 
CO
N’oubliez pas, au besoin, de sélectionner le trait et le remplissage.
NS
EI
L
5. Choisissez Modifier > Convertir en symbole, sélectionnez l’option Clip, puis cliquez sur 
OK pour créer le symbole.
6. Sélectionnez le clip sur la scène et donnez-lui le nom d’occurrence myClip dans l’inspecteur 
Propriétés.
7. Insérez un nouveau calque et renommez-le actions.
8. Ajoutez le code ActionScript suivant dans l’image 1 du calque actions : 
myClip._xscale = 50;
Cette ligne de code cible l’occurrence myClip sur la scène. Le code ActionScript réduit de 
moitié la largeur d’origine de l’occurrence. Le code étant sur le même scénario que le 
symbole de clip, il suffit de cibler l’occurrence par son nom. Si cette occurrence se trouvait 
sur un autre scénario ou était imbriquée dans une autre occurrence, le chemin cible devrait 
être modifié en conséquence.
Ciblage d’une occurrence imbriquée
Il est également possible de cibler des occurrences imbriquées dans d’autres occurrences. 
Supposons par exemple que vous souhaitez placer une seconde occurrence de clip dans 
l’occurrence myClip de l’exercice prla page 87. Vous pouvez également cibler cette occurrence imbriquée à l’aide d’ActionScript. 
Avant de commencer l’exercice suivant, vous devez terminer l’exercice de la section d’une occurrence », à la page 87, puis exécuter cette procédure pour cibler une occurrence 
imbriquée. 
88
Eléments fondamentaux du langage et de la syntaxe

Pour cibler une occurrence imbriquée :
1.
Ouvrez le fichier à partir de la procédure sur le ciblage d’une occurrence et 
renommez-le .
2. Double-cliquez sur l’occurrence myClip sur la scène.
3. Sélectionnez l’outil Ovale et tracez un autre ovale dans l’occurrence myClip.
4. Sélectionnez la nouvelle forme, puis choisissez Modifier > Convertir en symbole.
5. Sélectionnez l’option Clip et cliquez sur OK.
6. Sélectionnez la nouvelle occurrence et saisissez myOtherClip dans le champ Nom de 
l’occurrence de l’inspecteur Propriétés.
7. Dans la barre d’édition, cliquez sur Scène 1 pour revenir au scénario principal.
8. Ajoutez le code ActionScript suivant dans l’image 1 du calque actions :
myClip.myOtherClip._xscale = 50; 
Ce code ActionScript réduit de 50 % la largeur de l’occurrence myOtherClip. Le fichier 
ayant modifié la propriété _xscale des occurrences myClip, et myOtherClip 
étant un symbole imbriqué, vous remarquerez que la largeur de myOtherClip est 
maintenant de 25 % de la largeur d’origine.
Si vous travaillez avec des clips imbriqués possédant leurs propres scénarios, vous pouvez 
manipuler la tête de lecture dans le scénario d’une occurrence imbriquée à l’aide d’un code 
similaire au fragment suivant :
myClip.nestedClip.gotoAndPlay(15);
myClip.someOtherClip.gotoAndStop("tweenIn");
Remarquez que le clip que vous manipulez (tel que nestedClip) apparaît juste avant l’action. 
Vous remarquerez également cette tendance dans les sections suivantes.
Votre accès n’est pas limité aux méthodes et aux propriétés prédéfinies des occurrences de la 
scène présentées dans les exemples précédents. Vous pouvez également définir une variable à 
l’intérieur d’un clip, comme dans le code suivant qui définit une variable dans le clip starClip :
starClip.speed = 1.1;
starClip.gravity = 0.8;
Si des variables de vitesse ou de gravité existaient déjà dans l’occurrence du clip starClip, les 
valeurs précédentes ont été remplacées dès la définition des nouvelles valeurs. Vous pouvez 
ajouter de nouvelles propriétés au clip starClip puisque la classe MovieClip a été définie avec 
le mot-clé dynamic. Le mot-clé dynamic indique que les objets basés sur la classe spécifiée 
(dans le cas présent, MovieClip) peuvent ajouter des propriétés dynamiques et y accéder 
pendant la période d’exécution. Pour plus d’informations sur l’instruction dynamic, 
reportez-vous à l’instruction dynamic dans le Guide de référence du langage ActionScript 2.0.
Syntaxe à points et chemins cibles
89

Ciblage dynamique d’occurrences et de contenu chargé
Vous pouvez également créer un objet à l’aide d’ActionScript, puis utiliser un chemin de cible. 
Par exemple, le code ActionScript suivant permet de créer un clip. Vous pouvez ensuite 
modifier la rotation de ce clip à l’aide d’ActionScript, comme dans l’exemple suivant :   
Pour cibler une occurrence de clip créée de façon dynamique : 
1.
Créez un nouveau document FLA, puis enregistrez-le sous le nom .
2. Insérez un nouveau calque et renommez-le actions.
3. Ajoutez le code ActionScript suivant dans l’image 1 du calque actions : 
this.createEmptyMovieClip("rotateClip", this.getNextHighestDepth());
trace(rotateClip);
rotateClip._rotation = 50;
4. Choisissez Contrôe > Tester l’animation pour tester votre document. 
Vous savez que vous avez créé un clip par la présence de l’instruction trace, mais rien n’est 
visible sur la scène. Bien que vous ayez ajouté le code qui crée l’occurrence de clip, vous ne 
verrez rien sur la scène avant d’avoir ajouté un élément au clip. Vous pouvez par exemple 
charger une image dans le clip.
5. Revenez dans l’environnement de programmation, puis ouvrez le panneau Actions.
6. Tapez le code ActionScript suivant à la suite du code ajouté à l’étape 3 :
rotateClip.loadMovie("
");
Ce code charge une image dans le clip rotateClip que vous avez créé. Vous ciblez 
l’occurrence rotateClip avec ActionScript.
7. Choisissez Contrôle > Tester l’animation pour tester votre document. 
Une image doit à présent s’afficher sur la scène avec une rotation de 50º dans le sens des 
aiguilles d’une montre.
Vous pouvez également cibler ou identifier des parties de fichiers SWF chargés dans un fichier 
SWF de base.
90
Eléments fondamentaux du langage et de la syntaxe

Pour identifier un fichier SWF chargé :  
?
Utilisez _levelX, où X est le numéro du niveau spécifié dans la fonction loadMovie() qui 
a chargé le fichier SWF.
Par exemple, un fichier SWF chargé au niveau 99 a pour chemin cible _level99. 
Dans l’exemple suivant, un fichier SWF est chargé au niveau 99 et sa visibilité est définie 
sur false :
//Charge le SWF sur le niveau 99.
loadMovieNum("", 99);
// Définit la visibilité du niveau 99 sur false.
loaderClip.onEnterFrame = function(){
_level99._visible = false;
};
CO
Il est généralement recommandé d’éviter l’utilisation de niveaux si vous pouvez 
NS
charger le contenu dans des clips à différents niveaux. La méthode 
EI
MovieClip.getNextHighestDepth() vous permet de créer des occurrences de clip sur 
L
la scène de façon dynamique, sans qu’il soit nécessaire de vérifier s’il existe déjà une 
occurrence à une profondeur spécifique.
Définition de variables à l’aide d’un chemin 
Vous pouvez définir des variables pour des occurrences imbriquées dans d’autres occurrences. 
Par exemple, pour définir une variable pour un formulaire placé dans un autre formulaire, 
utilisez le code suivant. L’occurrence submitBtn est à l’intérieur de formClip sur le scénario 
principal :
this.formClip.submitBtn.mouseOver = true;
Vous pouvez déclarer une méthode ou une propriété d’un objet particulier (tel qu’un clip ou 
un champ de texte) à l’aide de ce modèle. Par exemple, la propriété d’un objet serait
myClip._alpha = 50;
Domaine et ciblage
Lorsque vous imbriquez des occurrences, le clip qui contient un second clip est appelé parent 
de l’occurrence imbriquée. L’occurrence imbriquée est elle appelée occurrence enfant. La scène 
principale et le scénario principal sont eux-mêmes avant tout un clip et peuvent donc être 
ciblés en tant que tels. Pour plus d’informations sur le domaine, consultez la section 
« Variables et domaine », à la page 62. 
Syntaxe à points et chemins cibles
91

Le code ActionScript vous permet de cibler des occurrences et des scénarios parents. 
Pour cibler le scénario actif, utilisez le mot-clé this. Par exemple, lorsque vous ciblez un clip 
appelé myClip situé sur le scénario principal, utilisez
this.myClip.
Vous pouvez même éventuellement abandonner le mot-clé this et utiliser simplement 
myClip
Le mot-clé this facilite la compréhension et la cohérence du code. Pour plus d’informations 
sur les pratiques de programmation conseillées, consultezet conventions de programmation pour ActionScript 2.0 », à la page 715.
Si vous suivez le clip pour l’un des fragments de code ci-dessus, _level0.myClip apparaît 
dans le panneau de sortie. Toutefois, si du code ActionScript est placé à l’intérieur du clip 
myClip alors que vous voulez cibler le scénario principal, vous devez cibler le parent du clip 
(c’est-à-dire la scène principale). Double-cliquez sur un clip et placez le code ActionScript 
suivant sur le scénario du clip :
trace("me: " + this);
trace("my parent: " + this._parent);
Testez le fichier SWF. Le message suivant s’affiche dans le panneau de sortie :
me: _level0.myClip
my parent: _level0
Il indique que vous avez ciblé le scénario principal. Vous pouvez utiliser un parent pour créer 
un chemin relatif vers un objet. Par exemple, si le clip dogClip est imbriqué dans le clip 
d’animation animalClip, l’instruction suivante de l’occurrence dogClip indique à animalClip 
d’arrêter l’animation :
();
Si vous connaissez bien Flash et ActionScript, vous avez certainement remarqué que certains 
utilisent le domaine _root. Le domaine _root fait généralement référence au scénario 
principal du document Flash actif. Dans la mesure du possible, évitez d’utiliser le domaine 
_root et utilisez les chemins cibles relatifs au lieu de _root. 
Si vous utilisez _root dans votre code, des erreurs risquent de survenir si vous chargez le 
fichier SWF dans un autre document Flash. Lors du chargement du fichier SWF dans un 
autre fichier SWF, le domaine _root du fichier chargé peut pointer vers le domaine racine du 
fichier SWF dans lequel il est chargé au lieu de faire référence à son propre domaine racine. 
L’opération peut donc entraîner des réactions inattendues, voire une défaillance totale de la 
fonctionnalité.
92
Eléments fondamentaux du langage et de la syntaxe

Utilisation du bouton Chemin cible 
Il n’est pas toujours simple de savoir à quoi correspond un chemin cible donné ou quel 
chemin cible est nécessaire pour quel fragment de code. Si vous ciblez une occurrence située 
sur la scène, le bouton Chemin cible permet d’identifier le chemin qui y conduit.
Pour utiliser le bouton Chemin cible :
1.
Dans le panneau Actions (Fenêtre > Actions), cliquez sur le bouton Insérer un chemin 
cible. Les clips de votre document actif s’affichent dans une boîte de dialogue.
2. Sélectionnez l’une des occurrences dans la liste.
3. Cliquez sur OK.
4. Le chemin cible de l’occurrence sélectionnée s’affiche dans la fenêtre de script.
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 prise en charge par ActionScript 1.0 dans Flash 
Player 7 et les versions antérieures, mais pas dans ActionScript 2.0 et Flash Player 7 ou 8.
L’utilisation de cette syntaxe est donc déconseillée, sauf lorsque vous n’avez pas le choix, par 
exemple lors de la création d’un contenu destiné spécifiquement à Flash Player 4 ou Flash 
Lite 1.1 (et versions antérieures). Pour plus d’informations sur Flash Lite, consultez la produit Flash Lite. 
Eléments de ponctuation 
Le langage de Flash comprend plusieurs éléments de ponctuation. Les plus courants sont les 
points-virgules (;), les deux-points (:), les parenthèses [()] et les accolades ({}). Chacun de 
ces éléments a une signification précise dans le langage de Flash et permet de définir des types 
de données, de clore des instructions ou de structurer le code ActionScript. Les sections 
suivantes abordent l’emploi de ces éléments de ponctuation dans votre code.
Pour plus d’informations sur les éléments de ponctuation, consultez les sections suivantes :
?
« Points-virgules et deux points », à la page 94
?
« Accolades », à la page 95
?
« Parenthèses », à la page 99
?
« Présentation des littéraux », à la page 99
?
« Présentation des commentaires », à la page 101
Pour plus d’informations sur l’opérateur point (.) et les opérateurs d’accès tableau ([]), 
consultez la section Pour plus d’informations sur les espaces blancs et le formatage du code, consultez la section 
« Mise en forme de la syntaxe ActionScript », à la page 750.
Eléments de ponctuation
93

Points-virgules et deux points 
Comme le montre les deux lignes de code suivantes, les instructions ActionScript se terminent 
par un point-virgule (;) : 
var myNum:Number = 50;
myClip._alpha = myNum;
Vous pouvez cependant omettre ce caractère car le compilateur ActionScript suppose alors que 
chaque ligne de code représente une instruction distincte. Néanmoins, la meilleure pratique 
consiste à utiliser des points-virgules, car cela rend le code plus lisible. Lorsque vous cliquez 
sur le bouton de formatage automatique du panneau Actions ou de la fenêtre de script, des 
points-virgules sont ajoutés par défaut à la fin de vos instructions.
REMARQUE
L’ajout d’un point-virgule à la fin de chaque instruction permet de placer plusieurs 
instructions sur une même ligne, mais dans ce cas, la lecture de votre code est rendue 
plus difficile.
Les points-virgules sont également employés dans les boucles for. Comme l’illustre l’exemple 
suivant, le point-virgule permet de séparer les paramètres. L’exemple fait une boucle de 0 à 9, 
puis affiche chaque nombre dans le panneau de sortie :
var i:Number;
for (i = 0; i < 10; i++) {
trace(i); // 0,1, ,9
}
Le caractère deux-points (:) est utilisé dans le code pour affecter des types de données aux 
variables. 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, comme illustré ci-dessous :
// typage strict de variable ou objet
var myNum:Number = 7;
var myDate:Date = new Date();
// typage strict de paramètres
function welcome(firstName:String, myAge:Number) {
}
// typage strict de paramètre et de valeur renvoyée
function square(num:Number):Number {
var squared:Number = num * num;
return squared;
}
94
Eléments fondamentaux du langage et de la syntaxe

Vous pouvez déclarer le type des données des objets en fonction des classes intégrées (Button, 
Date, MovieClip, etc.) et des classes et interfaces que vous créez. Le code suivant crée un 
nouvel objet de type personnalisé Student :
var firstStudent:Student = new Student();
Vous pouvez également spécifier que les objets sont de type Function ou Void. Pour plus 
d’informations sur l’affectation du type de données, consultez le types de données », à la page 35.
Accolades 
Les accolades ({}) permettent de regrouper des événements, des définitions de classe et des 
fonctions ActionScript dans des blocs. L’accolade d’ouverture doit être placée sur la même 
ligne que la déclaration.
REMARQUE
Vous pouvez également placer l’accolade d’ouverture sur la ligne qui suit la déclaration, 
mais il est conseillé de la placer sur la même ligne, pour plus de cohérence. Pour plus 
d’informations sur les accolades et les conventions de programmation, consultez le 
2.0 », à la page 715.
Placez les instructions entre accolades lorsqu’elles appartiennent à une structure de contrôle 
(par exemple  ou for), même lorsque cette dernière ne comporte qu’une seule 
instruction. Cette pratique conseillée permet d’éviter les erreurs dans le code ActionScript, 
telles que les oublis d’accolades. L’exemple suivant montre un code dont la forme est 
médiocre :
var numUsers:Number;
if (numUsers == 0)
  trace("no users found.");
Bien que ce code puisse être validé, sa présentation est médiocre dans la mesure où les 
accolades ne sont pas placées autour des instructions.
CO
Si vous cliquez sur le bouton Format automatique, des accolades seront ajoutées à cette 
NS
instruction.
EIL
Dans ce cas, le fait d’ajouter une seconde instruction après l’instruction trace permet de 
l’exécuter, que la variable numUsers soit égale à 0 ou non, ce qui risque de déboucher sur des 
résultats imprévus. Pour cette raison, ajoutez des accolades de façon à obtenir le code suivant :
var numUsers:Number;
if (numUsers == 0) {
  trace("no users found");
}
Eléments de ponctuation
95

L’exemple suivant crée un objet écouteur et une occurrence MovieClipLoader.
var imgUrl:String = "";
this.createEmptyMovieClip("img_mc", 100);
var mclListener:Object = new Object();
mclListener.onLoadStart = function() {
trace("starting");
};
mclListener.onLoadInit = function(target_mc:MovieClip):Void {
trace("success");
};
mclListener.onLoadError = function(target_mc:MovieClip):Void {
trace("failure");
};
var myClipl:MovieClipLoader = new MovieClipLoader();
myClipl.addListener(mclListener);
myClipl.loadClip(imgUrl, img_mc);
Le prochain exemple affiche un simple fichier de classe qui permet de créer un objet Student. 
Vous étudierez les fichiers de classe de manière approfondie dans la page 197.
Pour utiliser des accolades dans un fichier ActionScript :
1.
Choisissez Fichier > Nouveau, puis sélectionnez Fichier ActionScript.
2. Choisissez Fichier > Enregistrer sous et nommez le nouveau document .
3. Ajoutez le code ActionScript suivant dans le fichier AS.
//
class Student {
private var _id:String;
private var _firstName:String;
private var _middleName:String;
private var _lastName:String;
public function Student(id:String, firstName:String, 
middleName:String, lastName:String) {
this._id = id;
this._firstName = firstName;
this._middleName = middleName;
this._lastName = lastName;
}
public function get firstName():String {
return this._firstName;
}
public function set firstName(value:String):Void {
this._firstName = value;
}
//
}
96
Eléments fondamentaux du langage et de la syntaxe

4. Enregistrez le fichier de classe.
5. Choisissez Fichier > Nouveau, puis cliquez sur Document Flash pour créer un nouveau 
fichier FLA.
6. Enregistrer le fichier FLA sous le nom .
7. Saisissez le code ActionScript suivant sur l’image 1 du scénario principal :
//
import Student;
var firstStudent:Student = new Student("cst94121", "John", "H.", "Doe");
trace(firstStudent.firstName); // John
firstStudent.firstName = "Craig";
trace(firstStudent.firstName); // Craig
8. Choisissez Fichier > Enregistrer pour enregistrer les modifications dans le fichier 
.
9. Choisissez Contrôle > Tester l’animation pour tester les fichiers FLA et AS.
Le prochain exemple montre l’emploi des accolades avec les fonctions.
Pour utiliser des accolades avec des fonctions :
1.
Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA.
2. Choisissez Fichier > Enregistrer sous et nommez le fichier .
3. Faites glisser une occurrence de composant Label du panneau Composants jusqu’à la scène.
4. Ouvrez l’inspecteur des propriétés (Fenêtre > Propriétés > Propriétés) et, l’occurrence du 
composant Label étant sélectionnée, saisissez le nom status_lbl dans le champ Nom de 
l’occurrence.
5. Saisissez 200 dans le champ W (largeur) pour définir la largeur du composant sur 
200 pixels.
6. Faites glisser une occurrence du composant TextInput sur la scène et nommez-la 
firstName_ti.
7. Faites glisser une occurrence du composant Button sur la scène et nommez-la 
submit_button.
Eléments de ponctuation
97

8. Sélectionnez l’image 1 du scénario et, dans le panneau Actions, ajoutez le code ActionScript 
suivant :
function checkForm():Boolean {
= "";
if (.length == 0) {
= "Please enter a first name.";
return false;
}
return true;
}
function clickListener(evt_obj:Object):Void {
var success:Boolean = checkForm();
};
submit_button.addEventListener("click", clickListener);
9. Choisissez Fichier > Enregistrer pour enregistrer le document Flash.
10. Choisissez Contrôle > Tester l’animation pour tester le code dans l’environnement de 
programmation. 
Dans le fichier SWF, un message d’erreur apparaît si vous cliquez sur l’occurrence Button 
de la scène alors que le composant firstName_ti TextInput ne contient pas de texte. 
Cette erreur s’affiche dans le composant Label et signale à l’utilisateur qu’il doit saisir un 
prénom.
L’exemple suivant d’utilisation des accolades présente la création et la définition de propriétés 
à l’intérieur d’un objet. Dans cet exemple, les propriétés sont définies dans l’objet en plaçant 
les noms des variables entre des accolades ({}) :
var myObject:Object = {id:"cst94121", firstName:"John", middleName:"H.", 
lastName:"Doe"};
var i:String;
for (i in myObject) {
trace(i + ": " + myObject[i]);
}
/*
id: cst94121
firstName: John
middleName: H.
lastName: Doe
*/
Vous pouvez également utiliser des accolades vides comme syntaxe raccourcie pour la fonction 
new Object(). Le code suivant crée par exemple une occurrence d’objet vide :
var myObject:Object = {};
CO
N’oubliez pas de vérifier que chaque accolade d’ouverture est bien associée à une 
NS
accolade de fermeture.
EI
L
98
Eléments fondamentaux du langage et de la syntaxe

Parenthèses 
Comme l’illustrent les lignes de code suivantes, la définition d’une fonction dans ActionScript 
se fait en plaçant les paramètres entre parenthèses [()] :
function myFunction(myName:String, myAge:Number, happy:Boolean):Void {
  // Insérez votre code ici.
}
Lorsque vous appelez une fonction, vous incluez également tous les paramètres transmis à la 
fonction entre parenthèses, comme dans l’exemple suivant :
myFunction("Carl", 78, true);
Vous pouvez utiliser les parenthèses pour supplanter l’ordre de priorité d’ActionScript ou pour 
faciliter la compréhension de vos instructions ActionScript. Cela signifie que vous pouvez 
modifier l’ordre dans lequel les valeurs sont calculées en en plaçant certaines entre parenthèses, 
comme dans l’exemple suivant : 
var computedValue:Number = (circleClip._x + 20) * 0.8;
Du fait de l’ordre de priorité, si vous n’utilisez pas de parenthèses ou que vous utilisez deux 
instructions distinctes, la multiplication est d’abord calculée et la première opération est donc 
20 * 0,8. Le résultat, 16, est ensuite ajouté à la valeur actuelle de circleClip._x, puis affecté à la 
variable computedValue.
Si vous n’utilisez pas de parenthèses, vous devez ajouter une instruction pour évaluer 
l’expression, comme indiqué dans l’exemple suivant :
var tempValue:Number = circleClip._x + 20;
var computedValue:Number = tempValue * 0.8;
Comme pour les crochets et les accolades, vous devez vous assurer que chaque parenthèse 
d’ouverture est bien associée à une parenthèse de fermeture.
Présentation des littéraux 
Un littéral est une valeur qui apparaît directement dans le code. Ce sont des valeurs constantes 
(qui ne changent pas) dans les documents Flash. true, false, 0, 1, 52 ou la chaîne « foo » 
en sont des exemples. 
Voici quelques exemples de littéraux :
17
"hello"
-3
9.4
null
undefined
true
false
Eléments de ponctuation
99

Les littéraux peuvent également être regroupés pour former des littéraux composés. 
Les littéraux de tableau sont placés entre crochets ([]) et utilisent la virgule (,) pour séparer 
les éléments du tableau. Un littéral de tableau permet donc d’initialiser un tableau. 
Les exemples suivants présentent deux tableaux initialisés par des littéraux de tableau. 
Vous pouvez utiliser l’instruction new et transmettre le littéral composé sous forme de 
paramètre au constructeur de classe Array, ou affecter directement les valeurs littérales lors de 
l’instanciation des occurrences d’une classe ActionScript intégrée.  
// Utilisation de l’instruction new.
var myStrings:Array = new Array("alpha", "beta", "gamma");
var myNums:Array = new Array(1, 2, 3, 5, 8);
// affectation directe d’un littéral
var myStrings:Array = ["alpha", "beta", "gamma"];
var myNums:Array = [1, 2, 3, 5, 8];
Les littéraux permettent également d’initialiser un objet générique. Un objet générique est une 
occurrence de la classe Object. Les littéraux d’objet sont placés entre accolades ({}) et utilisent 
la virgule (,) pour séparer les propriétés de l’objet. Chaque propriété est déclarée avec le 
caractère deux-points (:), séparant le nom et la valeur de la propriété. 
Vous pouvez créer un objet générique via l’instruction new et transmettre le littéral d’objet 
sous forme de paramètre au constructeur de classe Object ou affecter directement le littéral 
d’objet à l’occurrence déclarée. L’exemple suivant crée un objet générique et initialise l’objet 
avec trois propriétés, propA, propB et propC, de valeurs respectives 1, 2 et 3.
// Utilisation de l’instruction new.
var myObject:Object = new Object({propA:1, propB:2, propC:3});
// affectation directe d’un littéral
var myObject:Object = {propA:1, propB:2, propC:3};
Ne confondez pas un littéral de chaîne avec un objet String. Dans l’exemple suivant, la 
première ligne de code crée le littéral de chaîne firstStr, et la deuxième ligne de code, l’objet 
String secondStr :
var firstStr:String = "foo" 
var secondStr:String = new String("foo") 
Utilisez des littéraux de chaîne sauf si, pour optimiser les performances, vous avez 
spécifiquement besoin d’un objet String. Pour plus d’informations sur les chaînes, consultez la 
section « Présentation des chaînes et de la classe String », à la page 443.
100
Eléments fondamentaux du langage et de la syntaxe

Présentation des commentaires
Les commentaires permettent d’annoter votre code à l’aide de descriptions claires qui sont 
ignorées par le compilateur. Vous pouvez insérer ces commentaires dans votre code pour 
décrire sa fonction ou les données renvoyées au document. Les commentaires permettent de se 
souvenir des choix de programmation importants et sont extrêmement utiles pour toute 
personne qui lit et doit comprendre votre code. Les commentaires doivent expliquer 
clairement l’objectif du code et ne pas se contenter de le paraphraser. Toute section qui ne 
s’explique pas d’elle-même dans le code doit faire l’objet de commentaires.
Il est vivement recommandé d’utiliser des commentaires pour ajouter des notes aux scripts. 
Les commentaires documentent les décisions prises lors de la programmation, en expliquant le 
pourquoi et le comment. Ils facilitent la compréhension du code ActionScript. Par exemple, 
vous devez décrire toute solution de contournement dans les commentaires. Ainsi, vous 
(ou tout autre développeur) pourrez aisément localiser les sections de code concernées pour les 
mettre à jour ou les corriger. De même, lorsqu’un problème est corrigé par la suite dans la 
version suivante de Flash ou Flash Player, vous pouvez améliorer le code ActionScript en 
supprimant ce contournement devenu inutile.
Evitez de surcharger vos commentaires. Une ligne de signes égal (=) ou d’astérisques (*) créant 
un bloc ou une séparation autour du commentaire est un bon exemple de commentaire 
surchargé. Dans ce cas, utilisez des espaces blancs pour séparer les commentaires du code 
ActionScript. Si vous formatez le code ActionScript à l’aide du bouton Format automatique 
du panneau Actions ou de la fenêtre de script, l’espace blanc sera supprimé. N’oubliez pas de 
rajouter un espace blanc dans votre code, ou d’utiliser des lignes de commentaires uniques 
(//) pour conserver l’espacement. Il est ensuite plus facile de supprimer ces lignes après la 
mise en forme du code que d’essayer de déterminer où se trouvaient les espaces. 
Avant le déploiement de votre projet, retirez du code tous les commentaires inutiles, tels que 
« Définition des variables x et y » ou autres commentaires évidents pour les autres 
développeurs. Si votre code ActionScript comporte trop de commentaires, envisagez la 
réécriture de certaines sections. La nécessité d’inclure de nombreux commentaires sur le 
fonctionnement du code ActionScript dénote généralement d’une programmation maladroite 
et peu intuitive.
Lorsque la coloration de la syntaxe est activée, les commentaires apparaissent en gris par 
défaut. Quelle que soit leur longueur, la taille du fichier exporté n’est pas affectée. 
Les commentaires ne sont pas soumis aux règles de syntaxe ou de mots-clés d’ActionScript.
REMARQUE
L’emploi de commentaires est particulièrement important lorsque le code ActionScript 
est destiné à la formation. Ajoutez des commentaires à votre code si vous créez des 
exemples d’application dans le but de former les utilisateurs à la programmation Flash ou 
si vous rédigez des articles et des didacticiels sur ActionScript.
Eléments de ponctuation
101

Commentaires sur une ligne
Ces commentaires sont limités à une ligne dans votre code. Vous pouvez alors commenter une 
seule ligne de code ou décrire brièvement l’objectif d’un fragment de code. Pour indiquer 
qu’une ligne ou portion de ligne est un commentaire, faites-la précéder de deux barres 
obliques (//), comme dans le code suivant : 
// Le code suivant définit une variable locale pour l’âge.
var myAge:Number = 26;
Les commentaires sur une ligne portent généralement sur un petit fragment de code. Utilisez 
ce type de commentaires lorsque le contexte le permet. L’exemple suivant inclut un 
commentaire sur une ligne :
while (condition) {
// Traiter la condition avec des instructions
}
Commentaires sur plusieurs lignes
Ces commentaires, également appelés blocs de commentaires, conviennent lorsque les 
commentaires comprennent plusieurs lignes. Les développeurs les utilisent pour décrire des 
fichiers, des structures de données, des méthodes et des descriptions de fichiers. Ces blocs sont 
généralement placés au début d’un fichier et avant ou à l’intérieur d’une méthode.
Pour créer un bloc de commentaires, entrez /* au début de la première ligne de commentaire, 
puis */ à la fin du bloc. Cette technique permet de créer des commentaires longs sans avoir à 
ajouter des // au début de chaque ligne. L’utilisation des // sur plusieurs lignes consécutives 
peut entraîner des problèmes en cas de modification des commentaires.
Le format d’un commentaire sur plusieurs lignes est le suivant. 
/*
The following ActionScript initializes variables used in the main and 
sub-menu systems. Variables are used to track what options are clicked.
*/
CO
Si vous placez les caractères de commentaire (/* et */) sur des lignes distinctes au début 
NS
et à la fin du commentaire, vous pouvez les supprimer facilement en les faisant précéder 
EI
de deux barres obliques (//) (par exemple, ///* et //*/). Cette fonction permet d’ajouter et 
L
de retirer facilement les commentaires de votre code.
102
Eléments fondamentaux du langage et de la syntaxe

En plaçant de gros pavés de code dans un bloc de commentaires, vous pouvez tester des 
sections spécifiques du script. Par exemple, lors de l’exécution du script suivant, le code 
intégré dans le bloc de commentaires n’est pas exécuté :
// Le code suivant s’exécute.
var x:Number = 15;
var y:Number = 20;
// Le code suivant est commenté et ne sera pas exécuté.
/*
// Crée un nouvel objet Date
var myDate:Date = new Date();
var currentMonth:Number = myDate.getMonth();
// Convertit le chiffre du mois en nom
var monthName:String = calcMonth(currentMonth);
var year:Number = myDate.getFullYear();
var currentDate:Number = myDate.getDate();
*/
// Le code ci-dessous s’exécute.
var namePrefix:String = "My name is";
var age:Number = 20;
CO
Il est recommandé de faire précéder chaque bloc de commentaires d’une ligne vierge.
N
S
EIL
Commentaires en fin de ligne
Ces commentaires permettent d’ajouter un commentaire dans une ligne de votre code. 
Ils apparaissent sur la même ligne que votre code ActionScript. Les développeurs les utilisent 
généralement pour décrire le contenu d’une variable ou une valeur renvoyée par une ligne du 
code ActionScript. Le format des commentaires en fin de ligne est le suivant :
var myAge:Number = 26; // Variable pour mon âge
trace(myAge); // 26
Déplacez les commentaires vers la droite, de sorte que les lecteurs les différencient bien du 
code. Dans la mesure du possible, alignez-les, comme illustré ci-dessous.
var myAge:Number = 28;            // mon âge
var myCountry:String = "Canada";
// mon pays
var myCoffee:String = "Hortons";
//mon café préféré
Si vous utilisez la fonction de formatage automatique (bouton Format automatique du 
panneau Actions), les commentaires en fin de ligne sont déplacés à la ligne suivante. 
Ajoutez ces commentaires après avoir formaté votre code ou changez-les de place après avoir 
utilisé la fonction de formatage automatique.
Eléments de ponctuation
103

Commentaires dans les classes
Ces commentaires permettent de documenter le contenu de vos classes et de vos interfaces et 
facilitent la compréhension des développeurs. Faites débuter tous vos fichiers de classe par un 
commentaire fournissant le nom de classe, son numéro de version, sa date et votre droit de 
propriété. Par exemple, vous pouvez documenter votre classe de la façon suivante :
/**
  Pelican class
  version 1.2
  10/10/2005
  copyright Adobe Systems Incorporated
*/
Servez-vous de blocs de commentaires pour décrire les fichiers, les structures de données et les 
méthodes. Ces blocs sont généralement placés au début d’un fichier et avant ou à l’intérieur 
d’une méthode.
Un fichier d’interface ou de classe comporte généralement deux types de commentaire : des 
commentaires de documentation et des commentaires d’implémentation. Les commentaires 
de documentation décrivent le cahier des charges du code, mais pas son implémentation. 
Ils documentent les interfaces, les classes, les méthodes et les constructeurs. Les commentaires 
d’implémentation décrivent le code ou l’implémentation de sections spécifiques du code.
Incluez un commentaire de documentation par classe, interface ou membre, et placez-le 
directement avant la déclaration. Si vous devez faire des ajouts à vos commentaires de 
documentation, utilisez des commentaires d’implémentation (sous forme de blocs de 
commentaires ou de commentaires sur une ligne). Les commentaires d’implémentation 
suivent directement la déclaration.
Ces deux types de commentaires utilisent des séparateurs légèrement différents. 
Les commentaires de documentation sont séparés par /** et */, tandis que les commentaires 
d’implémentation sont séparés par /* et */. 
CO
N’incluez pas les commentaires non directement relatifs à la classe en cours de lecture. 
NS
Par exemple, n’incluez pas de commentaires décrivant le package correspondant.
EI
L
Vous pouvez également utiliser des commentaires sur une ligne, des blocs de commentaires et 
des commentaires de fin de ligne dans les fichiers de classe. Pour plus d’informations sur ces 
types de commentaires, consultez les sections suivantes :
?
« Commentaires sur une ligne », à la page 102
?
« Commentaires sur plusieurs lignes », à la page 102
?
« Commentaires en fin de ligne », à la page 103
104
Eléments fondamentaux du langage et de la syntaxe

Présentation des constantes et des 
mots-clés
Les constantes et les mots-clés sont la base de la syntaxe ActionScript. Les constantes sont des 
propriétés dont la valeur est fixe et non modifiable. Elles ne changent donc jamais, même 
pendant l’exécution de l’ application. 
Flash comprend plusieurs constantes prédéfinies qui peuvent simplifier le développement 
d’application. Vous pouvez observer un exemple de constantes dans la classe Key, qui 
comprend de nombreuses propriétés, comme Key.ENTER ou . Lorsque vous utilisez 
des constantes, vous n’avez pas besoin de vous souvenir que les valeurs de code des touches 
Entrée et Page suivante sont 13 et 34. Ces constantes ne simplifient pas seulement le 
développement et le débogage, mais facilitent la compréhension de votre code par vos 
collègues développeurs.
Les mots-clés utilisés par ActionScript permettent d’exécuter des types d’actions spécifiques. 
Il s’agit également de mots réservés et vous ne pouvez donc pas les utiliser comme identifiants 
(noms de variable, de fonction, d’étiquette, etc.). Voici quelques exemples de mots-clés 
réservés : if, else, this, function et return. 
Pour plus d’informations sur les constantes et les mots-clés, consultez les sections suivantes :
?
« Utilisation des constantes », à la page 105
?
« Présentation des mots-clés », à la page 108
?
« Présentation des mots réservés », à la page 109
Pour plus d’informations sur les objets et les propriétés, consultez la section Object », à la page 43. Vous trouverez la liste des constantes du langage ActionScript (telles 
que false et NaN) dans la catégorie Eléments du langage ActionScript > Constantes du Guide 
de référence du langage ActionScript 2.0
.
Utilisation des constantes
Les constantes sont des propriétés de valeurs fixes non modifiables. En d’autres termes, elles ne 
changent jamais, même pendant l’exécution de l’application. Le langage ActionScript contient 
un grand nombre de constantes prédéfinies. Par exemple, les constantes BACKSPACE, ENTER, 
SPACE et TAB sont des propriétés de la classe Key qui font référence aux touches du clavier. 
La constante  a toujours la même signification : elle indique la touche Tab du clavier. 
Les constantes sont très utiles pour comparer des valeurs et utiliser des valeurs qui ne changent 
pas dans votre application.
Présentation des constantes et des mots-clés
105

Pour savoir si un utilisateur appuie sur la touche Entrée, vous pouvez utiliser l’instruction 
suivante :
var keyListener:Object = new Object();
keyListener.onKeyDown = function() {
if (Key.getCode() == Key.ENTER) {
trace("Are you ready to play?");
}
};
Key.addListener(keyListener);
Pour que le code ActionScript précédent fonctionne, il peut être nécessaire de désactiver les 
raccourcis clavier dans l’environnement de programmation. Dans le menu principal, 
choisissez Contrôle > Tester l’animation puis, avec un aperçu du fichier SWF dans le lecteur, 
choisissez Contrôle > Désactiver les raccourcis clavier dans la fenêtre d’aperçu du fichier SWF.
Flash ne vous permet pas de créer vos propres valeurs de constantes, sauf lorsque vous créez 
vos propres classes personnalisées avec des variables de membre privé. Vous ne pouvez pas 
créer de variable en « lecture seule » dans Flash.
Les variables doivent être en minuscules ou comprendre un mélange de minuscules et 
majuscules. Toutefois, les constantes (variables qui ne changent pas) doivent être en 
majuscules. Séparez les mots par un caractère de soulignement, comme dans l’exemple suivant 
de code ActionScript :
var BASE_URL:String = ""; // constante
var MAX_WIDTH:Number = 10; 
// constante
Tapez les constantes statiques en majuscules et séparez les mots par des caractères de 
soulignement. Ne codez pas directement les constantes numériques, sauf si leur valeur est 1, 
0 ou -1 que vous pouvez utiliser dans le cadre d’une boucle for en tant que valeur de 
compteur.
Vous pouvez utiliser des constantes pour les situations où vous devez faire référence à une 
propriété dont la valeur ne change jamais. Ceci permet d’identifier les erreurs typographiques 
qui risquent de passer inaperçues avec des littéraux. Ceci vous permet également de centraliser 
la modification des valeurs. Pour plus d’informations sur les littéraux, consultez la section 
« Présentation des littéraux », à la page 99.
Par exemple, la définition de classe de l’exemple suivant crée trois constantes qui respectent la 
convention d’appellation utilisée par ActionScript 2.0.
106
Eléments fondamentaux du langage et de la syntaxe

Pour utiliser des constantes dans une application :
1.
Choisissez Fichier > Nouveau, puis Fichier ActionScript pour créer un fichier AS.
2. Nommez ce fichier .
3. Saisissez le code suivant dans la fenêtre de script :
class ConstExample {
public static var EXAMPLE_STATIC:String = "Global access";
public var EXAMPLE_PUBLIC:String = "Public access";
private var EXAMPLE_PRIVATE:String = "Class access";
}
La propriété EXAMPLE_STATIC est statique, c’est-à-dire qu’elle s’applique à la classe entière et 
non à une occurrence particulière de la classe. Pour accéder à une propriété statique d’une 
classe, vous devez utiliser le nom de la classe à la place du nom de l’occurrence. Vous ne 
pouvez pas accéder à une propriété statique par l’intermédiaire d’une occurrence de classe. 
4. Créez un nouveau document Flash, puis enregistrez-le sous le nom .
5. Dans le panneau Actions, entrez le code suivant dans l’image 1 du scénario :
trace(ConstExample.EXAMPLE_STATIC); // résultat : Global access
Lorsque la propriété EXAMPLE_STATIC est déclarée statique, utilisez ce code pour accéder à 
sa valeur.
6. Choisissez Contrôle > Tester l’animation pour tester votre document. 
La mention Global access s’affiche dans le panneau de sortie.
7. Dans le panneau Actions, saisissez le code suivant après celui que vous avez ajouté à 
l’étape 5.
trace(ConstExample.EXAMPLE_PUBLIC); // Erreur
trace(ConstExample.EXAMPLE_PRIVATE); // erreur
8. Choisissez Contrôle > Tester l’animation pour tester votre document.
Les propriétés EXAMPLE_PUBLIC et EXAMPLE_PRIVATE ne sont pas statiques. Lorsque vous 
tentez d’accéder à leurs valeurs à travers la classe, le message d’erreur suivant apparaît :
The property being referenced does not have the static attribute.
Pour accéder à une propriété non statique, vous devez passer par l’occurrence de la classe. 
La propriété EXAMPLE_PUBLIC étant publique, le code peut y accéder en dehors de la 
définition de la classe. 
9. Dans le panneau Actions, supprimez l’instruction trace que vous avez ajoutée lors des 
étapes 5 et 7.
Présentation des constantes et des mots-clés
107

10. Tapez le code suivant dans le panneau Actions :
var myExample:ConstExample = new ConstExample();
trace(myExample.EXAMPLE_PUBLIC); // résultat : Public access
Ce code crée l’occurrence myExample et accède à la propriété EXAMPLE_PUBLIC.
11. Choisissez Contrôle > Tester l’animation pour tester votre document.
La mention Public access s’affiche dans le panneau de sortie.
12. Dans le panneau Actions, supprimez l’instruction trace que vous avez ajoutée à l’étape 10.
13. Tapez le code suivant dans le panneau Actions.
trace(myExample.EXAMPLE_PRIVATE); // erreur
La propriété EXAMPLE_PRIVATE étant privée, elle n’est accessible qu’à l’intérieur de la 
définition de la classe. 
14. Choisissez Contrôle > Tester l’animation pour tester votre document.
La mention The member is private and cannot be accessed s’affiche dans le 
panneau de sortie.
Pour plus d’informations sur les classes intégrées et la création de classes personnalisées, 
consultez le Chapitre 6, « Classes », à la page 197.
Présentation des mots-clés
Les mots-clés sont des mots d’ActionScript qui ont une fonction spéciale. Par exemple, le 
mot-clé var permet de déclarer une variable. Le mot-clé var est présenté dans le code 
suivant :
var myAge:Number = 26;
Il s’agit de mots réservés dont la signification est particulière : par exemple, le mot-clé class 
permet de définir une nouvelle classe ActionScript et le mot-clé var de déclarer des variables 
locales. Voici d’autres exemples de mots-clés réservés : if, else, this, function et return.
Les mots-clés ne peuvent pas servir d’identifiants (noms de variable, fonction ou étiquette) et 
il est préférable de ne pas les utiliser ailleurs que dans vos fichiers FLA pour d’autres éléments 
(tels que des noms d’occurrences). Vous avez déjà largement utilisé le mot-clé var, en 
particulier si vous avez lu le Chapitre 3, « Données et types de données », à la page 35. 
ActionScript réserve les mots du langage à un usage spécifique. De ce fait, vous ne pouvez pas 
les utiliser comme identifiants (noms de variable, de fonction ou d’étiquette). Vous trouverez 
la liste de ces mots-clés dans la section « Présentation des mots réservés », à la page 109.
108
Eléments fondamentaux du langage et de la syntaxe

Présentation des mots réservés
Les mots réservés ne peuvent pas servir d’identifiants dans votre code car leur utilisation est 
réservée à ActionScript. Ces mots réservés incluent les mots-clés, correspondant à des 
instructions ActionScript, et les mots réservés pour une utilisation future. Cela signifie que 
vous ne pouvez pas les utiliser comme noms de variables, d’occurrences, de classes 
personnalisées, etc., sans provoquer des problèmes techniques.
D’autres termes, qui ne sont pas des mots réservés, ne doivent pas non plus servir 
d’identifiants (par exemple les noms de variables ou d’occurrences) dans votre code 
ActionScript. Ces mots sont utilisés par les classes intégrées qui composent le langage 
ActionScript, ils sont appelés éléments de langage. N’utilisez donc pas non plus les noms des 
propriétés, méthodes, classes, interfaces, classes de composants et interfaces comme 
identifiants de variables, classes ou occurrences dans votre code.
Pour plus d’informations sur les mots-clés réservés susceptibles de provoquer des erreurs dans 
vos scripts et les mots-clés protégés pour une utilisation future par ActionScript ou la 
spécification ECMAScript (ECMA-262) édition 4, consultez la section des mots réservés et des éléments de langage à la page 719.
Pour connaître les noms des élements de langage, consultez le Guide de référence du langage 
ActionScript 2.0
.
Présentation des instructions
Une instruction est une action spécifique que vous demandez au fichier FLA d’exécuter. 
Par exemple, vous pouvez utiliser une instruction conditionnelle pour déterminer si quelque 
chose est vrai ou existe. Votre code peut ensuite exécuter les actions spécifiées, telles que des 
fonctions ou des expressions, selon si la condition est vraie ou non. 
Par exemple, l’instruction if est une instruction conditionnelle qui évalue une condition afin 
de déterminer l’action suivante du code. 
// instruction if
if (condition) {
// instructions ;
}
Dans un autre exemple, l’instruction return renvoie un résultat sous forme de valeur de la 
fonction dans laquelle elle s’exécute.
Il existe différents moyens pour formater ou rédiger du code ActionScript. Chacun choisit sa 
propre utilisation de la syntaxe et espace ou place différemment ses instructions ou accolades 
({}) dans le code. Il existe malgré tout des consignes générales à respecter lors de l’écriture 
d’un code ActionScript bien présenté.
Présentation des instructions
109

Ne placez qu’une seule instruction par ligne pour améliorer la lisibilité de votre code 
ActionScript. Vous trouverez ci-dessous des exemples d’utilisation conseillée ou déconseillée 
des instructions :
theNum++;       // recommandé
theOtherNum++;  // recommandé
aNum++; anOtherNum++;  // déconseillé
Affectez les variables en tant qu’instructions distinctes. Examinez l’exemple de code 
ActionScript suivant :
var myNum:Number = (a = b + c) + d;
Ce code imbrique une affectation dans le code, ce qui devient difficile à lire. Si l’affectation 
des variables s’effectue par des instructions distinctes, le code devient plus lisible, comme dans 
l’exemple suivant :
var a:Number = b + c;
var myNum:Number = a + d;
Les sections suivantes présentent la composition d’instructions spécifiques dans ActionScript. 
Pour plus d’informations sur la rédaction et la mise en forme des événements, consultez le 
Chapitre 9, « Gestion d’événements », à la page 311.
Pour plus d’informations sur chaque instruction, consultez les sections suivantes :
?
« Présentation des instructions composées », à la page 110
?
« Présentation des conditions », à la page 111
?
« Répétition d’actions à l’aide de boucles », à la page 122
Présentation des instructions composées
Une instruction composée contient plusieurs instructions placées entre des accolades ({}). 
Ces instructions composées peuvent contenir n’importe quel type d’instruction ActionScript. 
Voici un exemple d’instruction composée typique : 
Les instructions placées entre accolades sont en retrait par rapport à l’instruction composée, 
comme dans l’exemple de code ActionScript suivant :
var a:Number = 10;
var b:Number = 10;
if (a == b) {
  // Ce code est en retrait.
  trace("a == b");
  trace(a);
  trace(b);
}
110
Eléments fondamentaux du langage et de la syntaxe

Cette instruction composée contient plusieurs instructions mais se comporte comme une 
seule instruction dans votre code ActionScript. L’accolade d’ouverture est placée à la fin de 
l’instruction composée. L’accolade de fermeture débute une ligne et s’aligne sur le début de 
l’instruction composée. 
Pour plus d’informations sur l’utilisation des accolades, consultez la sectila page 95.
Présentation des conditions
Les conditions permettent de déterminer si une chose est vraie ou existe. Vous pouvez ensuite 
éventuellement répéter une action (à l’aide de boucles) ou exécuter des actions définies, par 
exemple des fonctions ou des expressions, selon l’état d’une condition (vraie ou fausse). 
Par exemple, vous pouvez déterminer si une certaine variable est définie ou a une certaine 
valeur, puis exécuter un bloc de code en fonction du résultat. De même, vous pourriez 
modifier les graphiques de votre document Flash selon l’heure de l’horloge système de 
l’utilisateur ou les conditions météorologiques de sa région.
Pour exécuter une action en fonction d’une condition ou pour la répéter (boucle), vous 
pouvez utiliser les instructions if, else, else if, for, while, do while,  ou 
switch.
Pour plus d’informations sur les conditions disponibles, et leur rédaction, consultez les 
sections suivantes :
?
« Rédaction des conditions », à la page 112
?
« Utilisation de l’instruction if », à la page 112
?
« Utilisation de l’instruction  », à la page 113
?
« Utilisation de l’instruction  if », à la page 115
?
« Utilisation de l’instruction switch », à la page 116
?
« Utilisation des instructions try..catch et try..catch..finally », à la page 118
?
« Opérateur conditionnel et syntaxe de remplacement », à la page 121
Présentation des instructions
111

Rédaction des conditions 
Les instructions qui vérifient l’état d’une condition commencent par le terme if. Si cette 
condition renvoie true, ActionScript exécute l’instruction suivante. Si la condition renvoie 
(false), ActionScript passe à l’instruction suivante à l’extérieur du bloc de code.
CO
Pour optimiser les performances de votre code, vérifiez d’abord les conditions les plus 
NS
probables.
EIL
Les instructions suivantes testent trois conditions. Le terme else if spécifie d’autres tests à 
effectuer si les conditions précédentes sont false.
if ((.length == 0) || (.length == 0)) {
  gotoAndStop("invalidLogin");
}  else if ( == userID){
  gotoAndPlay("startProgram");
}
Dans ce fragment de code, si la longueur des champs passwordTxt ou emailTxt est 0 (lorsque 
l’utilisateur ne les a pas renseignés par exemple), le document Flash redirige vers l’étiquette 
d’image invalidLogin. Si les champs passwordTxt et emailTxt contiennent des valeurs et 
que leur contenu correspond à la variable userID, le fichier SWF est redirigé vers l’étiquette 
d’image startProgram.
Pour vérifier une condition parmi d’autres, utilisez l’instruction switch, plutôt que plusieurs 
instructions else if. Pour plus d’informations sur les instructions switch, consultez la 
section « Utilisation de l’instruction switch », à la page 116.
Pour apprendre à rédiger les différents types de conditions dans vos applications ActionScript, 
consultez les sections suivantes.
Utilisation de l’instruction if
L’instruction if permet d’exécuter une suite d’instructions si une certaine condition est vraie 
(true). 
// instruction if
if (condition) {
  // instructions ;
}
Vous utiliserez fréquemment les instructions if lorsque vous travaillerez sur un projet Flash. 
Par exemple, si vous construisez un site Flash réclamant l’identification des utilisateurs pour 
l’accès à certaines pages, utilisez une instruction if pour vérifier si l’utilisateur a renseigné les 
champs Nom d’utilisateur et Mot de passe. 
112
Eléments fondamentaux du langage et de la syntaxe

Si le nom d’utilisateur et le mot de passe doivent être validés via une base de données externe, 
vous souhaiterez probablement vous assurer que la combinaison nom d’utilisateur/mot de 
passe saisie par l’utilisateur correspond à un enregistrement de la base de données. 
Vous souhaiterez également vérifier que l’utilisateur est bien autorisé à accéder à la partie du 
site spécifiée.
Si vous créez des animations à l’aide de script dans Flash, vous pouvez utiliser l’instruction if 
pour vérifier qu’une occurrence de la scène reste dans les limites de celle-ci. Par exemple, si 
une balle descend sous l’axe des y, il peut être nécessaire de déceler le moment où elle heurte le 
bord inférieur de la scène pour modifier sa direction et la faire rebondir.
Pour utiliser une instruction if :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2. Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau 
Actions :
// Création d’une chaîne pour gérer les heures AM et PM
var amPm:String = "AM";
// aucun paramètre ne renvoie de date, la date/heure en cours est
// renvoyée
var current_date:Date = new Date();
// si l’heure en cours est supérieure ou égale à 12, définition de 
// la chaîne amPm sur « PM ».
if (current_date.getHours() >= 12) {
amPm = "PM";
}
trace(amPm);
3. Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Dans ce code, vous créez une chaîne qui gère la mention AM ou PM en fonction de l’heure 
de la journée. Si l’heure est supérieure ou égale à 12, la chaîne amPM est définie sur PM. 
Enfin, vous suivez la chaîne amPm et lorsque l’heure devient supérieure ou égale à 12, la 
mention PM s’affiche. Dans le cas contraire, la mention AM apparaît.
Utilisation de l’instruction
L’instruction conditionnelle  permet de tester une condition, puis d’exécuter un 
bloc de code lorsque cette condition est positive et d’en exécuter un autre dans le cas contraire. 
Par exemple, le code suivant vérifie si la valeur de x est supérieure à 20 et génère une instruction 
trace() dans l’affirmative ou une autre instruction trace() dans le cas contraire :
if (x > 20) {
trace("x is > 20");
} else {
trace("x is <= 20");
}
Présentation des instructions
113

Si vous ne souhaitez pas exécuter un autre bloc de code, vous pouvez utiliser l’instruction if 
sans l’instruction else.
L’instruction  est similaire à l’instruction if. Par exemple, si vous utilisez 
l’instruction if pour vérifier que le nom et le mot de passe saisis par les utilisateurs 
correspondent bien à une valeur stockée dans la base de données, vous pouvez ensuite 
rediriger les utilisateurs selon si leurs identifiants sont corrects. En cas d’identification valide, 
l’utilisateur peut être dirigé vers une page d’accueil par le bloc if. Si l’identification échoue, 
vous pouvez rediriger l’utilisateur vers le formulaire d’identification et afficher un message 
d’erreur via le bloc else.
Pour utiliser une instruction  dans un document :
1.
Sélectionnez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau 
fichier FLA.
2. Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau 
Actions :
// création d’une chaîne chargée de gérer la mention AM/PM en fonction 
// de l’heure de la journée.
var amPm:String;
// aucun paramètre ne renvoie de date, la date/heure en cours est 
// renvoyée.
var current_date:Date = new Date();
// si l’heure en cours est supérieure ou égale à 12, définition de 
// la chaîne amPm sur « PM ».
if (current_date.getHours() >= 12) {
amPm = "PM";
} else {
amPm = "AM";
}
trace(amPm);
3. Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Dans ce code, vous créez une chaîne qui gère la mention AM ou PM en fonction de l’heure 
de la journée. Si l’heure est supérieure ou égale à 12, la chaîne amPM est définie sur PM. 
Enfin, vous suivez la chaîne amPm et lorsque l’heure devient supérieure ou égale à 12, la 
mention PM s’affiche. La mention AM s’affiche dans le panneau de sortie.
114
Eléments fondamentaux du langage et de la syntaxe

Utilisation de l’instruction if
L’instruction conditionnelle  if permet de tester plusieurs conditions. L’instruction 
 if utilise la syntaxe suivante :
// instruction else-if
if (condition) {
  // instructions ;
} else if (condition) {
  // instructions ;
} else {
  // instructions ;
}
Vous pouvez utiliser un bloc  if dans vos projets Flash lorsque vous voulez vérifier 
une série de conditions. Par exemple, si vous souhaitez afficher à l’écran une image qui diffère 
selon l’heure à laquelle l’utilisateur se connecte, vous pouvez créer une suite d’instructions if 
qui détermine s’il s’agit du matin, de l’après-midi, du soir ou de la nuit. Vous pouvez ensuite 
afficher l’image appropriée.
Le code suivant regarde non seulement si la valeur de x est supérieure à 20, mais également si 
la valeur de x est négative :
if (x > 20) {
trace("x is > 20");
} else if (x < 0) {
trace("x is negative");
}
Pour utiliser une instruction  if dans un document :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2. Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau 
Actions :
var now_date:Date = new Date();
var currentHour:Number = now_date.getHours();
// si l’heure est inférieure à 11 H (AM)
if (currentHour < 11) {
trace("Good morning");
// sinon.. si l’heure est inférieure à 15 H (3PM)
} else if (currentHour < 15) {
trace("Good afternoon");
// sinon.. s’il n’est pas encore 20 H (8PM)
} else if (currentHour < 20) {
trace("Good evening");
// sinon, l’heure est comprise entre 20 H (8PM) et 23H59 (11:59PM)
} else {
trace("Good night");
}
Présentation des instructions
115

3. Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Dans ce code, vous créez une chaîne appelée currentHour qui gère le nombre de l’heure 
en cours (par exemple, s’il est 6:19 pm, currentHour gère le nombre 18). Pour obtenir 
l’heure en cours, utilisez la méthode getHours() de la classe Date. Vous utilisez ensuite 
l’instruction  if pour envoyer les informations au panneau de sortie, selon le 
nombre renvoyé. Pour plus d’informations, consultez les commentaires du fragment de 
code précédent.
Utilisation de l’instruction switch
L’instruction switch crée une structure arborescente pour des instructions ActionScript. 
Comme pour l’instruction if, l’instruction switch teste une condition et exécute des 
instructions si cette condition renvoie la valeur true (vrai). 
Dans le cadre d’une instruction switch, l’instruction break force Flash à ignorer le reste des 
instructions dans le bloc de code de ce cas et passe à la première instruction qui suit 
l’instruction switch qui l’encadre. Si le bloc du cas ne contient pas d’instruction « break », 
une condition appelée « fall through » (passe au cas suivant) survient. Dans ctte situation, la 
première instruction du cas suivant s’exécute également jusqu’à ce que survienne une 
instruction « break » ou que l’instruction switch se termine. Ce comportement est illustré 
dans l’exemple suivant où la première instruction du cas ne contenant pas d’instruction break, 
les deux blocs de code des deux premiers cas (A et B) s’exécutent.
Toutes les instructions switch doivent inclure un cas default. Le cas default doit toujours 
être le dernier cas d’une instruction switch et comprendre également une instruction break 
afin d’éviter l’apparition d’une erreur « passer au cas suivant » (fall-through) en cas d’ajout 
d’un autre cas. Par exemple, si la condition de l’exemple suivant donne A, les deux 
instructions pour les cas A et B s’exécutent, dans la mesure où le cas A ne comporte pas 
d’instruction break. Lorsqu’un cas ne comporte pas d’instruction break, remplacez ce dernier 
par un commentaire, comme indiqué dans l’exemple suivant, après le cas A. Lorsque vous 
rédigez des instructions switch, utilisez le format suivant :
switch (condition) {
case A :
  // instructions
  // falls through
case B :
  // instructions
  break;
case Z :
  // instructions
  break;
default :
  // instructions
  break;
}
116
Eléments fondamentaux du langage et de la syntaxe

Pour utiliser une instruction switch dans un document :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2. Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau 
Actions :
var listenerObj:Object = new Object();
listenerObj.onKeyDown = function() {
// Utilisation de la méthode String.fromCharCode() pour renvoyer une 
chaîne.
switch (String.fromCharCode(Key.getAscii())) {
case "A" :
trace("you pressed A");
break;
case "a" :
trace("you pressed a");
break;
case "E" :
case "e" :
/* E doesn't have a break statement, so this block executes if you 
press e or E. */
trace("you pressed E or e");
break;
case "I" :
case "i" :
trace("you pressed I or i");
break;
default :
/* If the key pressed isn’t caught by any of the above cases, 
execute the default case here. */
trace("you pressed some other key");
}
};
Key.addListener(listenerObj);
3. Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Tapez des lettres au clavier, y compris les lettres a, e ou i. Lorsque vous appuyez sur ces 
trois touches, les instructions trace apparaissent dans le code ActionScript précédent. 
La ligne de code crée un nouvel objet que vous utilisez comme écouteur de la classe Key. 
Vous utilisez cet objet pour notifier l’événement onKeyDown() lorsque l’utilisateur appuie 
sur une touche. La méthode Key.getAscii() renvoyant le code ASCII de la dernière 
touche pressée ou relâchée par l’utilisateur, vous n’avez pas besoin d’utiliser la méthode 
String.fromCharCode() pour renvoyer une chaîne contenant les caractères représentés 
par les valeurs ASCII dans les paramètres. Le cas « E » ne présentant pas d’instruction 
break, le bloc s’exécute si l’utilisateur appuie sur la touche e ou E. Si la touche pressée ne 
correspond à aucun des trois premiers cas, le cas default s’exécute.
Présentation des instructions
117

Utilisation des instructions try..catch et try..catch..finally
L’utilisation des blocs try..catch..finally vous permet d’ajouter un traitement des erreurs 
dans vos applications Flash. Les mots-clés try..catch..finally vous permettent d’entourer 
un bloc de code dans lequel une erreur peut survenir et de réagir à cette erreur. Lorsqu’un code 
figurant dans le bloc try lance une erreur (via l’instruction throw), le contrôle est transmis au 
bloc catch lorsque ce dernier existe. Le contrôle est ensuite transmis au bloc de code finally 
s’il en existe un. Le bloc finally facultatif s’exécute toujours, qu’une erreur ait été lancée ou 
non. 
Si le code figurant dans le bloc try ne lance pas d’erreur (s’il se termine normalement), le code 
du bloc finally est tout de même exécuté.
REMARQUE
Le bloc finally s’exécute même si le bloc try se termine avec une instruction return.
Rédigez les instructions try..catch et try..catch..finally à l’aide du format suivant :
// try-catch
try {
  // instructions
} catch (myError) {
  // instructions
}
//try-catch-finally
try {
  // instructions
} catch (myError) {
  // instructions
} finally {
  // instructions
}
Chaque fois que votre code lance une erreur, vous pouvez rédiger des gestionnaires 
personnalisés pour réagir à cette défaillance en douceur et prendre les mesures appropriées. 
Vous pouvez tenter de charger des données externes depuis un service Web ou un fichier texte 
ou afficher un message d’erreur à l’utilisateur. Vous pouvez même utiliser le bloc catch pour 
tenter de vous connecter à un service Web qui signale l’erreur à l’administrateur de sorte qu’il 
puisse vérifier le bon fonctionnement de l’application.
118
Eléments fondamentaux du langage et de la syntaxe

Pour utiliser le bloc try..catch..finally pour valider les données avant de diviser 
certains nombres :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2. Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau 
Actions :
var n1:Number = 7;
var n2:Number = 0;
try {
if (n2 == 0) {
throw new Error("Unable to divide by zero");
}
trace(n1/n2);
} catch (err:Error) {
trace("ERROR! " + err.toString());
} finally {
delete n1;
delete n2;
}
3. Sélectionnez Contrôle > Tester l’animation pour tester le document.
4. Le panneau de sortie affiche le message Unable to divide by zero (Division par zéro 
impossible).
5. Revenez dans l’environnement de programmation et modifiez la ligne de code suivante :
var n2:Number = 0;
en
var n2:Number = 2;
6. Choisissez Contrôle > Tester l’animation pour tester de nouveau le document.
Si la valeur de n2 est égale à zéro, une erreur est lancée et interceptée par le bloc catch qui 
affiche un message dans le panneau de sortie. Si la valeur de y est différente de zéro, le 
panneau de sortie présente le résultat de n1 divisé par n2. Le bloc finally s’exécute dans 
tous les cas et supprime les valeurs des variables n1 et n2 du document Flash.
Vous n’êtes pas limité au lancement de nouvelles occurrences de la classe Error lorsqu’une 
erreur survient. Vous pouvez également étendre cette classe pour créer vos propres erreurs 
personnalisées, comme l’illustre l’exemple suivant.
Présentation des instructions
119

Pour créer une erreur personnalisée :
1.
Choisissez Fichier > Nouveau et créez un fichier ActionScript.
2. Choisissez Fichier > Enregistrer sous et nommez le fichier .
3. Saisissez le code ActionScript suivant dans la fenêtre de script :
// Dans :
class DivideByZeroException extends Error {
   var message:String = "Divide By Zero error";
}
4. Enregistrez le fichier ActionScript.
5. Créez un document Flash nommé  dans le même répertoire que le fichier 
ActionScript et enregistrez-le.
6. Dans le panneau Actions, saisissez le code ActionScript suivant sur l’image 1 du scénario 
principal :
var n1:Number = 7;
var n2:Number = 0;
try {
if (n2 == 0) {
throw new DivideByZeroException();
} else if (n2 < 0) {
throw new Error("n2 cannot be less than zero");
} else {
trace(n1/n2);
}
} catch (err:DivideByZeroException) {
trace(err.toString());
} catch (err:Error) {
trace("An unknown error occurred; " + err.toString());
}
7. Enregistrez le document Flash, puis choisissez Contrôle > Tester l’animation pour tester le 
fichier dans l’environnement de test. 
La valeur de n2 étant égale à 0, Flash renvoie votre classe d’erreur personnalisée 
DivideByZeroException et affiche le message Divide By Zero error dans le panneau de 
sortie. Si, à la ligne deux, vous modifiez la valeur de n2 de 0 en -1, et testez de nouveau le 
document Flash, le message An unknown error occurred; n2 cannot be less than 
zero (Erreur inconnue. n2 ne peut pas être inférieur à zéro) apparaît dans le panneau de 
sortie. La saisie de n’importe quelle valeur n2 supérieure à 0 entraîne l’affichage du résultat 
de la division dans le panneau de sortie. Pour plus d’informations sur la création de classes 
personnalisées, consultez le Chapitre 6, « Classes », à la page 197.
120
Eléments fondamentaux du langage et de la syntaxe

Opérateur conditionnel et syntaxe de remplacement
Si vous aimez les raccourcis, vous pouvez utiliser l’opérateur conditionnel (?:), également 
appelé expressions conditionnelles. L’opérateur conditionnel permet de convertir des 
instructions  simples en une seule ligne de code. Il permet donc de réduire la 
quantité de code rédigé dans un même objectif, mais le rend du même coup plus difficile 
à lire. 
La condition suivante est écrite en version longue et permet de vérifier que la variable numTwo 
est supérieure à zéro, ce qui renvoie le résultat numOne/numTwo ou une chaîne de carrot :
var numOne:Number = 8;
var numTwo:Number = 5;
if (numTwo > 0) {
  trace(numOne / numTwo); // 1.6
} else {
  trace("carrot");
}
L’utilisation d’une expression conditionnelle permet d’écrire ce même code dans le format 
suivant :
var numOne:Number = 8;
var numTwo:Number = 0;
trace((numTwo > 0) ? numOne/numTwo : "carrot");
Comme vous pouvez le voir, la syntaxe abrégée nuit à la lisibilité et doit donc être évitée. 
Si vous êtes obligé d’utiliser des opérateurs conditionnels, placez la première condition (avant 
le point d’interrogation [?]) entre parenthèses. Cette précaution améliore la lisibilité du code 
ActionScript. Vous trouverez ci-dessous un exemple de code ActionScript dont la lisibilité a 
été améliorée :
var numOne:Number;
(numOne >= 5) ? numOne : -numOne;
Vous pouvez écrire une instruction conditionnelle qui renvoie une valeur booléenne, comme 
dans l’exemple suivant :
if (cartArr.length > 0) {
  return true;
} else {
  return false;
}
Cependant, comparé avec le code précédent, le code ActionScript de l’exemple suivant est 
préférable :
return (cartArr.length > 0);
Le deuxième fragment de code est plus concis et comporte moins d’expressions à évaluer. Il est 
plus facile à lire et à comprendre.
Présentation des instructions
121

Lorsque vous écrivez des conditions complexes, il est conseillé de les regrouper entre 
parenthèses [()]. Si vous n’utilisez pas de parenthèses, vous (ou toute autre personne 
travaillant sur le code ActionScript) risquez de subir des erreurs au niveau de la priorité des 
opérateurs. Pour plus d’informations sur la priorité des opérateurs, consultez la section 
« Priorité et associativité des opérateurs », à la page 149.
Par exemple, le code suivant ne met pas la condition entre parenthèses :
if (fruit == "apple" && veggie == "leek") {}
Le code suivant met les conditions entre parenthèses de manière appropriée :
if ((fruit == "apple") && (veggie == "leek")) {}
Répétition d’actions à l’aide de boucles
ActionScript peut répéter une action un certain nombre de fois ou tant qu’une condition 
spécifique existe. Les boucles permettent de répéter une suite d’instructions lorsqu’une 
condition particulière est true (vraie). Il existe quatre types de boucles dans ActionScript : 
for, , while et do..while. Chaque type de boucle se comporte légèrement 
différemment et sert des objectifs distincts. 
La plupart des boucles utilisent un compteur d’un certain type pour contrôler le nombre 
d’exécutions d’une boucle. Chaque exécution d’une boucle est appelée itération. Vous pouvez 
déclarer une variable et rédiger une instruction qui augmente ou diminue sa valeur à chaque 
exécution de la boucle. Dans l’action for, le compteur et l’instruction qui l’incrémente font 
partie de l’action.
Boucle
Description
Boucles for
Répéter une action en utilisant un compteur intégré.
Boucles 
Effectuer une itération sur les enfants d’un clip ou d’un objet.
Boucles while
Répéter une action tant qu’une condition est vraie.
Boucles do..while
Similaires aux boucles while, sauf que l’expression est évaluée à la fin 
du bloc de code et la boucle est toujours exécutée au moins une fois.
122
Eléments fondamentaux du langage et de la syntaxe

La plus répandue est la boucle for, qui passe sur un bloc de code un nombre de fois prédéfini. 
Par exemple, pour exécuter une série d’instructions sur chaque élément d’un tableau, utilisez 
une boucle for et exécutez-la de 0 jusqu’au nombre d’éléments du tableau. La boucle 
 est également très utile lorsque vous souhaitez faire une boucle sur chaque paire 
nom/valeur d’un objet, puis exécuter un type d’action spécifique. Cela peut se révéler très 
pratique lors du débogage de projets Flash si vous devez afficher les valeurs chargées à partir de 
sources externes, telles que des services Web ou des fichiers texte/XML externes. Les deux 
derniers types de boucles (while et do..while) sont très pratiques lorsqu’il s’agit de passer en 
boucle sur une série d’instructions, sans nécessairement connaître le nombre de passages 
nécessaires. Dans ce cas, utilisez une boucle while qui tourne tant qu’une certaine condition 
est vraie.
ActionScript peut répéter une action un certain nombre de fois ou tant qu’une condition 
spécifique existe. Utilisez les actions while, do..while, for et  pour créer des 
boucles. Cette section présente des informations générales sur ces boucles. Pour plus 
d’informations sur chacune de ces boucles, consultez les procédures suivantes.
Pour répéter une action tant qu’une condition existe :    
?
Utilisez l’instruction while. 
La boucle while évalue une expression et exécute le code dans le corps de la boucle si 
l’expression est true. L’expression est évaluée à nouveau après l’exécution de chaque 
instruction du corps. Dans l’exemple suivant, la boucle est exécutée à quatre reprises :
var i:Number = 4;
while (i > 0) {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
i--;
}
Vous pouvez utiliser l’instruction do..while pour créer le même genre de boucle qu’avec 
une boucle while. Dans une boucle do..while, l’expression est évaluée à la fin du bloc de 
code et la boucle est toujours exécutée au moins une fois. 
Ceci est illustré par l’exemple suivant :
var i:Number = 4;
do {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
i--;
} while (i > 0);
Pour plus d’informations sur l’instruction while, consultezboucles while », à la page 129.
Présentation des instructions
123

Pour répéter une action en utilisant un compteur intégré :   
?
Utilisez l’instruction for.
La plupart des boucles utilisent un compteur d’un certain type pour contrôler le nombre 
d’exécutions d’une boucle. Chaque exécution d’une boucle est appelée itération
Vous pouvez déclarer une variable et rédiger une instruction qui augmente ou diminue sa 
valeur à chaque exécution de la boucle. Dans l’action for, le compteur et l’instruction qui 
l’incrémente font partie de l’action. 
Dans l’exemple suivant, la première expression (var i:Number = 4) est l’expression 
initiale qui est évaluée avant la première itération. La deuxième expression (i > 0) est la 
condition contrôlée avant chaque exécution de la boucle. La troisième expression (i--) est 
appelée post-expression et est évaluée après chaque exécution de la boucle.
for (var i:Number = 4; i > 0; i--) {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
}
Pour plus d’informations sur l’instruction for, consultboucles for », à la page 126.
Pour passer en boucle sur les enfants d’un clip ou d’un objet : 
?
Utilisez l’instruction . 
Les enfants sont composés d’autres clips, fonctions, objets et variables. L’exemple suivant 
utilise l’instruction trace pour envoyer les résultats dans le panneau de sortie : 
var myObject:Object = {name:'Joe', age:25, city:'San Francisco'};
var propertyName:String;
for (propertyName in myObject) {
trace("myObject has the property: " + propertyName + ", with the 
value: " + myObject[propertyName]);
}
Cet exemple donne les résultats suivants dans le panneau de sortie : 
myObject has the property: name, with the value: Joe
myObject has the property: age, with the value: 25
myObject has the property: city, with the value: San Francisco
Vous pouvez souhaiter que votre script boucle sur un type particulier d’enfants, par 
exemple, seulement sur les enfants d’un clip. Pour ce faire, utilisez  en 
conjonction avec l’opérateur typeof. Dans l’exemple suivant, une occurrence de clip 
enfant (appelée occurrence2) est située dans une occurrence de clip sur la scène. Ajoutez 
le code ActionScript suivant à l’Image 1 du scénario :
for (var myName in this) {
if (typeof (this[myName]) == "movieclip") {
trace("I have a movie clip child named " + myName);
}
}
124
Eléments fondamentaux du langage et de la syntaxe

Pour plus d’informations sur l’instruction , consultez la sboucles  », à la page 127.
AVERT
Dans Flash, les itérations s’exécutent très rapidement dans Flash Player, mais les 
boucles dépendent essentiellement du processeur. La quantité de ressources 
I
consommées par le processeur évolue en fonction du nombre d’itérations de la 
S
S
boucle et du nombre d’instructions exécutées dans chaque bloc. Les boucles mal 
EMENT
écrites peuvent générer des problèmes de performance et de stabilité.
Pour plus d’informations sur chaque instruction, consultez les sections suivantes de ce 
chapitre, telles que « Utilisation des boucles while », à la page 129, et leurs entrées respectives 
dans le Guide de référence du langage ActionScrip 2.0
Création et terminaison des boucles
L’exemple suivant présente un simple tableau de noms de mois. Une boucle for itère de 0 au 
nombre d’éléments présents dans le tableau et affiche chaque élément dans le panneau de sortie.
var monthArr:Array = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", 
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
var i:Number;
for (i = 0; i < monthArr.length; i++) {
trace(monthArr[i]);
}
Lorsque vous manipulez des tableaux, simples ou complexes, vous devez connaître la 
condition appelée boucle sans fin. Comme son nom l’indique, il s’agit d’une boucle qui n’a 
aucune condition de fin. Cela entraîne un véritable problème (le blocage de votre application 
Flash) : votre document Flash ne répond plus dans le navigateur Web ou a un comportement 
incohérent. Le code suivant est un exemple de boucle sans fin :
// MAUVAIS CODE- crée une boucle sans fin
// A vos risques et périls !
var i:Number;
for (i = 0; i < 10; i--) {
trace(i);
}
La valeur de i est initialisée sur 0 et la condition de fin survient lorsque i est supérieur ou égal 
à 10, la valeur de i étant décrémentée après chaque itération. L’erreur vous saute 
probablement déjà aux yeux : si la valeur de i diminue après chaque itération, la condition de 
fin n’arrive jamais. Le résultat varie selon les ordinateurs, et la rapidité du blocage dépend de la 
cadence du processeur et d’autres facteurs. Par exemple, la boucle s’exécute environ 
142 620 fois avant d’afficher un message d’erreur sur un ordinateur donné.
Présentation des instructions
125

Le message d’erreur suivant s’affiche dans une boîte de dialogue : 
A script in this movie is causing Flash Player to run slowly. If it 
continues to run, your computer may become unresponsive. Do you want to 
abort the script?
Lorsque vous utilisez des boucles (et en particulier while et do..while), n’oubliez jamais de 
vérifier que la boucle peut se terminer correctement, et ne continue pas sans fin.
Pour plus d’informations sur le contrôle des boucles, consultez la sectionl’instruction switch », à la page 116.
Utilisation des boucles for
La boucle for permet de faire une itération sur une variable dans une plage de valeurs 
spécifiques. La boucle for est très utile lorsque vous savez exactement combien de fois une 
série d’instructions ActionScript doit être répétée. Elle peut se révéler très utile lorsque vous 
souhaitez dupliquer un clip de la scène un certain nombre de fois ou passer en boucle dans un 
tableau et exécuter une tâche sur chacun de ses éléments. La boucle for répète une action à 
l’aide d’un compteur intégré. Le compteur et l’instruction qui l’incrémente font tous deux 
partie de l’instruction for. Rédigez les instructions for au format suivant :
for (init; condition; update) {
  // instructions ;
}
Vous devez fournir trois expressions dans une instruction for : une variable définie sur une 
valeur initiale, une instruction conditionnelle qui détermine le moment où la boucle prend fin 
et une expression qui modifie la valeur de la variable à chaque boucle. Par exemple, le code 
suivant boucle à cinq reprises. La valeur de la variable i commence à 0 et termine à 4. La sortie 
indique les nombres 0 à 4, chacun sur sa propre ligne.
var i:Number;
for (i = 0; i < 5; i++) {
trace(i);
}
Dans l’exemple suivant, la première expression (i = 0) est l’expression initiale évaluée avant la 
première itération. La deuxième expression (i < 5) est la condition contrôlée avant chaque 
exécution de la boucle. La troisième expression (i++) est appelée post-expression et est évaluée 
après chaque exécution de la boucle.
126
Eléments fondamentaux du langage et de la syntaxe

Pour créer une boucle for :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2. Créez un clip sur la scène.
3. Dans le panneau Bibliothèque, cliquez du bouton droit sur le symbole du clip et choisissez 
Liaison dans le menu contextuel. 
4. Cochez la case Exporter pour ActionScript, puis tapez libraryLinkageClassName dans le 
champ Classe. Cliquez sur OK.
5. Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau 
Actions :
var i:Number;
for (i = 0; i < 5; i++) {
this.attachMovie("libraryLinkageClassName", "clip" + i + "_mc", i, 
{_x:(i * 100)});
}
6. Choisissez Contrôle > Tester l’animation pour tester le code dans Flash Player.
Remarquez la duplication des cinq clips en haut de la scène. Ce code ActionScript 
reproduit le symbole de clip de la bibliothèque et repositionne les clips sur la scène, aux 
coordonnées x de 0, 100, 200, 300 et 400 pixels. La boucle s’exécute à cinq reprises, une 
valeur comprise entre 0 et 4 étant affectée à la variable i. A la dernière itération, la valeur 
de i devient 4 et la seconde expression (i < 5) n’étant plus vraie, la boucle s’arrête.
Vous devez inclure un espace après chaque expression d’une instruction for. Pour plus 
d’informations, reportez-vous à for statement dans le Guide de référence du langage 
ActionScript 2.0
.
Utilisation des boucles
L’instruction  permet d’exécuter une boucle (ou de faire une itération) sur les enfants 
d’un clip, les propriétés d’un objet ou les éléments d’un tableau. Les enfants, référencés 
précédemment, sont composés d’autres clips, fonctions, objets et variables. La boucle  
est souvent utilisée pour passer en boucle sur les occurrences d’un scénario ou sur les paires 
clé/valeur d’un objet. Ce passage en boucle sur des objets se révèle efficace pour déboguer les 
applications car il permet de voir les données renvoyées par les services Web ou les documents 
externes, tels que les fichiers texte ou XML. 
Présentation des instructions
127

Par exemple, utilisez une boucle for in pour faire une itération sur les propriétés d’un 
objet générique (les propriétés d’un objet n’étant pas conservées dans un ordre particulier, elles 
apparaissent dans un ordre imprévisible) :
var myObj:Object = {x:20, y:30};
for (var i:String in myObj) {
trace(i + ": " + myObj[i]);
}
Ce code donne les résultats suivants dans le panneau de sortie :
x: 20
y: 30
Vous pouvez également faire une itération sur les éléments d’un tableau :
var myArray:Array = ["one", "two", "three"];
for (var i:String in myArray) {
trace(myArray[i]);
}
Ce code donne les résultats suivants dans le panneau de sortie :
three
two
one
Pour plus d’informations sur les objets et les propriétés, consultez la section Object », à la page 43.
REMARQUE
Vous ne pouvez pas itérer sur les propriétés d’un objet lorsqu’il s’agit d’une occurrence 
de classe personnalisée, sauf si la classe est dynamique. Et même dans ce dernier cas, 
vous ne pouvez faire d’itération que sur les propriétés ajoutées dynamiquement.
REMARQUE
Les accolades ({}), qui servent normalement à entourer le bloc d’instructions que la 
boucle  doit exécuter, peuvent être omises si une seule instruction s’exécute.
L’exemple suivant utilise une boucle  sur les propriétés d’un objet :
128
Eléments fondamentaux du langage et de la syntaxe

Pour créer une boucle for :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2. Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau 
Actions :
var myObj:Object = {name:"Tara", age:27, city:"San Francisco"};
var i:String;
for (i in myObj) {
  trace("myObj." + i + " = " + myObj[i]);
}
3. Choisissez Contrôle > Tester l’animation pour tester le code dans Flash Player.
Lorsque vous testez le fichier SWF, le message suivant s’affiche dans le panneau de sortie :
= Tara
= 27
= San Francisco
Si vous écrivez une boucle  dans un fichier de classe (fichier ActionScript externe), les 
membres de l’occurrence ne seront plus disponibles dans la boucle, contrairement aux 
membres statiques. Cependant, si vous écrivez une boucle  dans un fichier FLA pour 
une occurrence de la classe, les membres de l’occurrence restent disponibles, mais pas les 
membres statiques. Pour plus d’informations sur la rédaction de fichiers de classe, consultez le 
Chapitre 6, « Classes », à la page 197. Pour plus d’informations, reportez-vous à  
statement dans le Guide de référence du langage ActionScript 2.0.
Utilisation des boucles while
L’instruction while permet de répéter une action tant qu’une condition existe, comme 
l’instruction if qui se répète tant que la condition est true (vraie). 
Une boucle while évalue une expression et exécute le code présent dans la boucle si 
l’expression est true. Si la condition renvoie true, une instruction ou une série d’instructions 
est exécutée avant de revenir en arrière et d’évaluer de nouveau la condition. Lorsque la 
condition renvoie false (faux), l’instruction ou la série d’instructions est ignorée et la boucle 
se termine. Les boucles while se révèlent très utiles lorsque vous ne savez pas précisément 
combien de boucles doivent être exécutées sur un bloc de code.
Par exemple, ce code envoie les nombres suivants dans le panneau de sortie :
var i:Number = 0;
while (i < 5) {
trace(i);
i++;
}
Présentation des instructions
129

Les nombres suivants doivent s’afficher dans le panneau de sortie :
0
1
2
3
4
L’un des inconvénients que présente la boucle while par rapport à la boucle for est que les 
risques de boucles sans fin sont plus importants avec les boucles while. Par exemple, le code 
qui utilise la boucle for ne passera pas la compilation si vous omettez l’expression qui 
incrémente la variable du compteur, alors que le code qui utilise la boucle while sera compilé. 
Et sans l’expression qui incrémente i, la boucle se poursuit sans fin.
Pour créer et utiliser une boucle while dans un fichier FLA, procédez comme dans cet 
exemple.
Pour créer une boucle while :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2. Ouvrez le panneau Composants et faites glisser un composant DataSet sur la scène.
3. Ouvrez l’inspecteur des propriétés (Fenêtre > Propriétés > Propriétés) et entrez le nom 
d’occurrence users_ds.
4. Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau 
Actions :
var .components.DataSet;
//
users_ds.addItem({name:"Irving", age:34});
users_ds.addItem({name:"Christopher", age:48});
users_ds.addItem({name:"Walter", age:23});
//
users_ds.first();
while (users_ds.hasNext()) {
  trace("name:" + users_ds.currentItem["name"] + ", age:" + 
users_ds.currentItem["age"]);
  ();
}
5. Sélectionnez Contrôle > Tester l’animation pour tester le document.
Les informations suivantes apparaissent dans le panneau de sortie :
name:Irving, age:34
name:Christopher, age:48
name:Walter, age:23
Pour plus d’informations, reportez-vous à l’instruction while dans le Guide de 
référence du langage ActionScript 2.0.
130
Eléments fondamentaux du langage et de la syntaxe

Présentation des boucles do..while
Vous pouvez utiliser l’instruction do..while pour créer le même genre de boucle qu’avec une 
boucle while. Toutefois, dans une boucle do..while, l’expression est évaluée à la fin du bloc 
de code (après son exécution) et la boucle est toujours exécutée au moins une fois. 
Les instructions ne sont exécutées que lorsque la condition est true (vraie). 
Le code suivant présente un exemple simple de boucle do..while générant une sortie même 
lorsque la condition n’est pas remplie.
var i:Number = 5;
do {
trace(i);
i++;
} while (i < 5);
// Résultat : 5
Lorsque vous utilisez des boucles, faites attention à ne pas créer de boucle sans fin. Si la 
condition d’une boucle do..while renvoie true (vrai) en permanence, une boucle sans fin est 
créée et entraîne l’affichage d’un avertissement ou le blocage de Flash Player. Si vous 
connaissez le nombre d’itérations nécessaires, choisissez plutôt une boucle for. Pour plus 
d’informations et des exemples de l’instruction do..while, consultez le Guide de référence 
du langage ActionScript 2.0
.
Utilisation de boucles imbriquées dans le code ActionScript
L’exemple suivant décrit la construction d’un tableau d’objets et l’affichage de chaque valeur 
dans la structure imbriquée. Cet exemple présente l’utilisation de la boucle for pour effectuer 
une itération sur chaque élément du tableau et de la boucle  pour effectuer une 
itération sur chaque paire clé/valeur dans les objets imbriqués.
Pour imbriquer une boucle dans une autre :
1.
Créez un document Flash.
2. Choisissez Fichier > Enregistrer sous et nommez le document .
3. Ajoutez le code suivant à l’image 1 du scénario :
var myArr:Array = new Array();
myArr[0] = {name:"One", value:1};
myArr[1] = {name:"Two", value:2};
//
var i:Number;
var item:String;
for (i = 0; i < myArr.length; i++) {
trace(i);
for (item in myArr[i]) {
trace(item + ": " + myArr[i][item]);
}
trace("");
}
Présentation des instructions
131

4. Choisissez Contrôle > Tester l’animation pour tester votre code.
Les informations suivantes apparaissent dans le panneau de sortie.
0
name: One
value: 1
1
name: Two
value: 2
Comme vous connaissez le nombre d’éléments présents dans le tableau, vous pouvez 
utiliser une simple boucle for pour passer sur chaque élément. Chaque objet du tableau 
pouvant présenter des paires nom/valeur différentes, vous pouvez utiliser une boucle 
 pour effectuer une itération sur chaque valeur et afficher les résultats dans le 
panneau de sortie. 
Présentation des tableaux 
Un tableau est un objet dont les propriétés sont identifiées par des nombres représentant leurs 
positions dans la structure. Avant tout, un tableau est une liste d’éléments. Il est important de 
ne pas oublier que tous les éléments d’un tableau ne sont pas obligatoirement du même type 
de données. Vous pouvez combiner des nombres, des dates, des chaînes, des objets ou même 
ajouter un tableau imbriqué dans chaque index de tableau.
L’exemple suivant présente un simple tableau de noms de mois.
var myArr:Array = new Array();
myArr[0] = "January";
myArr[1] = "February";
myArr[2] = "March";
myArr[3] = "April";
Le tableau précédent de noms de mois peut également être réécrit comme suit :
var myArr:Array = new Array("January", "February", "March", "April");
Vous pouvez également utiliser une syntaxe abrégée :
var myArr:Array = ["January", "February", "March", "April"];
Un tableau correspond à une structure de données. On peut le comparer à un bâtiment au 
sein duquel chaque étage contiendrait un morceau de données différent (tel que la 
comptabilité au niveau 3 et l’ingénierie au niveau 5). Ainsi, il est possible de stocker des types 
de données différents, y compris d’autres tableaux, dans un même tableau. Chaque niveau du 
bâtiment peut contenir de nombreux types de contenus (la direction et la comptabilité peuvent 
partager le niveau 3). 
132
Eléments fondamentaux du langage et de la syntaxe

Le tableau contient des éléments, qui correspondent à chaque étage du bâtiment. Chaque 
élément occupe une position numérique (l’index), à laquelle vous faites référence dans le 
tableau. De la même façon, chaque niveau du bâtiment est associé à un numéro d’étage. 
Chaque élément peut contenir une part de données (un nombre, une chaîne, une valeur 
booléenne ou même un tableau ou un objet) ou être vide.  
Vous pouvez également contrôler et modifier le tableau lui-même. Par exemple, vous pouvez 
déménager le service d’ingénierie au rez-de-chaussée du bâtiment. Les tableaux vous 
permettent de déplacer les valeurs qu’ils contiennent et de modifier leur taille (disons de 
rénover le bâtiment et d’ajouter ou de supprimer des étages). Ainsi, vous pouvez ajouter ou 
supprimer des éléments et déplacer les valeurs vers d’autres éléments.
De ce fait, le bâtiment (tableau) contient des étages (éléments) numérotés (index), et chaque 
étage contient un ou plusieurs services (valeurs).
Pour plus d’informations sur la modification des tableaux, consultez la section des tableaux », à la page 135. Pour plus d’informations sur l’utilisation des tableaux et des 
index, consultez la section « Utilisation des tableaux », à la page 133. Pour plus d’informations 
sur l’ajout ou la suppression d’éléments, consultez la section d’éléments », à la page 137. Pour plus d’informations sur l’opérateur d’accès au tableau, 
consultez la section « Utilisation des opérateurs point et d’accès au tableau », à la page 153.
Pour un exemple de fichier source  qui décrit la manipulation des tableaux à l’aide du 
code ActionScript, consultez la page d’exemples Flash à l’adresse 
;Téléchargez et décompressez le fichier zip Exemples 
et naviguez jusqu’au dossier ActionScript2.0/Arrays afin d’accéder à l’exemple. Le code de cet 
exemple crée un tableau et trie, ajoute et supprime des éléments de deux composants List.
Utilisation des tableaux 
Vous pouvez utiliser des tableaux de différentes manières dans vos projets. Vous pouvez y 
stocker des listes d’objets, par exemple un lot d’articles renvoyés. Si vous chargez les données à 
partir de serveurs Web distants, vous pouvez même les recevoir sous forme de tableaux 
d’objets imbriqués. Les tableaux contiennent souvent des données de format similaire. 
Par exemple, si vous développez une application audio dans Flash, vous pouvez stocker la liste 
de lecture de l’utilisateur sous forme de tableau d’informations sur les chansons, stockées dans 
des objets. Chaque objet contient le titre du morceau, le nom de l’interprète, la durée de la 
chanson, l’emplacement du ficher audio (par exemple MP3) ou toute autre information 
devant être associée à un fichier particulier.
L’emplacement d’un élément au sein du tableau est appelé index. Tous les tableaux sont basés 
sur zéro, ce qui signifie que le premier élément du tableau est [0], le deuxième est [1], etc. 
Présentation des tableaux
133

Il existe différents types de tableaux, comme vous le découvrirez dans les sections suivantes. 
Les tableaux les plus courants utilisent un index numérique pour rechercher un élément 
particulier dans un tableau indexé. Le second type de tableau, appelé tableau associatif, recherche 
les informations à l’aide d’un index de texte, non numérique. Pour plus d’informations sur les 
tableaux les plus courants, consultez la section « Présentation des tableaux », à la page 132. 
Pour plus d’informations sur les tableaassociatifs », à la page 141. Pour plus d’informations sur les tableaux multidimensionnels, 
consultez la section « Création de tableaux multidimensionnels », à la page 138. Pour plus 
d’informations sur l’opérateur d’accès au tableau, consultez la sectpoint et d’accès au tableau », à la page 153. 
La classe intégrée Array vous permet d’accéder aux tableaux et de les manipuler. Pour créer un 
objet Array, utilisez le constructeur new Array() ou l’opérateur d’accès au tableau ([]). 
Pour accéder aux éléments d’un tableau, utilisez également l’opérateur d’accès ([]). L’exemple 
suivant utilise un tableau indexé.
Pour utiliser des tableaux dans votre code : 
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’Image 1 du scénario :
// définition d’un nouveau tableau
var myArr:Array = new Array();
// définition des valeurs de deux index
myArr[1] = "value1";
myArr[0] = "value0";
// itération sur les éléments du tableau
var i:String;
for (i in myArr) {
// suivi des paires clé/valeur
trace("key: " + i + ", value: " + myArr[i]);
}
Dans la première ligne de code ActionScript, vous définissez un nouveau tableau pour 
stocker les valeurs. Vous définissez ensuite les données (value0 et value1) sur deux index 
du tableau. Vous utilisez une boucle  pour faire une itération sur chaque élément 
de ce tableau et afficher les paires clé/valeur dans le panneau de sortie à l’aide d’une 
instruction trace.
3. Choisissez Contrôle > Tester l’animation pour tester votre code. 
Le texte suivant apparaît dans le panneau de sortie :
key: 0, value: value0
key: 1, value: value1
Pour plus d’informations sur les boucles , consultez la section boucles  », à la page 127.
134
Eléments fondamentaux du langage et de la syntaxe

Pour plus d’informations sur la création de types de tableaux différents, consultez les sections 
suivantes :
?
« Création de tableaux indexés », à la page 137
?
« Création de tableaux multidimensionnels », à la page 138
?
« Création de tableaux associatifs », à la page 141
Pour un exemple de fichier source  qui décrit la manipulation des tableaux à l’aide du 
code ActionScript, consultez la page d’exemples Flash à l’adresse 
Téléchargez et décompressez le fichier zip Exemples 
et naviguez jusqu’au dossier ActionScript2.0/Arrays afin d’accéder à l’exemple. Le code de cet 
exemple crée un tableau et trie, ajoute et supprime des éléments de deux composants List.
Modification des tableaux 
Vous pouvez également contrôler et modifier un tableau avec ActionScript. Vous pouvez 
déplacer des valeurs dans le tableau ou modifier la taille de celui-ci. Par exemple, pour 
échanger les données de deux index d’un tableau, vous pouvez utiliser le code suivant :
var buildingArr:Array = new Array();
buildingArr[2] = "Accounting";
buildingArr[4] = "Engineering";
trace(buildingArr); // undefined,undefined,Accounting,undefined,Engineering
var temp_item:String = buildingArr[2];
buildingArr[2] = buildingArr[4];
buildingArr[4] = temp_item;
trace(buildingArr); // undefined,undefined,Engineering,undefined,Accounting
Vous vous demandez peut-être pourquoi vous avez dû créer une variable temporaire dans 
l’exemple précédent. En fait, la copie du contenu de l’index 4 du tableau dans l’index 2 et vice 
versa, aurait entraîné la perte du contenu original de l’index 2 du tableau. En copiant la valeur 
de l’un des index dans une variable temporaire, vous enregistrez la valeur et la recopiez ensuite 
dans votre code. Par exemple, si vous utilisez le code suivant, vous pouvez voir que la valeur de 
l’index 2 du tableau (Accounting) a été perdue. Vous avez maintenant deux équipes 
d’ingénieurs mais plus de comptables.
// méthode incorrecte (pas de variable temporaire)
buildingArr[2] = buildingArr[4];
buildingArr[4] = buildingArr[2];
trace(buildingArr); // 
undefined,undefined,Engineering,undefined,Engineering
Pour un exemple de fichier source  qui décrit la manipulation des tableaux à l’aide du 
code ActionScript, consultez la page d’exemples Flash à l’adresse 
Téléchargez et décompressez le fichier zip Exemples 
et naviguez jusqu’au dossier ActionScript2.0/Arrays afin d’accéder à l’exemple. Le code de cet 
exemple crée un tableau et trie, ajoute et supprime des éléments de deux composants List.
Présentation des tableaux
135

Référencement et recherche de longueur
Pour manipuler les tableaux, il est souvent nécessaire de connaître le nombre d’éléments qu’ils 
contiennent. Cette information se révèle très utile pour l’écriture des boucles for chargées 
d’effectuer une itération sur chaque élément du tableau et d’exécuter une série d’instructions. 
Le code suivant en est un exemple :
var monthArr:Array = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", 
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
trace(monthArr); // Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec
trace(monthArr.length); // 12
var i:Number;
for (i = 0; i < monthArr.length; i++) {
monthArr[i] = monthArr[i].toUpperCase();
}
trace(monthArr); // JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC
Dans l’exemple précédent, vous créez un tableau et le remplissez avec les noms de mois. 
Le contenu est affiché, de même que la longueur du tableau. Une boucle for fait une itération 
sur chaque élément du tableau, met la valeur en majuscule, et le contenu du tableau est affiché 
de nouveau.
Dans le code ActionScript suivant, si vous créez un élément à l’index 5 d’un tableau, la 
longueur du tableau renvoie 6 (le tableau étant basé sur zéro), et non le nombre réel 
d’éléments du tableau auquel vous vous attendiez :
var myArr:Array = new Array();
myArr[5] = "five";
trace(myArr.length); // 6
trace(myArr); // undefined,undefined,undefined,undefined,undefined,five
Pour plus d’informations sur les boucles for, consultez la section for », à la page 126. Pour plus d’informations sur l’opérateur d’accès au tableau, consultez la 
section « Utilisation des opérateurs point et d’accès au tableau », à la page 153.
Pour un exemple de fichier source  qui décrit la manipulation des tableaux à l’aide du 
code ActionScript, consultez la page d’exemples Flash à l’adresse 
;Téléchargez et décompressez le fichier zip Exemples 
et naviguez jusqu’au dossier ActionScript2.0/Arrays afin d’accéder à l’exemple. Le code de cet 
exemple crée un tableau et trie, ajoute et supprime des éléments de deux composants List.
136
Eléments fondamentaux du langage et de la syntaxe

Ajout et suppression d’éléments
Chaque élément d’un tableau occupe une position numérique (l’index), à laquelle vous faites 
référence. Chaque élément peut contenir des données ou être vide. Un élément peut contenir 
les données suivantes : un nombre, une chaîne, une valeur booléenne ou encore un tableau ou 
un objet.
Lorsque vous créez des éléments dans un tableau, il est préférable, dans la mesure du possible, 
de créer les index en séquence. Le débogage de vos applications s’en trouvera simplifié. A la 
section « Référencement et recherche de longueur », à la page 136, vous avez vu que si vous 
affectez une seule valeur à l’index 5 d’un tableau, la longueur du tableau renvoie 6. 
Cinq valeurs indéfinies sont alors insérées dans le tableau.
L’exemple suivant décrit la création d’un nouveau tableau, la suppression d’un élément au 
niveau d’un index particulier et l’ajout et le remplacement des données d’un index du 
tableau :
var monthArr:Array = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", 
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
delete monthArr[5];
trace(monthArr); // Jan,Feb,Mar,Apr,May,undefined,Jul,Aug,Sep,Oct,Nov,Dec
trace(monthArr.length); // 12
monthArr[5] = "JUN";
trace(monthArr); // Jan,Feb,Mar,Apr,May,JUN,Jul,Aug,Sep,Oct,Nov,Dec
Bien que vous ayez supprimé l’élément à l’index 5, la longueur du tableau demeure 12 car 
l’élément de l’index 5 n’a pas entièrement disparu mais a été remplacé par une chaîne vide.
Pour un exemple de fichier source  qui décrit la manipulation des tableaux à l’aide du 
code ActionScript, consultez la page d’exemples Flash à l’adrlearn_fl_samples_fr. Téléchargez et décompressez le fichier zip Exemples et naviguez jusqu’au 
dossier ActionScript2.0/Arrays afin d’accéder à l’exemple. Le code de cet exemple crée un 
tableau et trie, ajoute et supprime des éléments de deux composants List.
Création de tableaux indexés
Les tableaux indexés stockent des suites d’une ou plusieurs valeurs. Vous pouvez rechercher les 
éléments par leur position dans le tableau, ce que vous avez peut-être fait dans les sections 
précédentes. Le premier index correspond toujours au nombre 0. L’index est ensuite 
incrémenté d’une unité pour chaque élément ajouté consécutivement au tableau. Vous pouvez 
créer un tableau indexé en appelant le constructeur de classe Array ou en initialisant le tableau 
avec un littéral de tableau. L’exemple suivant permet de créer des tableaux à l’aide du 
constructeur Array et d’un littéral de tableau.
Présentation des tableaux
137

Pour créer un tableau indexé :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’Image 1 du scénario :
var myArray:Array = new Array();
("one");
("two");
("three");
trace(myArray); // one,two,three
Dans la première ligne de code ActionScript, vous définissez un nouveau tableau pour 
stocker les valeurs. 
3. Choisissez Contrôle > Tester l’animation pour tester votre code. 
Le texte suivant apparaît dans le panneau de sortie :
one,two,three
4. Revenez dans l’outil de programmation, puis supprimez le code dans le panneau Actions.
5. Ajoutez le code ActionScript suivant à l’Image 1 du scénario :
var myArray:Array = ["one", "two", "three"];
trace(myArray); // one,two,three
Dans ce code, vous utilisez le littéral de tableau pour définir un nouveau tableau pour 
votre code. Ce code est similaire à celui que vous avez écrit à l’étape 2. Lorsque vous le 
testez, le même résultat apparaît dans le panneau de sortie.  
Création de tableaux multidimensionnels
ActionScript permet d’implémenter des tableaux imbriqués correspondant avant tout à des 
tableaux de tableaux. Les tableaux imbriqués, également appelés tableaux multidimensionnels
sont considérés comme des matrices ou des grilles. Lorsque vous programmez, vous pouvez 
utiliser les tableaux multidimensionnels pour reproduire ce type de structures. Par exemple, 
un échiquier est une grille de huit colonnes et huit lignes qui peut être reproduit sous forme 
de tableau contenant huit éléments, chacun d’eux correspondant également à un tableau 
contenant huit éléments.
Prenons par exemple une liste de tâches stockée sous forme de tableau indexé de chaînes :
var tasks:Array = ["wash dishes", "take out trash"];
Pour stocker une liste de tâches distincte pour chaque jour de la semaine, vous pouvez créer 
un tableau multidimensionnel avec un élément pour chaque jour. Chaque élément contient à 
son tour un tableau indexé qui stocke la liste des tâches. 
ATTEN
Lorsque vous utilisez l’opérateur d’accès au tableau, le compilateur ActionScript ne peut 
pas vérifier si l’élément auquel vous avez accédé est une propriété valable de l’objet.
T
ION
138
Eléments fondamentaux du langage et de la syntaxe

Pour créer un tableau multidimensionnel de base et récupérer les éléments du 
tableau :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’Image 1 du scénario :
var twoDArray:Array = new Array(new Array("one","two"), new 
Array("three", "four"));
trace(twoDArray);
Ce tableau, twoDArray, se compose de deux éléments. Ces éléments sont eux-mêmes des 
tableaux de deux éléments. Dans ce cas, twoDArray est le tableau principal qui contient 
deux tableaux imbriqués.
3. Choisissez Contrôle > Tester l’animation pour tester le code. Les informations suivantes 
apparaissent dans le panneau de sortie :
one,two,three,four
4. Reprenez l’outil de programmation et ouvrez le panneau Actions. Commentez l’instruction 
trace, comme suit :
// trace(twoDArray);
5. Ajoutez le code ActionScript suivant à la suite de votre code dans l’image 1 du scénario :
trace(twoDArray[0][0]); // un
trace(twoDArray[1][1]); // quatre
Pour récupérer les éléments d’un tableau multidimensionnel, utilisez plusieurs opérateurs 
d’accès ([]) après le nom du tableau de niveau supérieur. Le premier opérateur [] fait 
référence à l’index du tableau de niveau supérieur. Les opérateurs d’accès au tableau 
suivants font référence aux éléments des tableaux imbriqués. 
6. Choisissez Contrôle > Tester l’animation pour tester le code. Les informations suivantes 
apparaissent dans le panneau de sortie :
one
four
Vous pouvez utiliser des boucles for imbriquées pour créer des tableaux multidimensionnels. 
L’exemple suivant décrit cette procédure.
Présentation des tableaux
139

Pour créer un tableau multidimensionnel à l’aide d’une boucle for : 
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’Image 1 du scénario :
var gridSize:Number = 3;
var mainArr:Array = new Array(gridSize);
var i:Number;
var j:Number;
for (i = 0; i < gridSize; i++) {
mainArr[i] = new Array(gridSize);
for (j = 0; j < gridSize; j++) {
mainArr[i][j] = "[" + i + "][" + j + "]";
}
}
trace(mainArr);
Ce code ActionScript crée un tableau 3 x 3 et définit la valeur de chaque noeud sur son 
index. Vous suivez ensuite le tableau (mainArr).
3. Choisissez Contrôle > Tester l’animation pour tester le code. 
Les informations suivantes apparaissent dans le panneau de sortie :
[0][0],[0][1],[0][2],[1][0],[1][1],[1][2],[2][0],[2][1],[2][2]
Vous pouvez également utiliser des boucles for imbriquées pour effectuer une itération sur les 
éléments d’un tableau multidimensionnel, comme l’illustre l’exemple suivant. 
Pour utiliser une boucle for pour effectuer une itération sur un tableau 
multidimensionnel :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’Image 1 du scénario :
// De l’exemple précédent
var gridSize:Number = 3;
var mainArr:Array = new Array(gridSize);
var i:Number;
var j:Number;
for (i = 0; i < gridSize; i++) {
mainArr[i] = new Array(gridSize);
for (j = 0; j < gridSize; j++) {
mainArr[i][j] = "[" + i + "][" + j + "]";
}
}
Dans ce code, issu de l’exemple précédent, la boucle extérieure effectue une itération sur 
chaque élément de  mainArray. La boucle intérieure effectue une itération sur chaque 
tableau imbriqué et renvoie chaque nœud du tableau.
140
Eléments fondamentaux du langage et de la syntaxe

3. Ajoutez le code ActionScript suivant dans l’image 1 du scénario, à la suite du code saisi à 
l’étape 2 :
// Itération sur les éléments
var outerArrayLength:Number = mainArr.length;
for (i = 0; i < outerArrayLength; i++) {
var innerArrayLength:Number = mainArr[i].length;
for (j = 0; j < innerArrayLength; j++) {
trace(mainArr[i][j]);
}
}
Ce code ActionScript effectue une itération sur les éléments du tableau. Vous utilisez la 
propriété length de chaque tableau comme condition de la boucle.
4. Choisissez Contrôle > Tester l’animation pour voir les éléments qui apparaissent dans le 
panneau de sortie. Les informations suivantes apparaissent dans le panneau de sortie :
[0][0]
[0][1]
[0][2]
[1][0]
[1][1]
[1][2]
[2][0]
[2][1]
[2][2]
Pour plus d’informations sur l’utilisation des tableaux, consultez la sectiontableaux », à la page 133. Pour plus d’informations sur les éléments de tableaux, consultez la 
section « Ajout et suppression d’éléments », à la page 137. Pour plus d’informations sur 
l’opérateur d’accès au tableau, consultez la section au tableau », à la page 153.
Création de tableaux associatifs
Un tableau associatif, similaire à un objet, se compose de clés et de valeurs non triées. 
Pour organiser les valeurs stockées, les tableaux associatifs utilisent des clés à la place des index 
numériques. Chaque clé est une chaîne unique et n’est associée et utilisée que pour accéder à 
une seule valeur. Le type des données de cette valeur peut être Number, Array, Object, etc. 
Lorsque vous créez du code pour rechercher la valeur associée à une clé, vous indexez ou 
effectuez une recherche. Vous utiliserez probablement les tableaux associatifs dans cet objectif. 
Présentation des tableaux
141

L’association entre une clé et une valeur est généralement appelée liaison. La clé et la valeur 
sont mises en correspondance. Par exemple, un carnet d’adresses peut être considéré comme un 
tableau associatif, les noms étant les clés et les adresses de messagerie les valeurs.
REMARQUE
Les tableaux associatifs sont des collections non triées de paires de clés et de valeurs. 
Votre code ne doit pas s’attendre à ce que les clés d’un tel tableau se présentent dans un 
ordre précis.
Lorsque vous utilisez des tableaux associatifs, vous pouvez appeler l’élément désiré à l’aide 
d’une chaîne plutôt que d’un nombre, souvent plus simple à mémoriser. L’inconvénient est 
que ces tableaux ne sont pas très utiles dans une boucle car ils n’utilisent pas de nombre 
comme valeur d’index. Ils sont cependant très utiles lorsque vous avez fréquemment besoin de 
faire des recherches par valeurs de clés. Par exemple, dans le cas d’un tableau de noms et d’âges 
très sollicité, vous pouvez utiliser un tableau associatif.
L’exemple suivant décrit la création d’un objet et la définition d’une série de propriétés dans 
un tableau associatif.
Pour créer un tableau associatif simple :
1.
Créez un document Flash.
2. Saisissez le code ActionScript suivant sur l’image 1 du scénario :
// Définition de l’objet à utiliser comme tableau associatif.
var someObj:Object = new Object();
// Définition d’une série de propriétés.
someObj.myShape = "Rectangle";
= 480;
= 360;
= 100;
= 200;
someObj.myAlpha = 72;
someObj.myColor = 0xDFDFDF;
// Affichage d’une propriété à l’aide d’un opérateur point et de 
// la syntaxe d’accès au tableau.
trace(someObj.myAlpha); // 72
trace(someObj["myAlpha"]); // 72
La première ligne de code ActionScript définit un nouvel objet (someObj) utilisé comme 
tableau associatif. Ensuite, vous définissez une série de propriétés dans someObj. 
Pour finir, vous affichez une propriété sélectionnée à l’aide d’un opérateur point et de la 
syntaxe d’accès au tableau.
REMA
Deux méthodes permettent d’accéder aux variables d’un tableau associatif : la syntaxe 
à point (someObj.myColor) et la syntaxe de tableau (someObj[‘myColor’]).
R
Q
UE
142
Eléments fondamentaux du langage et de la syntaxe

3. Choisissez Contrôle > Tester l’animation pour tester votre code ActionScript.
Le panneau de sortie affiche le nombre 72 à deux reprises, représentant les deux niveaux 
alpha que vous avez suivis.
Deux méthodes permettent de créer des tableaux associatifs dans ActionScript 2.0 :
?
Utiliser un constructeur Object
?
Utiliser un constructeur Array
Les deux méthodes sont présentées dans les exemples suivants.
REMARQUE
L’exemple précédent utilisait un constructeur Object pour créer le tableau associatif.
Si vous créez un tableau associatif via un constructeur Object, vous profiter de l’initialisation 
de votre tableau à l’aide d’un littéral d’objet. Une occurrence de la classe Object, également 
appelée objet générique, présente le même fonctionnement qu’un tableau associatif. En fait, 
les occurrences Object sont essentiellement des tableaux associatifs. Vous pouvez utiliser ces 
tableaux pour des fonctions de type dictionnaire, lorsque les clés de chaîne sont plus pratiques 
que les index numériques. Chaque nom de propriété de l’objet générique devient la clé qui 
permet d’accéder à une valeur stockée. Pour plus d’informations sur les littéraux, consultez la 
section « Présentation des littéraux », à la page 99. Pour plus d’informations sur les classes, 
consultez le Chapitre 6, « Classes », à la page 197.
Pour créer un tableau associatif à l’aide d’un constructeur Object :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’Image 1 du scénario :
var monitorInfo:Object = {type:"Flat Panel", resolution:"1600 x 1200"};
trace(monitorInfo["type"] + ", " + monitorInfo["resolution"]); 
Ce code crée un tableau associatif appelé monitorInfo et utilise un littéral d’objet pour 
initialiser le tableau avec deux paires clé/valeur. 
REMA
Si vous n’avez pas besoin d’initialiser le tableau lors de la déclaration, vous pouvez 
utiliser le constructeur Object pour créer le tableau.
R
Q
UE
var monitorInfo:Object = new Object();
Présentation des tableaux
143

3. Choisissez Contrôle> Tester l’animation. 
Le panneau de sortie affiche le texte suivant :
Flat Panel, 1600 x 1200
4. Ajoutez le code ActionScript suivant dans l’image 1 du scénario, à la suite du code saisi 
précédemment :
monitorInfo["aspectRatio"] = "16:10";
monitorInfo.colors = "16.7 million";
trace(monitorInfo["aspectRatio"] + ", " + monitorInfo.colors);
Après avoir créé le tableau à l’aide d’un littéral d’objet ou d’un constructeur de classe 
Object, vous pouvez lui ajouter de nouvelles valeurs en utilisant l’opérateur crochets ([]) 
ou l’opérateur point (.), comme l’illustre le code suivant. Le code que vous venez de saisir 
ajoute deux nouvelles valeurs au tableau monitorInfo.
5. Choisissez Contrôle > Tester l’animation. 
Le panneau de sortie affiche le texte suivant :
16:10, 16.7 million
Remarquez que les clés peuvent contenir des espaces. Cela est possible dans le cas de 
l’opérateur crochets, mais génère une erreur avec l’opérateur point. L’utilisation d’espace 
dans le nom de vos clés n’est donc pas conseillée. Pour plus d’informations sur les 
opérateurs crochets et point, consultez la section la page 145. Pour plus d’informations sur le code correctement formaté, consultez la 
section « Mise en forme de la syntaxe ActionScript », à la page 750.
Le second moyen pour créer un tableau associatif consiste à utiliser le constructeur Array, puis 
l’opérateur crochets ([]) ou point (.) pour ajouter les paires de clé/valeur dans le tableau. 
Si vous déclarez votre tableau associatif comme étant de type Array, vous ne pouvez pas utiliser 
de littéral d’objet pour l’initialiser. 
RE
L’utilisation du constructeur Array pour créer un tableau associatif ne présente aucun 
MA
avantage. Ce constructeur convient mieux à la création des tableaux indexés.
R
Q
UE
L’exemple suivant présente l’utilisation du constructeur Array pour créer un tableau associatif.
144
Eléments fondamentaux du langage et de la syntaxe

Pour créer un tableau associatif à l’aide du constructeur Array :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’Image 1 du scénario :
var monitorInfo:Array = new Array();
monitorInfo["type"] = "Flat Panel";
monitorInfo["resolution"] = "1600 x 1200";
trace(monitorInfo["type"] + ", " + monitorInfo["resolution"]);
Ce code crée un tableau associatif appelé monitorInfo à l’aide du constructeur Array et 
ajoute les clés appelées type et resolution, avec leurs valeurs.
3. Choisissez Contrôle > Tester l’animation. 
Le panneau de sortie affiche le texte suivant :
Flat Panel, 1600 x 1200
REMARQUE
L’utilisation du constructeur Array pour créer un tableau associatif ne présente aucun 
avantage. Ce constructeur convient mieux à la création des tableaux indexés.
Les tableaux associatifs sont essentiellement des occurrences de la classe Object et l’utilisation 
du constructeur Array pour créer des tableaux associatifs ne présente aucun avantage. Même si 
vous créez un tableau associatif à l’aide du constructeur new Array(), vous ne pouvez utiliser 
aucune méthode ou propriété de la classe Array (telle que sort() ou length) lorsque vous 
utilisez un tableau associatif. Si vous souhaitez utiliser des paires clé/valeur au lieu d’un index 
numérique, vous devez utiliser la classe Object et non un tableau associatif.
Présentation des opérateurs
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é.
Les opérateurs sont des caractères qui spécifient comment combiner, comparer ou modifier les 
valeurs d’une expression. Une expression est une instruction que Flash peut évaluer et qui 
renvoie une valeur. Pour créer une expression, vous pouvez associer des opérateurs et des 
valeurs ou appeler une fonction. Pour plus d’informations sur les expressions, consultez la 
section « Présentation de la syntaxe, des instructions et des expressions », à la page 82.
Présentation des opérateurs
145

Une expression mathématique, par exemple, utilise des opérateurs numériques pour 
manipuler les valeurs que vous utilisez. +, <, * et = sont des exemples d’opérateurs. 
Une expression se compose d’opérateurs et d’opérandes. Elle désigne toute combinaison valide 
de symboles ActionScript représentant une valeur. Un opérande est une partie du code sur 
laquelle l’opérateur exécute une action. Par exemple, dans l’expression x + 2, x et 2 sont des 
opérandes et + est un opérateur.
Dans votre code, vous utilisez fréquemment des expressions et des opérateurs. Pour créer une 
expression, vous pouvez associer des opérateurs et des valeurs ou appeler une fonction.
REMARQUE
Cette section décrit brièvement l’utilisation de chaque type d’opérateur. Pour plus 
d’informations sur chaque opérateur, y compris les opérateurs spéciaux qui ne font pas 
partie des catégories suivantes, consultez le Guide de référence du langage 
ActionScript 2.0
.
Les parties de votre code sur lesquelles les opérateurs agissent sont appelés opérandes
Vous pouvez utiliser l’opérateur d’addition (+) pour ajouter des valeurs à un littéral 
numérique, par exemple pour ajouter la valeur d’une variable appelée myNum. 
myNum + 3;
Dans cet exemple, myNum et 3 sont des opérandes. 
Cette section décrit les règles générales qui régissent les types courants d’opérateurs, leur 
priorité et leur associativité.
?
« Utilisation d’opérateurs pour manipuler les valeurs », à la page 147
?
« Priorité et associativité des opérateurs », à la page 149
?
« Utilisation d’opérateurs avec des chaînes », à la page 151
?
« Utilisation des opérateurs point et d’accès au tableau », à la page 153
?
« Présentation des opérateurs de suffixe », à la page 155
?
« Présentation des opérateurs unaires », à la page 156
?
« Présentation des opérateurs de multiplication », à la page 156
?
« Présentation des opérateurs d’ajout », à la page 157
?
« Utilisation des opérateurs numériques », à la page 157
?
« Présentation des opérateurs relationnels », à la page 158
?
« Présentation des opérateurs d’égalité », à la page 159
?
« Utilisation des opérateurs relationnels et d’égalité », à la page 159
?
« Présentation des opérateurs d’affectation », à la page 162
?
« Utilisation des opérateurs d’affectation », à la page 163
?
« Présentation des opérateurs logiques », à la page 163
146
Eléments fondamentaux du langage et de la syntaxe

?
« Utilisation des opérateurs logiques », à la page 164
?
« Présentation des opérateurs de décalage au niveau du bit », à la page 165
?
« Présentation des opérateurs logiques au niveau du bit », à la page 166
?
« Utilisation des opérateurs au niveau du bit », à la page 166
?
« Présentation de l’opérateur conditionnel », à la page 168
?
« Utilisation des opérateurs dans un document », à la page 168
Pour plus d’informations sur les opérateurs qui n’entrent pas dans ces catégories, consultez le 
Guide de référence du langage ActionScript 2.0, qui contient des informations sur tous les 
opérateurs disponibles. 
Les sections suivantes présentent quelques utilisations courantes des opérateurs. Pour plus 
d’informations sur l’utilisation de plusieurs opérateurs dans un même code, consultez la 
section « Utilisation des opérateurs dans un document », à la page 168.
Utilisation d’opérateurs pour manipuler les valeurs 
Les opérateurs sont souvent utilisés pour manipuler des valeurs dans Flash. Par exemple, vous 
pouvez créer un jeu dans lequel le score change selon les interactions de l’utilisateur avec les 
occurrences de la scène. Vous pouvez utiliser une variable pour stocker la valeur et des 
opérateurs pour manipuler la valeur de la variable.
Par exemple, vous pouvez augmenter la valeur d’une variable appelée myScore. L’exemple 
suivant décrit l’utilisation des opérateurs + (addition) et += (affectation d’addition) pour 
ajouter et incrémenter des valeurs de votre code.
Pour manipuler les valeurs à l’aide d’opérateurs :
1.
Créez un document Flash.
2. Ouvrez le panneau Actions (Fenêtre > Actions) et saisissez le code suivant dans la fenêtre 
de script :
// Exemple un
var myScore:Number = 0;
myScore = myScore + 1;
trace("Example one: " + myScore); // 1
// Exemple deux
var secondScore:Number = 1;
secondScore += 3;
trace("Example two: " + secondScore); // 4
Présentation des opérateurs
147

3. Choisissez Contrôle > Tester l’animation. 
Le panneau de sortie affiche le texte suivant :
Example one: 1
Example two: 4
L’opérateur d’addition est très simple car il se contente d’additionner deux valeurs. Dans le 
premier exemple de code, il additionne la valeur actuelle de myScore avec le nombre 1, 
puis stocke le résultat dans la variable myScore.
Le deuxième exemple de code utilise l’opérateur d’affectation d’addition pour ajouter et 
affecter une nouvelle valeur dans la même étape. Vous pouvez réécrire la ligne myScore = 
myScore + 1 (de l’exercice précédent) sous la forme myScore++ ou encore myScore += 1. 
L’opérateur d’incrémentation (++) est un moyen simple de dire myScore = myScore + 1, car 
il traite simultanément une incrémentation et une affectation. Vous pouvez voir un exemple 
de ce type d’opérateur dans le code ActionScript suivant :
var myNum:Number = 0;
myNum++;
trace(myNum); // 1
myNum++;
trace(myNum); // 2
Notez que le code précédent ne contient pas d’opérateur d’affectation, mais repose sur un 
opérateur d’incrémentation.
Vous pouvez manipuler la valeur d’une variable à l’aide d’opérateurs tant qu’une condition est 
true (vraie). Par exemple, vous pouvez utiliser l’opérateur d’incrémentation (++) pour 
incrémenter la variable i tant que la condition est vraie. Dans le code suivant, la condition est 
true tant que i est inférieur à 10. Tant que cette condition est vraie, i est incrémenté d’une 
unité via i++.
var i:Number;
for (i = 1; i < 10; i++) {
trace(i);
}
Le panneau de sortie affiche les nombres 1 à 9, c’est-à-dire i dont la valeur est incrémentée 
jusqu’à ce que la condition de fin soit atteinte (i égale 10). La dernière valeur affichée est 9. 
De ce fait, la valeur de i est 1 lorsque la lecture du fichier SWF commence, puis 9 à la fin 
du suivi.
Pour plus d’informations sur les conditions et les boucles, consultez la sectiodes instructions », à la page 109.
148
Eléments fondamentaux du langage et de la syntaxe

Priorité et associativité des opérateurs
Lorsque plusieurs opérateurs sont utilisés dans la même instruction, certains sont prioritaires 
par rapport à d’autres. La priorité et l’associativité des opérateurs déterminent leur ordre de 
traitement. La hiérarchie d’ActionScript détermine l’ordre d’exécution des opérateurs. 
Le tableau décrivant cette hiérarchie est présenté à la fin de cette section. 
Bine qu’il soit évident, pour ceux qui connaissent bien l’arithmétique ou la programmation de 
base, que le compilateur traite l’opérateur de multiplication (*) avant l’opérateur d’addition 
(+), le compilateur a besoin d’instructions claires quant à l’ordre à appliquer aux opérateurs. 
L’ensemble de ces instructions est appelé ordre de priorité des opérateurs.
L’utilisation des opérateurs de multiplication et d’addition constitue un exemple de priorité 
des opérateurs :
var mySum:Number;
mySum = 2 + 4 * 3;
trace(mySum); // 14
Le résultat de cette instruction est 14, car la multiplication est prioritaire. Ainsi, 4 * 3 est 
d’abord calculé, puis 2 est ajouté au résultat.
Vous pouvez contrôler l’ordre des opérations en plaçant les expressions entre parenthèses. 
ActionScript définit une priorité par défaut que l’opérateur parenthèses (()) permet de 
modifier. Si l’addition est mise entre parenthèses, ActionScript l’effectue en premier :
var mySum:Number;
mySum = (2 + 4) * 3;
trace(mySum); // 18
Dans ce cas, le résultat est 18.
Il est également possible que des opérateurs aient la même priorité. Dans ce cas, l’associativité 
détermine leur ordre d’exécution. L’associativité peut aller de gauche à droite ou de droite à 
gauche.
Examinons de nouveau l’opérateur de multiplication. Comme il présente une associativité de 
gauche à droite, les deux instructions sont identiques.
var mySum:Number;
var myOtherSum:Number;
mySum = 2 * 4 * 3;
myOtherSum = (2 * 4) * 3;
trace(mySum); // 24
trace(myOtherSum); // 24
Présentation des opérateurs
149

Il arrive que plusieurs opérateurs de même priorité apparaissent dans la même expression. 
Dans ce cas, le compilateur utilise les règles d’associativité pour identifier le premier opérateur 
à traiter. Tous les opérateurs binaires, sauf les opérateurs d’affectation, sont associatifs gauche
ce qui signifie que les opérateurs de gauche sont traités avant ceux de droite. Les opérateurs 
d’affectation et l’opérateur conditionnel (?:) sont associatifs droit, ce qui signifie que les 
opérateurs de droite sont traités avant ceux de gauche. Pour plus d’informations sur 
l’affectation des opérateurs, consultez la sla page 163. Pour plus d’informations sur l’opérateur conditionnel, consultez la section 
« Présentation de l’opérateur conditionnel », à la page 168.
Prenons par exemple les opérateurs inférieur à (<) et supérieur à (>), qui ont le même ordre de 
priorité. Lorsque les deux opérateurs sont employés dans la même expression, celui de gauche 
est traité en premier puisque tous deux sont associatifs gauche. Cela signifie que les deux 
instructions suivantes donnent le même résultat :
trace(3 > 2 < 1);   // false
trace((3 > 2) < 1); // false
L’opérateur supérieur à (>) est traité en premier, donnant un résultat true puisque l’opérande 
3 est supérieur à l’opérande 2. La valeur true est alors transmise à l’opérateur inférieur à (<), 
avec l’opérande 1. L’opérateur inférieur à (<) convertit la valeur true en valeur numérique 1 et 
compare cette valeur au second opérande 1 pour renvoyer la valeur false (la valeur 1 n’est pas 
inférieure à 1).
N’oubliez pas l’ordre des opérandes dans votre code ActionScript, en particulier lorsque vous 
élaborez des conditions complexes et que vous savez combien de fois elles sont vraies. 
Par exemple, si vous savez que i sera supérieur à 50 dans votre condition, vous devez 
commencer par écrire i<50. Ce chiffre sera ainsi vérifié en premier et la seconde condition 
écrite n’a pas besoin d’être vérifiée systématiquement.
Le tableau suivant présente les opérateurs d’ActionScript 2.0 par ordre décroissant de priorité. 
Chaque ligne du tableau contient des opérateurs de même priorité. Chaque ligne d’opérateurs 
a une priorité supérieure à la ligne située juste après dans le tableau. Pour plus d’informations 
et des recommandations d’utilisation des opérateurs et des parenthèses, consultez le 
Chapitre 17, « Mise en forme de la syntaxe ActionScript », à la page 750.
Groupe
opérateurs
Primaire
[] {x:y} () f(x) new x.y x[y]
Suffixe
x++ x--
Unaire
++x --x + - ~ ! delete typeof void
De multiplication
* / %
Additive
+ -
150
Eléments fondamentaux du langage et de la syntaxe

Groupe
opérateurs
Décalage au niveau 
<< >> >>>
du bit
Relationnels
< > <= >= instanceof 
Egalité
== != === !==
AND au niveau du bit
&
XOR au niveau du bit
^
OR au niveau du bit
|
AND logique
&&
OR logique
||
Conditionnelle
?:
Affectation
= *= /= %= += -= <<= >>= >>>= &= ^= |=
Virgule
,
Utilisation d’opérateurs avec des chaînes
Si deux types de données sont différents, les opérateurs de comparaison convertissent le type 
d’un opérande pour le faire correspondre au type de l’autre opérande. Si un seul opérande est 
une chaîne et que l’autre est un nombre, ActionScript convertit l’opérande de chaîne en 
nombre et effectue une comparaison numérique. Cette règle a une exception : l’opérateur 
d’égalité stricte (===) qui se comporte de la même façon que l’opérateur d’égalité (==), à la 
différence que les types de données ne sont pas convertis. Le résultat est true lorsque les deux 
expressions sont égales, types de données inclus. Pour plus d’informations sur les opérateurs 
numériques, consultez la section « Utilisation des opérateurs numériques », à la page 157.
A l’exception de l’opérateur d’égalité (==), les opérateurs de comparaison (>, >=, < et <=) 
n’affectent pas les chaînes de la même façon que les autres valeurs. 
Ces opérateurs comparent les chaînes pour déterminer celle qui apparaît en premier dans 
l’ordre alphabétique. Les chaînes en majuscules ont priorité sur celles qui sont en minuscules. 
Cela signifie que le terme « Egg » vient avant « chicken ».
var c:String = "chicken";
var e:String = "Egg";
trace(c < e); // false
var riddleArr:Array = new Array(c, e);
trace(riddleArr); // chicken,Egg
trace(()); // Egg,chicken
Présentation des opérateurs
151

Dans ce code ActionScript, la méthode sort() de la classe Array trie le contenu du tableau 
dans l’ordre alphabétique. Vous voyez alors que la valeur « Egg » vient avant la valeur 
« chicken » car la majuscule E vient avant la minuscule c. Pour comparer des chaînes 
indépendamment de la casse, vous devez les convertir en majuscules ou en minuscules avant la 
comparaison. Pour plus d’informations sur les opérateurs de comparaison, consultez les 
sections relationnels et d’égalité », à la page 159. 
Les méthodes toLowerCase() ou toUpperCase() permettent de convertir les chaînes en une 
même casse avant de les comparer. Dans l’exemple suivant, les deux chaînes sont converties en 
minuscules puis comparées. Le terme « chicken » vient maintenant avant « egg » :
var c:String = "chicken";
var e:String = "Egg";
trace(c.toLowerCase() < e.toLowerCase()); // true
REMARQUE
Les opérateurs de comparaison ne comparent que deux chaînes. Par exemple, ils ne 
comparent pas les valeurs lorsqu’un opérande est une valeur numérique. Si l’un des 
opérandes est une chaîne, ActionScript convertit les deux opérandes en nombres et 
effectue une comparaison numérique. 
Les opérateurs permettent de manipuler des chaînes. Vous pouvez utiliser l’opérateur 
d’addition (+) pour concaténer deux opérandes de chaînes. Vous avez peut-être déjà fait cette 
opération si vous avez écrit des instructions trace. Par exemple, vous pouvez écrire le code 
suivant :
var myNum:Number = 10;
trace("The variable is " +  myNum + ".");
Lorsque vous testez le code, le résultat suivant s’affiche dans le panneau de sortie :
The variable is 10.
Dans l’exemple précédent, l’instruction trace utilise l’opérateur + pour concaténer au lieu 
d’additionner. Lorsque vous manipulez des chaînes et des nombres, Flash préfère parfois 
concaténer plutôt qu’additionner numériquement.
Par exemple, vous pouvez concaténer deux chaînes à partir de variables différentes dans un 
seul champ de texte. Dans le code ActionScript suivant, la variable myNum fait une 
concaténation avec une chaîne, et cette dernière affiche le champ myTxt sur la scène.
this.createTextField("myTxt", 11, 0, 0, 100, 20);
myTxt.autoSize = "left";
var myNum:Number = 10;
= "One carrot. " + myNum + " large eggplants.";
+= " Lots of vegetable broth.";
152
Eléments fondamentaux du langage et de la syntaxe

Ce code donne le résultat suivant dans un champ de texte avec le nom d’occurrence myTxt :
One carrot. 10 large eggplants. Lots of vegetable broth.
L’exemple précédent décrit l’utilisation des opérateurs d’addition (+) et d’affectation 
d’addition (+=) pour concaténer les chaînes. Remarquez comment la troisième ligne de code 
utilise l’opérateur d’addition pour concaténer la valeur de la variable myNum dans le champ de 
texte, et comment la quatrième ligne utilise l’opérateur d’affectation d’addition pour 
concaténer une chaîne sur la valeur existante du champ de texte.
Si un seul opérande de chaîne de texte est une chaîne, Flash convertit l’autre opérande en 
chaîne. De ce fait, la valeur de myNum est convertie en une chaîne dans l’exemple précédent.
REMARQUE
ActionScript traite les espaces au début ou à la fin d’une chaîne comme faisant partie de 
la chaîne.
Utilisation des opérateurs point et d’accès au tableau 
Vous pouvez utiliser les opérateurs point (.) et d’accès au tableau ([]) pour accéder aux 
propriétés ActionScript intégrées ou personnalisées. Vous utilisez les opérateurs point pour 
cibler certains index dans un objet. Par exemple, si l’un de vos objets contient des informations 
d’utilisateur, vous pouvez indiquer un certain nom de clé dans l’opérateur d’accès au tableau 
afin de récupérer le nom de l’utilisateur, comme l’illustre le code ActionScript suivant :
var someUser:Object = {name:"Hal", id:2001};
trace("User's name is: " + someUser["name"]); // Le nom de l’utilisateur 
// est : Hal
trace("User's id is: " + someUser["id"]); // L’ID de l’utilisateur est : 
// 2001
Par exemple, le code ActionScript suivant utilise l’opérateur point pour définir certaines 
propriétés à l’intérieur des objets :
myTextField.border = true;
= 9;
= "My text";
Les opérateurs point et d’accès au tableau sont très similaires. L’opérateur point prend un 
identifiant en tant que propriété, mais l’opérateur d’accès au tableau évalue le contenu en 
nom, puis accède à la valeur de la propriété de ce nom. L’opérateur d’accès au tableau permet 
de définir et extraire de façon dynamique les variables et les noms d’occurrence.
L’opérateur d’accès au tableau se révèle très utile lorsque vous ignorez quelles clés sont stockées 
dans un objet. Dans ce cas, vous pouvez utiliser une boucle  pour effectuer une 
itération sur un objet ou un clip et afficher son contenu.
Présentation des opérateurs
153

Pour utiliser les opérateurs point et d’accès au tableau :
1.
Dans un nouveau document Flash, créez un clip sur le scénario principal.
2. Sélectionnez le clip et ouvrez l’inspecteur des propriétés.
3. Saisissez le nom d’occurrence de myClip.
4. Ajoutez le code ActionScript suivant à l’Image 1 du scénario :
= 5;
trace(); // 5
Pour définir une valeur dans l’occurrence myClip du scénario actif, vous pouvez utiliser les 
opérateurs point ou d’accès au tableau, comme dans ce code ActionScript. Si vous écrivez 
une expression dans l’opérateur d’accès au tableau, ce dernier évalue d’abord l’expression, 
puis utilise le résultat comme nom de variable.
5. Sélectionnez Contrôle > Tester l’animation pour tester le document. 
Le panneau de sortie affiche 5. 
6. Revenez dans l’environnement de programmation, puis remplacez la première ligne de 
code ActionScript par ce qui suit :
myClip["spam"] = 10;
7. Sélectionnez Contrôle > Tester l’animation pour tester le document. 
Le panneau de sortie affiche 10. 
8. Revenez dans l’environnement de programmation et double-cliquez sur l’occurrence 
myClip.
9. Ajoutez quatre nouvelles occurrences dans l’occurrence myClip.
10. Utilisez l’inspecteur des propriétés pour donner les noms d’occurrences suivants aux quatre 
nouvelles occurrences : nestedClip1nestedClip2nestedClip3nestedClip4.
11. Ajoutez le code suivant à l’image 1 du scénario principal :
var i:Number;
for (i = 1; i <= 4; i++) {
myClip["nestedClip" + i]._visible = false;
}
Ce code ActionScript désactive la visibilité de chaque clip imbriqué.
12. Choisissez Contrôle > Tester l’animation pour tester le code ActionScript que vous venez 
d’ajouter. 
Les quatre occurrences imbriquées sont à présent invisibles. Vous utilisez l’opérateur 
d’accès au tableau pour effectuer une itération sur chaque clip imbriqué dans l’occurrence 
myClip et définir sa propriété de visibilité dynamiquement. Vous gagnez ainsi du temps 
car vous n’avez plus besoin de cibler chaque occurrence de façon spécifique.
154
Eléments fondamentaux du langage et de la syntaxe

Vous pouvez également utiliser l’opérateur d’accès au tableau du côté gauche d’une 
affectation, ce qui vous permet de définir les noms d’occurrence, de variable et d’objet 
dynamiquement :
myNum[i] = 10;
Dans ActionScript 2.0, l’opérateur crochets permet d’accéder aux propriétés d’un objet créées 
dynamiquement, pour le cas où la définition de la classe de cet objet ne fournit pas l’attribut 
dynamic. Vous pouvez également créer des tableaux multidimensionnels à l’aide de cet 
opérateur. Pour plus d’informations sur la création de tableaux multidimensionnels à l’aide 
d’opérateurs d’accès au tableau, consultez la section multidimensionnels », à la page 138.
Présentation des opérateurs de suffixe 
Les opérateurs de suffixe prennent un opérateur et incrémentent ou décrémentent sa valeur. 
Bien que ces opérateurs soient des opérateurs unaires, ils sont classés à part du fait de leur 
priorité supérieure et de leur comportement particulier. Pour plus d’informations sur les 
opérateurs unaires, consultez la section « Présentation des opérateurs unaires », à la page 156.
Lorsque vous utilisez un opérateur de suffixe dans une expression plus grande, la valeur de 
l’expression est renvoyée avant le traitement de cet opérateur. Par exemple, le code suivant 
montre comment la valeur de l’expression xNum++ est renvoyée avant l’incrémentation de la 
valeur.
var xNum:Number = 0;
trace(xNum++); // 0
trace(xNum); // 1
Lorsque vous suivez ce code, le texte suivant s’affiche dans le panneau de sortie :
0
1
Les opérateurs de ce tableau ont le même ordre de priorité. 
Opérateur Opération effectuée
++
Incrémentation (suffixe)
--
Décrémentation (suffixe)
Présentation des opérateurs
155

Présentation des opérateurs unaires 
Les opérateurs unaires prennent un opérande. Les opérateurs d’incrémentation (++) et de 
décrémentation (--) de ce groupe sont des opérateurs de préfixe, c’est-à-dire qu’ils apparaissent 
avant l’opérande dans une expression. Ils peuvent aussi apparaître après l’opérande, auquel cas 
il s’agit d’opérateurs de suffixe. Pour plus d’informations sur les opérateurs de suffixe, 
consultez la section « Présentation des opérateurs de suffixe », à la page 155.
Les opérateurs de préfixe diffèrent de leur équivalent suffixe car l’opération d’incrémentation 
ou de décrémentation est effectuée avant le renvoi de la valeur de l’expression globale. 
Par exemple, le code suivant montre comment la valeur de l’expression xNum++ est renvoyée 
avant l’incrémentation de la valeur.
var xNum:Number = 0;
trace(++xNum); // 1
trace(xNum); // 1
Tous les opérateurs de ce tableau ont le même ordre de priorité.
Opérateur Opération effectuée
++
Incrémentation (préfixe)
--
Décrémentation (préfixe)
+
Unaire +
!
Unaire - (négation)
typeof
Renvoie les informations de type
void
Renvoie une valeur non définie
Présentation des opérateurs de multiplication 
Les opérateurs de multiplication prennent deux opérandes et effectuent des multiplications, 
des divisions ou des calculs de modulo. Les autres opérateurs numériques comprennent les 
opérateurs d’ajout. Pour plus d’informations sur les opérateurs d’ajout, consultez la section 
« Présentation des opérateurs d’ajout », à la page 157. 
Tous les opérateurs de ce tableau ont le même ordre de priorité.
Opérateur Opération effectuée
*
Multiplication
/
Division
%
Modulo
Pour plus d’informations sur les opérateurs de multiplication, consultez la section des opérateurs numériques », à la page 157.
156
Eléments fondamentaux du langage et de la syntaxe

Présentation des opérateurs d’ajout 
Les opérateurs d’ajout prennent deux opérandes et effectuent des calculs d’addition ou de 
soustraction. Les autres opérateurs numériques comprennent les opérateurs de multiplication. 
Pour plus d’informations sur les opérateurs de multiplication, consultez la section 
« Présentation des opérateurs de multiplication », à la page 156.
Les opérateurs de ce tableau ont le même ordre de priorité. 
Opérateur Opération effectuée
+
Addition
-
Soustraction
Pour plus d’informations sur l’utilisation des opérateurs d’ajout, consultez la section 
« Utilisation des opérateurs numériques », à la page 157.
Utilisation des opérateurs numériques 
Les opérateurs numériques permettent d’ajouter, de soustraire, de diviser et de multiplier des 
valeurs dans ActionScript. Vous pouvez effectuer différentes sortes d’opérations arithmétiques. 
Le plus courant est l’opérateur d’incrémentation, généralement présenté sous la forme i++. 
Cet opérateur permet d’effectuer d’autres opérations. Pour plus d’informations sur l’opérateur 
d’incrémentation, consultez la section à la page 147.
L’incrémentation peut être placé avant (pré-incrémentation) ou après (post-incrémentation) une 
opérande.
Pour comprendre les opérateurs numériques du langage ActionScript :
1.
Créez un document Flash.
2. Saisissez le code ActionScript suivant sur l’image 1 du scénario :
// Exemple un
var firstScore:Number = 29;
if (++firstScore >= 30) {
// devrait suivre
trace("Success! ++firstScore is >= 30");
}
// Exemple deux
var secondScore:Number = 29;
if (secondScore++ >= 30) {
// ne devrait pas suivre
trace("Success! secondScore++ is >= 30");
}
Présentation des opérateurs
157

3. Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Le bloc de code « Exemple un » suit, mais pas celui de « Exemple deux ». Le premier 
exemple utilise une pré-incrémentation (++firstScore) pour incrémenter et calculer 
firstScore avant sa vérification par rapport à 30. De ce fait, firstScore est incrémenté 
à 30, puis testé par rapport à 30.
L’exemple deux utilise lui une post-incrémentation (secondScore++), c’est-à-dire que 
l’évaluation est effectuée après le test. Ainsi, 29 est comparé à 30, puis incrémenté à 30 
après l’évaluation.
L’utilisation de l’opérateur d’addition peut donner lieu à des résultats inattendus si vous tentez 
d’ajouter des valeurs dans une expression, comme le montre l’exemple suivant :
trace("the sum of 5 + 2 is: " + 5 + 2); // La somme de 5 + 2 est : 52
Flash concatène les valeurs 5 et 2 au lieu de les additionner. Pour contourner le problème, 
vous pouvez placer l’expression 5+2 entre parenthèses, comme dans le code suivant :
trace("the sum of 5 + 2 is: " + (5 + 2)); // La somme de 5 + 2 est : 7
Pour plus d’informations sur la priorité des opérateurs, consultez la sectassociativité des opérateurs », à la page 149.
Lorsque vous transférez des données à partir de sources externes (tels que des fichiers XML, 
FlashVars, des services Web, etc.), faites très attention en utilisant les opérateurs numériques. 
Flash traite parfois les nombres comme des chaînes car le fichier SWF n’est pas conscient de leur 
type de données. Ainsi, l’addition de 3 et 7 pourrait donner 37 car les deux nombres peuvent 
être concaténés comme des chaînes au lieu d’être additionnés numériquement. Dans ce cas, vous 
devez convertir manuellement les données de chaînes en nombres via la fonction Number().
Présentation des opérateurs relationnels 
Les opérateurs relationnels prennent deux opérandes, comparent leur valeurs et renvoient une 
valeur booléenne. Tous les opérateurs de ce tableau ont le même ordre de priorité.
Opérateur Opération effectuée
<
Inférieur à
>
Supérieur à
<=
Inférieur ou égal à
>=
Supérieur ou égal à
instanceof
Vérifie la chaîne prototype
in
Vérifie les propriétés des objets
Pour plus d’informations sur l’utilisation des opérateurs relationnels, consultez la section 
« Utilisation des opérateurs relationnels et d’égalité », à la page 159.
158
Eléments fondamentaux du langage et de la syntaxe

Présentation des opérateurs d’égalité 
Les opérateurs d’égalité prennent deux opérandes, comparent leur valeurs et renvoient une 
valeur booléenne. Tous les opérateurs de ce tableau ont le même ordre de priorité.
Opérateur Opération effectuée
==
Egalité
!=
Inégalité
===
Egalité stricte
!==
Inégalité stricte
Pour plus d’informations sur l’utilisation des opérateurs d’égalité, consultez la section 
« Utilisation des opérateurs relationnels et d’égalité », à la page 159.
Utilisation des opérateurs relationnels et d’égalité 
Ces opérateurs, également appelés opérateurs de comparaison, comparent les valeurs des 
expressions et renvoient une valeur booléenne : true (vrai) ou false (faux). Ces opérateurs 
sont fréquemment employés dans des boucles et des instructions conditionnelles pour 
spécifier la condition de fin de la boucle. 
Vous pouvez utiliser l’opérateur d’égalité (==) pour déterminer si les valeurs ou les références 
de deux opérandes sont égales et si cette comparaison renvoie une valeur booléenne. 
Les valeurs d’opérandes de type chaîne, nombre ou booléen effectuent la comparaison à l’aide 
d’une valeur. Les opérandes de type objet et tableau sont comparés par une référence.
Dans cet exemple, vous pouvez observer l’utilisation de l’opérateur d’égalité pour tester la 
longueur du tableau et afficher un message dans le panneau de sortie lorsque le tableau ne 
contient pas d’élément.
var myArr:Array = new Array();
if (myArr.length == 0) {
trace("the array is empty.");
}
Lorsque vous choisissez Contrôle > Tester l’animation, la chaîne the array is empty 
(le tableau est vide) s’affiche dans le panneau de sortie.
Vous pouvez utiliser l’opérateur d’égalité pour comparer des valeurs, mais pas pour les définir. 
Une erreur courante consiste à utiliser l’opérateur d’affectation (=) pour contrôler l’égalité.
Présentation des opérateurs
159

Pour utiliser les opérateurs relationnels et d’égalité dans votre code :
1.
Créez un document Flash.
2. Saisissez le code ActionScript suivant sur l’image 1 du scénario :
var myNum:Number = 2;
if (myNum == 2) {
// action
trace("It equals 2");
}
Dans ce code ActionScript, vous utilisez l’opérateur d’égalité (==) pour vérifier l’égalité. 
Vous vérifiez si la variable myNum est égale à 2.
3. Choisissez Contrôle > Tester l’animation. 
La chaîne It equals 2 (est égal à 2) s’affiche dans le panneau de sortie.
4. Revenez dans l’environnement de programmation et modifiez :
var myNum:Number = 2;
en :
var myNum:Number = 4;
5. Choisissez de nouveau Contrôle > Tester l’animation. 
La chaîne It equals 2 (est égal à 2) ne s’affiche pas dans le panneau de sortie.
6. Revenez dans l’environnement de programmation et modifiez :
if (myNum == 2) {
en
if (myNum = 2) {
7. Choisissez de nouveau Contrôle > Tester l’animation. 
La chaîne It equals 2 (est égal à 2) s’affiche de nouveau dans le panneau de sortie.
A l’étape 6, vous affectez la valeur 2 à myNum, au lieu de comparer myNum à 2. Dans ce cas, 
l’instruction if s’exécute quelle que soit la valeur précédente de myNum, ce qui peut donner 
des résultats imprévus lors du test du document Flash. 
Pour plus d’informations sur l’utilisation appropriée de l’opérateur d’affectation, consultez 
la section « Utilisation des opérateurs d’affectation », à la page 163.
L’opérateur d’égalité stricte (===) est similaire à l’opérateur d’égalité, sauf qu’il n’effectue pas 
de conversion de type. Si les deux opérandes sont de types différents, l’opérateur d’égalité 
renvoie false (faux). L’opérateur d’inégalité stricte (!==) renvoie l’inverse de l’opérateur 
d’égalité stricte. 
160
Eléments fondamentaux du langage et de la syntaxe

Le code ActionScript suivant présente la principale différence entre l’opérateur d’égalité (==) 
et l’opérateur d’égalité stricte (===) :
var num1:Number = 32;
var num2:String = new String("32");
trace(num1 == num2); // true
trace(num1 === num2); // false
D’abord, vous définissez les variables numériques : num1 et num2. Si vous comparez les 
variables à l’aide de l’opérateur d’égalité, Flash tente de convertir les valeurs dans le même type 
de données, puis les compare afin de vérifier leur égalité. Lorsque vous utilisez l’opérateur 
d’égalité stricte (===), Flash n’effectue aucune conversion de type de données avant de 
comparer les valeurs. En résultat, Flash voit les variables comme deux valeurs distinctes.
Dans l’exemple suivant, vous allez utiliser l’opérateur supérieur ou égal à (>=) pour comparer les 
valeurs et exécuter le code en fonction de la valeur saisie par l’utilisateur dans un champ de texte.
Pour utiliser l’opérateur supérieur ou égal à dans votre code :
1.
Sélectionnez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau 
fichier FLA.
2. Ajoutez le code suivant à l’image 1 du scénario principal :
this.createTextField("myTxt", 20, 0, 0, 100, 20);
= "input";
myTxt.border = true;
myTxt.restrict = "0-9";
this.createEmptyMovieClip("submit_mc", 30);
submit_mc.beginFill(0xFF0000);
submit_mc.moveTo(0, 0);
submit_mc.lineTo(100, 0);
submit_mc.lineTo(100, 20);
submit_mc.lineTo(0, 20);
submit_mc.lineTo(0, 0);
submit_mc.endFill();
submit_mc._x = 110;
submit_mc.onRelease = function(evt_obj:Object):Void {
var myNum:Number = Number();
if (isNaN(myNum)) {
trace("Please enter a number");
return;
}
if (myNum >= 10) {
trace("Your number is greater than or equal to 10");
} else {
trace("Your number is less than 10");
}
};
Présentation des opérateurs
161

3. Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Vous pouvez également vérifier si certaines conditions sont vraies, puis exécuter un autre 
bloc si la condition ne l’est pas.
4. Modifiez la condition de votre code ActionScript de la façon suivante.
if (myNum == 10) {
trace("Your number is 10");
} else {
trace("Your number is not 10");
}
5. Choisissez Contrôle > Tester l’animation pour tester de nouveau le code ActionScript.
A l’exception de l’opérateur d’égalité stricte (===), 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, les deux opérandes sont convertis en nombres et une comparaison numérique est 
effectuée. Pour plus d’informations sur les chaînes et les opérateurs, consultez la section 
« Utilisation d’opérateurs avec des chaînes », à la page 151. Pour plus d’informations sur 
l’impact de l’ordre et de la priorité des opérateurs sur votre code ActionScript, consultez la 
section « Priorité et associativité des opérateurs », à la page 149.
Présentation des opérateurs d’affectation 
Les opérateurs d’affectation prennent deux opérandes et affectent une valeur à l’un d’eux en 
fonction de la valeur de l’autre. Tous les opérateurs de ce tableau ont le même ordre de priorité. 
Opérateur Opération effectuée
=
Affectation
*=
Affectation de multiplication
/=
Affectation de division
%=
Affectation modulo
+=
Affectation d’addition
-=
Affectation de soustraction
<<=
Affectation de décalage gauche au niveau du bit
>>=
Affectation de décalage droit au niveau du bit
>>>=
Affectation de décalage droit au niveau du bit non signé
&=
Affectation AND au niveau du bit
^=
Affectation XOR au niveau du bit
|=
Affectation OR au niveau du bit
Pour plus d’informations sur l’utilisation des opérateurs d’affectation, consultez la section 
« Utilisation des opérateurs d’affectation », à la page 163.
162
Eléments fondamentaux du langage et de la syntaxe

Utilisation des opérateurs d’affectation 
L’opérateur d’affectation (=) permet d’affecter une valeur donnée à une variable. Vous pouvez 
affecter une chaîne à une variable, comme suit :
var myText:String = "ScratchyCat";
Vous pouvez également utiliser l’opérateur d’affectation pour affecter plusieurs variables dans 
la même expression. Dans l’instruction suivante, la valeur 10 est affectée aux variables numOne, 
numTwo et numThree.
var numOne:Number;
var numTwo:Number;
var numThree:Number;
numOne = numTwo = numThree = 10;
Vous pouvez aussi utiliser des opérateurs d’affectation composés pour combiner des 
opérations. Ces opérateurs agissent sur les deux opérandes, puis affectent la nouvelle valeur au 
premier. Par exemple, les deux instructions suivantes donnent le même résultat :
var myNum:Number = 0;
myNum += 15;
myNum = myNum + 15;
Présentation des opérateurs logiques 
Les opérateurs logiques comparent des valeurs booléennes (true et false) et renvoient une 
troisième valeur booléenne dépendant de la comparaison. Par exemple, si deux opérandes 
renvoient true, l’opérateur logique AND (&&) renvoie true. Si l’un des opérandes, ou les 
deux, renvoie(nt) true, l’opérateur logique OR (||) renvoie true.
Les opérateurs logiques prennent deux opérandes et renvoient une valeur booléenne. L’ordre 
de priorité de ces opérateurs diffère et ils sont présentés dans le tableau suivant par ordre 
décroissant de priorité :
Opérateur Opération effectuée
&&
AND logique
||
OR logique
Pour plus d’informations sur l’utilisation des opérateurs logiques, consultez la section 
« Utilisation des opérateurs logiques », à la page 164.
Présentation des opérateurs
163

Utilisation des opérateurs logiques 
Les opérateurs logiques sont souvent utilisés en complément des opérateurs de comparaison 
pour déterminer la condition d’une instruction if, comme dans l’exemple suivant.
Pour utiliser des opérateurs logiques dans votre code :
1.
Choisissez Fichier > Nouveau et créez un document Flash.
2. Dans le panneau Actions, entrez le code ActionScript suivant sur l’image 1 du scénario :
this.createTextField("myTxt", 20, 0, 0, 100, 20);
= "input";
myTxt.border = true;
myTxt.restrict = "0-9";
this.createEmptyMovieClip("submit_mc", 30);
submit_mc.beginFill(0xFF0000);
submit_mc.moveTo(0, 0);
submit_mc.lineTo(100, 0);
submit_mc.lineTo(100, 20);
submit_mc.lineTo(0, 20);
submit_mc.lineTo(0, 0);
submit_mc.endFill();
submit_mc._x = 110;
submit_mc.onRelease = function():Void {
var myNum:Number = Number();
if (isNaN(myNum)) {
trace("Please enter a number");
return;
}
if ((myNum > 10) && (myNum < 20)) {
trace("Your number is between 10 and 20");
} else {
trace("Your number is NOT between 10 and 20");
}
};
Dans ce code ActionScript, créez un champ de texte au moment de l’exécution. Si vous 
entrez un nombre dans ce champ de texte, puis cliquez sur un bouton de la scène, Flash 
utilise l’opérateur logique pour afficher un message dans le panneau de sortie. Le message 
dépend de la valeur du nombre saisi dans le champ.
164
Eléments fondamentaux du langage et de la syntaxe

Lorsque vous utilisez des opérandes, prenez garde à l’ordre employé, en particulier avec des 
conditions complexes. Le code suivant présente l’utilisation de l’opérateur logique AND pour 
vérifier qu’un nombre est compris entre 10 et 20. Selon le résultat, un message approprié 
s’affiche. Si le nombre est inférieur à 10 ou supérieur à 20, un autre message s’affiche dans le 
panneau de sortie.
submit_mc.onRelease = function():Void {
var myNum:Number = Number();
if (isNaN(myNum)) {
trace("Please enter a number");
return;
}
if ((myNum > 10) && (myNum < 20)) {
trace("Your number is between 10 and 20");
} else {
trace("Your number is NOT between 10 and 20");
}
};
Présentation des opérateurs de décalage au niveau 
du bit
Ces opérateurs prennent deux opérandes et décalent les bits du premier selon la valeur 
spécifiée dans le second. Tous les opérateurs de ce tableau ont le même ordre de priorité.
Opérateur Opération effectuée
<<
Décalage gauche au niveau du bit
>>
Décalage droit au niveau du bit
>>>
Décalage droit non signé au niveau du bit
Pour plus d’informations sur l’utilisation des opérateurs au niveau du bit, consultez la section 
« Utilisation des opérateurs au niveau du bit », à la page 166. Pour des informations 
spécifiques sur chaque opérateur au niveau du bit, consultez la section correspondante du 
Guide de référence du langage ActionScript 2.0.
Présentation des opérateurs
165

Présentation des opérateurs logiques au niveau du bit
Ces opérateurs prennent deux opérandes et effectuent des opérations logiques au niveau des 
bits. La priorité de ces opérateurs diffère et ils sont présentés dans le tableau suivant par ordre 
décroissant de priorité :
Opérateur Opération effectuée
&
AND au niveau du bit
^
XOR au niveau du bit
|
OR au niveau du bit
Pour plus d’informations sur l’utilisation des opérateurs au niveau du bit, consultez la section 
« Utilisation des opérateurs au niveau du bit », à la page 166. Pour des informations 
spécifiques sur chaque opérateur au niveau du bit, consultez la section correspondante du 
Guide de référence du langage ActionScript 2.0.
Utilisation des 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 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. Pour obtenir la liste des opérateurs de décalage au niveau du bit, 
consultez la section la page 165. Pour obtenir la liste des opérateurs logiques au niveau du bit, consultez la section 
« Présentation des opérateurs logiques au niveau du bit », à la page 166.
L’utilisation d’opérateurs au niveau du bit dans Flash n’est pas très fréquente, mais peut se 
révéler très utile dans certains cas. Par exemple, vous pouvez créer une matrice d’autorisations 
pour un projet Flash, sans créer de variables distinctes pour chaque type d’autorisation. 
Dans ce cas, vous pouvez utiliser des opérateurs du niveau du bit.
L’exemple suivant décrit l’utilisation de l’opérateur OR au niveau du bit avec la méthode 
() pour spécifier les options de tri.
166
Eléments fondamentaux du langage et de la syntaxe

Pour utiliser l’opérateur OR au niveau du bit :
1.
Choisissez Fichier > Nouveau et créez un document Flash.
2. Saisissez le code ActionScript suivant dans le panneau Actions :
var myArr:Array = new Array("Bob", "Dan", "doug", "bill", "Hank", 
"tom");
trace(myArr); // Bob,Dan,doug,bill,Hank,tom
(Array.CASEINSENSITIVE | Array.DESCENDING);
trace(myArr); // tom,Hank,doug,Dan,Bob,bill
La première ligne définit un tableau de noms aléatoires et les suit dans le panneau de sortie. 
Vous appelez ensuite la méthode () et spécifiez deux options de tri à l’aide des 
valeurs constantes Array.CASEINSENSITIVE et Array.DESCENDING. Cette méthode trie les 
éléments du tableau en ordre inverse (de z à a). La recherche ne respecte pas la casse. 
Les lettres a et A sont traitées à l’identique, plutôt que d’obtenir un Z avant un a.
3. Choisissez Contrôle > Tester l’animation pour tester votre code ActionScript. Le texte 
suivant apparaît dans le panneau de sortie :
Bob,Dan,doug,bill,Hank,tom
tom,Hank,doug,Dan,Bob,bill
Cinq options sont disponibles dans la méthode de tri :
?
1 ou Array.CASEINSENSITIVE (binaire = 1)
?
2 ou Array.DESCENDING (binaire = 10)
?
4 ou Array.UNIQUESORT (binaire = 100)
?
8 ou Array.RETURNINDEXEDARRAY (binaire = 1000)
?
16 ou Array.NUMERIC (binaire = 10000)
Trois méthodes différentes permettent de définir les options de tri d’un tableau :
(Array.CASEINSENSITIVE | Array.DESCENDING); // Constantes
(1 | 2); // Nombres
(3); // Ajout de nombres
Bien que cela ne soit pas immédiatement évident, les valeurs des nombres des options de tri 
sont en fait des chiffres au niveau du bit (binaire ou base 2). La valeur de la constante 
Array.CASEINSENSITIVE est égale à la valeur numérique 1, correspondant également à la 
valeur binaire de 1. La valeur de la constante Array.DECENDING est égale à la valeur 
numérique 2 ou la valeur binaire 10. 
L’utilisation des nombres binaires prête parfois à confusion. Ils n’ont que deux valeurs 
possibles, 1 ou 0, raison pour laquelle 2 est représenté par 10. Sous forme binaire, le nombre 3 
devient 11 (1+10), le nombre 4 devient 100, 5 devient 101, etc.
Présentation des opérateurs
167

Le code ActionScript suivant présente le tri d’un tableau de valeurs numériques par ordre 
décroissant via l’utilisation de l’opérateur AND au niveau du bit pour additionner les 
constantes Array.DESCENDING et Array.NUMERIC.
var scores:Array = new Array(100,40,20,202,1,198);
trace(scores); // 100,40,20,202,1,198
trace(()); // 1,100,198,20,202,40
var flags:Number = Array.NUMERIC|Array.DESCENDING;
trace(flags); // 18 (base 10)
trace(flags.toString(2)); // 10010 (binaire -- base 2)
trace((flags)); // 202,198,100,40,20,1
Présentation de l’opérateur conditionnel
L’opérateur conditionnel est un opérateur ternaire, c’est-à-dire qu’il prend trois opérandes. 
Il correspond à une méthode abrégée de l’application de l’instruction conditionnelle 
 :
Opérateur Opération effectuée
?:
Conditionnelle
Pour plus d’informations sur l’utilisation des opérateurs conditionnels, consultez la section     
« Opérateur conditionnel et syntaxe de remplacement », à la page 121.
Utilisation des opérateurs dans un document
Dans l’exemple suivant, vous utilisez la méthode Math.round() pour arrondir des calculs 
selon un nombre arbitraire de décimales. Cette méthode arrondit la valeur du paramètre 
score à l’entier immédiatement supérieur ou inférieur et renvoie la valeur. En modifiant 
légèrement le code ActionScript, vous pouvez faire en sorte que Flash arrondisse les résultats à 
un certain nombre de décimales.
Dans l’exemple, vous utilisez également les opérateurs de division et de multiplication pour 
calculer la note de l’utilisateur en divisant le nombre de réponses correctes par le nombre total 
de questions. La note de l’utilisateur peut ensuite être multipliée par un certain nombre et être 
présentée sous forme de pourcentage entre 0 % et 100 %. Vous utilisez ensuite l’opérateur 
d’addition pour concaténer la note de l’utilisateur dans une chaîne affichée dans le panneau de 
sortie.
168
Eléments fondamentaux du langage et de la syntaxe

Pour utiliser des opérateurs dans votre code ActionScript :
1.
Créez un document Flash.
2. Saisissez le code ActionScript suivant sur l’image 1 du scénario principal :
var correctAnswers:Number = 11;
var totalQuestions:Number = 13;
// Arrondi au nombre entier le plus proche
// var score:Number = Math.round(correctAnswers / totalQuestions * 100);
// Arrondi à deux chiffres après la virgule
var score:Number = Math.round(correctAnswers / totalQuestions * 100 * 
100) / 100;
trace("You got " + correctAnswers + " out of " + totalQuestions + " 
answers correct, for a score of " + score + "%.");
3. Choisissez Contrôle> Tester l’animation. 
Le panneau de sortie affiche le texte suivant :
You got 11 out of 13 answers correct, for a score of 84.62%.
Lorsque vous appelez la méthode Math.round() dans cet exemple, la note est arrondie au 
nombre entier le plus proche (85) et s’affiche dans le panneau de sortie. Si vous multipliez 
le nombre par 100 avant d’appeler la méthode Math.round(), puis le divisez par 100, 
Flash arrondit la note à deux chiffres après la virgule. Ainsi, la note est plus précise.
4. Affectez la valeur 3 à la variable correctAnswers, puis choisissez Contrôle > Tester 
l’animation pour tester de nouveau le fichier SWF.
Si vous développez une application de test, vous pouvez créer une série de questions vrai/faux 
ou à choix multiples à l’aide des composants RadioButton et Label. Lorsque l’utilisateur a 
terminé et clique sur le bouton pour soumettre son questionnaire rempli, vous pouvez 
comparer ses réponses aux clés de correction, puis calculer sa note.
Présentation des opérateurs
169

170
Eléments fondamentaux du langage et de la syntaxe

CHAPITRE 5
Fonctions et méthodes
5
Lorsque vous créez du code et des classes ActionScript et utilisez des méthodes, il est 
important de bien comprendre les fonctions. Vous allez exploiter plusieurs sortes de fonctions. 
Ce chapitre vous permet de découvrir les fonctions et les méthodes : comment les utiliser dans 
vos applications lorsque vous avez recours à des classes intégrées et comment les écrire. Dans le 
Chapitre 6, « Classes », vous allez créer des classes personnalisées dans lesquelles vous écrirez 
régulièrement des fonctions. Vous découvrirez également comment écrire des fonctions dans 
des fichiers de classe ActionScript.
Vous pouvez utiliser des fonctions dans votre code pour ajouter de l’interactivité, des 
animations et d’autres effets à vos applications. Ce chapitre traite des types de fonction que 
vous pouvez écrire dans vos applications Flash. Pour obtenir des d’informations sur les 
fonctions et les méthodes, ainsi que des exercices dans lesquels vous pouvez écrire et utiliser 
des fonctions et des méthodes dans Flash, consultez les rubriques suivantes :
Présentation des fonctions et des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Fonctionnement des méthodes  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Présentation des fonctions et des 
méthodes 
Ces éléments sont des blocs de code ActionScript que vous pouvez réutiliser n’importe où 
dans un fichier SWF. Vous pouvez écrire une fonction dans le fichier FLA ou dans un fichier 
ActionScript externe, puis l’appeler depuis tout emplacement de vos documents. 
Les méthodes sont simplement des fonctions placées dans la définition d’une classe 
ActionScript. Vous pouvez définir des fonctions pour exécuter une série d’instructions sur des 
valeurs transmises. Vos fonctions peuvent également renvoyer des valeurs. Une fois définie, 
une fonction peut être appelée à partir de tout scénario, y compris celui d’un fichier SWF 
chargé. 
171

Si vous transmettez des valeurs en tant que paramètres à une fonction, cette dernière peut 
exécuter des calculs à l’aide de ces valeurs. Chaque fonction possède ses propres 
caractéristiques. Certaines vous demandent de transmettre des types de valeurs ou certaines 
valeurs. Si vous transmettez à une fonction plus de valeurs qu’elle n’en réclame, les valeurs 
excédentaires sont ignorées. Si vous omettez un paramètre obligatoire, la fonction lui attribue 
le type de données non défini. Cet oubli peut provoquer des erreurs au moment de 
l’exécution. Une fonction peut également renvoyer des valeurs (voir depuis les fonctions », à la page 192).
REMARQUE
Pour appeler une fonction, sa définition doit se trouver dans l’image que la tête de lecture 
a atteinte.
Une fonction bien rédigée peut être considérée comme une « boîte noire ». Si cette fonction 
contient des commentaires pertinents et judicieusement placés, au sujet de son entrée, sa 
sortie et son rôle, toute personne qui l’utilise n’a pas nécessairement besoin de comprendre son 
fonctionnement interne.
La syntaxe de base d’une simple fonction nommée est la suivante : 
function traceMe() {
trace("your message");
}
traceMe();
Pour plus d’informations sur l’écriture des fonctions nommées, consultezdes fonctions nommées », à la page 177.
La syntaxe de base d’une simple fonction nommée se basant sur l’exemple précédent en 
transmettant un paramètre, yourMessage, est la suivante : 
function traceMe(yourMessage:String) {
trace(yourMessage);
}
traceMe("How you doing?");
Si vous souhaitez transmettre plusieurs paramètres, vous pouvez utiliser le code suivant :
var yourName:String = "Ester";
var yourAge:String = "65";
var favSoftware:String = "Flash";
function traceMe(favSoftware:String, yourName:String, yourAge:String) {
trace("I’m " + yourName + ", I like " + favSoftware + ", and I’m " + 
yourAge + ".");
}
traceMe(favSoftware,yourName,yourAge);
172
Fonctions et méthodes

Pour plus d’informations sur la transmission de paramètres, consultez la section 
« Transmission de paramètres à une fonction », à la page 190.
Vous pouvez écrire de nombreux types de fonction. Pour plus d’informations sur l’écriture de 
fonctions et pour obtenir des liens vers des sections sur l’écriture de types de fonction 
particuliers, consultez la section « Types de méthodes et de fonctions », à la page 173. Pour un 
exemple comparatif entre les méthodes et les fonctions, consultez la sectiondes méthodes », à la page 194. 
REMARQUE
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script, consultez 
le guide Utilisation de Flash.
Pour plus d’informations sur les fonctions et les méthodes, consultez les rubriques suivantes :
?
« Types de méthodes et de fonctions », à la page 173
Types de méthodes et de fonctions 
Les fonctions qui appartiennent à une classe sont considérées comme les méthodes de cette 
classe. Dans vos applications, vous pouvez utiliser plusieurs types de fonction, dont des 
fonctions intégrées, des fonctions nommées et définies par l’utilisateur, des fonctions 
anonymes, des fonctions de rappel, des fonctions constructeur et des littéraux de fonction. 
Les sections suivantes contiennent des informations sur la façon de définir ces fonctions. 
Vous pouvez également écrire des fonctions dans un fichier ActionScript. Vous les utilisez 
comme méthodes dans vos scripts. Dans l’exemple suivant, la classe Person affiche une 
méthode de constructeur et des méthodes de classe, d’occurrence et d’accesseur (lecture et 
définition). Les commentaires contenus dans cet exemple de code indiquent où ont lieu ces 
méthodes dans le code.
RE
Pour plus d’informations sur la rédaction de fichiers de classe comme celui-ci, consultez 
MA
le Chapitre 6, « Classes », à la page 197.
R
Q
UE
Présentation des fonctions et des méthodes
173

class Personne {
public static var numPeople:Number = 0;
// Membres d’occurrence
private var _speed:Number;
// Constructeur
public function Person(speed:Number) {
Person.numPeople++;
this._speed = speed;
}
// Méthodes statiques
public static function getPeople():Number {
return Person.numPeople;
}
// Méthodes d’occurrence
public function walk(speed:Number):Void {
this._speed = speed;
}
public function run():Void {
this._speed *= 2;
}
public function rest():Void {
this._speed = 0;
}
// Lecture/définition (méthodes d’accesseur)
public function get speed():Number {
return this._speed;
}
}
Pour consulter une démonstration complète sur la façon de rédiger des méthodes comme celle 
de l’exemple de code précédent, consultez le Les méthodes utilisées dans votre code peuvent appartenir à une classe intégrée au langage 
ActionScript. MovieClip et Math sont des exemples de classes de niveau supérieur que vous 
pouvez utiliser dans une application. Lorsque vous utilisez des méthodes issues de ces classes 
dans votre code, il s’agit de fonctions écrites dans la classe intégrée (similaire à l’exemple de 
code précédent). Vous pouvez également utiliser les méthodes d’une classe personnalisée que 
vous créez vous-même.
Les fonctions qui n’appartiennent pas à une classe sont appelées fonctions de niveau supérieur 
(ou encore fonctions prédéfinies ou intégrées). Cela signifie que vous pouvez les appeler sans 
constructeur. trace() et setInterval() sont des exemples de fonctions intégrées au niveau 
supérieur du langage ActionScript. 
174
Fonctions et méthodes

Pour ajouter un appel de fonction de niveau supérieur à votre code, il vous suffit d’ajouter une 
seule ligne de code dans la fenêtre de script du panneau Actions. Par exemple, tapez ce qui 
suit :
trace("my message");
Lorsque vous testez le fichier SWF avec cette ligne de code unique, la fonction trace() de 
niveau supérieur est appelée et du texte apparaît dans le panneau de sortie. 
N’oubliez pas que lorsque vous souhaitez affecter une méthode à une propriété, vous devez 
omettre les parenthèses après le nom de la méthode puisque vous transmettez une référence à 
la fonction :
my_mc.myMethod = aFunction;
Toutefois, lorsque vous invoquez une méthode dans votre code, vous devez inclure les 
parenthèses à la suite du nom de la méthode :
my_mc.myMethod();
REMARQUE
Pour plus d’informations sur les fonctions de niveau supérieur, consultez la section 
« Présentation des fonctions de niveau supérieur et intégrées », à la page 176.
Vous pouvez également définir des fonctions de nombreuses autres manières. Pour plus 
d’informations sur chaque type de fonction, consultez les sections suivantes :
?
« Présentation des fonctions de niveau supérieur et intégrées », à la page 176
?
« Ecriture des fonctions nommées », à la page 177
?
« Ecriture de fonctions anonymes et de rappel », à la page 178
?
« Présentation des littéraux de fonction », à la page 181
?
« Ciblage et appel de fonctions définies par l’utilisateur », à la page 183
?
« Présentation des fonctions constructeur », à la page 182
Pour plus d’informations sur l’écriture et l’utilisation des fonctions et méthodes, consultez les 
sections suivantes. Pour plus d’informations sur l’utilisation des fonctions, consultez la section 
« Utilisation des fonctions dans Flash », à la page 185. Pour plus d’informations sur 
l’utilisation des méthodes, consultez la section la page 194. 
RE
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script, consultez 
M
A
le guide Utilisation de Flash.
R
Q
UE
Présentation des fonctions et des méthodes
175

Présentation des fonctions de niveau supérieur et intégrées 
Comme l’indique la section fonction est un bloc de code ActionScript qui peut être réutilisé n’importe où dans un fichier 
SWF. Si vous transmettez des valeurs en tant que paramètres à une fonction, cette dernière 
agit en conséquence. Une fonction peut également renvoyer des valeurs. 
Vous pouvez utiliser les fonctions qui sont intégrées au langage ActionScript. Elles peuvent 
être de niveau supérieur, comme l’indique la sectla page 173, ou faire partie d’une classe intégrée, telle que Math ou MovieClip, que vous 
utilisez comme méthode dans votre application. 
Dans ActionScript, les fonctions intégrées vous permettent d’effectuer certaines tâches et 
d’accéder à des informations. Par exemple, à l’aide de la fonction getTimer(), vous pouvez 
obtenir la durée, en millisecondes, de la lecture du fichier SWF. A l’aide de la fonction 
getVersion(), vous pouvez obtenir le numéro de la version du Flash Player qui héberge le 
fichier. Les fonctions appartenant à un objet sont appelées méthodes. Les fonctions qui 
n’appartiennent pas à un objet sont appelées fonctions de niveau supérieur et se trouvent dans 
les sous-catégories de la catégorie Fonctions globales du panneau Actions. 
Certaines fonctions vous obligent à transmettre certaines valeurs. Si vous transmettez plus de 
paramètres qu’il n’est nécessaire à la fonction, les valeurs supplémentaires sont ignorées. 
Si vous ne transmettez pas un paramètre nécessaire, les paramètres vides reçoivent le type de 
données undefined, ce qui peut provoquer des erreurs lors de l’exécution du script. 
REMARQUE
Pour appeler une fonction, sa définition doit se trouver dans l’image que la tête de lecture 
a atteinte.
Les fonctions de niveau supérieur sont faciles à utiliser. Pour appeler une fonction, utilisez 
tout simplement son nom et transmettez les paramètres requis par cette fonction. (Pour plus 
d’informations sur les paramètres requis, reportez-vous à l’entrée de la fonction dans le Guide 
de référence du langage ActionScript 2.0
). Par exemple, ajoutez le code ActionScript suivant à 
l’image 1 du scénario :
trace("my message");
176
Fonctions et méthodes

Lorsque vous testez le fichier SWF, my message apparaît dans le panneau de sortie. Voici deux 
autres exemples de fonctions de niveau supérieur : setInterval() et getTimer(). L’exemple 
qui suit indique comment utiliser ces deux actions ensemble. Ajoutez le code suivant à 
l’image 1 du scénario :
function myTimer():Void {
trace(getTimer());
}
var intervalID:Number = setInterval(myTimer, 100);
Ce code crée un minuteur simple à l’aide de getTimer() et utilise les fonctions de niveau 
supérieur setInterval() et trace() pour afficher le temps de lecture écoulé 
(en millisecondes) du fichier SWF dans Flash Player. 
L’appel d’une fonction de niveau supérieur est identique à celui d’une fonction définie par 
l’utilisateur
. Pour plus d’informations, voir l’utilisateur », à la page 183. Pour plus d’informations sur les différentes fonctions, consultez 
les sections correspondantes du Guide de référence du langage ActionScript 2.0.
Ecriture des fonctions nommées
Une fonction nommée est un type de fonction que vous créez généralement dans votre code 
ActionScript pour effectuer tous types d’actions. Lorsque vous créez un fichier SWF, les 
fonctions nommées sont d’abord compilées, ce qui signifie que vous pouvez y faire référence à 
tout endroit de votre code, tant que la fonction a été définie dans l’image en cours ou une 
image précédente. Par exemple, si une fonction est définie dans l’Image 2 d’un scénario, vous 
ne pouvez pas accéder à cette fonction dans l’Image 1 du scénario.
Le format standard des fonctions nommées est le suivant :
function functionName(parameters) {
// Bloc de la fonction
}
Cet élément de code contient les parties suivantes :
?
functionName est le nom unique de la fonction. Tous les noms des fonctions d’un 
document doivent être uniques.
?
parameters contient un ou plusieurs des paramètres que vous transmettez à la fonction. 
Les paramètres sont parfois appelés arguments. Pour plus d’informations sur les 
paramètres, consultez la section la page 190. 
?
// Bloc de la fonction contient tout le code ActionScript exécuté par la fonction. 
Cette partie contient les instructions « actives ». Vous pouvez y placer le code à exécuter. 
Le commentaire // Bloc de la fonction est un espace réservé au code correspondant 
au bloc de la fonction. 
Présentation des fonctions et des méthodes
177

Pour utiliser une fonction nommée : 
1.
Créez un document appelé .
2. Importez un petit fichier audio dans la bibliothèque. Pour ce faire, cliquez sur Fichier > 
Importer > Importer dans la bibliothèque, puis sélectionnez un fichier audio.
3. Cliquez sur le fichier audio avec le bouton droit de la souris, puis sélectionnez Liaison.
4. Tapez mySoundID dans le champ Identifiant.
5. Sélectionnez l’image 1 du scénario, puis ajoutez le code suivant dans le panneau Actions :
function myMessage() {
trace("mySoundID completed");
}
var my_sound:Sound = new Sound();
my_sound.attachSound("mySoundID");
my_sound.onSoundComplete = myMessage;
my_sound.start();
Dans ce code, vous créez une fonction nommée appelée myMessage, que vous utiliserez 
ensuite dans le script pour appeler une fonction trace().
6. Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
Pour créer votre propre fonction dans ActionScript, utilisez l’instruction function. N’oubliez 
pas que les paramètres sont facultatifs. Cependant, même sans paramètres, vous devez inclure 
les parenthèses. Le contenu placé entre accolades ({}) est appelé bloc de fonction.
Vous pouvez écrire des fonctions dans le scénario principal ou dans des fichiers ActionScript 
externes, y compris des fichiers de classe.
Vous pouvez également écrire des fonctions constructeur dans des fichiers de classe à l’aide de ce 
format. Toutefois, dans ce cas, le nom de la fonction correspond à la classe. Pour plus 
d’informations sur les fonctions constructeur, consultez laconstructeur », à la page 244. Reportez-vous également au pour obtenir des exemples et plus d’informations sur l’écriture de fonctions dans des classes. 
Ecriture de fonctions anonymes et de rappel
Une fonction nommée est une fonction à laquelle vous faites référence dans votre script avant 
ou après l’avoir définie, tandis qu’une fonction anonyme est une fonction sans nom qui se 
référence elle-même. Vous faites référence à la fonction anonyme lors de sa création. 
En rédigeant votre code ActionScript, vous créerez de nombreuses fonctions anonymes. 
Les fonctions anonymes sont fréquemment utilisées avec les gestionnaires d’événements. 
Pour écrire une fonction anonyme, vous pouvez stocker un littéral de fonction dans une 
variable. Ainsi, vous pouvez faire référence à la fonction ultérieurement dans votre code. 
L’exemple suivant montre l’écriture d’une fonction anonyme.
178
Fonctions et méthodes

Pour écrire une fonction anonyme :
1.
Créez un clip sur la scène, puis sélectionnez-le.
2. Ouvrez l’inspecteur des propriétés et tapez my_mc dans la zone de texte Nom de 
l’occurrence.
3. Sélectionnez l’image 1 du scénario, puis tapez le code suivant dans le panneau Actions :
var myWidth = function () {
trace(my_mc._width);
};
// Plus loin, vous pouvez ajouter dans le code
myWidth();
4. Choisissez Contrôle > Tester l’animation. 
La largeur du clip apparaît dans le panneau de sortie.
Vous pouvez également créer une fonction dans un objet, tel que XML ou LoadVars. 
Vous pouvez associer une fonction anonyme à un événement donné pour créer une fonction de 
rappel
. Une fonction appelle une fonction de rappel après un événement spécifique, tel que la 
fin d’un téléchargement (onLoad()) ou la fin d’une animation (onMotionFinished()).  
Par exemple, vous avez parfois besoin d’écrire du code ActionScript pour manipuler des 
données chargées dans un fichier SWF à partir du serveur. Après avoir chargé les données dans 
un fichier SWF, vous pouvez y accéder depuis cet emplacement. Il est important d’utiliser 
ActionScript pour s’assurer que les données ont bien été entièrement chargées. Vous pouvez 
utiliser les fonctions de rappel pour envoyer un signal indiquant que les données ont bien été 
chargées dans le document.
Dans la fonction de rappel suivante, dans laquelle vous chargez un document XML distant, 
vous associez une fonction anonyme à l’événement onLoad(). Vous utilisez () et la 
fonction de rappel, comme le montre l’exemple suivant. Tapez le code suivant dans l’image 1 
du scénario :
var my_xml:XML = new XML();
my_xml.onLoad = function(success:Boolean):Void {
trace(success);
};
("");
Dans le fragment de code suivant, vous constatez que le gestionnaire d’événement onLoad() 
utilise une fonction anonyme pour gérer l’événement onLoad().
Pour plus d’informations sur les fonctions de rappel, consultez led’événements », à la page 311.
Présentation des fonctions et des méthodes
179

Vous pouvez utiliser des fonctions anonymes avec la fonction setInterval(), comme le 
montre le code suivant, qui utilise setInterval() pour appeler la fonction anonyme environ 
toutes les 100 millisecondes (soit toutes les secondes) :
setInterval(function() {trace("interval");}, 1000);
A la place des fonctions anonymes, vous pouvez utiliser des fonctions nommées. Ces dernières 
sont souvent plus faciles à interpréter et à comprendre (sauf dans certaines circonstances, par 
exemple dans le cas de fonctions de rappel). Vous pouvez également pré-référencer une 
fonction nommée, ce qui signifie que vous y faites référence avant qu’elle n’existe dans le 
scénario.
Vous ne pouvez pas référencer une fonction anonyme n’importe où dans votre code (sauf si 
vous l’affectez à une variable), alors que vous pouvez le faire avec une fonction nommée. 
Supposons par exemple que votre fichier FLA comporte des fonctions anonymes sur 
l’Image 5, comme indiqué ci-dessous :
//avec un clip appelé my_mc qui correspond au scénario
stop();
var myWidth = function () {
trace(my_mc._width);
};
Si vous placez le code suivant sur l’Image 1, il ne peut pas faire référence à la fonction :
myWidth();
De la même manière, le code suivant placé sur n’importe quelle image ne fonctionne pas :
myWidth();
var myWidth:Function = function () {
trace(my_mc._width);
};
En revanche, ce code fonctionne correctement :
var myWidth:Function = function () {
trace(my_mc._width);
};
myWidth();
RE
Vous pouvez également placer myWidth() sur n’importe quelle image suivant l’image qui 
M
A
contient la fonction myWidth.
R
Q
UE
180
Fonctions et méthodes

Lorsque vous définissez une fonction nommée, vous pouvez l’appeler dans un script d’image 
même si le code équivalent avec une fonction anonyme ne fonctionne pas :
// le code suivant fonctionne car vous appelez une fonction nommée :
myWidth();
function myWidth() {
trace("foo");
}
// le code suivant ne fonctionne pas car vous appelez une fonction anonyme :
myWidth();
var myWidth:Function = function () {
trace("foo");
};
Pour plus d’informations, voir « Ecriture des fonctions nommées », à la page 177. 
REMARQUE
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script, consultez 
le guide Utilisation de Flash
Présentation des littéraux de fonction 
Un littéral de fonction est une fonction sans nom que vous déclarez dans une expression et non 
dans une instruction. Ces fonctions littérales s’avèrent très pratiques lorsque vous devez 
utiliser une fonction momentanément ou une fonction dans votre code à la place d’une 
expression. La syntaxe des littéraux de fonction est la suivante :
function (param1, param2, etc) {
// instructions
};
Par exemple, le code suivant utilise un littéral de fonction en tant qu’expression :
var yourName:String = "Ester";
setInterval(function() {trace(yourName);}, 200);
REMARQUE
Lorsque vous redéfinissez un littéral de fonction, la nouvelle définition de fonction 
remplace l’ancienne. 
Vous pouvez stocker un littéral de fonction dans une variable afin d’y accéder ultérieurement 
dans votre code. Pour ce faire, vous utilisez une fonction anonyme. Pour plus d’informations, 
voir « Ecriture de fonctions anonymes et de rappel », à la page 178.
Présentation des fonctions et des méthodes
181

Présentation des fonctions constructeur
Le constructeur d’une classe est une fonction spéciale appelée automatiquement lorsque vous 
créez une occurrence de classe en utilisant le mot-clé new (tel que var my_xml:XML = new 
XML();). La fonction constructeur porte le même nom que la classe qui la contient. 
Par exemple, une classe Person personnalisée que vous créez contiendrait la fonction 
constructeur suivante : 
public function Person(speed:Number) {
Person.numPeople++;
this._speed = speed;
}
Vous pouvez alors créer une nouvelle occurrence à l’aide de :
var myPerson:Person = new Person();
REMARQUE
Si vous ne déclarez aucune fonction constructeur explicitement dans votre fichier de 
classe, c’est-à-dire, si vous ne créez pas de fonction dont le nom correspond à celui de 
la classe, le compilateur crée automatiquement une fonction constructeur vide.
Une classe ne peut contenir qu’une seule fonction constructeur ; les fonctions constructeur 
étendues ne sont pas autorisées dans ActionScript 2.0. En outre, une fonction constructeur ne 
peut pas avoir de type de renvoi. Pour plus d’informations sur l’écriture de fonctions 
constructeur dans des fichiers de classe, consultez la sectconstructeur », à la page 244.
Définition des fonctions globales et de scénario 
Dans la section « Présentation des fonctions et des méthodes », à la page 171, vous avez 
découvert les différentes sortes de fonctions disponibles dans Flash. Comme les variables, les 
fonctions sont associées au scénario du clip qui les définit, et vous devez utiliser un chemin 
cible pour les appeler. Comme pour les variables, vous pouvez utiliser l’identifiant _global 
pour déclarer une fonction globale accessible à tous les scénarios et les domaines sans 
employer de chemin cible. Pour définir une fonction globale, faites précéder son nom de 
l’identifiant _global, comme illustré ci-dessous : 
_global.myFunction = function(myNum:Number):Number {
   return (myNum * 2) + 3;
};
trace(myFunction(5)) // 13
Pour plus d’informations sur _global et le domaine, consultez la section domaine », à la page 62.
182
Fonctions et méthodes

Pour définir une fonction de scénario, utilisez l’instruction function suivie du nom de la 
fonction, des paramètres qui doivent être transmis à la fonction et des instructions 
ActionScript qui indiquent le rôle de la fonction.
L’exemple suivant illustre une fonction nommée areaOfCircle et dotée du paramètre 
radius :
function areaOfCircle(radius:Number):Number {
  return ( * radius * radius);
}
trace (areaOfCircle(8));
Vous pouvez également définir des fonctions de nombreuses autres manières. Pour plus 
d’informations sur chaque type de fonction, consultez les sections suivantes :
?
« Présentation des fonctions de niveau supérieur et intégrées », à la page 176
?
« Ecriture des fonctions nommées », à la page 177
?
« Ecriture de fonctions anonymes et de rappel », à la page 178
?
« Présentation des littéraux de fonction », à la page 181
?
« Présentation des fonctions constructeur », à la page 182 
?
« Ciblage et appel de fonctions définies par l’utilisateur », à la page 183
Pour plus d’informations sur l’appellation des fonctions », à la page 185. Pour des exemples concrets d’emploi de fonctions dans un fichier 
de classe externe, consultez la section « Utilisation des fonctions dans Flash », à la page 185 et 
le Chapitre 6, « Classes », à la page 197. 
REMARQUE
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script, consultez 
le guide Utilisation de Flash.
Ciblage et appel de fonctions définies par l’utilisateur
Les fonctions définies par l’utilisateur sont celles que vous créez vous-même pour les utiliser 
dans vos applications, à la différence des fonctions des classes intégrées qui exécutent des 
fonctions prédéfinies. Vous choisissez leur nom et ajoutez des instructions dans le bloc de la 
fonction. Les sections précédentes traitent de l’écriture de différentes fonctions (fonctions de 
rappel, nommées et sans nom). Pour plus d’informations sur l’appellation des fonctions, 
consultez la section « Appellation des fonctions », à la page 185. Pour l’utilisation des 
fonctions, consultez la section « Utilisation des fonctions dans Flash », à la page 185. 
Présentation des fonctions et des méthodes
183

Vous pouvez utiliser un chemin cible pour appeler une fonction d’un scénario, quel qu’il soit, 
à partir de n’importe quel autre scénario, y compris celui d’un fichier SWF chargé. 
Pour appeler une fonction, tapez le chemin cible dans son nom, si nécessaire, puis transmettez 
tous les paramètres requis entre parenthèses. Il existe plusieurs formes de syntaxe pour les 
fonctions définies par l’utilisateur. Le code suivant utilise un chemin pour appeler la fonction 
initialize() qui a été définie dans le scénario actuel et n’exige aucun paramètre :
this.initialize();
L’exemple suivant utilise un chemin relatif pour appeler la fonction list() qui a été définie 
dans le clip functionsClip :
(6);
Pour plus d’informations sur l’écriture des fonctions nommées, consultezdes fonctions nommées », à la page 177. Pour plus d’informations sur les paramètres, 
consultez la section « Transmission de paramètres à une fonction », à la page 190.
Vous pouvez également définir vos propres fonctions nommées. Par exemple, la fonction 
nommée suivante helloWorld() est définie par l’utilisateur :
function helloWorld() {
trace("Hello world!");
};
L’exemple suivant montre comment utiliser une fonction définie par l’utilisateur dans un 
fichier FLA.
Pour créer et appeler une simple fonction définie par l’utilisateur : 
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
function traceHello(name:String):Void {
trace("hello, " + name + "!");
}
traceHello("world"); // hello, world!
Le code précédent crée une fonction définie par l’utilisateur appelée traceHello() qui 
prend un argument, name, et suit un message de bienvenue. Pour appeler la fonction 
définie par l’utilisateur, vous pouvez appeler traceHello à partir du même scénario que la 
définition de fonction et transmettre une seule valeur de chaîne.
3. Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Pour plus d’informations sur les fonctions nommées, fonctions nommées », à la page 177. Les classes contiennent de nombreuses fonctions définies 
par l’utilisateur. Pour plus d’informations sur l’écriture des fonctions dans des fichiers de 
classe, consultez la section « Utilisation des fonctions dans Flash », à la page 185. Reportez-
vous également aux sections suivantes dans le Chapitre 6, « Classes » : méthodes et des propriétés d’un fichier de classe », à la page 219, et propriétés (membres) publiques, privées et statiques », à la page 221membres de classe », à la page 224.
184
Fonctions et méthodes

Appellation des fonctions 
Les noms de fonction doivent commencer par une minuscule. Ils doivent décrire la valeur 
renvoyée par la fonction, le cas échéant. Par exemple, si la fonction renvoie le titre d’une 
chanson, nommez-la getCurrentSong().
Etablissez des normes d’appellation pour regrouper les fonctions similaires (celles qui sont 
apparentées par leur fonctionnalité), car ActionScript n’autorise pas la surcharge. Dans le cas 
de la programmation orientée objet (OOP), la surcharge consiste à autoriser des 
comportements différents pour vos fonctions, selon les types de données qui leurs sont passés.
Comme avec les variables, vous ne pouvez pas utiliser de caractères spéciaux et le nom de 
méthode ne peut pas débuter par un chiffre. Pour plus d’informations, voir d’appellation », à la page 717. Pour plus d’informations sur l’appellation des méthodes, 
consultez la section « Appellation des méthodes », à la page 196.
Utilisation des fonctions dans Flash 
Cette section présente l’utilisation des fonctions dans une application. Certains des exemples 
de code suivants utilisent du code ActionScript qui réside dans le fichier FLA. Les autres 
placent les fonctions dans un fichier de classe à titre de comparaison. Pour obtenir plus 
d’informations et des exemples sur l’utilisation des fonctions dans un fichier de classe, 
consultez le Chapitre 6, « Classes », à la page 197. Pour obtenir des informations détaillées et 
des instructions sur la façon d’écrire des fonctions pour un fichier de classe, consultez la 
section « Exemple : Ecriture de classes personnalisées », à la page 238.
Pour réduire la somme de travail nécessaire, ainsi que la taille de votre fichier SWF, réutilisez 
des blocs de code existants chaque fois que possible. Pour ce faire, vous pouvez appeler la 
même fonction à plusieurs reprises, au lieu de créer du code de toutes pièces à chaque fois. 
Les fonctions peuvent comporter du code générique, ce qui permet d’utiliser les mêmes blocs 
à des fins légèrement différentes dans un fichier SWF. Le recyclage du code permet de créer 
des applications efficaces et de réduire la quantité de code ActionScript à écrire, et donc la 
durée du développement.  
Vous pouvez créer des fonctions dans un fichier FLA ou de classe ou écrire du code 
ActionScript qui réside dans un composant à base de code. Les exemples suivants présentent la 
création de fonctions sur un scénario et dans un fichier de classe.
CO
En réunissant vos scripts dans des fichiers de classe ou des composants à base de 
NS
code, vous pouvez facilement partager, distribuer et réutiliser vos blocs de code. 
EIL
L’utilisateur peut installer votre composant, le faire glisser sur la scène et utiliser le code 
que vous avez stocké dans le fichier, tel que le flux de travail pour les composants à base 
de code disponibles dans (Fenêtre > Bibliothèques communes > Classes).
L’exemple suivant montre comment créer et appeler une fonction dans un fichier FLA.
Présentation des fonctions et des méthodes
185

Pour créer et appeler une fonction dans un fichier FLA : 
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Choisissez Fenêtre > Actions pour ouvrir le panneau Actions.
3. Tapez le code ActionScript suivant dans la fenêtre de script :
function helloWorld() {
// instructions ici
trace("Hello world!");
};
Ce code ActionScript définit la fonction (nommée et définie par l’utilisateur) appelée 
helloWorld(). Si vous testez votre fichier SWF à ce stade, rien ne se produit. 
Par exemple, vous ne voyez pas l’instruction trace dans le panneau de sortie. Pour ce 
faire, vous devez appeler la fonction helloWorld().
4. Tapez la ligne suivante à la suite de la fonction :
helloWorld();
Ce code appelle la fonction helloWorld().
5. Choisissez Contrôle > Tester l’animation pour tester le fichier FLA. 
Le texte suivant apparaît dans le panneau de sortie : Hello world!
Pour plus d’informations sur la transmission de valeurs (paramètres) à une fonction, consultez 
la section « Transmission de paramètres à une fonction », à la page 190.
Il existe plusieurs manières pour écrire des fonctions dans le scénario principal. Les plus 
utilisées sont les fonctions nommées et anonymes. Par exemple, vous pouvez utiliser la syntaxe 
suivante pour créer des fonctions :
function myCircle(radius:Number):Number {
return ( * radius * radius);
}
trace(myCircle(5));
Les fonctions anonymes sont souvent plus difficiles à interpréter. Comparez le code suivant au 
précédent.
var myCircle:Function = function(radius:Number):Number {
// Bloc de fonction ici
return ( * radius * radius);
};
trace(myCircle(5));
186
Fonctions et méthodes

Vous pouvez également placer des fonctions dans des fichiers de classe si vous utilisez 
ActionScript 2.0, comme l’illustre l’exemple suivant :
class Cercle {
public function area(radius:Number):Number {
return ( * (radius, 2));
}
public function perimeter(radius:Number):Number {
return (2 * * radius);
}
public function diameter(radius:Number):Number {
return (radius * 2);
}
}
Pour plus d’informations sur l’écriture de fonctions dans un fichier de classe, consultez le 
Chapitre 6, « Classes », à la page 197.
Comme l’indique l’exemple de code précédent, vous n’avez pas besoin de placer des fonctions 
sur un scénario. L’exemple suivant place également des fonctions dans un fichier de classe. 
Cette technique est judicieuse lorsque vous créez des applications volumineuses à l’aide 
d’ActionScript 2.0 car elle vous permet de réutiliser facilement votre code dans plusieurs 
applications. Lorsque vous devez utiliser de nouveau les fonctions dans d’autres applications, 
vous pouvez importer la classe existante sans avoir à ré-écrire le code de toutes pièces ou 
dupliquer les fonctions dans la nouvelle application.
Pour créer des fonctions dans un fichier de classe :
1.
Créez un document ActionScript, puis enregistrez-le sous le nom .
2. Tapez le code ActionScript suivant dans la fenêtre de script :
class Utils {
  public static function randomRange(min:Number, max:Number):Number {
    if (min > max) {
      var temp:Number = min;
      min = max;
      max = temp;
    }
    return (Math.floor(Math.random() * (max - min + 1)) + min);
  }
  public static function arrayMin(num_array:Array):Number {
    if (num_array.length == 0) {
      return ;
    }
    (Array.NUMERIC | Array.DESCENDING);
    var min:Number = Number(());
    return min;
  }
Présentation des fonctions et des méthodes
187

  public static function arrayMax(num_array:Array):Number {
    if (num_array.length == 0) {
      return undefined;
    }
    (Array.NUMERIC);
    var max:Number = Number(());
    return max;
  }
}
3. Sélectionnez Fichier > Enregistrer pour enregistrer le fichier ActionScript.
4. Créez un document Flash et enregistrez-le sous le nom  dans le même 
répertoire que .
5. Choisissez Fenêtre > Actions pour ouvrir le panneau Actions.
6. Tapez le code ActionScript suivant dans la fenêtre de script :
var randomMonth:Number = Utils.randomRange(0, 11);
var min:Number = Utils.arrayMin([3, 3, 5, 34, 2, 1, 1, -3]);
var max:Number = Utils.arrayMax([3, 3, 5, 34, 2, 1, 1, -3]);
trace("month: " + randomMonth);
trace("min: " + min); // -3
trace("max: " + max); // 34
7. Choisissez Contrôle > Tester l’animation pour tester les documents. Le texte suivant 
apparaît dans le panneau de sortie :
month: 7
min: -3
max: 34
REMARQUE
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script, 
consultez le guide Utilisation de Flash.
188
Fonctions et méthodes

Utilisation de variables dans les fonctions
Les variables locales sont des outils qui simplifient grandement l’organisation du code et en 
facilitent la compréhension. Lorsqu’une fonction utilise des variables locales, elle peut les 
cacher à tous les autres scripts du fichier SWF. Les variables locales ont un domaine limité au 
corps de la fonction et sont détruites à la sortie de celle-ci. Flash traite également tous les 
paramètres transmis à une fonction en tant que variables locales.
REMARQUE
Vous pouvez également utiliser des variables normales dans une fonction. Cependant, si 
vous modifiez des variables normales dans une fonction, il est judicieux de commenter 
ces changements.
Pour utiliser des variables dans les fonctions :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var myName:String = "Ester";
var myAge:String = "65";
var myFavSoftware:String = "Flash";
function traceMe(yourFavSoftware:String, yourName:String, 
yourAge:String) {
trace("I’m " + yourName + ", I like " + yourFavSoftware + ", and I’m " 
+ yourAge + ".");
}
traceMe(myFavSoftware, myName, myAge);
3. Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Pour plus d’informations sur la transmission de paramètres, consultez la section de paramètres à une fonction », à la page 190. Pour plus d’informations sur les variables et les 
données, consultez le Chapitre 3, « Données et types de données », à la page 35.
Présentation des fonctions et des méthodes
189

Transmission de paramètres à une fonction 
Les paramètres, également appelés arguments, sont les éléments sur lesquels une fonction 
exécute son code. Dans cet ouvrage, les termes paramètre et argument sont interchangeables. 
Vous pouvez transmettre des paramètres (valeurs) à une fonction. Vous pouvez ensuite utiliser 
ces paramètres pour le traitement de la fonction. Vous utilisez les valeurs au sein du bloc de la 
fonction (ses instructions).
Certains paramètres sont obligatoires, d’autres sont facultatifs. Vous pouvez même avoir des 
paramètres obligatoires et facultatifs dans la même fonction. Si vous ne transmettez pas 
suffisamment de paramètres à une fonction, Flash définit les valeurs des paramètres manquants 
sur undefined, ce qui peut générer des résultats inattendus dans votre fichier SWF.
La fonction suivante, appelée myFunc(), prend le paramètre someText :
function myFunc(someText:String):Void {
trace(someText);
}
Après la transmission du paramètre, vous pouvez transmettre une valeur à la fonction lorsque 
vous appelez celle-ci. Cette valeur apparaît dans le panneau de sortie, comme suit :
myFunc("This is what traces");
Lorsque vous appelez la fonction, vous devez toujours transmettre le nombre de paramètres 
spécifié sauf si votre fonction recherche des valeurs indéfinies et si les valeurs par défaut sont 
définies en conséquence. La fonction substitue les valeurs transmises aux paramètres de la 
définition de la fonction. Si l’un des paramètres est manquant, Flash lui affecte la valeur 
undefined. Dans votre code ActionScript, vous êtes fréquemment amené(e) à transmettre des 
paramètres aux fonctions.
Vous pouvez également transmettre plusieurs paramètres à la même fonction, aussi 
simplement que dans l’exemple suivant :
var birthday:Date = new Date(1901, 2, 3);
trace(birthday);
Les paramètres sont séparés par des virgules. De nombreuses fonctions intégrées du langage 
ActionScript possèdent plusieurs paramètres. Par exemple, la méthode startDrag() de la 
classe MovieClip prend cinq paramètres : lockCenter, left, top, right et bottom.
startDrag(lockCenter:Boolean, left:Number, top:Number, right:Number, 
bottom:Number):Void
190
Fonctions et méthodes

Pour transmettre un paramètre à une fonction :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code suivant à l’image 1 du scénario : 
function traceMe(yourMessage:String):Void {
trace(yourMessage);
}
traceMe("Comment allez-vous ?");
Les premières lignes du code créent une fonction définie par l’utilisateur, appelée 
traceMe(), qui prend un seul paramètre, yourMessage. La dernière ligne du code appelle 
la fonction traceMe() et transmet la valeur de chaîne « Comment allez-vous ? ».
3. Choisissez Contrôle > Tester l’animation pour tester le document Flash.
L’exemple suivant montre comment transmettre plusieurs paramètres à une fonction.
Pour transmettre plusieurs paramètres à une fonction :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code suivant à l’image 1 du scénario principal :
function getArea(width:Number, height:Number):Number {
     return width * height;
}
La fonction getArea() réclame deux paramètres : width et height.
3. Tapez le code suivant à la suite de la fonction :
var area:Number = getArea(10, 12);
trace(area); // 120  
L’appel de la fonction getArea() affecte les valeurs 10 et 12 aux paramètres width et 
height, respectivement, et vous enregistrez la valeur renvoyée dans l’occurrence area. 
Ensuite, vous suivez les valeurs enregistrées dans l’occurrence area. 
4. Choisissez Contrôle > Tester l’animation pour tester le fichier SWF. 
La mention 120 s’affiche dans le panneau de sortie.
Les paramètres de la fonction getArea() sont similaires aux valeurs d’une variable locale : 
ils existent tant que la fonction est appelée et cessent d’exister à la sortie de la fonction.
Dans l’exemple suivant, le code ActionScript renvoie la valeur NaN (Non numérique) si vous 
ne renseignez pas suffisamment de paramètres dans la fonction addNumbers().
Présentation des fonctions et des méthodes
191

Pour transmettre un nombre variable de paramètres à une fonction :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code suivant à l’image 1 du scénario principal :
function addNumbers(a:Number, b:Number, c:Number):Number {
return (a + b + c);
}
trace(addNumbers(1, 4, 6)); // 11
trace(addNumbers(1, 4)); // NaN (Non numérique), c est undefined
trace(addNumbers(1, 4, 6, 8)); // 11
Si vous ne transmettez pas suffisamment de paramètres à la fonction addNumbers, la 
valeur undefined est affectée par défaut aux arguments manquants. Si vous en 
transmettez trop, les arguments excédentaires sont ignorés.
3. Choisissez Contrôle > Tester l’animation pour tester le document Flash. 
Flash affiche alors les valeurs suivantes : 11, NaN, 11.
Renvoi de valeurs depuis les fonctions
Utilisez l’instruction return pour renvoyer des valeurs depuis les fonctions. L’instruction 
return indique la valeur renvoyée par une fonction. L’instruction return renvoie le résultat 
d’une évaluation sous la forme d’une valeur de la fonction dans laquelle une expression est 
exécutée. L’instruction return renvoie son résultat immédiatement au code appelant. 
Pour plus d’informations, consultez la section instruction return du Guide de référence du 
langage ActionScript 2.0
.
Les règles suivantes régissent l’emploi de l’instruction return dans les fonctions :
?
Si vous spécifiez un type de renvoi autre que Void pour une fonction, vous devez inclure 
une instruction return  suivie par la valeur renvoyée dans la fonction.
?
Si vous spécifiez un type de renvoi Void, l’instruction return est inutile, mais dans ce cas, 
elle ne doit être suivie par aucune valeur.
?
Quel que soit le type de renvoi choisi, vous pouvez utiliser une instruction return pour 
quitter la fonction en son milieu.
?
Si vous ne spécifiez pas de type de renvoi, l’incorporation d’une instruction return est 
facultative.
Par exemple, la fonction suivante renvoie le carré du paramètre myNum et spécifie que la valeur 
renvoyée doit être de type Number :
function sqr(myNum:Number):Number {
  return myNum * myNum;
}
Certaines fonctions effectuent une série de tâches sans renvoyer de valeur. L’exemple suivant 
renvoie la valeur traitée. Vous récupérez cette valeur dans une variable, puis vous utilisez cette 
variable dans votre application.
192
Fonctions et méthodes

Pour renvoyer une valeur et la récupérer dans une variable :
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code suivant à l’image 1 du scénario principal :
function getArea(width:Number, height:Number):Number {
     return width * height;
}
La fonction getArea() réclame deux paramètres : width et height.
3. Tapez le code suivant à la suite de la fonction :
var area:Number = getArea(10, 12);
trace(area); // 120 
L’appel de la fonction getArea() affecte les valeurs 10 et 12 aux paramètres width et 
height respectivement et vous enregistrez la valeur renvoyée dans l’occurrence area. 
Ensuite, vous suivez les valeurs enregistrées dans l’occurrence area.
4. Choisissez Contrôle > Tester l’animation pour tester le fichier SWF. 
La mention 120 s’affiche dans le panneau de sortie.
Les paramètres de la fonction getArea() sont similaires aux valeurs d’une variable locale : 
ils existent tant que la fonction est appelée et cessent d’exister à la sortie de la fonction.
Présentation des fonctions imbriquées 
Vous pouvez appeler une fonction de l’intérieur d’une autre fonction. Ainsi, vous pouvez 
imbriquer des fonctions les unes dans les autres pour qu’elles exécutent des tâches spéciales 
dans Flash. 
Par exemple, vous pouvez imbriquer plusieurs fonctions dans un scénario pour exécuter des 
tâches spécifiques sur une chaîne. Tapez le code suivant dans l’image 1 du scénario :
var myStr:String = "My marshmallow chicken is yellow.";
trace("Original string: " + myStr);
function formatText():Void {
changeString("Put chicken in microwave.");
trace("Changed string: " + myStr);
}
function changeString(newtext:String):Void {
myStr = newtext;
}
// Appel de la fonction.
formatText();
Choisissez Contrôle > Tester l’animation pour tester la fonction imbriquée. Les deux 
fonctions formatText() et changeString() sont appliquées à la chaîne lorsque vous appelez 
la fonction formatText().
Présentation des fonctions et des méthodes
193

Fonctionnement des méthodes 
Les méthodes sont des fonctions associées à une classe. La classe peut être personnalisée ou 
intégrée au langage ActionScript. Pour en savoir plus sur la comparaison entre les méthodes et 
les fonctions, consultez la page 171 et « Types de méthodes et de fonctions », à la page 173. 
Par exemple, sortOn() est une méthode intégrée associée à la classe Array (sortOn est une 
fonction de la classe Array prédéfinie intégrée à Flash). 
Pour utiliser la méthode sortOn() dans un fichier FLA : 
1.
Créez un document Flash et enregistrez-le sous le nom .
2. Ajoutez le code suivant à l’image 1 du scénario :
var userArr:Array = new Array();
({firstname:"George", age:39});
({firstname:"Dan", age:43});
({firstname:"Socks", age:2});
userArr.sortOn("firstname");
var userArrayLenth:Number = userArr.length;
var i:Number;
for (i = 0; i < userArrayLenth; i++) {
trace(userArr[i].firstname);
}
Vous utilisez la méthode sortOn() de la classe Array pour créer un nouvel objet Array 
appelé userArr. Ce nouveau tableau est rempli par trois objets contenant un prénom et 
un âge, puis il est trié sur la base de la valeur de la propriété firstname de chaque objet. 
Pour finir, vous passez en boucle sur chaque élément du tableau, vous affichez le prénom 
dans le panneau de sortie et vous triez les noms par ordre alphabétique.
3. Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
Ce code donne les résultats suivants dans le panneau de sortie : 
Dan
George
Socks
Comme le démontre la section « Ecriture des fonctions nommées », à la page 177, lorsque 
vous écrivez le code suivant sur l’image 1 du scénario, votre code ActionScript définit une 
fonction appelée eatCabbage().
function eatCabbage() {
    trace("tastes bad");
}
eatCabbage();
194
Fonctions et méthodes

Toutefois, si vous écrivez la fonction eatCabbage() dans un fichier de classe et que vous 
appelez, par exemple, la fonction eatCabbage() dans le fichier FLA, eatCabbage() est 
considérée comme une méthode.
Les exemples suivants montrent comment créer des méthodes dans une classe.
Pour comparer des méthodes et des fonctions :  
1.
Créez un fichier ActionScript, sélectionnez Fichier > Enregistrer sous, puis enregistrez-le 
sous le nom .
2. Tapez le code ActionScript suivant dans la fenêtre de script : 
class EatingHabits {
  public function eatCabbage():Void {
    trace("tastes bad");
  }
}
3. Enregistrez les modifications apportées au fichier .
4. Créez un document Flash, sélectionnez Fichier > Enregistrer sous, nommez-le 
, puis enregistrez ce fichier dans le même répertoire que .
5. Tapez le code ActionScript suivant dans l’image 1 du scénario :
var myHabits:EatingHabits = new EatingHabits();
myHabits.eatCabbage();
Lorsque vous utilisez ce code ActionScript, vous appelez la méthode eatCabbage() de la 
classe EatingHabits.
REMARQUE
Lorsque vous utilisez des méthodes d’une classe intégrée (en plus de la classe 
personnalisée que vous avez créée précédemment dans cette procédure), vous 
utilisez une méthode sur un scénario.
6. A la suite de la ligne ActionScript précédente, ajoutez le code suivant :
function eatCarrots():Void {
    trace("tastes good");
}
eatCarrots();
Dans ce code, vous écrivez et appelez la fonction eatCarrots().
7. Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
Fonctionnement des méthodes
195

Appellation des méthodes 
Utilisez de préférence des verbes pour nommer les méthodes et des casses différentes pour les 
mots concaténés, en conservant la première lettre en minuscule. Par exemple, vous pouvez 
nommer les méthodes de la façon suivante :
chanter();
boogie();
chanterFort();
danserVite();
Les verbes sont généralement associés aux noms des méthodes dans la mesure où ces dernières 
exécutent une opération sur un objet. Comme avec les variables, vous ne pouvez pas utiliser de 
caractères spéciaux et le nom de méthode ne peut pas débuter par un chiffre. Pour plus 
d’informations, voir « Conventions d’appellation », à la page 717.
196
Fonctions et méthodes

CHAPITRE 6
Classes
6
Ce chapitre présente l’utilisation et l’écriture des classes avec ActionScript 2.0. Les classes sont 
le cœur d’ActionScript 2.0 et leur importance s’est encore accrue dans cette version de Flash. 
Vous vérifierez par vous-même la véracité de cette assertion tout au long de ce chapitre.
Ce chapitre commence par présenter la terminologie de base et ses rapports avec les classes et 
la programmation orientée objet (OOP). Vous découvrez ensuite un exemple de fichier de 
classe, avec le fonctionnement de chacune de ses sections et l’organisation de la classe. Le reste 
du chapitre vous guidera dans la création de vos propres classes personnalisées et dans leur 
utilisation au sein de vos documents Flash. Vous découvrez les chemins de classe de Flash et 
apprenez à documenter vos classes de sorte que les personnes amenées à lire ou utiliser votre 
code puissent aisément le comprendre, ainsi que l’objectif général de vos classes.
Cette section contient les exemples de code qui permettent de se familiariser avec la création 
de classes dans ActionScript 2.0. A la fin de ce chapitre, vous devriez pouvoir écrire un fichier 
de classe typique, comprendre et reconnaître les classes de Flash et être à même de lire sans 
peine les fichiers de classes créés par d’autres personnes.
Si vous ne maîtrisez pas la rédaction de scripts ActionScript 2.0, consultet le Chapitre 4, « Eléments fondamentaux du langage et de la syntaxe », à la page 81.
197

Pour plus d’informations sur l’utilisation des classes intégrées et personnalisée de données, 
consultez les rubriques suivantes :
Présentation de la programmation orientée objet et de Flash . . . . . . . . . . . . . . . . . 198
Ecriture de fichiers de classe personnalisée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  208
Utilisation des classes personnalisées dans une application . . . . . . . . . . . . . . . . . . .211
Exemple : Ecriture de classes personnalisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .238
Exemple : Utilisation de fichiers de classe personnalisée dans Flash. . . . . . . . . . .253
Affectation d’une classe à des symboles dans Flash . . . . . . . . . . . . . . . . . . . . . . . . .256
Compilation et exportation de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258
Distinction entre classes et domaine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
Présentation des classes de niveau supérieur et intégrées. . . . . . . . . . . . . . . . . . . .263
Utilisation des classes intégrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .274
Présentation de la programmation 
orientée objet et de Flash 
ActionScript 2.0 est un langage orienté objet. Ces langages reposent sur le concept de classes et 
d’occurrences. Une classe définit toutes les propriétés qui distinguent une série d’objets. 
Par exemple, une classe User représente un groupe d’utilisateurs qui utilisent votre 
application. Puis, vous avez une instanciation de la classe, laquelle, pour la classe User, 
correspond à l’un des utilisateurs individuels—l’un des membres de la classe. L’instanciation 
produit une occurrence de la classe User qui présente toutes les propriétés de la classe User. 
Les classes sont également considérées comme des types de données ou des modèles, que vous 
pouvez créer pour définir un nouveau type d’objet. Par exemple, si vous avez besoin du type 
de données Lettuce dans votre application, vous pouvez écrire la classe Lettuce. L’opération 
définit l’objet Lettuce et vous permet d’affecter ensuite vos méthodes Lettuce (wash()) et vos 
propriétés (leafy ou bugs). Pour définir une classe, vous utilisez le mot-clé class dans un 
fichier de script externe. Pour créer ce fichier de script externe dans l’outil de programmation 
de Flash, choisissez Fichier > Nouveau puis sélectionnez Fichier ActionScript.
198
Classes

ActionScript 2.0 inclut des fonctionnalités telles que des effets de filtre, le chargement et le 
téléchargement de fichiers et l’API externe ; il reprend également plusieurs concepts et 
mots-clés de la programmation orientée objet (tels que class, interface et package) 
provenant d’autres langages, tels que Java. Le langage de programmation vous permet de créer 
des structures logicielles réutilisables, évolutives, fiables et faciles à maintenir. En fournissant 
aux utilisateurs une aide à la programmation et des informations de débogage approfondies, il 
réduit également les délais de développement. ActionScript2.0 permet de créer des objets et 
d’établir des héritages, de créer des classes personnalisées et d’étendre les classes intégrées et de 
niveau supérieur de Flash. Dans ce chapitre, vous allez apprendre à créer des classes 
personnalisées et à les utiliser.
Flash comprend près de 65 classes intégrées et de niveau supérieur couvrant à peu près tous les 
types de données, de base ou primitifs (Array, Boolean, Date, etc.), jusqu’aux erreurs et 
événements personnalisés, ainsi que plusieurs moyens de charger du contenu externe (XML, 
images, données binaires brutes, etc.). Vous pouvez également écrire vos propres classes 
personnalisées et les intégrer dans vos documents Flash, ou encore étendre les classes de niveau 
supérieur et ajouter vos propres fonctionnalités ou modifier celles qui existent. Par exemple 
« Présentation des membres de classe », à la page 224 dans ce chapitre, explique comment 
créer une classe personnalisée qui contient des propriétés personnalisées pour le nom et l’âge 
des individus. Vous pouvez ensuite traiter cette classe personnalisée comme un nouveau type 
de données dans vos documents et en créer une nouvelle occurrence à l’aide du 
nouvelopérateur.
Pour plus d’informations sur l’utilisation des OOP, consultez les rubriques suivantes :
?
« Avantages de l’utilisation des classes », à la page 200
?
« Présentation des packages », à la page 200
?
« Présentation des valeurs et des types de données », à la page 204
?
« Bases de la programmation orientée objet. », à la page 204
Présentation de la programmation orientée objet et de Flash
199

Avantages de l’utilisation des classes 
En programmation orientée objet, une classe définit une catégorie d’objets. Une classe décrit 
les propriétés (données) et les méthodes (comportements) d’un objet, comme un plan 
d’architecte décrit les caractéristiques d’un immeuble. Vous écrivez votre classe personnalisée 
dans un fichier ActionScript (AS) externe et pouvez ensuite l’importer dans votre application 
lorsque vous compilez le fichier FLA.
Les classes se révèlent très utiles lors du développement d’applications Flash volumineuses car 
elles permettent d’organiser une grande partie de la complexité du code dans des fichiers de 
classes externes. Lorsque vous déplacez une bonne partie du code vers une classe 
personnalisée, vous simplifiez non seulement la réutilisation ultérieure du code, mais vous 
pouvez également « masquer » certaines des méthodes et propriétés des autres parties du code 
ActionScript. Vous évitez ainsi que les utilisateurs accèdent à des informations confidentielles 
ou puissent modifier des données qui ne doivent pas l’être.
En utilisant une classe, vous pouvez également étendre les classes existantes et ajouter de 
nouvelles fonctionnalités ou modifier celles qui existent. Par exemple, si vous créez trois classes 
très similaires, vous pouvez écrire une classe de base, puis deux autres classes qui sont une 
extension de la première. Ces deux classes peuvent ajouter des méthodes et des propriétés 
supplémentaires, ainsi il n’est pas nécessaire de créer trois fichiers de classe dupliquant tous le 
même code et la même logique.
La possibilité de réutilisation du code est un autre avantage des classes. Par exemple, si vous 
créez une classe personnalisée qui crée une barre de progression personnalisée via l’interface de 
programmation d’applications de dessin (API), vous pouvez enregistrer la classe de la barre de 
progression dans votre chemin de classe, puis réutiliser le même code dans tous vos documents 
Flash en important la classe personnalisée Pour plus d’informations sur la configuration du 
chemin de classe, consultez « Importation de fichiers de classe », à la page 212 et et modification du chemin de classe », à la page 214.
Présentation des packages 
Lorsque vous créez des classes, placez vos fichiers de classe ActionScript dans des packages
Un package est un répertoire qui contient un ou plusieurs fichiers de classe et qui réside dans 
un répertoire de chemin de classe désigné (consultez les sections classe », à la page 212 et « Définition et modification du chemin de classe », à la page 214). 
Un package peut également contenir d’autres packages, appelés sous-packages, chacun 
possédant ses propres fichiers de classe. 
200
Classes

Comme les variables, les noms de packages doivent être des identifiants. Ainsi, le premier 
caractère peut être une lettre, un caractère de soulignement (_) ou le signe dollar ($), et chaque 
caractère suivant doit être une lettre, un nombre, un caractère de soulignement ou le signe 
dollar. Il y a des façons conseillées de nommer des packages, par exemple en évitant d’utiliser 
des caractères de soulignement ou le signe dollar. Pour plus d’informations sur les appellations 
des packages, consultez le « Appellation des packages », à la page 726..
Les packages sont généralement utilisés pour organiser des classes connexes. Vous pouvez par 
exemple avoir trois classes connexes, Carre, Cercle et Triangle, définies dans , 
 et . Supposons que vous ayez enregistré les fichiers ActionScript dans un 
répertoire spécifié dans le chemin de classe, comme dans l’exemple suivant :
// Dans  :
class Square {}
// Dans  :
class Circle {}
// Dans  :
class Triangle {}
Etant donné que ces trois classes sont connexes, vous pouvez choisir de les placer dans un 
package (répertoire) nommé Formes. Dans ce cas, le nom complet de la classe contient le 
chemin du package aussi bien que le nom de classe simple. Les chemins de package sont 
symbolisés par une syntaxe de point (.), chaque point représentant un sous-répertoire. 
Par exemple, si vous placez tous les fichiers ActionScript qui définissent une forme dans le 
répertoire Formes, vous devrez alors changer le nom de chaque fichier de classe pour 
répercuter le nouvel emplacement, comme suit : 
// Dans  :
class Shapes.Square {}
// Dans  :
class Shapes.Circle {}
// Dans  :
class Shapes.Triangle {}
Pour faire référence à une classe qui réside dans un répertoire de package, vous pouvez soit 
spécifier son nom complet, soit importer son package à l’aide de l’instruction import. 
Pour plus d’informations, voir « Fonctionnement des packages », à la page 202.
Présentation de la programmation orientée objet et de Flash
201

Comparaison des classes et des packages 
En programmation orientée objet, une classe définit une catégorie d’objets. Les classes sont 
avant tout des types de données que vous pouvez créer pour définir un nouveau type d’objet 
dans votre application. La classe décrit les propriétés (données) et les comportements (méthodes) 
d’un objet, comme un plan d’architecte décrit les caractéristiques d’un immeuble. 
Les propriétés (variables définies au sein d’une classe) et les méthodes d’une classe sont 
collectivement appelées membres de la classe. Pour utiliser les propriétés et méthodes définies 
par une classe, vous devez tout d’abord créer une occurrence de cette classe (sauf pour les 
classes comportant tous les membres statiques ( vclasse », à la page 276, telle que la classe de niveau supérieur Mastatiques », à la page 223). La relation entre une occurrence et sa classe est similaire à la 
relation entre une maison et ses plans.
Dans Flash, les packages sont des répertoires qui contiennent un ou plusieurs fichiers de classe 
et résident dans un chemin de classe désigné. Placez tous les fichiers de classes personnalisées 
connexes dans un même répertoire Par exemple, vous pourriez avoir trois classes appelées 
AcierWidget, PlastiqueWidget et BoisWidget définies dans , 
 et et les organiser dans le package Widget. Pour plus 
d’informations sur les packages, consultez les sections la page 202 et « Création et mise en package de vos fichiers de classe », à la page 241.
Fonctionnement des packages
Les packages 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é. Par exemple, le package flash.filters est un 
répertoire sur votre disque dur contenant plusieurs fichiers de classe pour chaque type de filtre 
(tels que BevelFilter, BlurFilter, DropShadowFilter, etc.) dans Flash 8.
REMAR
Pour utiliser l’instruction import, vous devez spécifier ActionScript 2.0 et Flash Player 6 
ou une version plus récente dans l’onglet Flash de la boîte de dialogue Paramètres de 
publication de votre fichier FLA.
Q
UE
L’instruction import permet d’accéder aux classes sans spécifier leur nom complet, avec 
qualificatifs. Par exemple, si vous souhaitez utiliser la classe BlurFilter dans un script, vous 
devez y faire référence avec son nom suivi de tous ses attributs (flash.filters.BlurFilter) ou 
l’importer. Si vous l’importez, vous pouvez y faire référence avec son nom de classe 
(BlurFilter). Le code ActionScript suivant démontre les différences entre l’utilisation de 
l’instruction import et l’utilisation des noms de classes complets.
202
Classes

Si vous n’importez pas la classe BlurFilter, votre code devra comporter les noms de classes 
complets (le nom du package suivi par le nom de classe) afin d’utiliser le filtre :
// sans importation 
var myBlur:flash.filters.BlurFilter = new flash.filters.BlurFilter(10, 10, 
3); 
Le même code, écrit avec une instruction import , vous permet d’accéder à BlurFilter en 
utilisant seulement le nom de classe au lieu de devoir toujours utiliser le nom complet du 
service. Cela peut éviter d’avoir à retaper, et réduire ainsi les éventuelles erreurs de 
typographies :
// avec importation 
import flash.filters.BlurFilter; 
var myBlur:BlurFilter = new BlurFilter(10, 10, 3);
Si vous importez plusieurs classes au sein d’un package (par exemple, BlurFilter, 
DropShadowFilter, et GlowFilter) il vous est possible d’utiliser l’une des deux méthodes pour 
importer chaque classe. La première méthode d’importation de classes multiples est 
d’importer chaque classe en utilisant une instruction import séparée, comme indiqué dans le 
fragment suivant :
import flash.filters.BlurFilter;
import flash.filters.DropShadowFilter;
import flash.filters.GlowFilter;
L’utilisation d’instructions import individuelles pour chaque classe dans un package peut 
prendre beaucoup de temps et conduire à des erreurs de typographie. La deuxième méthode 
d’importation de classes dans un package est d’utiliser un import générique, qui importe 
toutes les classes dans le niveau donné d’un package. L’ActionScript suivante montre un 
exemple d’utilisation d’un import générique :
import flash.filters.*; // importe chaque classe dans le package 
flash.filters
L’instruction import s’applique uniquement au script courant (image ou objet) dans lequel 
elle est appelée. Par exemple, supposons que vous deviez importer l’ensemble des classes du 
package dans l’image 1 d’un document Flash. Dans cette image, vous pouvez faire 
référence aux classes de ce package par leur nom de classe au lieu de leurs noms complets. 
Si vous souhaitez cependant utiliser le nom de classe dans un autre script d’image, vous devez 
faire référence aux classes de ce package par leur nom complet, ou ajouter une instruction 
import à l’autre image qui importe les classes dans ce package.
Présentation de la programmation orientée objet et de Flash
203

Lors de l’utilisation d’instructions import, Il est également important de noter que les classes 
sont importées seulement pour le niveau indiqué. Par exemple, si vous avez importé toutes les 
classes dans le package mx.transitions, seules les classes du répertoire /transitions/ sont 
importées, et non toutes les classes des sous-répertoires (telles les classes du package 
mx.transitions.easing).
CO
Si vous importez une classe, mais ne l’utilisez pas dans votre script, cette dernière n’est 
NS
pas exportée avec le fichier SWF. Ceci signifie que vous pouvez importer des packages 
EIL
volumineux sans vous soucier de la taille du fichier SWF. Le pseudo-code binaire 
associé à une classe n’est inclus dans un fichier SWF que si cette classe est 
véritablement utilisée.
Présentation des valeurs et des types de données 
Les données, les valeurs et les types sont des concepts importants lorsque vous commencez à 
écrire des classes et à les utiliser. Vous avez étudié les fichiers « Données et types de données », à la page 35. Lorsque vous travaillez avec des classes, 
n’oubliez pas que les types de données décrivent la nature des informations qu’une variable ou 
qu’un élément ActionScript peut contenir, par exemple Boolean, Number et String. Pour plus 
d’informations, voir « Présentation des types de données », à la page 36.
Les expressions ont des valeurs alors que les valeurs et les propriétés ont des types. Les valeurs 
que vous pouvez définir et obtenir pour et à partir d’une propriété de votre classe doivent être 
compatibles avec cette propriété. La compatibilité de type signifie que le type d’une valeur est 
compatible avec le type utilisé, comme dans l’exemple suivant :
var myNum:Number = 10;
Pour plus d’informations sur le typage strict des données, consultez la types de données et typage strict », à la page 45.
Bases de la programmation orientée objet.
Au cours des sections suivantes, vous allez vous familiariser avec la terminologie employée tout 
au long de ce chapitre avant de commencer à écrire du code ActionScript. Cette brève 
introduction aux principes du développement orienté objet vous aide à mieux comprendre les 
exemples et les sections de ce chapitre et du reste de ce manuel. Ces principes sont présentés 
de façon plus approfondie dans le reste de ce chapitre ; ainsi que les détails de leur 
implémentation dans Flash.
Les sections suivantes utilisent l’analogie d’un chat en démontrant comment les chats peuvent 
être comparés à des concepts de programmation orientée objet.
204
Classes

Objets
Pensez à un objet du monde réel, un chat, par exemple. Supposons qu’un chat ait des 
propriétés (ou états), telles que nom, âge et couleur, et des comportements, tels que dormir, 
manger et ronronner. Dans le monde de la programmation orientée objet, les objets ont 
également des propriétés et des comportements. En utilisant les techniques de programmation 
orientée objet, vous pouvez modeler un objet du monde réel (comme un chat) ou quelque 
chose de plus abstrait (un processus chimique, par exemple).
REMARQUE
Le mot comportement est utilisé ici au sens général et ne fait pas référence au panneau 
Comportements de l’environnement de programmation de Flash.
Pour plus d’informations sur les objets, consultezla page 43.
Occurrences et membres de classe
Reprenons, si vous le voulez bien, l’analogie du chat. Supposons qu’il existe des chats de 
couleur, d’âge et de nom différents, qui mangent et ronronnent de façon différente. 
Indépendamment de leurs différences individuelles, tous les chats appartiennent à la même 
catégorie, qui en termes de programmation orientée objet serait appelée une classe : la classe 
des chats. Dans la terminologie de la programmation orientée objet, chaque chat est une 
occurrence de la classe Cat. 
De même, en programmation orientée objet, une classe définit un modèle de type d’objets. 
Les caractéristiques et comportements qui appartiennent à une classe sont appelés membres de 
cette classe. Les caractéristiques (dans l’exemple du chat, nom, âge et couleur) sont appelées 
propriétés de la classe et sont représentées sous forme de variables. Les comportements (jouer, 
dormir) sont appelés méthodes de la classe et sont représentés sous forme de fonctions. 
Pour plus d’informations sur les occurrences et membres de classe, consultez les sections 
« Présentation des membres de classe », à la page 224 et la page 228.
Présentation de la programmation orientée objet et de Flash
205

Héritage  
L’un des principaux avantages de la programmation orientée objet est que vous pouvez créer 
des sous-classes de la classe ou étendre la classe. La sous-classe hérite alors de l’ensemble des 
propriétés et méthodes de la classe. La sous-classe définit en général des méthodes et propriétés 
supplémentaires ou annule les méthodes ou propriétés définies dans la super-classe. 
Les sous-classes peuvent également supplanter (apporter leurs propres définitions) les 
méthodes définies dans une super-classe. 
L’un des principaux avantages de l’utilisation de la structure super-classe/sous-classe est qu’il 
est plus simple de réutiliser un code similaire entre divers classes. Par exemple, vous pouvez 
créer une super-classe appelée Animal, contenant les caractéristiques et les comportements 
communs à tous les animaux. Vous pouvez ensuite créer plusieurs sous-classes qui héritent de 
la super-classe Animal et ajoutent les caractéristiques et les comportements d’un type d’animal 
spécifique.
Vous pouvez créer une classe Chat qui hérite d’une autre classe. Par exemple, vous créez une 
classe Mammifère qui définit certaines propriétés et certains comportements communs à tous 
les mammifères. Vous pouvez alors créer une sous-classe Chat qui permet d’étendre la classe 
Mammifère. Une autre sous-classe, la classe Siamois par exemple, peut étendre la classe Chat 
(sous-classe), et ainsi de suite.
L’écriture de sous-classes vous permet de réutiliser le code. Au lieu de créer à nouveau le code 
commun aux deux classes, il vous suffit d’étendre la classe existante.
CO
Dans une application complexe, la définition de la structure hiérarchique des classes 
NS
représente une partie essentielle du processus de conception. Assurez-vous de bien 
EI
définir cette hiérarchie avant de démarrer la programmation.
L
Pour plus d’informations sur les héritages et les sous-classes, consultez le « Héritage », à la page 281.
Interfaces
En programmation orientée objet, les Interfaces peuvent être décrites comme des modèles de 
définitions de classe,et les classes qui les implémentent servent à implémenter ce modèle de 
méthodes. En utilisant l’analogie du chat, une interface est similaire à un modèle de chat : 
Le modèle vous informe des parties dont vous avez besoin, mais pas nécessairement de quelle 
façon ces parties sont assemblées, ou comment elles travaillent. 
Vous pouvez utiliser les interfaces pour ajouter de la structure et une facilité de maintenance à 
vos applications. Étant donné qu’ActionScript 2.0 ne prend en charge que l’extension d’une 
seule superclasse, vous pouvez utiliser des interfaces comme forme d’héritage multiple limité.
206
Classes

Une interface peut également être considérée comme un « contrat de programmation » 
destiné à imposer des relations entre des classes non connexes. Par exemple, supposons que 
vous travailliez avec une équipe de programmeurs et que chacun de vous travaille sur une 
partie (classe) différente de la même application. Lors de la réalisation de l’application, vous 
vous mettez d’accord sur un ensemble de méthodes que les différentes classes utiliseront pour 
communiquer. Ainsi, vous créez une interface qui déclare ces méthodes, leurs paramètres et 
leurs types de retour. Toute classe qui implémente cette interface doit fournir des définitions 
pour ces méthodes; dans le cas contraire, une erreur du compilateur se produit. 
Pour plus d’informations sur les héritages, consultpage 281. Pour plus d’informations sur les interfaces, consultez le la page 295.
Encapsulation
Dans une conception orientée objet intelligente, les objets sont considérés comme des « boîtes 
noires » qui contiennent ou encapsulent des fonctionnalités. Un programmeur doit pouvoir 
interagir avec un objet en ne connaissant que ses propriétés, ses méthodes et ses événements 
(son interface de programmation), sans connaître les détails de son implémentation. Cette 
approche permet aux programmeurs d’atteindre un niveau supérieur d’abstraction et met en 
place un cadre de structuration pour la création de systèmes complexes. 
L’encapsulation permet à ActionScript 2.0 d’inclure, par exemple, le contrôle de l’accès des 
membres, de sorte que les détails de l’implémentation restent privés et invisibles pour tout 
codage en dehors d’un objet. Le code situé en dehors d’un objet doit interagir avec l’interface 
de programmation de l’objet plutôt qu’avec les détails d’implémentation (qui peuvent être 
dissimulés dans les méthodes et propriétés privées). Cette approche présente des avantages 
importants. Par exemple, elle permet au créateur de l’objet de changer son implémentation 
sans modifier le code externe à l’objet, tant que l’interface de programmation reste inchangée.
Pour plus d’informations sur l’encapsulation, consultez la sectionl’encapsulation », à la page 236.
Polymorphisme
La programmation orientée objet permet d’exprimer les différences entre les classes 
individuelles par une technique appelée polymorphisme qui permet aux classes de supplanter 
les méthodes de leurs super-classes et de définir des implémentations spécialisées de ces 
méthodes. Dans Flash, les sous-classes peuvent définir des implémentations spécialisées de 
méthodes héritées de sa superclasse, mais ne peuvent accéder à l’implémentation de la 
superclasse, comme dans d’autres langages de programmation. 
Présentation de la programmation orientée objet et de Flash
207

Par exemple, vous pouvez commencer par une classe appelée Mammifère qui comporte les 
méthodes play() et sleep(). Vous créez ensuite les sous-classes Chat, Singe et Chien pour 
étendre la classe Mammifère. Les sous-classes supplantent la méthode play() de la classe 
Mammal, de façon à représenter de façon plus réaliste ces types d’animaux. La classe Singe 
implémente la méthode play() pour se balancer aux arbres ; la classe Chat implémente la 
méthode play() pour courir après une pelote ; la classe Chien implémente la méthode 
play() pour rapporter une balle. Dans la mesure où la fonctionnalité sleep() reste similaire 
quel que soit l’animal, vous utilisez l’implémentation de super-classe.
Pour plus d’informations sur le polymorphisme, consultez le page 281 et la section « Utilisation du polymorphisme dans une application », à la page 290.
Ecriture de fichiers de classe 
personnalisée
L’exemple suivant présente les différentes parties d’un fichier de classe. Vous apprenez à écrire 
une classe et à la modifier pour étendre son utilisation avec Flash. Vous découvrez également 
les différentes parties d’une classe et comment les importer, de même que des informations sur 
la manipulation des fichiers de classe personnalisée dans Flash. 
Nous allons commencer par une classe très simple. L’exemple suivant présente l’organisation 
d’une classe simple appelée UserClass.
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). La structure de la classe concerne 
également les fichiers d’interface. Cette structure est illustrée ci-dessous, suite à quoi vous allez 
créer une classe. 
?
Le fichier de classe commence par des commentaires de documentation qui incluent une 
description générale du code, en plus des informations sur l’auteur et la version.
?
Ajoutez vos instructions d’importation (le cas échéant).
?
Ecrivez une instruction de package, une déclaration de classe ou d’interface, comme suit :
class UserClass { }
?
Incluez tout commentaire d’implémentation de classe ou d’interface nécessaire. Dans ces 
commentaires, ajoutez des informations pertinentes pour l’ensemble de la classe ou de 
l’interface.
?
Ajoutez toutes vos variables statiques. Ecrivez les variables de classe publiques en premier, 
suivies des variables de classe privées.
?
Ajoutez des variables d’occurrence. Ecrivez les variables de membre publiques en premier, 
suivies des variables de membre privées.
208
Classes

?
Ajoutez l’instruction de constructeur, par exemple celui de l’exemple suivant :
public function UserClass(username:String, password:String) { }
?
Ecrivez vos méthodes. Regroupez-les par fonctionnalités et non par accessibilité ou 
domaine. En organisant les méthodes de cette manière, vous améliorez la lisibilité et la 
clarté de votre code.
?
Ecrivez les méthodes de lecture/définition dans le fichier de classe.
L’exemple suivant examine une simple classe ActionScript nommée User.
Pour créer des fichiers de classe :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2. Choisissez Fichier > Enregistrer sous et nommez le fichier .
3. Saisissez le code ActionScript suivant dans la fenêtre de script :
/**
Classe User
auteur : John Doe
version : 0.8
modifié le : 08/21/2005
copyright : Adobe Systems Incorporated
Ce code définit une classe User personnalisée qui vous permet de créer 
de nouveaux utilisateurs et de spécifier leurs informations de 
connexion.
*/
class User {
// Variables d’occurrence privées
private var __username:String;
private var __password:String;
// Instruction de constructeur
public function User(p_username:String, p_password:String) {
this.__username = p_username;
this.__password = p_password;
}
public function get username():String {
return this.__username;
}
public function set username(value:String):Void {
this.__username = value;
}
public function get password():String {
return this.__password;
}
public function set password(value:String):Void {
this.__password = value;
}
}
Ecriture de fichiers de classe personnalisée
209

4. Enregistrez les modifications apportées au fichier de classe.
Le code précédent commence par un commentaire de documentation standard, qui indique 
le nom de la classe, l’auteur, la version, la date de la dernière modification, les 
informations de copyright et une brève description de la fonction de la classe. 
L’instruction de constructeur de la classe User demande deux paramètres : p_username et 
p_password, copiés dans les variables d’occurrence privés __username et __password de 
la classe. Le reste du code de la classe définit les propriétés de lecture et de définition pour 
les variables d’occurrence privées. Si vous voulez créer une propriété en lecture seule, 
définissez une fonction de lecture, et non de définition. Par exemple, pour être certain 
qu’un nom d’utilisateur ne peut plus être modifié après sa définition, supprimez la 
fonction de définition username dans le fichier de la classe User.
5. Choisissez Fichier > Nouveau, puis Document Flash.
6. Choisissez Fichier > Enregistrer sous et nommez le fichier . Enregistrez le 
fichier dans le même répertoire que .
7. Saisissez le code ActionScript suivant sur l’image 1 du scénario :
import User;
var user1:User = new User("un1", "pw1");
trace("Before:");
trace("\t username = " + user1.username); // un1
trace("\t password = " + user1.password); // pw1
user1.username = "1nu";
user1.password = "1wp";
trace("After:");
trace("\t username = " + user1.username); // 1nu
trace("\t password = " + user1.password); // 1wp
La classe User créée précédemment étant très simple, le code ActionScript du document 
Flash est également très direct. La première ligne de code importe la classe User 
personnalisée dans votre document Flash. L’importation de cette classe User permet 
d’utiliser la classe comme un type de données personnalisé.
Une seule occurrence de la classe User est définie et affectée à une variable nommée user1. 
Vous affectez une valeur à l’objet User user1 et définissez un nom d’utilisateur un1 et 
un mot de passe pw1. Les deux instructions trace suivantes affichent la valeur actuelle 
de user1.username et user1.password via les fonctions de lecture de la classe User, qui 
retournent toutes les deux des chaînes. Les deux lignes suivantes utilisent les fonctions de 
définition de la classe User pour définir de nouvelles valeurs pour les variables username et 
password. Enfin, vous envoyez les valeurs des variables username et password au 
panneau de sortie. Les instructions trace affichent les valeurs modifiées que vous avez 
définies via les fonctions de définition.
210
Classes

8. Enregistrez le fichier FLA, puis choisissez Contrôle > Tester l’animation pour tester les 
fichiers. 
Les résultats des instructions trace s’affichent dans le panneau de sortie. Dans les 
exemples suivants, vous utilisez ces fichiers dans une application.
Pour des exemples qui démontrent comment créer un menu dynamique avec des données 
XML et un fichier de classe personnalisée, consultez les exemples Flash à l’;Cet exemple appelle le constructeur ActionScript 
XmlMenu() et lui transmet deux paramètres : Le chemin d’accès au fichier menu XML et une 
référence au scénario actuel. Téléchargez et décompressez le fichier zip Exemples et naviguez 
jusqu’au dossier ActionScript2.0/XML_Menu afin d’accéder à ces exemples.
?
 
?
 
Utilisation des classes personnalisées 
dans une application
Dans la section « Ecriture de fichiers de classe personnalisée », à la page 208, vous avez créé un 
fichier de classe personnalisée. Dans les sections suivantes, vous utilisez ce fichier de classe 
dans une application. Le flux de travail de création de classes implique au minimum les étapes 
suivantes :
1.
Définition d’une classe dans un fichier de classe ActionScript externe. Pour plus 
d’informations sur la définition et l’écriture d’un fichier de classe, consultez la section 
« Ecriture de fichiers de classe personnalisée », à la page 208.
2. Enregistrement du fichier de classe dans un répertoire de chemin de classe spécifique 
(emplacement où Flash recherche les classes) ou dans le même répertoire que le fichier FLA 
de l’application. Pour plus d’informations sur la définition du chemin de classe, consultez 
la section« Définition et modification du chemin de classe », à la page 214. Pour une 
comparaison et plus d’informations sur l’importation de classes, consultez la section 
« Importation de fichiers de classe », à la page 212.
3. Création d’une occurrence de la classe dans un autre script, soit dans un document FLA, 
soit dans un fichier de script externe, ou création d’une sous-classe basée sur la classe 
d’origine. Pour plus d’informations sur la création d’une occurrence de classe, consultez la 
section « Création d’occurrences de classes dans un exemple », à la page 255.
Utilisation des classes personnalisées dans une application
211

Les sections suivantes contiennent des exemples de code qui vous permettent de vous 
familiariser avec la création de classes dans ActionScript 2.0. Si vous ne maîtrisez pas 
ActionScript 2.0, consultez le Chapitre 3, « Données et types de données », à la page 35 et le 
Chapitre 4, « Eléments fondamentaux du langage et de la syntaxe », à la page 81.
Pour plus d’informations sur l’utilisation des classes personnalisées, consultez les rubriques 
suivantes :
?
« Importation de fichiers de classe », à la page 212
?
« Utilisation d’un fichier de classe dans Flash », à la page 218
?
« Utilisation des méthodes et des propriétés d’un fichier de classe », à la page 219
?
« Présentation des membres de classe », à la page 224
?
« Présentation des méthodes de lecture et définition », à la page 229
?
« Résolution des références de classe par le compilateur », à la page 217
?
« Présentation des classes dynamiques », à la page 233
?
« Utilisation de l’encapsulation », à la page 236
?
« Utilisation du mot-clé this dans les classes », à la page 237
Pour des exemples qui démontrent comment créer un menu dynamique avec des données 
XML et un fichier de classe personnalisée, consultez les exemples Flash à l’adresse 
Cet exemple appelle le constructeur ActionScript 
XmlMenu() et lui transmet deux paramètres : le chemin au fichier menu XML et une référence 
au scénario. Téléchargez et décompressez le fichier zip Exemples et naviguez jusqu’au dossier 
ActionScript2.0/XML_Menu afin d’accéder à ces exemples.
?
 
?
 
Importation de fichiers de classe
Pour pouvoir utiliser une classe ou une interface que vous avez définie, Flash doit pouvoir 
localiser les fichiers ActionScript externes qui contiennent la définition de la classe ou de 
l’interface ; il peut ainsi importer le fichier. La liste des répertoires dans lesquels Flash 
recherche les définitions de classe, d’interface, de fonction et de variable est appelée chemin de 
classe
. Flash a deux paramètres de chemin de classe - un chemin de classe global et un chemin 
de classe au niveau du document : 
?
Le chemin de classe global est un chemin de classe partagé par tous les documents Flash. 
Vous le définissez dans la boîte de dialogue Préférences (Edition > Préférences (Windows) 
ou Flash > Préférences (Macintosh), cliquez sur ActionScript dans la liste Catégorie, puis 
sur Paramètres ActionScript 2.0).
212
Classes

?
Le chemin de classe au niveau du document est un chemin de classe défini de façon 
spécifique pour un seul document Flash. Il est défini dans la boîte de dialogue Paramètres 
de publication (Fichier > Paramètres de publication, sélectionnez l’onglet Flash, puis 
cliquez sur le bouton Paramètres).
Lorsque vous importez des fichiers de classe, les règles suivantes s’appliquent :
?
Les instructions d’importation peuvent se trouver aux emplacements suivants :
?
N’importe où avant la définition de classe des fichiers de classe
?
N’importe où dans les scripts d’image ou d’objet
?
N’importe où dans les fichiers ActionScript que vous incluez dans une application 
(en utilisant l’instruction #include).
?
La syntaxe suivante permet d’importer des définitions individuelles mises en package :
import flash.display.BitmapData;
?
La syntaxe de caractère générique permet d’importer des packages entiers :
import flash.display.*;
Vous pouvez également inclure le code ActionScript dans un fichier Flash (FLA) à l’aide d’une 
instruction include. Les règles suivantes s’appliquent à l’instruction include :
?
Les instructions include sont pour l’essentiel un copier-coller du contenu dans le fichier 
ActionScript inclus.
?
Les instructions include utilisées dans les fichiers ActionScript sont liées au sous-
répertoire qui contient le fichier.
?
Dans un document FLA, une instruction include ne peut apporter que du code valide 
dans les fichiers FLA. Cette restriction est également vraie pour les autres emplacements 
comprenant des instructions include. Par exemple, si vous avez une instruction include 
dans une définition de classe, seules les définitions de propriétés et de méthodes peuvent 
être présentes dans le fichier ActionScript inclus :
//
class Foo {
#include ""
}
// :
var fooProp;
function fooMethod() {}
trace("Foo"); // Cette instruction est interdite dans une définition 
// de classe.
Pour plus d’informations sur l’instruction include, consultez la section relative à la directive 
#include dans le Guide de référence du langage ActionScript 2.0 : Pour plus d’informations sur 
les chemins de classe, consultez la section à la page 214.
Utilisation des classes personnalisées dans une application
213

Définition et modification du chemin de classe
Pour utiliser une classe ou une interface que vous avez définie, Flash doit localiser les fichiers 
ActionScript externes qui contiennent sa définition. La liste des répertoires dans lesquels Flash 
recherche les définitions de classe et d’interface est appelée chemin de classe.   
Lorsque vous créez un fichier de classe ActionScript, vous devez enregistrer le fichier dans l’un 
des répertoires spécifiés dans le chemin de classe, ou dans l’un de ses sous-répertoires. 
(Vous pouvez modifier le chemin de classe pour inclure le chemin souhaité.) Sinon, Flash ne 
sera pas en mesure de résoudre (localiser) la classe ou l’interface spécifiée dans le script. 
Les sous-répertoires que vous créez dans un répertoire de chemin de classe sont appelés 
packages. Ils vous permettent d’organiser vos classes. (Pour plus d’informations sur les 
packages, consultez la sectionla page 241.)
Flash dispose de deux paramètres de chemin de classe : un chemin de classe global et un chemin 
de classe au niveau du document
. Le chemin de classe global est celui que partagent tous vos 
documents Flash. Le chemin de classe au niveau du document est celui qui est défini 
spécialement pour un seul document Flash. 
Le chemin de classe global s’applique aux fichiers ActionScript externes et aux fichiers FLA ; 
vous les définissez dans la boîte de dialogue (Windows: Edition > Préférences (Windows) ou 
Flash > Préférences (Macintosh), puis sélectionnez ActionScript dans la liste Catégories, puis 
cliquez sur les Paramètres ActionScript 2.0). Vous pouvez définir le chemin de classe au niveau 
du document dans la boîte de dialogue Paramètres de publication (Fichier > Paramètres de 
publication, et sélectionnez l’onglet Flash, puis cliquez sur le bouton Paramètres). 
REMARQUE
Lorsque vous cliquez sur le bouton de vérification de la syntaxe situé au-dessus de la 
fenêtre de script lors de la modification d’un fichier ActionScript, le compilateur 
n’examine que le chemin de classe global. Les fichiers ActionScript ne sont pas associés 
aux fichiers FLA en mode édition et ne disposent pas de leur propre chemin de classe.
Utilisation d’un chemin de classe global
Le chemin de classe global est celui que partagent tous vos documents Flash.
Vous pouvez modifier le chemin de classe global à l’aide de la boîte de dialogue Préférences. 
Pour modifier le paramètre de chemin de classe au niveau du document, utilisez la boîte de 
dialogue Paramètres de publication pour le fichier FLA. Dans les deux cas, vous pouvez 
ajouter des chemins de répertoires absolus (par exemple C:/mes_classes) et des chemins de 
répertoires relatifs (par exemple, ../mes_classes ou « . »). L’ordre des répertoires dans la 
boîte de dialogue correspond à l’ordre de recherche.
214
Classes

Par défaut, le chemin de classe global contient un chemin absolu et un chemin relatif. 
Le chemin absolu est indiqué par $(LocalData)/Classes dans la boîte de dialogue Préférences. 
L’emplacement du chemin absolu est indiqué ici :
?
Windows : Disque dur\Documents and Settings\utilisateur\Local Settings\Application 
Data\Adobe\Adobe Flash CS3\langue\Configuration\Classes. 
?
Macintosh : Disque dur/Utilisateurs/utilisateur/Library/Application Support/Adobe/
Adobe Flash CS3/langue/Configuration/Classes
REMARQUE
Ne supprimez pas le chemin de classe global absolu. Flash l’utilise pour accéder aux 
classes intégrées. Si vous supprimez ce chemin de classe par inadvertance, 
rétablissez-le en ajoutant $(LocalData)/Classes comme nouveau chemin de classe.
La section chemin relatif du chemin de classe global est identifiée par un point (.) et cette 
section pointe vers le répertoire de documents actuel. Notez que les chemins de classe relatifs 
peuvent pointer vers des répertoires différents, en fonction de l’emplacement du document 
compilé ou publié.
La procédure suivante permet d’ajouter un chemin de classe global ou de modifier un chemin 
de classe existant.
Pour modifier le chemin de classe global : 
1.
Sélectionnez Edition > Préférences (Windows) ou Flash > Préférences (Macintosh) pour 
ouvrir la boîte de dialogue Préférences.
2. Dans la colonne de gauche, cliquez sur ActionScript, puis sur le bouton Paramètres 
d’ActionScript 2.0.
3. Cliquez sur le bouton Rechercher le chemin et localisez le dossier que vous souhaitez ajouter.
4. Rechercher le chemin que vous souhaitez ajouter, puis cliquez sur OK.
Pour supprimer un répertoire du chemin de classe :
1.
Sélectionnez le chemin dans la liste des chemins de classe.
2. Cliquez sur le bouton Supprimer du chemin.
RE
Ne supprimez pas le chemin de classe global absolu. Flash l’utilise pour accéder aux 
M
A
classes intégrées. Si vous supprimez ce chemin de classe par inadvertance, vous 
R
pouvez le rétablir en ajoutant $(LocalData)/Classes comme nouveau chemin de 
Q
UE
classe.
Pour plus d’informations sur l’importation des packages, consultez la section 
« Fonctionnement des packages », à la page 202.
Utilisation des classes personnalisées dans une application
215

Utilisation d’un chemin de classe au niveau du document
Le chemin de classe au niveau du document ne s’applique qu’aux fichiers FLA. Vous définissez 
le chemin de classe au niveau du document dans la boîte de dialogue Paramètres de 
publication d’un fichier FLA spécifique (Fichier > Paramètres de publication, puis cliquez sur 
l’onglet Flash et sur les Paramètres d’ActionScript 2.0). Le chemin de classe au niveau du 
document est vide par défaut. Lorsque vous créez et enregistrez un fichier FLA dans un 
répertoire, ce dernier devient un répertoire du chemin de classe désigné.
Lorsque vous créez des classes, il peut être nécessaire de les placer dans un répertoire que vous 
ajoutez ensuite à la liste de répertoires de chemin de classe globaux dans les situations 
suivantes : 
?
Si vous avez un ensemble de classes d’utilitaires que tous vos projets utilisent
?
Si vous souhaitez vérifier la syntaxe de votre code (cliquez sur le bouton Vérifier la syntaxe) 
dans le fichier ActionScript externe
La création d’un répertoire permet d’empêcher la perte de classes personnalisées si vous devez 
désinstaller puis réinstaller Flash ou si le répertoire du chemin de classe global est supprimé ou 
remplacé.
Par exemple, vous pouvez créer le répertoire suivant pour vos classes personnalisées :
?
Windows : Hard Disk\Documents et Paramètres\utilisateur\classes personnalisées. 
?
Macintosh : Hard Disk\Utilisateurs\utilisateur\classes personnalisées.
Vous devez ensuite ajouter ce chemin à la liste de chemins de classe globaux (consultez la 
section « Utilisation d’un chemin de classe global », à la page 214).
Lorsque Flash tente de résoudre les références à des classes dans un script FLA, il recherche en 
premier le chemin de classe de niveau document spécifié pour ce fichier FLA. Si la classe ne 
figure pas dans ce chemin de classe ou si cette classe est vide, Flash recherche le chemin de 
classe global. Si Flash ne trouve pas la classe dans le chemin de classe global, une erreur de 
compilation se produit.
216
Classes

Pour modifier le chemin de classe au niveau du document :
1.
Choisissez Fichier > Paramètres de publication pour ouvrir la boîte de dialogue Paramètres 
de publication.
2. Cliquez sur l’onglet Flash.
3. Cliquez sur le bouton Paramètres en regard du menu déroulant Version d’ActionScript.
4. Vous pouvez saisir le chemin du fichier manuellement ou cliquer sur le bouton Rechercher 
le chemin pour localiser le répertoire à ajouter au chemin de classe.
REMARQUE
Pour modifier un répertoire de chemin de classe existant, sélectionnez le chemin 
dans la liste Chemin de classe, cliquez sur le bouton Rechercher le chemin, ouvrez le 
répertoire que vous souhaitez ajouter et cliquez sur OK.
REMARQUE
Pour supprimer un répertoire du chemin de classe, sélectionnez le chemin dans la 
liste Chemin de classe, puis cliquez sur le bouton Supprimer le chemin sélectionné 
(-).
Pour plus d’informations sur les packages, consultez la sela page 200.
Résolution des références de classe par le 
compilateur
Lorsque Flash tente de résoudre les références de classe dans un script FLA, il recherche en 
premier le chemin de classe de niveau document spécifié pour ce fichier FLA. Si la classe ne 
figure pas dans ce chemin de classe ou si cette classe est vide, Flash recherche le chemin de 
classe global. Si la classe n’est pas trouvée dans le chemin de classe global, une erreur de 
compilation se produit. 
Lorsque vous cliquez sur le bouton Vérifier la Syntaxe pendant la modification d’un fichier 
ActionScript, le compilateur consulte uniquement le chemin de classe global ; les fichiers 
ActionScript ne sont pas associés à des FLA en mode Edition et ne disposent pas de leur 
propre chemin de classe.
Utilisation des classes personnalisées dans une application
217

Utilisation d’un fichier de classe dans Flash
Pour créer une occurrence de classe ActionScript, utilisez l’opérateur new pour appeler la 
fonction constructeur de la classe. La fonction constructeur porte toujours le même nom que 
la classe dont elle renvoie une occurrence, que vous affectez généralement à une variable. 
Par exemple, si vous utilisez la classe User de la section personnalisée », à la page 208, vous pouvez écrire le code suivant pour créer un nouvel objet 
User :
var firstUser:User = new User();
REMARQUE
Dans certains cas, il n’est pas nécessaire de créer une occurrence de classe pour 
employer ses propriétés et ses méthodes. Pour plus d’informations sur les membres 
(statiques) de classe, consultez les sectioclasse », à la page 276 et « Méthodes et propriétés statiques », à la page 223.
Utilisez l’opérateur point (.) pour accéder à la valeur d’une propriété dans une occurrence. 
Entrez le nom de l’occurrence à gauche du point et le nom de la propriété à droite. 
Par exemple, dans l’instruction suivante, firstUser représente l’occurrence et username la 
propriété :
firstUser.username
Dans un document Flash, vous pouvez également utiliser les classes intégrées ou de niveau 
supérieur qui composent le langage ActionScript. Le code suivant crée par exemple un nouvel 
objet Array, puis affiche sa propriété length :
var myArray:Array = new Array("apples", "oranges", "bananas");
trace(myArray.length); // 3
Pour plus d’informations sur l’utilisation des classes personnalisées, consultez l’Utilisation de fichiers de classe personnalisée dans Flash », à la page 253. Pour plus 
d’informations sur les fonctions constructeur, consultez la section constructeur », à la page 244.
218
Classes

Utilisation des méthodes et des propriétés d’un fichier 
de classe
En programmation orientée objet, les membres (propriétés ou méthodes) d’une classe peuvent 
être des membres d’occurrence ou de classe. Les membres d’occurrence sont créés pour chaque 
occurrence de la classe ; ils sont définis sur le prototype de la classe lorsqu’ils sont initialisés 
dans la définition de classe. Par contraste, les membres de classe sont créés une fois par classe 
(ils sont également appelés membres statiques).
Les propriétés sont des attributs qui définissent un objet. Par exemple, length est une 
propriété qui s’applique à tous les tableaux et spécifie le nombre d’éléments qu’ils contiennent. 
Les méthodes sont des fonctions associées à une classe. Pour plus d’informations sur les 
fonctions et les méthodes, consultez le page 171.
L’exemple suivant décrit la création d’une méthode dans un fichier de classe :
class Sample {
  public function myMethod():Void {
    trace("myMethod");
  }

Vous pourriez ensuite invoquer cette méthode dans votre document. Pour invoquer une 
méthode d’occurrence ou accéder à une propriété d’occurrence, faites référence à une 
occurrence de la classe. Dans l’exemple suivant, picture01, une occurrence de la classe 
personnalisée Picture (disponible dans l’exercice suivant), appelle la méthode showInfo() :
var img1:Picture = new Picture("
");
// Invocation de la méthode showInfo().
img1.showInfo();
L’exemple suivant présente l’écriture d’une classe personnalisée Picture qui stocke les divers 
éléments d’informations relatifs à une photo. 
Utilisation des classes personnalisées dans une application
219

Pour utiliser les classes Picture et PictureClass dans un fichier FLA :
1.
Choisissez Fichier > Nouveau, puis sélectionnez Fichier ActionScript. Enregistrez le 
document sous le nom  puis cliquez sur OK. 
Vous écrivez votre classe Picture personnalisée dans ce document.
2. Saisissez le code ActionScript suivant dans la fenêtre de script :
/**
Classe Picture
auteur : John Doe
version : 0.53
modifié le : 6/24/2005
copyright : Adobe Systems Incorporated
La classe Picture est utilisée comme conteneur d’une image et de son 
URL.
*/
class Picture {
private var __infoObj:Object;
public function Picture(src:String) {
this.__infoObj = new Object();
= src;
}
public function showInfo():Void {
trace(this.toString());
}
private function toString():String {
return "[Picture src=" + + "]";
}
public function get src():String {
return ;
}
public function set src(value:String):Void {
= value;
}
}
3. Enregistrez le fichier ActionScript.
4. Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA. 
Enregistrez-le sous le nom  dans le même répertoire que le fichier de classe 
Picture.
220
Classes

5. Saisissez le code ActionScript suivant sur l’image 1 du scénario : 
var picture1:Picture = new Picture("
");
picture1.showInfo();
this.createEmptyMovieClip("img_mc", 9);
img_mc.loadMovie();
6. Enregistrez le document Flash.
7. Sélectionnez Contrôle > Tester l’animation pour tester le document. 
Le texte suivant apparait dans le panneau de sortie :
[Picture ]
Pour des exemples qui démontrent comment créer un menu dynamique avec des données 
XML et un fichier de classe personnalisée, consultez les exemples Flash à l’adresse 
Cet exemple appelle le constructeur ActionScript 
XmlMenu() et lui transmet deux paramètres : le chemin au fichier menu XML et une référence 
au scénario. Téléchargez et décompressez le fichier zip Exemples et naviguez jusqu’au dossier 
ActionScript2.0/XML_Menu afin d’accéder à ces exemples.
?
 
?
 
Présentation des méthodes et propriétés (membres) 
publiques, privées et statiques
Lorsque vous écrivez des fichiers de classe ActionScript dans un fichier de script externe, vous 
pouvez créer quatre types de méthodes et propriétés. méthodes et propriétés publiques, 
méthodes et propriétés privées, méthodes et propriétés publiques statiques, et propriétés et 
méthodes privées et statiques. Ces méthodes et propriétés définissent l’accès de Flash aux 
variables et permettent de spécifier les parties du code autorisées à accéder à certaines 
méthodes et propriétés. 
Lorsque vous développez des applications, petites ou grandes, à base de classes, il est 
particulièrement important de déterminer si une méthode ou une propriété doit être privée ou 
publique. Ces précautions vous permettent de sécuriser votre code autant que possible. 
Par exemple, si vous développez une classe User, vous souhaiterez peut-être ne pas autoriser les 
utilisateurs qui s’en servent à modifier l’identifiant des utilisateurs. En définissant la propriété 
de la classe (parfois appelée membre d’occurrence) comme privée, vous pouvez limiter l’accès à 
la propriété au code de la classe ou à des sous-classes de cette classe, et empêcher ainsi tout 
autre utilisateur de la modifier directement.
Utilisation des classes personnalisées dans une application
221

Méthodes et propriétés publiques 
Le mot-clé public indique qu’une variable ou une fonction est accessible à tout appelant. 
Les variables et les fonctions étant publiques par défaut, le mot-clé this est surtout utilisé 
pour des raisons de style et de lisibilité, indiquant que la variable existe dans le domaine 
actuel. Vous pouvez par exemple employer le mot-clé this pour des raisons de cohérence dans 
un bloc de code qui contient également des variables privées ou statiques. Le mot-clé this 
peut être utilisé avec le mot-clé public ou privé.
La classe Sample suivante présente déjà une méthode publique nommée myMethod() :
class Sample {
private var ID:Number;
public function myMethod():Void {
= 15;
trace(); // 15
trace("myMethod");
}
}
Pour ajouter une propriété publique, utilisez le mot-clé « public » au lieu de « private », 
comme dans l’exemple de code suivant :
class Sample {
private var ID:Number;
public var email:String;
public function myMethod():Void {
trace("myMethod");
}
}
La propriété email étant publique, vous pouvez la modifier dans la classe Sample, ou 
directement dans un fichier FLA.
Méthodes et propriétés privées
Le mot-clé private spécifie qu’une variable ou une fonction est accessible uniquement par la 
classe qui la déclare ou la définit, ou par les sous-classes de cette classe. Par défaut, une variable 
ou une fonction est publique et accessible par tout appelant. Utilisez le mot-clé this lorsque 
vous souhaitez restreindre l’accès à une variable ou une fonction, comme dans l’exemple 
suivant : 
class Sample {
private var ID:Number;
public function myMethod():Void {
= 15;
trace(); // 15
trace("myMethod");
}
}
222
Classes

Pour ajouter une propriété privée à la classe précédente, il vous suffit d’utiliser le mot-clé 
private avant le mot-clé var.
Si vous tentez d’accéder à la propriété ID privée depuis l’extérieur de la classe Sample, vous 
obtenez une erreur de compilation et une erreur de référence dans le panneau de sortie. 
Le message indique que le membre est privé et n’est pas accessible.
Méthodes et propriétés statiques
Le mot-clé static spécifie qu’une variable ou une fonction n’est créée qu’une fois par classe et 
non pas dans chaque objet basé sur cette classe. Vous pouvez accéder à un membre de classe 
statique sans créer une occurrence de sa classe. Les propriétés et méthodes statiques peuvent 
être définies dans le domaine public ou privé. 
Les membres statiques, également appelés membres de la classe, sont affectés à la classe et non à 
n’importe quelle occurrence de la classe. Pour invoquer une méthode de classe ou accéder à 
une propriété de classe, faites référence au nom de la classe plutôt qu’à l’une de ses 
occurrences, comme indiqué dans le code suivant :
trace( / 8); // 0.392699081698724
Si vous saisissez cette seule ligne de code dans la fenêtre de script du panneau Actions, le 
résultat s’affiche dans le panneau de sortie.
Par exemple, dans la classe Sample précédente, vous auriez pu créer une variable statique pour 
garder une trace du nombre d’occurrences créées de cette classe, comme dans le code suivant :
class Sample {
public static var count:Number = 0;
private var ID:Number;
public var email:String;
public function Sample() {
Sample.count++;
trace("count updated: " + Sample.count);
}
public function myMethod():Void {
trace("myMethod");
}
}
Chaque fois que vous créez une nouvelle occurrence de la classe Sample, la méthode 
constructeur suit le nombre total de classes Sample d’occurrence définies jusque-là.
Certaines classes ActionScript de niveau supérieur disposent de membres de classe 
(ou membres statiques), comme vous l’avez vu précédemment dans cette section lorsque vous 
avez appelé la propriété . Pour invoquer les membres de classe (propriétés et 
méthodes) ou y accéder, vous utilisez le nom de la classe, et non l’une de ses occurrences. Il ne 
faut donc pas créer une occurrence de la classe pour utiliser ces propriétés et méthodes.
Utilisation des classes personnalisées dans une application
223

Par exemple, la classe de niveau supérieur Math comprend uniquement des méthodes et des 
propriétés statiques. Pour appeler ses méthodes, au lieu de créer une occurrence de la classe 
Math, appelez tout simplement les méthodes de la classe Math. Le code suivant appelle la 
méthode sqrt() de la classe Math :
var squareRoot:Number = (4);
trace(squareRoot); // 2
Le code suivant appelle la méthode max() de la classe Math afin de déterminer lequel de deux 
nombres est le plus grand :
var largerNumber:Number = (10, 20);
trace(largerNumber); // 20
Pour plus d’informations sur la création de membres de classe, consultez les sections 
« Présentation des membres de classe », à la page 224 et la page 228.
Pour des exemples qui démontrent comment créer un menu dynamique avec des données 
XML et un fichier de classe personnalisée, consultez les exemples Flash à l’adresse 
Cet exemple appelle le constructeur ActionScript 
XmlMenu() et lui transmet deux paramètres : le chemin au fichier menu XML et une référence 
au scénario. Téléchargez et décompressez le fichier zip Exemples et naviguez jusqu’au dossier 
ActionScript2.0/XML_Menu afin d’accéder à ces exemples.
?
 
?
 
Présentation des membres de classe
La plupart des membres (méthodes et propriétés) abordés jusqu’à présent dans ce chapitre font 
partie d’un type appelé membre d’occurrence. Pour chaque membre d’occurrence, il existe une 
copie unique de ce membre dans chaque occurrence de la classe. Par exemple, la variable du 
membre email de la classe Sample a un membre d’occurrence, dans la mesure où chaque 
personne a une adresse de messagerie différente.
Vous disposez également d’un autre type de membre, appelé membre de classe. Il ne peut y 
avoir qu’une seule copie d’un membre de classe, et vous l’utilisez pour l’ensemble de la classe. 
Toute variable déclarée dans une classe, mais en dehors d’une fonction, est une propriété de la 
classe. Dans l’exemple suivant, la classe Person a deux propriétés, age et username, 
respectivement de type chaîne et nombre.
class Person {
public var age:Number;
public var username:String;
}
224
Classes

De la même façon, toute fonction déclarée dans une classe est considérée comme étant une 
méthode de cette classe. Dans l’exemple de la classe Person, vous pouvez créer une méthode 
unique appelée getInfo() :
class Person {
public var age:Number;
public var username:String;
public function getInfo():String {
// définition de la méthode getInfo()
}
}
Dans le code précédent, la méthode getInfo() de la classe Person, ainsi que les propriétés 
age et username, sont toutes des membres d’occurrence publics. La propriété age ne 
constituerait pas un bon membre de classe, car chaque personne a un âge différent. Seules les 
propriétés et les méthodes qui sont partagées par l’ensemble des individus de la classe doivent 
être des membres de classe.
Supposons que chaque classe doit disposer d’une variable appelée species, afin de donner le 
nom latin des espèces représentées par la classe. Pour chaque objet Person, l’espèce est Homo 
sapiens
. Il serait fastidieux de stocker une copie unique de la chaîne « Homo sapiens » pour 
chaque occurrence de la classe, ce qui implique que ce membre soit un membre de classe.
Les membres de classe sont déclarés avec le mot-clé static. Par exemple, vous pouvez déclarer 
le membre de classe species avec le code suivant :
class Person {
  public static var species:String = "Homo sapiens";
  //
}
Vous pouvez également déclarer les méthodes d’une classe comme étant statiques, comme 
illustré par l’exemple de code suivant :
public static function getSpecies():String {
return Person.species;
}
Les méthodes statiques ne peuvent accéder qu’aux propriétés statiques, pas aux propriétés 
d’occurrence. Par exemple, le code suivant génère une erreur de compilation, car la méthode 
de classe getAge() fait référence à la variable d’occurrence age :
class Person {
public var age:Number = 15;
//
public static function getAge():Number {
return age; /* **Erreur** : Il est impossible d’accéder aux variables 
d’occurrence dans des fonctions statiques. */
}
}
Utilisation des classes personnalisées dans une application
225

Pour résoudre ce problème, vous pouvez soit faire de la méthode une méthode d’occurrence, 
soit faire de la variable une variable de classe.
Pour plus d’informations sur les membres de classe (ou propriétés statiques), consultez la 
section « Méthodes et propriétés statiques », à la page 223.
Pour des exemples qui démontrent comment créer un menu dynamique avec des données 
XML et un fichier de classe personnalisée, consultez les exemples Flash à l’adresse 
Cet exemple appelle le constructeur ActionScript 
XmlMenu() et lui transmet deux paramètres : le chemin au fichier menu XML et une référence 
au scénario en cours. Téléchargez et décompressez le fichier zip Exemples et naviguez jusqu’au 
dossier ActionScript2.0/XML_Menu afin d’accéder à ces exemples.
?
 
?
 
Utilisation du modèle de conception Singleton
L’un des modes d’utilisation de membres de classe le plus répandu est le modèle de conception 
Singleton. Un modèle de conception définit une approche formelle destinée à structurer votre 
code. En général, vous concevez un modèle de structure pour résoudre un problème de 
programmation courant. Il existe de nombreux modèles de conception, tels que Singleton. 
Ce modèle permet de s’assurer que chaque classe ne dispose que d’une seule occurrence et 
offre une méthode globale d’accès à l’occurrence. Pour des informations détaillées sur le 
modèle de conception Singleton, consultez le site 

Certaines situations nécessitent un objet d’un type spécifique dans un système. Par exemple, 
un jeu d’échec implique un échiquier unique et chaque pays n’a qu’une seule capitale. 
Bien qu’il n’y ait qu’un seul objet, il est préférable d’encapsuler sa fonctionnalité dans une 
classe. Il peut être néanmoins nécessaire de gérer une occurrence de cet objet et d’y accéder. 
L’utilisation d’une variable globale est une possibilité, mais les variables globales ne sont pas 
souhaitables dans la plupart des projets. La meilleure approche consiste à laisser la classe gérer 
l’occurrence unique de l’objet à l’aide de membres de classe. L’exemple suivant montre une 
utilisation typique de modèle de conception Singleton, où l’occurrence Singleton est créée une 
seule fois.
226
Classes

Pour utiliser le modèle de conception Singleton :
1.
Choisissez Fichier > Nouveau, puis sélectionnez Fichier ActionScript. Enregistrez le 
document sous le nom .
2. Saisissez le code ActionScript suivant dans la fenêtre de script :
/**
Classe Singleton
auteur : John Doe
version : 0.53
modifié le : 6/24/2008
copyright : Adobe Systems Incorporated
*/
class Singleton {
private static var instance:Singleton = null;
public function trackChanges():Void {
trace("tracking changes.");
}
public static function getInstance():Singleton {
if (Singleton.instance == null) {
trace("creating new Singleton.");
Singleton.instance = new Singleton();
}
return Singleton.instance;
}
}
3. Enregistrez le document .
4. Choisissez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau 
fichier FLA, et enregistrez-le sous le nom  dans le même répertoire que 
celui du fichier de classe singleton.
5. Saisissez le code ActionScript suivant sur l’image 1 du scénario : 
Singleton.getInstance().trackChanges(); // Suivi des modifications.
var s:Singleton = Singleton.getInstance(); // Suivi des modifications.
s.trackChanges();
6. Enregistrez le document Flash.
7. Sélectionnez Contrôle > Tester l’animation pour tester le document. 
L’objet Singleton n’est pas créé avant d’être nécessaire, lorsqu’une autre section de code 
l’appelle par l’intermédiaire de la méthode getInstance(). Cette formule est généralement 
appelée création en dilettante ; elle peut accroître l’efficacité de votre code dans certains cas.
Utilisation des classes personnalisées dans une application
227

Souvenez-vous de ne pas utiliser trop ou trop peu de fichiers de classes dans votre application, 
dans la mesure où ceci peut déboucher sur de nombreux fichiers de classe mal conçus et nuire 
aux performances de l’application ou du flux de travail. Vous devriez toujours essayer d’utiliser 
des fichiers de classe au lieu de placer du code à d’autres endroits (par exemple des scénarios) ; 
cependant, évitez de créer beaucoup de classes avec peu de fonctionnalités, ou peu de classes 
gérant de nombreuses fonctionnalités. Ces deux scénarios peuvent indiquer une conception 
médiocre.
Utilisation de membres de classe
Vous pouvez notamment utiliser des membres de classe (statiques) pour conserver les 
informations d’état sur une classe et ses occurrences. Supposons par exemple que vous 
souhaitez consigner le nombre d’occurrences créées à partir d’une classe donnée. Vous pouvez 
facilement y parvenir en utilisant une propriété de classe incrémentée à chaque création d’une 
nouvelle occurrence.
Dans l’exemple suivant, vous créez une classe nommée Gadget qui définit un compteur 
d’occurrences statiques unique nommé widgetCount. A chaque création d’une nouvelle 
occurrence de la classe, la valeur de widgetCount est incrémentée de 1 et la valeur actuelle de 
widgetCount est affichée dans le panneau de sortie.
Pour créer un compteur d’occurrence en utilisant une variable de classe : 
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK. 
2. Saisissez le code suivant dans la fenêtre de script :
class Widget {
// Initialisation de la variable de classe
public static var widgetCount:Number = 0; 
public function Widget() {
Widget.widgetCount++;
trace("Creating widget #" + Widget.widgetCount);
}
}
La variable widgetCount est déclarée comme statique ; elle est donc initialisée à 0 une 
seule fois. Chaque fois que l’instruction constructeur de la classe Widget est appelée, elle 
ajoute 1 à la variable widgetCount, puis affiche le numéro de l’occurrence en cours de 
création.
3. Enregistrez votre fichier sous le nom .
4. Choisissez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau 
document FLA, et enregistrez-le sous le nom  dans le même répertoire que 

228
Classes

5. Dans , saisissez le code suivant sur l’image 1 du scénario :
//Avant de créer une occurrence de la classe,
// Widget.widgetCount affiche zéro (0).
trace("Widget count at start: " + Widget.widgetCount); // 0
var widget1:Widget = new Widget(); // 1
var widget2:Widget = new Widget(); // 2
var widget3:Widget = new Widget(); // 3
trace("Widget count at end: " + Widget.widgetCount); // 3 
6. Enregistrez les modifications du fichier .
7. Choisissez Contrôle > Tester l’animation pour tester le fichier.
Flash donne les résultats suivants dans le panneau Sortie : 
Widget count at start: 0
Creating widget # 1
Creating widget # 2
Creating widget # 3
Widget count at end: 3
Présentation des méthodes de lecture et définition
Les méthodes de lecture/définition sont des méthodes d’accesseur, c’est-à-dire qu’elles 
constituent généralement une interface publique qui permet de changer les membres de classe 
privés. Vous utilisez les méthodes de lecture/définition pour définir une propriété. 
Vous accédez à ces méthodes comme à des propriétés extérieures à la classe, même si vous les 
définissez au sein de la classe en tant que méthodes. Ces propriétés externes à la classe peuvent 
porter un nom différent de celui de la propriété dans la classe. 
Le choix des méthodes de lecture/définition présente quelques avantages, notamment la 
possibilité de créer des membres avec une fonctionnalité complexe auxquels vous pouvez 
accéder comme à des propriétés. Elles permettent également de créer des propriétés en lecture 
et écriture seules.
Bien que ces méthodes soient très pratiques, il est préférable de ne pas en abuser car, entre 
autres problèmes, elles risquent de compliquer la maintenance du code. De même, elles 
offrent un accès à l’implémentation de votre classe, comme les membres publics. 
La programmation orientée objet décourage l’accès direct aux propriétés à l’intérieur 
d’une classe. 
Utilisation des classes personnalisées dans une application
229

Lorsque vous écrivez des classes, vous êtes encouragés à rendre autant que possible toutes vos 
variables d’occurrence privées et à ajouter des méthodes de définition et de lecture en 
conséquence. En effet, il arrive souvent que vous ne souhaitiez pas autoriser les utilisateurs à 
modifier certaines variables à l’intérieur de vos classes. Par exemple, lorsqu’une méthode 
statique privée surveille le nombre d’occurrences créées pour une classe spécifique, vous ne 
souhaitez pas qu’un utilisateur puisse modifier ce compteur à l’aide du code. Seule 
l’instruction constructor doit pouvoir incrémenter cette variable à chaque appel. Dans ce cas, 
vous pouvez créer une variable d’occurrence privée et n’autoriser qu’une méthode de lecture 
pour la variable du compteur. Les utilisateurs peuvent ainsi récupérer la valeur actuelle juste à 
l’aide de la méthode de lecture, et non pas définir de nouvelles valeurs via la méthode de 
définition. Créer une méthode de lecture sans associer de méthode de définition est un moyen 
simple de mettre certaines des variables de votre classe en lecture seule.
Utilisation des méthodes de lecture et définition
La syntaxe des méthodes de lecture et de définition est la suivante :
?
Une méthode de lecture ne réclame aucun paramètre et renvoie toujours une valeur.
?
Une méthode de définition réclame toujours un paramètre et ne renvoie jamais de valeur.
Les classes définissent généralement des méthodes de lecture qui fournissent un accès en 
lecture et des méthodes de définition qui fournissent un accès en écriture à une propriété 
donnée. Imaginons par exemple une classe contenant une propriété nommée userName : 
private var userName:String;
Au lieu de permettre aux occurrences de la classe d’accéder directement à cette propriété 
(user.userName = "Buster", par exemple), la classe peut utiliser deux méthodes, 
getUserName() et setUserName(), qui seront implémentées dans l’exemple suivant.
Utilisation de méthodes de lecture et définition :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK. 
2. Saisissez le code suivant dans la fenêtre de script :
class Login {
private var __username:String;
public function Login(username:String) {
this.__username = username;
}
public function getUserName():String {
return this.__username;
}
public function setUserName(value:String):Void {
this.__username = value;
}
}
230
Classes

3. Enregistrez le document ActionScript sous le nom de .
Comme vous pouvez le constater, getUserName() renvoie la valeur actuelle de userName 
et setUserName() définit le paramètre de chaîne transmis à la méthode en tant que valeur 
de userName.
4. Choisissez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau 
document FLA, et enregistrez-le sous le nom  dans le même répertoire que 
.
5. Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var user:Login = new Login("RickyM");
// Appel de la méthode getUserName()
var userName:String = user.getUserName();
trace(userName); // RickyM
// Appel de la méthode setUserName()
user.setUserName("EnriqueI");
trace(user.getUserName()); // EnriqueI
6. Choisissez Contrôle > Tester l’animation pour tester le fichier.
Flash donne les résultats suivants dans le panneau Sortie : 
RickyM
EnriqueI
Si, toutefois, vous préférez une syntaxe plus concise, vous pouvez utiliser des méthodes de 
lecture/définition implicites. Celles-ci permettent d’accéder directement aux propriétés de 
classe, tout en conservant de bonnes pratiques de programmation orientée objet.
Pour définir ces méthodes, utilisez les attributs de méthodes get et set. Créez des méthodes 
qui obtiennent ou définissent la valeur d’une propriété et ajoutez le mot-clé get ou set avant 
le nom de méthode, comme dans l’exemple suivant.
REMARQUE
Les méthodes de lecture et définition implicites sont des abréviations syntaxiques de la 
méthode Object.addProperty() dans ActionScript 1.0.
Utilisation des classes personnalisées dans une application
231

Utilisation de méthodes de lecture et définition implicites :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK. 
2. Saisissez le code suivant dans la fenêtre de script :
class Login2 {
private var __username:String;
public function Login2(username:String) {
this.__username = username;
}
public function get userName():String {
return this.__username;
}
public function set userName(value:String):Void {
this.__username = value;
}
}
3. Enregistrez le document ActionScript sous le nom .
N’oubliez pas que les méthodes de lecture ne réclament aucun paramètre. Une méthode 
set (définition) doit prendre exactement un paramètre requis. Une méthode de définition 
peut avoir le même nom qu’une méthode de lecture dans le même domaine. Les méthodes 
de lecture et définition n’ont pas le même nom que les autres propriétés. Par exemple, dans 
le code ci-dessus qui définit des méthodes de lecture et de définition nommées userName, 
vous ne pourriez pas avoir de propriété nommée userName dans la même classe.
4. Choisissez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau 
document FLA, et enregistrez-le sous le nom  dans le même répertoire que 
.
5. Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var user:Login2 = new Login2("RickyM");
// appel de la méthode « get »
var userNameStr:String = user.userName;
trace(userNameStr); // RickyM
// appel de la méthode « get »
user.userName = "EnriqueI";
trace(user.userName); // EnriqueI
Contrairement aux méthodes ordinaires, les méthodes de lecture et de définition sont 
appelées sans parenthèses ni arguments. Les méthodes de lecture et de définition sont 
appelées de la même manière qu’une propriété.
232
Classes

6. Enregistrez le document Flash, puis choisissez Contrôle > Tester l’animation pour tester le 
fichier.
Flash donne les résultats suivants dans le panneau Sortie : 
RickyM
EnriqueI
REMARQUE
Vous ne pouvez pas utiliser d’attributs de méthode de lecture/définition dans des 
déclarations de méthode d’interface.
Présentation des classes dynamiques
L’ajout du mot-clé dynamic à une définition de la classe spécifie que les objets basés sur la 
classe spécifiée peuvent ajouter des propriétés dynamiques et y accéder pendant la période 
d’exécution. Il est préférable de ne créer de classes dynamiques que lorsque cette 
fonctionnalité est réellement nécessaire.
La vérification du type des classes dynamiques est moins stricte que pour les classes non 
dynamiques, dans la mesure où les membres sollicités au sein de la définition de classe et dans 
les occurrences de classe ne sont pas comparées à celles qui sont définies dans le domaine de la 
classe. Les fonctions des membres de classe, cependant, peuvent toujours faire l’objet d’une 
vérification du type de renvoi ou de paramètre.
Pour plus d’informations sur la création de classes dynamiques, consultez la section de classes dynamiques », à la page 233.
Création de classes dynamiques
Par défaut, les propriétés et méthodes d’une classe sont fixes. C’est-à-dire que l’occurrence 
d’une classe ne peut créer ou accéder à des propriétés ou méthodes qui n’étaient pas déclarées 
ou définies à l’origine par la classe. Considérons par exemple une classe Person qui définit 
deux propriétés, userName et age. 
Utilisation des classes personnalisées dans une application
233

Pour créer une classe non dynamique :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2. Saisissez le code ActionScript suivant dans la fenêtre de script :
class Person {
public var userName:String;
public var age:Number;
}
Si, dans un autre script, vous créez une occurrence de la classe Personne et essayez 
d’accéder à une propriété de la classe qui n’existe pas, le compilateur génère une erreur.
3. Enregistrez le fichier dans votre disque dur sous le nom .
4. Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA, 
puis cliquez sur OK.
5. Choisissez Fichier > Enregistrez sous, nommez le fichier , et enregistrez-le 
dans le même répertoire que la classe Person créée précédemment.
6. Ajoutez le code suivant pour créer une nouvelle occurrence de la classe Person 
(firstPerson) et tentez d’affecter une valeur à une propriété nommée hairColor 
(qui n’existe pas dans la classe Person).
var firstPerson:Person = new Person();
firstPerson.hairColor = "blue"; // Erreur. Il n’existe aucune propriété 
// nommée ’hairColor’.
7. Enregistrez le document Flash.
8. Choisissez Contrôle > Tester l’animation pour tester le code.
Ce code crée une erreur de compilation car la classe Person ne déclare pas de propriété 
nommée hairColor. Dans la plupart des cas, c’est exactement ce que vous souhaitez qu’il 
se passe. Les erreurs de compilation peuvent sembler indésirables, mais se révèlent souvent 
bénéfiques pour les programmeurs. Les bons messages d’erreur vous aident à écrire votre 
code correctement en mettant les erreurs en évidence de manière précoce dans le processus 
de programmation.
Dans certains cas, cependant, il peut être utile d’ajouter et d’accéder à des propriétés ou 
méthodes d’une classe à l’exécution qui ne sont pas définies dans la définition de classe 
originale. Le modificateur de classe dynamique vous permet de le faire. 
234
Classes

Pour créer une classe dynamique :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2. Choisissez Fichier > Enregistrer sous et nommez le fichier . Enregistrez le fichier 
sur votre disque dur.
3. Saisissez le code suivant dans la fenêtre de script :
dynamic class Person2 {
public var userName:String;
public var age:Number;
}
Ce code ActionScript ajoute le mot-clé dynamic à la classe Person de l’exemple précédent. 
Les occurrences de la classe Person2 peuvent désormais ajouter et accéder aux propriétés et 
méthodes qui ne sont pas définies dans cette classe.
4. Enregistrez les modifications apportées au fichier ActionScript.
5. Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA, 
puis cliquez sur OK.
6. Choisissez Fichier > Enregistrer sous et nommez le fichier . Enregistrez le 
fichier dans le même répertoire que .
7. Ajoutez le code suivant pour créer une nouvelle occurrence de la classe Person2 
(firstPerson) et affecter une valeur à une propriété nommée hairColor (qui n’existe pas 
dans la classe Person2).
var firstPerson:Person2 = new Person2();
firstPerson.hairColor = "blue";
trace(firstPerson.hairColor); // blue
8. Enregistrez les modifications apportées au fichier .
9. Choisissez Contrôle > Tester l’animation pour tester le code.
La classe personnalisée Flash étant dynamique, vous pouvez lui ajouter des méthodes et 
des propriétés au moment de l’exécution (pendant la lecture du fichier SWF). Lorsque 
vous testez le code, le texte blue s’affiche dans le panneau de sortie.
Lorsque vous développez des applications, il est préférable de ne pas rendre les classes 
dynamiques si ce n’est pas vraiment nécessaire. L’une des raisons en est que cette vérification 
du type des classes dynamiques est moins stricte que celle des classes non dynamiques, dans la 
mesure où les membres sollicités au sein de la définition de classe et dans les occurrences de 
classe ne sont pas comparées à celles qui sont définies dans le domaine de la classe. 
Les fonctions des membres de la classe, cependant, peuvent toujours faire l’objet d’une 
vérification du type de renvoi ou de paramètre.
Utilisation des classes personnalisées dans une application
235

Les sous-classes des classes dynamiques sont également dynamiques, à une exception près. 
Les sous-classes de la classe MovieClip ne sont pas dynamiques par défaut, bien que la classe 
MovieClip elle-même le soit. Cette implémentation permet de bénéficier de davantage de 
contrôle sur les sous-classes de la classe MovieClip, car vous pouvez rendre vos sous-classes 
dynamiques si vous le souhaitez.
class A extends MovieClip {} // A n’est pas une sous-classe dynamique
dynamic class B extends A {} // B est une sous-classe dynamique
class C extends B {} // C est une sous-classe dynamique
class D extends A {} // D n’est pas une sous-classe dynamique
dynamic class E extends MovieClip{} // E est une sous-classe dynamique
Pour plus d’informations sur les sous-classes, consultez le page 281.
Utilisation de l’encapsulation
Dans une conception orientée objet intelligente, les objets sont considérés comme des « boîtes 
noires » qui contiennent ou encapsulent des fonctionnalités. Un programmeur doit pouvoir 
interagir avec un objet en ne connaissant que ses propriétés, ses méthodes et ses événements 
(son interface de programmation), sans connaître les détails de son implémentation. 
Cette approche permet aux programmeurs d’atteindre un niveau supérieur d’abstraction et 
met en place un cadre de structuration pour la création de systèmes complexes. 
L’encapsulation permet à ActionScript 2.0 d’inclure, par exemple, le contrôle de l’accès des 
membres, de sorte que les détails de l’implémentation restent privés et invisibles pour tout 
codage en dehors d’un objet. Le code situé en dehors d’un objet doit interagir avec l’interface 
de programmation de l’objet plutôt qu’avec les détails d’implémentation. Cette approche 
présente des avantages importants. Par exemple, elle permet au créateur de l’objet de changer 
son implémentation sans modifier le code externe à l’objet, tant que l’interface de 
programmation reste inchangée.
L’encapsulation dans Flash consiste par exemple à définir tous vos membres et toutes les 
variables de classe comme privés et à forcer les utilisateurs qui implémentent vos classes à 
accéder à ces variables via les méthodes de définition et de lecture. Cette méthode 
d’encapsulation permet, si vous avez un jour besoin de modifier la structure des variables, de 
modifier uniquement le comportement des fonctions de lecture et de définition plutôt que 
d’obliger chaque développeur à changer sa méthode d’accès aux variables de la classe.
236
Classes

Le code suivant décrit la modification de la classe Person utilisée dans les exemples précédents, 
définit ses membres d’occurrence comme privés et des méthodes de lecture et de définition 
pour les membres d’occurrence privés :
class Person {
private var __userName:String;
private var __age:Number;
public function get userName():String {
return this.__userName;
}
public function set userName(value:String):Void {
this.__userName = value;
}
public function get age():Number {
return this.__age;
}
public function set age(value:Number):Void {
this.__age = value;
}
}
Utilisation du mot-clé this dans les classes
Utilisez le mot-clé this en tant que préfixe au sein de vos classes pour les méthodes et les 
variables de membre. Bien que non indispensable, ce mot-clé this permet d’indiquer 
facilement si une propriété ou une méthode appartient à une classe lorsqu’elle comporte un 
préfixe. En l’absence de ce mot-clé, vous ne pouvez pas savoir si la propriété ou la méthode 
appartient à la super-classe. 
Vous pouvez également utiliser un préfixe de nom de classe pour les variables statiques et les 
méthodes, y compris dans une classe. Ceci permet de qualifier vos références et de rendre le 
code plus lisible. Selon l’environnement de programmation utilisé, l’ajout de préfixes permet 
également de bénéficier de conseils de code.
REMAR
Ces préfixes sont facultatifs et certains développeurs les considèrent superflus. Il est 
recommandé d’ajouter le mot clé this en tant que préfixe, dans la mesure où il améliore 
la lisibilité et permet d’écrire un code explicite en fournissant le contexte des méthodes 
Q
UE
et des variables.
Utilisation des classes personnalisées dans une application
237

Exemple : Ecriture de classes 
personnalisées
Maintenant que vous connaissez les bases d’un fichier de classe et les types d’éléments qu’il 
contient, il est temps de connaître quelques directives générales liées à la création d’un tel 
fichier. Le premier exemple de ce chapitre décrit l’écriture des classes et leur mise en package. 
Le second exemple présente l’utilisation de ces fichiers de classe avec un fichier FLA.
A
TTEN
Le code ActionScript des fichiers externes est compilé dans un fichier SWF lors de la 
publication, de l’exportation, du test ou du débogage d’un fichier FLA. Cela signifie que 
TION
si vous apportez des modifications à un fichier externe, vous devez enregistrer le fichier 
et recompiler tous les fichiers FLA qui l’utilisent.
Comme nous l’avons vu dans la sectila page 208, une classe comprend deux parties : la déclaration et le corps. La déclaration de la 
classe comporte au minimum l’instruction class, suivie de l’identifiant du nom de la classe, 
puis des accolades d’ouverture et de fermeture ({}). Tout ce qui figure entre les accolades 
constitue le corps de la classe, comme indiqué dans l’exemple suivant :
class className {
  // corps de la classe
}
N’oubliez pas que vous pouvez définir des classes uniquement dans des fichiers ActionScript 
externes. Par exemple, vous ne pouvez pas définir de classe dans un script d’image d’un fichier 
FLA. Vous allez donc créer un nouveau fichier pour cet exemple. 
Dans sa forme la plus simple, une déclaration de classe comprend le mot-clé class, suivi du 
nom de la classe (Person, dans ce cas), puis des accolades d’ouverture et de fermeture ({}). 
Tout ce qui est entre les accolades est appelé corps de la classe et c’est ici que les propriétés et 
méthodes de la classe sont définies.
A la fin de cet exemple, l’ordre de base de vos fichiers de classe est le suivant :
?
Commentaires de documentation
?
Déclaration de classe
?
Fonction constructeur
?
Corps de la classe
238
Classes

Nous n’écrivons pas de sous-classes dans ce chapitre. Pour plus d’informations sur les héritages 
et les sous-classes, consultez le Chapitre 7, « Héritage », à la page 281.
Cet exemple aborde les sujets suivants :
?
« Directives générales sur la création d’une classe », à la page 239
?
« Création et mise en package de vos fichiers de classe », à la page 241
?
« Ecriture de la fonction constructeur », à la page 244
?
« Ajout de méthodes et de propriétés », à la page 245
?
« Contrôle de l’accès des membres dans vos classes », à la page 249
?
« Documentation des classes », à la page 251
Pour des exemples qui démontrent comment créer un menu dynamique avec des données 
XML et un fichier de classe personnalisée, consultez les exemples Flash à l’adresse 
Cet exemple appelle le constructeur ActionScript 
XmlMenu() et lui transmet deux paramètres : le chemin au fichier menu XML et une référence 
au scénario en cours. Téléchargez et décompressez le fichier zip Exemples et naviguez jusqu’au 
dossier ActionScript2.0/XML_Menu afin d’accéder à ces exemples.
?
 
?
 
Directives générales sur la création d’une classe
Voici quelques conseils à suivre lors de l’écriture de fichiers de classe personnalisés. Ils vous 
aideront à écrire des classes correctes et bien constituées. Vous mettez en pratique ces 
directives dans les exemples suivants.
?
De manière générale, ne placez qu’une seule déclaration par ligne. Ne placez pas le même 
type de déclaration ou des types différents sur une même ligne. Formatez vos déclarations 
comme dans l’exemple ci-dessous :
private var SKU:Number; // numéro de stock du produit (numéro 
// d’identification)
private var quantity:Number; // Quantité du produit
?
Initialisez les variables locales lorsque vous les déclarez, à moins que cette valeur initiale ne 
soit déterminée par un calcul. Pour plus d’informations sur l’initialisation des variables, 
consultez la section « Ajout de méthodes et de propriétés », à la page 245.
Exemple : Ecriture de classes personnalisées
239

?
Déclarez les variables avant de les utiliser (y compris dans les boucles). Par exemple, le 
code suivant pré déclare la variable d’itérateur de boucle (i) avant de l’utiliser dans la 
boucle for  :
var my_array:Array = new Array("one", "two", "three");
var i:Number;
for (i = 0 ; i < my_array.length; i++) {
trace(i + " = " + my_array[i]);
}
?
Evitez d’utiliser des déclarations locales qui masquent des déclarations de niveau 
englobant. Par exemple, ne déclarez les variables qu’une seule fois, comme dans l’exemple 
ci-dessous :
// Code incorrect
var counter:Number = 0;
function myMethod() {
var counter:Number;
for (counter = 0; counter <= 4; counter++) {
// instructions ;
}
}
Ce code déclare la même variable dans un bloc interne.
?
N’affectez pas plusieurs variables à une valeur unique dans une instruction car la lecture 
devient alors difficile, comme dans l’exemple de code ActionScript suivant :
// Forme incorrecte
xPos = yPos = 15;
ou
// Forme incorrecte
class User {
private var m_username:String, m_password:String;
}
?
Ne rendez pas publiques sans raison des variables d’occurrence ou des variables de membre 
ou de classe statique. Ces variables doivent être déclarées explicitement comme publiques 
avant d’être créées de cette façon.
?
Définissez la plupart des variables de membre sur privé à moins qu’il n’y ait une bonne 
raison de les rendre publiques. Il est préférable, du point de vue de la conception, de 
définir les variables de membre sur privé et de restreindre leur accès par l’intermédiaire 
d’un petit groupe de fonctions de lecture et définition.
240
Classes

Appellation des fichiers de classe
Les noms de classes doivent être des identifiants : le premier caractère doit être une lettre, un 
soulignement (_) ou le signe dollar ($), et chaque caractère suivant doit être une lettre, un 
nombre, un soulignement ou le signe dollar. Il est recommandé de toujours tenter de limiter 
les noms de classe à des lettres.
Le nom de classe doit correspondre exactement au nom du fichier ActionScript qui le 
contient, majuscules comprises. Dans l’exemple suivant, si vous créez une classe nommée 
Rock, le fichier ActionScript qui contient sa définition doit s’appeler  :
// Dans le fichier
class Rock {
  // Corps de la classe Rock
}
Dans la section suivante, vous créez et nommez une définition de classe. Pour créer, nommer 
et mettre en package les fichiers de classe, consultez la sede vos fichiers de classe », à la page 241. Pour plus d’informations sur l’appellation de fichiers 
de classe, consultez la section « Appellation des classes et des objets », à la page 724.
Création et mise en package de vos fichiers de classe
Dans cette section, vous allez créer, nommer et mettre en package vos fichiers de classe pour 
cet exemple (« Exemple : Ecriture de classes personnalisées », à la page 238). Les sections 
suivantes présentent l’écriture complète (et pourtant simple) de fichiers de classe. Pour des 
informations détaillées sur les packages, consultez les la page 200,des packages », à la page 202.
Lorsque vous créez un fichier de classe, choisissez un emplacement de stockage pour le fichier. 
Au cours des étapes suivantes, vous allez enregistrer le fichier de classe et le fichier 
d’application FLA qui l’utilise dans le même répertoire pour plus de simplicité. Toutefois, si 
vous souhaitez vérifier la syntaxe, vous devez également indiquer à Flash comment localiser le 
fichier. De façon générale, lorsque vous créez une application, ajoutez le répertoire dans lequel 
vous stockez votre application et les fichiers de classe dans le chemin de classe Flash. Pour plus 
d’informations sur les chemins de classe, consultez la section chemin de classe », à la page 214.
Les fichiers de classe sont également appelés fichiers ActionScript (AS). Vous créez des fichiers 
AS dans l’outil de programmation Flash ou à l’aide d’un éditeur externe. Par exemple, 
Macromedia Dreamweaver peut créer des fichiers AS.
REMARQUE
Le nom d’une classe (ClassA) doit correspondre exactement au nom du fichier AS qui la 
contient (). Ce point est très important. Si ces deux noms ne correspondent 
pas exactement, y compris les majuscules, la compilation de la classe échoue.
Exemple : Ecriture de classes personnalisées
241

Pour créer un fichier de classe et une déclaration de classe :
1.
Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau document 
FLA, puis cliquez sur OK.
2. Choisissez Fichier > Enregistrer sous et nommez le nouveau fichier , puis 
enregistrez le document Flash dans le répertoire actif. 
Ultérieurement, vous ajouterez du contenu dans ce document Flash.
3. Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
4. Choisissez Fichier > Enregistrer sous, et créez un nouveau sous-répertoire nommé com
puis procédez comme suit :
a. Dans le sous-dossier com, créez un nouveau sous-répertoire appelé adobe
b. Dans le sous-dossier adobe, créez un nouveau sous-répertoire appelé utils
c. Enregistrez le document ActionScript actif dans le répertoire utils et nommez le fichier 
.
5. Saisissez le code suivant dans la fenêtre de script :
class com.adobe.utils.ClassA {
}
Le code précédant crée une nouvelle classe nommée ClassA dans le package 
com.adobe.utils.
6. Enregistrez le document ActionScript sous le nom .
7. Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
8. Choisissez Fichier > Enregistrez sous, nommez le fichier , et enregistrez-le dans le 
même répertoire que le fichier  créé précédemment.
9. Saisissez le code suivant dans la fenêtre de script :
class com.adobe.utils.ClassB {
}
Le code précédant crée une nouvelle classe nommée ClassB dans le package 
com.adobe.utils.
10. Enregistrez les modifications apportées aux fichiers de classe et .
Les fichiers de classe que vous utilisez dans un fichier FLA sont importés dans un fichier SWF 
lors de sa compilation. Le code que vous écrivez dans un fichier de classe doit respecter une 
certaine méthodologie et un certain ordre, tous deux abordés dans les sections suivantes.
242
Classes

Si vous créez plusieurs classes personnalisées, utilisez des packages pour organiser vos fichiers de 
classe. Un package est un répertoire qui contient un ou plusieurs fichiers de classe et qui réside 
dans un répertoire de chemin de classe désigné. Les noms de classe doivent être pleinement 
qualifiés dans le fichier dans lequel ils sont déclarés : ils doivent indiquer le nom du répertoire 
(package) dans lequel ils sont enregistrés. Pour plus d’informations sur les chemins de classe, 
consultez la section « Définition et modification du chemin de classe », à la page 214.
Par exemple, une classe nommée .YourClass est stockée dans le répertoire 
com/adobe/docs. La déclaration de classe dans le fichier ressemble à cela :
class .YourClass {
// Votre classe
}
REMARQUE
Vous écrirez la déclaration de classe qui reflète le répertoire de package dans la section 
suivante : « Exemple : Ecriture de classes personnalisées », à la page 238.
De ce fait, il est recommandé de planifier votre structure de packages avant de commencer la 
création de classes. En effet, si vous décidez de déplacer les fichiers de classe après leur 
création, vous devrez modifier les instructions de déclaration de classe pour indiquer leur 
nouvel emplacement.
Pour mettre vos fichiers de classe en package :
1.
Choisissez le nom de package que vous désirez utiliser. 
Les noms de package doivent être intuitifs et facilement identifiables par les autres 
développeurs. N’oubliez pas que le nom du package correspond également à une structure 
de répertoires spécifique. Par exemple, les classes du package com.adobe.utils doivent 
être placées dans un dossier com/adobe/utils sur votre disque dur.
2. Créez la structure de répertoires requise après avoir choisi un nom de package. 
Par exemple, si votre package s’appelle com.adobe.utils, créez une structure de 
répertoires com/adobe/utils et placez vos classes dans le dossier utils.
3. Utilisez le préfixe com.adobe.utils pour toute classe créée dans ce package. 
Par exemple, si votre nom de classe était ClassA, son nom complet devrait être 
com.adobe.utils.ClassA au sein du fichier de classe .
4. Si, par la suite, vous modifiez la structure de package, souvenez-vous de modifier non 
seulement la structure de répertoires, mais aussi le nom de package dans chaque fichier de 
classe, ainsi que dans chaque instruction d’importation ou référence à une classe au sein de 
ce package.
Pour poursuivre l’écriture des fichiers de classe, consultez la section constructeur », à la page 244.
Exemple : Ecriture de classes personnalisées
243

Ecriture de la fonction constructeur
Vous avez déjà découvert l’écriture de la déclaration de classe dans la section en package de vos fichiers de classe », à la page 241. Dans cette partie du chapitre, vous écrivez 
ce que l’on appelle la fonction constructeur du fichier de classe.
REMARQUE
Vous allez découvrir l’écriture des commentaires, des instructions et des déclarations 
dans les sections suivantes.
Les constructeurs sont des fonctions que vous utilisez pour initialiser (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 Person et implémente une fonction constructeur. En programmation 
orientée objet, la fonction constructeur initialise toutes les nouvelles occurrences d’une classe. 
Un constructeur de classe est une fonction spéciale appelée automatiquement lorsque vous 
créez une occurrence de classe à l’aide de l’opérateur new. La fonction constructeur porte le 
même nom que la classe qui la contient. Par exemple, la classe Person créée précédemment 
contenait la fonction constructeur suivante :
// Fonction constructeur de la classe Person
public function Person (uname:String, age:Number) {
  this.__name = uname;
  this.__age = age;
}
Lorsque vous écrivez des fonctions constructeur, gardez à l’esprit les points suivants :
?
Si aucune fonction constructeur n’est explicitement déclarée, c’est-à-dire, si vous ne créez 
pas de fonction dont le nom correspond à celui de la classe, le compilateur crée 
automatiquement une fonction constructeur vide.
?
Une classe ne peut contenir qu’une seule fonction constructeur ; les fonctions 
constructeur étendues ne sont pas autorisées dans ActionScript 2.0.
?
La fonction constructeur ne doit pas avoir de type de renvoi.
Le terme constructeur est généralement utilisé lorsque vous créez (instanciez) un objet en 
fonction d’une classe particulière. Les instructions suivantes sont des appels aux fonctions 
constructeur pour la classe de niveau supérieur Array et pour la classe Person personnalisée :
var day_array:Array = new Array("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", 
"Sat");
var somePerson:Person = new Person("Tom", 30);
244
Classes

Vous allez ensuite ajouter une fonction spéciale appelée constructeur.
REMARQUE
L’exercice suivant est associé à lla page 238. Si vous ne souhaitez pas suivre l’exemple, il vous est possible de 
télàcharger les fichiers de classe depuis 
Pour ajouter les fonctions constructeur à vos fichiers de classe :
1.
Ouvrez le fichier de classe  dans l’outil de programmation Flash.
2. Modifiez les fichiers de classe existants de sorte qu’ils correspondent au code suivant 
(les modifications à effectuer apparaissent en gras) :
class com.adobe.utils.ClassA {
function ClassA() {
trace("ClassA constructor");
}
}
Le code précédent définit une méthode constructeur pour la classe ClassA. 
Ce constructeur envoie une chaîne simple au panneau de sortie qui vous avertit lorsqu’une 
nouvelle occurrence de la classe a été créée.
3. Ouvrez le fichier de classe  dans l’outil de programmation Flash.
4. Modifiez le fichier de classe de sorte qu’il corresponde au code suivant (les modifications à 
effectuer apparaissent en gras) :
class com.adobe.utils.ClassB {
function ClassB() {
trace("ClassB constructor");
}
}
5. Enregistrez les deux fichiers ActionScript avant de continuer.
Pour poursuivre l’écriture des fichiers de classe, consultez la section propriétés », à la page 245.
Ajout de méthodes et de propriétés
Pour créer des propriétés pour les classes ClassA et ClassB, utilisez le mot-clé var qui définit 
des variables.
REMA
Les trois exercices suivants sont associés à l’personnalisées », à la page 238. Si vous ne souhaitez pas suivre l’exemple, il vous est 
R
possible de télécharger les fichiers de classe depuis 
Q
UE

Exemple : Ecriture de classes personnalisées
245

Pour ajouter des propriétés aux classes ClassA et ClassB :
1.
Ouvrez les fichiers  et  dans l’outil de programmation Flash.
2. Modifiez le fichier ActionScript, de sorte qu’il corresponde au code suivant 
(les modifications à effectuer apparaissent en gras) :
class com.adobe.utils.ClassA {
static var _className:String;
function ClassA() {
trace("ClassA constructor");
}
}
Le bloc de code précédent ajoute une seule nouvelle variable statique, _className, qui 
contient le nom de la classe active.
3. Modifiez la classe ClassB et ajoutez la variable statique de sorte qu’elle corresponde au code 
précédent.
4. Enregistrez les deux fichiers ActionScript avant de continuer.
CO
Par convention, les propriétés de classe sont définies dans la partie supérieure du 
NS
corps de la classe. Procédez ainsi simplifie la lecture du code, mais n’est pas 
EI
obligatoire.
L
Utilisez la syntaxe à deux points (par exemple var username:String et var age:Number) 
dans la déclaration des variables. Ceci est un exemple de typage strict des données. Lorsque 
vous typez une variable à l’aide du format var variableName:variableType, le compilateur 
ActionScript s’assure que toute valeur affectée à cette variable correspond au type spécifié. Si le 
type de données correct n’est pas utilisé dans le fichier FLA qui importe cette classe, le 
compilateur renvoie une erreur. Pour plus d’informations sur le typage strict des données, 
consultez la section « Affectation des types de données et typage strict », à la page 45.
Les membres d’une classe se composent de propriétés (déclarations de variables) et de 
méthodes (déclarations de fonctions). Vous devez déclarer et définir toutes les propriétés et 
méthodes dans le corps de la classe (entre accolades [{}]), sinon une erreur se produit lors de 
la compilation. Pour plus d’informations sur les membres, consultez la des méthodes et propriétés (membres) publiques, privées et statiques », à la page 221.
246
Classes

Pour ajouter des méthodes aux classes ClassA et ClassB :
1.
Ouvrez les fichiers  et  dans l’outil de programmation Flash.
2. Modifiez les fichiers de classe ClassA, de sorte qu’ils correspondent au code suivant 
(les modifications à effectuer apparaissent en gras) :
class com.adobe.utils.ClassA {
static var _className:String;
function ClassA() {
trace("ClassA constructor");
}
function doSomething():Void {
trace("ClassA - doSomething()");
}
}
Le bloc de code en gras crée une nouvelle méthode dans la classe, qui envoie une chaîne au 
panneau de sortie.
3. Dans , choisissez Outils > Vérifier la syntaxe pour vérifier la syntaxe de votre 
fichier ActionScript.
Si des erreurs sont signalées dans le panneau de sortie, comparez le code de votre script au 
code final de l’étape précédente. Si vous ne parvenez pas à réparer l’erreur, copiez et collez 
le code complet dans la fenêtre de script avant de continuer.
4. Vérifiez la syntaxe de comme vous l’avez fait pour . 
Si des erreurs apparaissent dans le panneau de sortie, copiez et collez le code complet dans 
la fenêtre de script avant de continuer :
class com.adobe.utils.ClassB {
static var _className:String;
function ClassB() {
trace("ClassB constructor");
}
function doSomething():Void {
trace("ClassB - doSomething()");
}
}
5. Enregistrez les deux fichiers ActionScript avant de continuer.
Exemple : Ecriture de classes personnalisées
247

Vous pouvez initialiser des propriétés en ligne, c’est-à-dire lorsque vous les déclarez, avec des 
valeurs par défaut, comme dans l’exemple suivant : 
class Person {
  var age:Number = 50;
  var username:String = "John Doe";
}
Lorsque vous initialisez des propriétés alignées, l’expression du côté droit de l’affectation doit 
être une constante de compilation. C’est à dire que l’expression ne peut pas faire référence à 
un élément paramétré ou défini au moment de l’exécution. Les constantes de compilation 
comprennent les chaînes littérales, les nombres, les valeurs booléennes, null et undefined, ainsi 
que les fonctions constructeur pour les classes de niveau supérieur suivantes : Array, Boolean, 
Number, Object et String.
Pour initialiser des propriétés alignées :
1.
Ouvrez les fichiers  et  dans l’outil de programmation Flash.
2. Modifiez les fichiers de classe ClassA, de sorte qu’ils correspondent à l’ActionScript suivant 
(les modifications à effectuer apparaissent en gras) :
class com.adobe.utils.ClassA {
static var _className:String = "ClassA";
function ClassA() {
trace("ClassA constructor");
}
function doSomething():Void {
trace("ClassA - doSomething()");
}
}
La seule différence entre le fichier de classe existant et le bloc de code précédent est qu’une 
valeur est à présent définie pour la variable statique _className, « ClassA ». 
3. Modifiez le fichier de classe ClassB et ajoutez la propriété alignée, en modifiant la valeur 
sur « ClassB ».
4. Enregistrez les deux fichiers ActionScript avant de continuer.
Cette règle s’applique uniquement aux variables d’occurrence (variables copiées dans chaque 
occurrence d’une classe). Elle ne s’applique pas aux variables de classe (variables qui 
appartiennent véritablement à la classe). 
REMARQUE
Lorsque vous initialisez les tableaux alignés, un seul tableau est créé pour toutes les 
occurrences de la classe.
Pour poursuivre l’écriture de votre fichier de classe, consultez la section des membres dans vos classes », à la page 249.
248
Classes

Contrôle de l’accès des membres dans vos classes
Par défaut, toute propriété ou méthode de classe est accessible à toute autre classe : tous les 
membres d’une classe sont considérés comme publics par défaut. Toutefois, dans certains cas, 
vous pouvez souhaiter que d’autres classes n’aient pas accès aux données ou aux méthodes 
d’une classe. Vous devez alors faire en sorte que ces membres deviennent privés, c’est-à-dire 
disponibles uniquement pour la classe qui les déclare ou les définit.
Pour spécifier des membres publics ou privés, utilisez l’attribut de membre public ou private. 
Par exemple, le code suivant déclare une variable privée (une propriété) et une méthode privée 
(une fonction). La classe suivante (LoginClass) définit une propriété privée nommée 
userName et une méthode privée nommée getUserName() :
class LoginClass {
  private var userName:String;
  private function getUserName():String {
    return this.userName;
  }
  // Constructeur :
  public function LoginClass(user:String) {
    this.userName = user;
  }
}
Les membres privés (propriétés et méthodes) sont uniquement accessibles à la classe qui 
définit ces membres et aux sous-classes de cette classe d’origine. Les occurrences de la classe 
d’origine ou celles des sous-classes de cette classe ne peuvent pas accéder aux propriétés et 
méthodes privées ; c’est-à-dire que les membres privés ne sont accessibles qu’au sein des 
définitions de classe, et non au niveau des occurrences. Dans l’exemple suivant, vous modifiez 
l’accès des membres à vos fichiers de classe.
REMARQUE
Cet exercice est associé à lla page 238. Si vous ne souhaitez pas suivre l’exemple, il vous est possible de 
télécharger les fichiers de classe depuis 
Exemple : Ecriture de classes personnalisées
249

Pour contrôler l’accès des membres :
1.
Ouvrez les fichiers  et  dans l’outil de programmation Flash.
2. Modifiez le fichier ActionScript, de sorte que son contenu corresponde au code 
ActionScript suivant (les modifications à effectuer apparaissent en gras) :
class com.adobe.utils.ClassA {
private static var _className:String = "ClassA";
public function ClassA() {
trace("ClassA constructor");
}
public function doSomething():Void {
trace("ClassA - doSomething()");
}
}
Le code précédent définit les deux méthodes (la constructeur ClassA et la méthode 
doSomething() comme publiques, ce qui signifie que les scripts externes peuvent y 
accéder. La variable statique _className est définie comme privée, ce qui signifie qu’elle 
n’est accessible qu’au sein de la classe et pas depuis des scripts externes.
3. Modifiez le fichier ActionScript  et ajoutez les mêmes méthode et propriété que 
dans le fichier ClassA.
4. Enregistrez les deux fichiers ActionScript avant de continuer.
Une occurrence de ClassA ou ClassB ne peut pas accéder aux membres privés. Par exemple, le 
code suivant, ajouté à l’image 1 du scénario d’un fichier FLA, provoquerait une erreur de 
compilation indiquant que la méthode est privée et qu’il est impossible d’y accéder :
import com.adobe.utils.ClassA;
var a:ClassA = new ClassA();
trace(a._className); // Erreur. Le membre est privé et n’est pas accessible.
Le contrôle de l’accès des membres est une fonction de compilation uniquement ; à 
l’exécution, Flash Player ne fait aucune distinction entre les membres publics et privés.
Pour poursuivre l’écriture de votre fichier de classe, consultez la section classes », à la page 251.
250
Classes

Documentation des classes
L’insertion de commentaires dans vos classes et interfaces constitue pour les autres utilisateurs 
un élément essentiel de leur documentation. Par exemple, vous pouvez distribuer vos fichiers 
de classe dans la communauté Flash ou travailler avec une équipe de concepteurs ou de 
développeurs amenés à utiliser vos fichiers dans leur travail ou dans le cadre d’un projet en 
cours. La documentation permet aux autres utilisateurs de mieux comprendre l’objectif et les 
origines de la classe.
Un fichier d’interface ou de classe comporte généralement deux types de commentaire : les 
commentaires de documentation et les commentaires d’implémentation. Les commentaires de 
documentation décrivent le cahier des charges du code, mais pas son implémentation. 
Les commentaires d’implémentation décrivent le code ou l’implémentation de sections 
spécifiques du code. Ces deux types de commentaires utilisent des séparateurs légèrement 
différents. Les commentaires de documentation sont séparés par /** et */, tandis que les 
commentaires d’implémentation sont séparés par /* et */. 
REMARQUE
Les commentaires de documentation ne constituent pas un élément de langage dans 
ActionScript 2.0. Cependant, ils constituent une manière commune de structurer des 
commentaires dans un fichier de classe que vous pouvez utiliser dans vos fichiers AS.
Servez-vous des commentaires de documentation pour décrire les interfaces, les classes, les 
méthodes et les constructeurs. Incluez un commentaire de documentation par classe, interface 
ou membre, et placez-le directement avant la déclaration. 
Si vous vous devez ajouter des informations supplémentaires à vos commentaires de 
documentation, utilisez des commentaires d’implémentation (sous la forme de blocs de 
commentaires ou de commentaires sur une ligne, décrits dans la section commentaires », à la page 101). Les commentaires d’implémentation, si vous les ajoutez, 
suivent directement la déclaration.
RE
N’incluez pas les commentaires qui ne se rapportent pas directement à la classe en 
MA
cours de lecture. Par exemple, n’incluez pas de commentaires décrivant le package 
R
correspondant.
Q
UE
REMARQUE
L’exercice suivant est associé à lla page 238. Si vous ne souhaitez pas suivre l’exemple, il vous est possible de 
télécharger les fichiers de classe depuis 
Exemple : Ecriture de classes personnalisées
251

Pour documenter vos fichiers de classe :
1.
Ouvrez les fichiers  et  dans l’outil de programmation Flash.
2. Modifiez le fichier de classe ClassA et ajoutez le nouveau code (les modifications à effectuer 
sont en gras) en haut du fichier de classe :
/**
Classe ClassA
version 1.1
6/21/2005
copyright Adobe Systems Incorporated

 */
class com.adobe.utils.ClassA {
private static var _className:String = "ClassA";
public function ClassA() {
trace("ClassA constructor");
}
public function doSomething():Void {
trace("ClassA - doSomething()");
}
}
Le code ci-dessus a ajouté un commentaire en haut du fichier de classe. Il est toujours 
conseillé d’ajouter des commentaires à votre code ActionScript et à vos fichiers Flash afin 
d’indiquer des informations très utiles telles que l’auteur de la classe, la date de la dernière 
modification, des informations de copyright ou tout problème/bogue éventuel pouvant 
être lié au fichier.
3. Ajoutez un commentaire similaire en haut du fichier ActionScript , en modifiant 
le nom de la classe et toute autre information nécessaire.
4. Enregistrez les deux fichiers ActionScript avant de continuer.
Vous pouvez également ajouter un bloc de commentaires ou des commentaires d’une seule 
ligne ou de fin de ligne dans le code de la classe. Pour plus d’informations sur la rédaction de 
commentaires pertinents, consultez la section la page 728. Pour plus d’informations sur les commentaires, consultezune ligne », à la page 102, « Commentaires sur plusieurs lignes », à la page 102 et 
« Commentaires en fin de ligne », à la page 103.
Pour apprendre à utiliser ces fichiers de classe personnalisée dans un fichier SWF, consultez la 
section « Exemple : Utilisation de fichiers de classe personnalisée dans Flash », à la page 253.
252
Classes

Exemple : Utilisation de fichiers de classe 
personnalisée dans Flash
Cet exemple utilise des fichiers de classe répertoriés dans l’exemple : classes personnalisées », à la page 238 ; vous pouvez également les télécharger depuis 
Si vous avez complété classes personnalisées », à la page 238, localisez et sur votre disque dur.
Le package du fichier de la classe ClassA portant le nom com.adobe.utils.ClassA, vous 
devez vous assurer d’avoir enregistré les fichiers de classe dans la structure de répertoires 
appropriée. Créez un sous-dossier appelé com dans le répertoire actif. Dans ce dossier com, 
créez un dossier nommé adobe. Enfin, ajoutez un troisième et dernier sous-répertoire nommé 
utils dans le dossier adobe. Enregistrez les deux fichiers de classe  et  dans ce 
dossier utils. Vous êtes maintenant prêt à commencer avec cet exemple.
Vous pouvez utiliser les classes personnalisées écrites dans le cadre de lclasses personnalisées », à la page 238 avec un fichier FLA. Dans cet exemple, vous utilisez les 
classes personnalisées pour créer une petite application dans Flash. Vos classes sont compilées 
dans le fichier SWF lorsque vous publiez le document, et l’ensemble fonctionne ensuite de 
concert. Dans les exercices suivants, vous allez découvrir les chemins de classe, l’utilisation des 
fichiers de classe dans votre application, ainsi que la manière d’importer des classes et des 
packages.
Pour poursuivre cet exemple, passez à la section la page 253.
Importation de classes et de packages
Pour faire référence à une classe dans un autre script, vous devez faire précéder le nom de la 
classe par son nom de package. La combinaison du nom de la classe et de son chemin de 
package correspond au nom pleinement qualifié de la classe. Si une classe réside dans un 
répertoire de chemin de classe de premier niveau (et non dans un sous-répertoire du répertoire 
de chemin de classe), son nom de classe est également son nom pleinement qualifié.
Pour spécifier des chemins de package, utilisez une notation de type point (.) pour séparer les 
noms des répertoires de package. Les chemins de package sont hiérarchiques : chaque point 
représente un répertoire imbriqué. Supposons par exemple que vous créiez une classe nommée 
ClassName, qui réside dans un package com/adobe/docs/learnAs2 dans votre chemin de classe. 
Pour créer une occurrence de cette classe, vous pouvez spécifier le nom complet de la classe.
Exemple : Utilisation de fichiers de classe personnalisée dans Flash
253

Vous pouvez également utiliser le nom de classe complet pour taper vos variables, comme 
illustré dans l’exemple suivant :
var .learnAs2.ClassName = new 
.learnAs2.ClassName();
Vous pouvez utiliser l’instruction import pour importer des paquets dans un script, ce qui 
vous permet d’utiliser le nom abrégé d’une classe à la place de son nom complet. Vous pouvez 
également utiliser le caractère générique * pour importer toutes les classes dans un package. 
Dans ce cas, vous n’avez pas besoin d’utiliser le nom de classe complet à chaque emploi de la 
classe.
Supposons par exemple que dans un autre script, vous ayez importé la classe ci-dessus avec 
l’instruction import, comme dans l’exemple suivant :
import .UserClass;
Par la suite, dans le même script, vous pouvez faire référence à cette classe par son nom abrégé, 
comme dans l’exemple suivant :
var myUser:UserClass = new UserClass();
Vous pouvez également utiliser le caractère générique (*) pour importer toutes les classes dans 
un package donné. Supposons que vous ayez un package nommé com.adobe.utils 
contenant deux fichiers de classe ActionScript,  et . Dans un autre script, 
vous pouvez importer les deux classes dans ce package en utilisant le caractère générique, 
comme dans l’exemple suivant :
import com.adobe.utils.*;
L’exemple suivant indique que vous pouvez faire référence aux deux classes directement dans 
le même script :
var myA:ClassA = new ClassA();
var myB:ClassB = new ClassB();
L’instruction import s’applique uniquement au script actif (image ou objet) dans lequel elle 
est appelée. Si une classe importée n’est pas utilisée dans un script, elle n’est pas incluse dans le 
pseudo-code binaire du fichier SWF résultant, et n’est pas disponible dans les fichiers SWF 
susceptibles d’être chargés par le fichier FLA contenant l’instruction import.
REMA
L’exercice suivant est associé à lpersonnalisée dans Flash », à la page 253 qui succède aux exemples « Exemple : 
R
Ecriture de classes personnalisées ». Si vous avez besoin de ClassA et ClassB, il vous 
Q
UE
est possible de télécharger les fichiers de classe depuis learnas/classes/.
254
Classes

Pour importer une classe ou un package :
1.
Ouvrez le fichier .
2. Saisissez le code suivant dans la fenêtre de script :
import com.adobe.utils.*;
var a = new ClassA(); // Constructeur ClassA
var b = new ClassB(); // Constructeur ClassB
Le bloc de code précédent commence par importer chacune des classes dans le package 
com.adobe.utils via le caractère générique *. Ensuite, vous créez une nouvelle 
occurrence de la classe ClassA, ce qui entraîne l’envoi d’un message dans le panneau de 
sortie. Une occurrence de la classe ClassB est également créée, ce qui envoie également des 
messages de débogage au panneau de sortie.
3. Enregistrez les modifications apportées au document Flash avant de continuer.
Pour continuer à utiliser ces fichiers de classe dans un fichier Flash, consultez la section 
« Création d’occurrences de classes dans un exemple », à la page 255.
Création d’occurrences de classes dans un exemple
Les occurrences sont des objets qui contiennent toutes les propriétés et les méthodes d’une 
classe donnée. Par exemple, les tableaux étant des occurrences de la classe Array, vous pouvez 
utiliser n’importe quelle méthode ou propriété de la classe Array avec n’importe quelle 
occurrence de tableau. Vous pouvez également créer votre propre classe, par exemple 
UserSettings, puis créer une occurrence de la classe UserSettings.
Reprenons l’exemple commencé dans le cadre de l’personnalisée dans Flash », à la page 253, lorsque vous avez modifié un fichier FLA pour 
importer les classes de manière à ne plus avoir à utiliser leurs noms complets.
Dans cet exla page 253), l’étape suivante consiste à créer une occurrence des classes ClassA et ClassB dans 
un script, telle qu’un script d’image dans un document Flash  et de l’affecter à 
une variable. Pour créer une occurrence d’une classe personnalisée, utilisez l’opérateur new, 
comme pour créer une occurrence de classe ActionScript de niveau supérieur (telle que Date 
ou Array). Vous faites référence à la classe par son nom de classe complet, ou vous l’importez, 
comme dans la section « Importation de classes et de packages », à la page 253.
REMARQUE
L’exercice suivant est associé à lpersonnalisée dans Flash », à la page 253 qui succède aux exemplesEcriture de classes personnalisées ».
Exemple : Utilisation de fichiers de classe personnalisée dans Flash
255

Pour créer une nouvelle occurrence des classes ClassA et ClassB :
1.
Ouvrez le fichier .
2. Saisissez le code en gras suivant dans la fenêtre de script :
import com.adobe.utils.*;
var a:ClassA = new ClassA(); // Constructeur ClassA
a.doSomething(); // appel de la méthode doSomething() de ClassA
var b:ClassB = new ClassB(); // Constructeur ClassB
b.doSomething(); // appel de la méthode doSomething() de ClassB
Le fait de saisir vos objets dans cet exemple de code permet au compilateur de s’assurer que 
vous n’essayez pas d’accéder aux propriétés ou aux méthodes qui ne sont pas définies dans 
votre classe personnalisée. Pour plus d’informations sur le typage strict des données, 
consultez la section « Affectation des types de données et typage strict », à la page 45. 
Une exception au typage strict de vos objets, serait de déclarer que la classe est dynamique 
à l’aide du mot clé dynamic. Voir « Création de classes dynamiques », à la page 233. 
3. Enregistrez les modifications apportées au fichier FLA avant de continuer.
A présent, les bases de la création et de l’utilisation des classes dans les documents Flash ne 
devraient plus avoir de secrets pour vous. N’oubliez pas que vous pouvez également créer des 
occurrences des classes ActionScript de niveau supérieur ou intégrées (voir classes intégrées », à la page 274). 
Pour continuer à utiliser ces fichiers de classe dans un fichier Flash, consultez la section 
« Affectation d’une classe à des symboles dans Flash », à la page 256.
Affectation d’une classe à des symboles 
dans Flash
Vous pouvez également affecter une classe aux symboles susceptibles d’être utilisés dans un 
fichier Flash, tels qu’un clip sur la scène. 
Pour affecter une classe à un symbole de clip :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2. Choisissez Fichier > Enregistrer sous, et nommez le fichier , puis sauvegardez le 
fichier sur votre disque dur.
3. Saisissez le code suivant dans la fenêtre de script :
class Animal {
public function Animal() {
trace("Animal::constructor");
}
}
Ce code ActionScript crée une nouvelle classe appelée Animal qui dispose d’une méthode 
constructeur envoyant une chaîne au panneau de sortie.
256
Classes

4. Enregistrez les modifications apportées au fichier ActionScript.
5. Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA, 
puis cliquez sur OK.
6. Choisissez Fichier > Enregistrez sous et nommez le fichier  ; enregistrez le 
fichier dans le même dossier que le fichier créé à l’étape 2.
7. Choisissez Insertion > Nouveau Symbole pour ouvrir la boîte de dialogue Créer un 
symbole.
8. Saisissez le nom de symbole d’un animal et sélectionnez l’option Movie Clip.
9. Cliquez sur le bouton Avancé dans le coin inférieur de la boîte de dialogue Créer un 
nouveau symbole, pour activer davantage d’options.
Le bouton Avancé est disponible lorsque vous êtes en mode basique de la boîte de dialogue 
Créer un nouveau symbole. 
10. Dans la section Liaison, activez la case à cocher Exporter pour ActionScript. 
L’activation de cette option vous permet de joindre dynamiquement des occurrences de ce 
symbole à vos documents Flash pendant l’exécution.
11. Saisissez une valeur pour l’identifiant animal_id et définissez la Classe ActionScript 2.0 sur 
Animal (selon le nom de classe spécifié à l’étape 3).
12. Sélectionnez la case à cocher Exporter dans la première image, puis cliquez sur OK pour 
appliquer vos modifications et fermer la boîte de dialogue.
13. Enregistrez le document Flash et choisissez Contrôle > Tester l’animation.
Le texte provenant de la fonction constructeur de votre classe Animal apparaît dans le 
panneau de sortie.
REMARQUE
Si vous devez modifier les propriétés de liaison du clip, cliquez du bouton droit sur le 
symbole dans la bibliothèque du document et choisissez Propriétés ou Liaison dans 
le menu contextuel.
Affectation d’une classe à des symboles dans Flash
257

Compilation et exportation de classes
Par défaut, les classes utilisées par un fichier SWF sont mises en packages et exportées dans la 
première image du fichier SWF. Vous pouvez également spécifier une image différente dans 
laquelle vos classes sont mises en package et exportées. Cette option est très pratique, par 
exemple lorsqu’un fichier SWF utilise de nombreuses classes dont le téléchargement est long 
(telles que des composants). Si les classes sont exportées vers la première image, l’utilisateur 
doit attendre que tout le code de classe soit téléchargé avant de voir apparaître cette image. 
En spécifiant une image ultérieure dans le scénario, vous pouvez afficher une courte 
animation de chargement dans les premières images du scénario, pendant le téléchargement 
du code de classe dans l’image ultérieure.
Pour spécifier l’image à exporter pour les classes d’un document Flash :
1.
Choisissez Fichier > Nouveau, puis Document Flash. Enregistrez le nouveau document 
sous le nom .
2. Renommez le calque par défaut content, faites glisser un composant ProgressBar du 
panneau Composants vers la scène et donnez-lui my_pb comme nom d’occurrence.
3. Créez un nouveau calque, faites-le glisser sur le calque Contenu, et renommez-le actions.
4. Ajoutez le code ActionScript suivant à l’image 1 du calque actions du scénario principal :
my_pb.indeterminate = true;
5. Créez une nouvelle image-clé sur Image 2 du calque actions et ajoutez le code ActionScript 
suivant :
var classesFrame:Number = 10;
if (_framesloaded < classesFrame) {
trace(this.getBytesLoaded() + " of " + this.getBytesTotal() + " bytes 
loaded");
gotoAndPlay(1);
} else {
gotoAndStop(classesFrame);
}
6. Créez une nouvelle image-clé sur Image 10 du calque actions et ajoutez le code 
ActionScript suivant :
stop();
7. Créez une nouvelle image-clé sur Image 10 du calque actions et faites glisser plusieurs 
composants sur la scène.
8. Cliquez avec le bouton droit sur chaque composant (masquez ProgressBar) dans le panneau 
Bibliothèque et choisissez Liaison dans le menu contextuel pour lancer la boîte de dialogue 
Propriétés de liaison.
258
Classes

9. Dans la boîte de dialogue Propriétés de liaison, assurez-vous que l’option Exporter pour 
ActionScript est sélectionnée, désélectionnez la boîte de dialogue Exporter dans la première 
image, et cliquez sur OK.
10. Choisissez Fichier > Paramètres de publication. 
11. Dans la boîte de dialogue Paramètres de publication, cliquez sur l’onglet Flash. 
12. Cliquez sur le bouton Paramètres qui se trouve en regard du menu contextuel de la version 
ActionScript pour ouvrir la boîte de dialogue Paramètres d’ActionScript. 
13. Dans le champ de texte Exporter l’image pour les classes, saisissez le numéro de l’image 
cible (Image 10). 
Si l’image spécifiée n’existe pas dans le scénario, un message d’erreur apparaît lors de la 
publication du fichier SWF.
14. Cliquez sur OK pour fermer la boîte de dialogue Paramètres d’ActionScript, puis cliquez 
de nouveau sur OK pour fermer la boîte de dialogue Paramètres de publication.
15. Choisissez Contrôle > Tester l’animation pour tester le document Flash. Si les composants 
se chargent trop rapidement, sélectionnez View > Simuler le téléchargement depuis le 
fichier SWF. Flash simule le téléchargement du document Flash à une vitesse inférieure, 
qui vous permet de voir les composants de la barre de progression s’animer tandis que les 
fichiers de classe se téléchargent.
Pour plus d’informations sur les fichiers ASO, reportez-vous à à la page 259.
Utilisation des fichiers ASO
Lors de la compilation, Flash crée parfois des fichiers portant l’extension .aso dans le sous-
répertoire /aso du répertoire de chemin de classe global par défaut (consultez la section 
« Définition et modification du chemin de classe », à la page 214). L’extension .aso signifie 
objet ActionScript (ASO). Pour chaque fichier ActionScript 2.0 importé de façon implicite ou 
explicite et pour lequel la compilation est réussie, Flash génère un fichier ASO. Ce fichier 
contient le pseudo-code binaire issu du fichier ActionScript associé. Ces fichiers contiennent 
donc la forme compilée (le pseudo-code binaire) d’un fichier de classe. 
Flash ne doit recréer le fichier ASO que dans les cas suivants :
?
Le fichier AS correspondant a été modifié.
?
Les fichiers ActionScript qui contiennent des définitions importées ou utilisées par le 
fichier ActionScript correspondant ont été modifiés.
?
Les fichiers ActionScript inclus par le fichier ActionScript correspondant ont été modifiés.
Compilation et exportation de classes
259

Le compilateur crée des fichiers ASO pour faciliter la gestion du cache. La première 
compilation est plus lente que les compilations suivantes. Ceci est dû au fait que les fichiers 
AS ont changé et sont recompilés en tant que fichiers ASO. Pour les fichiers AS ne 
comportant pas de modifications, le compilateur lit le pseudo-code compilé directement dans 
le fichier ASO, sans recompiler le fichier AS.
Le format de fichier ASO est un format intermédiaire développé pour l’usage interne. Il n’est 
pas documenté et n’a pas été conçu pour la redistribution. 
Si Flash semble compiler des versions plus anciennes d’un fichier que vous avez édité, 
supprimez les fichiers ASO et compilez-les de nouveau. Si vous prévoyez de supprimer des 
fichiers ASO, supprimez-les lorsque Flash n’effectue aucune autre opération, telle que la 
vérification de la syntaxe ou l’exportation de SWF.
Pour supprimer des fichiers ASO : 
Si vous modifiez un fichier FLA et que vous souhaitez supprimer un fichier ASO, sélectionnez 
l’une des actions suivantes dans l’environnement auteur :
?
Sélectionnez Contrôle > Supprimer fichiers ASO pour supprimer des fichiers ASO et 
poursuivre la modification. 
?
Sélectionnez Contrôle > Supprimer fichiers ASO et Tester l’animation pour supprimer des 
fichiers ASO et tester l’application.
Si vous modifiez un document ActionScript dans la fenêtre de script : 
?
Sélectionnez Contrôle > Supprimer fichiers ASO pour supprimer des fichiers ASO et 
poursuivre la modification.
?
Sélectionnez Contrôle > Supprimer fichiers ASO et Tester le projet pour supprimer des 
fichiers ASO et tester l’application.
La quantité de code pouvant être insérée dans un classe n’est pas illimitée : Le pseudo-code 
d’une définition de classe dans un fichier SWF exporté ne doit faire plus de 32767octets. 
Un message d’avertissement s’affiche s’il dépasse cette limite.
Vous ne pouvez pas prédire la taille du pseudo-code d’une classe donnée, mais les classes 
comportant jusqu’à 1 500 lignes dépassent rarement la limite.
Si votre classe dépasse la limite, déplacez une partie du code dans une autre classe. En général, 
une programmation orientée objet de qualité consiste à créer des classes aussi concises que 
possible.
260
Classes

Distinction entre classes et domaine
Lorsque vous placez du code ActionScript dans des classes, il peut être nécessaire de modifier 
le mode d’utilisation du mot-clé this. Par exemple, si une méthode de classe utilise une 
fonction de rappel (telle que la méthode onLoad() de la classe LoadVars) dans votre code, il 
sera difficile de savoir si le mot-clé this fait référence à la classe ou à l’objet. Dans ce cas, il 
peut être nécessaire de créer un pointeur vers la classe actuelle, comme dans l’exemple suivant.
Pour distinguer le domaine et les fichiers de classe externes :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2. Saisissez ou collez le code suivant dans la fenêtre de script :
/**
Classe Product

*/
class Product {
  private var productsXml:XML;
  // Constructeur
  // targetXmlStr - chaîne, contient le chemin d’un fichier XML
  function Product(targetXmlStr:String) {
    /* Crée une référence locale à la classe actuelle. 
       Même si vous êtes au niveau du gestionnaire d’événement onLoad du 
code XML, 
       vous pouvez faire référence à la classe actuelle et pas seulement 
au paquet XML.
    */
    var thisObj:Product = this;
    // Crée une variable locale qui permet de charger le fichier XML.
    var prodXml:XML = new XML();
    prodXml.ignoreWhite = true;
    prodXml.onLoad = function(success:Boolean) {
      if (success) {
        /* Lorsque le code XML se charge et est analysé correctement,
           définir la variable productsXml de la classe sur le document 
           XML analysé et appeler la fonction init.
        */
        thisObj.productsXml = this;
        ();
      } else {
        /* Une erreur s’est produite pendant le chargement du fichier 
XML. */
        trace("error loading XML");
      }
    };
    // Amorcer le chargement du document XML.
    (targetXmlStr);
  }
  public function init():Void {
    // Afficher le package XML.
    trace(this.productsXml);
  }
}
Distinction entre classes et domaine
261

Dans la mesure où vous tentez de référencer la variable du membre privé au sein d’un 
gestionnaire onLoad, le mot-clé this fait en réalité référence à l’occurrence prodXml et non 
à la classe Product, à laquelle on s’attendrait. Par conséquent, vous devez créer un pointeur 
vers le fichier de classe local de façon à pouvoir référencer directement la classe à partir du 
gestionnaire onLoad. Vous pouvez maintenant utiliser cette classe dans un document Flash.
3. Enregistrez le code ActionScript précédent sous le nom .
4. Créez un nouveau document Flash nommé  dans le même répertoire.
5. Sélectionnez l’image 1 du scénario principal.
6. Saisissez le code ActionScript suivant dans le panneau Actions :
var myProduct:Product = new Product("
");
7. Choisissez Contrôle > Tester l’animation pour tester ce code dans l’environnement de test.
Le contenu du document XML spécifié s’affiche dans le panneau de sortie.
Les variables et les fonctions statiques sont un autre type de domaine rencontré avec l’utilisation 
de ces classes. Le mot-clé static indique qu’une variable ou une fonction n’est créée qu’une 
fois par classe et non pas dans chaque occurrence de cette classe. Vous pouvez accéder à un 
membre de classe statique sans créer d’occurrence de la classe en utilisant la syntaxe 
someClassName.username. Pour plus d’informations sur les variables et les fonctions statiques, 
consultez les sections statiques », à la page 221 et « Utilisation de membres de classe », à la page 228.
Un autre avantage des variables statiques est qu’elles ne perdent pas leurs valeurs à la fin de 
leur domaine. L’exemple suivant présente l’utilisation du mot-clé static pour créer un 
compteur chargé de suivre le nombre d’occurrences de la classe Flash créées. La variable 
numInstances étant statique, elle n’est créée qu’une fois pour l’ensemble de la classe, et pas 
pour chaque occurrence.
Pour utiliser le mot-clé static :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2. Saisissez le code suivant dans la fenêtre de script :
class User {
  private static var numInstances:Number = 0;
  public function User() {
    User.numInstances++;
  }
  public static function get instances():Number {
    return User.numInstances;
  }
}
Le code précédent définit une classe User qui surveille le nombre d’appels au constructeur. 
Une variable statique privée (User.numInstances) est incrémentée dans la méthode 
constructeur.
262
Classes

3. Enregistrez le document sous le nom .
4. Choisissez Fichier > Nouveau puis sélectionnez Document Flash pour créer un nouveau 
document FLA, et enregistrez-le dans le même répertoire que .
5. Saisissez le code ActionScript suivant sur l’image 1 du scénario :
trace(User.instances); // 0
var user1:User = new User();
trace(User.instances); // 1
var user2:User = new User();
trace(User.instances); // 2
La première ligne de code appelle la méthode de lecture statique instances() qui renvoie 
la valeur de la variable statique privée numInstances. Le reste du code crée de nouvelles 
occurrences de la classe User et affiche la valeur actuelle renvoyée par la méthode de lecture 
instances().
6. Choisissez Contrôle > Tester l’animation pour tester les documents.
Pour plus d’informations sur l’utilisation du mot-clé this dans les classes, consultez la section 
« Utilisation du mot-clé this dans les classes », à la page 237.
Présentation des classes de niveau 
supérieur et intégrées
Outre les principaux éléments de langage, constructions (boucles for et while, par exemple) 
et types de données primitives (nombres, chaînes et valeurs booléennes) décrits précédemment 
dans ce manuel (vActionScript fournit également plusieurs classes intégrées (types de données complexes). 
Ces classes offrent de nombreuses options et fonctionnalités à vos scripts. Vous avez utilisé les 
classes de niveau supérieur et d’autres classes intégrées du langage ActionScript dans les 
chapitres précédents et vous allez encore les exploiter dans les chapitres restants. 
De nombreuses classes fournies avec Flash permettent d’ajouter interactivité et fonctionnalité 
dans vos fichiers SWF ou encore de développer des applications complexes. Par exemple, vous 
pouvez utiliser la classe Math pour calculer des équations dans vos applications. Vous pouvez 
également utiliser la classe BitmapData pour créer des animations codées et des pixels.
Les classes de niveau supérieur, énumérées dans « Classes de niveau supérieur », à la page 265, 
sont écrites dans Flash Player. Dans la boîte à outils Actions, ces classes sont situées dans le 
répertoire ActionScript 2.0 Classes. Certaines d’entre elles reposent sur les spécifications 
ECMAScript (ECMA-262) edition 3 language specification et sont appelées classes ActionScript 
de base
. Elles comprennent les classes Array, Boolean, Date et Math. Pour plus d’informations 
sur les packages, consultez la section « Fonctionnement des packages », à la page 202.
Présentation des classes de niveau supérieur et intégrées
263

Vous pouvez trouver les classes ActionScript installées sur votre disque dur. Vous pouvez 
trouver les dossiers classes dans :
?
Windows : Disque dur\Documents and Settings\utilisateur\Local Settings\Application 
Data\Adobe\Flash CS3\langue\Configuration\Classes. 
?
Macintosh : Disque dur/Utilisateurs/utilisateur/Library/Application Support/Adobe/
Adobe Flash CS3/langue/Configuration/Classes
Le document Do note the Read Me placé dans ce répertoire pour plus d’information sur sa 
structure.
La distinction entre les classes ActionScript de base et les classes spécifiques à Flash est 
similaire à celle qui existe entre les classes JavaScript de base et côté client. Tout comme les 
classes JavaScript côté client permettent de contrôler l’environnement du client (le navigateur 
Web et le contenu des pages Web), les classes spécifiques à Flash permettent de contrôler 
l’apparence et le comportement d’une application Flash à l’exécution. 
Les autres classes intégrées ActionScript sont spécifiques à Flash et au modèle d’objet Flash 
Player. Parmi ces classes, citons Camera, MovieClip et LoadVars. D’autres classes sont 
organisées en packages, telles que flash.display. Toutes ces classes sont parfois dites intégrées 
(classes prédéfinies pouvant être utilisées pour ajouter des fonctionnalités à vos applications).
Les sections suivantes présentent les classes ActionScript intégrées, et décrivent les tâches 
fondamentales que vous effectuez avec ces classes intégrées. Pour un aperçu de l’utilisation des 
classes et des objets en programmation orientée objet, consultez la sclasses intégrées », à la page 274. Les exemples de code en utilisant ces classes sont inclus dans 
tout le manuel. 
Pour plus d’informations sur les éléments du langage (constantes, opérateurs et instructions), 
consultez le Chapitre 4, « Eléments fondamentaux du langage et de la syntaxe », à la page 81
Pour plus d’informations sur les classes intégrées et de niveau supérieur, consultez les 
rubriques suivantes :
?
« Classes de niveau supérieur », à la page 265
?
« Le package flash.display », à la page 270
?
« Package flash.external », à la page 270
?
« Le package flash.filters », à la page 270
?
« Package  », à la page 272
?
« Package  », à la page 272
?
« package  », à la page 273
?
« Le package  », à la page 273
?
« Les packages System et TextField », à la page 273
264
Classes

 Autres éléments du langage
Il y a d’autres éléments de langage qui constituent ActionScript, en dehors des classes. 
Ils incluent des directives, des constantes, des fonctions globales, des propriétés globales, des 
opérateurs et des instructions. Pour plus d’informations sur l’utilisation de chacun de ces 
éléments de langage, consultez les rubriques suivantes :
?
Chapitre 4, « Eléments fondamentaux du langage et de la syntaxe »
?
Chapitre 5, « Fonctions et méthodes »
Vous trouverez une liste de ces éléments de language dans les sections suivantes de Guide de 
référence du langage ActionScript 2.0 
:
?
Directives de compilation
?
Constantes
?
Fonctions globales
?
propriétés globales
?
opérateurs
?
Instructions
Classes de niveau supérieur
Le niveau supérieur contient les fonctions globales et les classes ActionScript qui, pour la 
plupart, fournissent les fonctionnalités de base de vos applications. Les classes de base
directement empruntées à ECMAScript, comprennent Array, Boolean, Date, Error, Function, 
Math, Number, Object, String et System. Pour plus d’informations sur chaque classe, 
consultez le tableau suivant. 
REMARQUE
Les classes CustomActions et XMLUI sont uniquement disponibles dans 
l’environnement de programmation Flash.
Classe
Description
Accessibility
La classe Accessibility gère la communication entre les fichiers SWF et 
les applications de lecture d’écran. Conjointement avec la propriété 
globale _accProps, les méthodes de cette classe permettent de 
contrôler les propriétés accessibles des clips, des boutons et des 
champs de texte lors de l’exécution. Reportez-vous à Accessibilité.
Présentation des classes de niveau supérieur et intégrées
265

Classe
Description
Array
La classe Array représente des tableaux dans ActionScript et tous les 
objets de tableau sont des occurrences de cette classe. Elle contient 
les méthodes et propriétés réservées aux objets de tableau. 
Reportez-vous à Array.
AsBroadcaster
Cette classe offre des capacités de notification d’événement et de 
gestion des écouteurs pouvant être ajoutées à d’autres objets. 
Reportez-vous à AsBroadcaster.
Boolean
La classe Boolean est une enveloppe pour les valeurs booléennes 
(true ou false). Reportez-vous à Boolean.
Button
La classe Button fournit des méthodes, propriétés et gestionnaires 
d’événement pour l’utilisation des boutons. Reportez-vous à Button. 
Notez que la classe intégrée Button est différente de la classe du 
composant Button, associée au composant Button version 2.
Camera
La classe Camera vous permet d’accéder à la caméra de l’utilisateur, 
s’il en a installé une. Utilisé avec Flash Media Server, votre fichier SWF 
peut saisir, diffuser et enregistrer les images et les vidéos de la caméra 
d’un utilisateur. Reportez-vous à Camera.
Color
La classe Color permet de définir la valeur des couleurs RVB et leur 
évolution dans les occurrences de clips, puis de récupérer ces valeurs 
après leur définition. La classe Color est abandonnée dans Flash Player 
8 en faveur de la classe ColorTransform. Pour plus d’informations sur 
ColorTransform, se reporter à ColorTransform 
(.ColorTransform).
ContextMenu
La classe ContextMenu conditionne le contenu du menu contextuel de 
Flash Player à l’exécution. Vous pouvez associer des objets 
ContextMenu distincts à des objets MovieClip, Button ou TextField à 
l’aide de la propriété menu de ces classes. Vous avez aussi tout loisir 
d’utiliser la classe ContextMenuItem pour ajouter des éléments de 
menu personnalisés à un objet ContextMenu. Reportez-vous à 
ContextMenu.
ContextMenuItem
La classe ContextMenuItem vous permet de créer des éléments de 
menu dans le menu contextuel de Flash Player. Pour ajouter les 
éléments de menu que vous créez à l’aide de cette classe au menu 
contextuel de Flash Player, vous utilisez la classe ContextMenu. 
Reportez-vous à ContextMenuItem.
CustomActions
La classe CustomActions vous permet de gérer toute action 
personnalisée enregistrée avec l’outil de programmation 
Reportez-vous à CustomActions.
266
Classes

Classe
Description
Date
La classe Date détermine la représentation des dates et des heures 
dans ActionScript et prend en charge leurs opérations de manipulation. 
La classe Date permet également de récupérer la date et l’heure 
actuelle du système d’exploitation. Reportez-vous à Date.
Error
La classe Error contient des informations sur les erreurs d’exécution 
survenant dans vos scripts. En règle générale, vous utilisez 
l’instruction throw pour générer une condition d’erreur, que vous 
pouvez ensuite gérer à l’aide d’une instruction try.catch.finally. 
Reportez-vous à Error.
Function
La classe Function est la représentation sous forme de classe de toutes 
les fonctions ActionScript, y compris celles qui sont natives 
d’ActionScript et celles que vous définissez. Reportez-vous à 
Function.
Key
La classe Key fournit des méthodes et propriétés permettant d’obtenir 
des informations sur les actions effectuées sur le clavier et les touches 
par l’utilisateur. Reportez-vous à Key.
LoadVars
La classe LoadVars permet de transférer des variables en paires 
nom-valeur d’un fichier SWF à un serveur. Reportez-vous à LoadVars.
LocalConnection
La classe LocalConnection permet de développer des fichiers SWF 
qui peuvent échanger des instructions entre eux sans utiliser la 
méthode fscommand() ni JavaScript. Reportez-vous à 
LocalConnection.
Math
La classe Math fournit un accès pratique aux constantes 
mathématiques les plus courantes et offre plusieurs fonctions 
mathématiques. Toutes les propriétés et méthodes de la classe Math 
sont statiques et doivent être appelées à l’aide de la syntaxe 
Math.méthode(paramètre) ou Math.constante. Reportez-vous à Math.
Microphone
La classe Microphone vous permet d’accéder au micro de l’utilisateur, 
s’il en a installé un. Utilisé avec Flash Media Server, votre fichier SWF 
peut diffuser et enregistrer les sons du microphone d’un utilisateur. 
Reportez-vous à Microphone.
Mouse
La classe Mouse vous permet de contrôler la souris dans un fichier 
SWF. Vous pouvez l’utiliser pour masquer ou afficher le pointeur de la 
souris, par exemple. Reportez-vous à Mouse.
MovieClip
Chaque clip d’un fichier SWF est une occurrence de la classe 
MovieClip. Utilisez les méthodes et propriétés de cette classe pour 
contrôler les objets de clip. Reportez-vous à MovieClip.
Présentation des classes de niveau supérieur et intégrées
267

Classe
Description
MovieClipLoader
Cette classe permet d’implémenter des rappels d’écouteur qui 
fournissent des informations d’état lors du chargement des fichiers 
SWF, JPEG, GIF et PNG dans les occurrences de clips. 
Reportez-vous à MovieClipLoader.
NetConnection
La classe NetConnection établit une connexion locale en flux continu 
pour la lecture de fichiers Flash Video (FLV) à partir d’une adresse 
HTTP ou du système de fichiers local. Reportez-vous à 
NetConnection.
NetStream
La classe NetStream contrôle la lecture des fichiers FLV à partir d’un 
système de fichiers local ou d’une adresse HTTP. Reportez-vous à 
NetStream.
Number
La classe Number est une enveloppe pour le type de données primitif 
numérique. Reportez-vous à Number.
Object
La classe Object est à la racine de la hiérarchie des classes 
ActionScript. Toutes les autres classes héritent de ses méthodes et 
propriétés. Reportez-vous à Object.
PrintJob
La classe PrintJob permet d’imprimer du contenu à partir d’un fichier 
SWF, y compris le contenu créé de façon dynamique et les documents 
à plusieurs pages. Reportez-vous à PrintJob.
Selection
La classe Selection permet de définir et de contrôler le champ de texte 
dans lequel se trouve le point d’insertion (celui qui a le focus). 
Reportez-vous à Selection.
SharedObject
La classe SharedObject crée un stockage de données permanent sur 
l’ordinateur client, similaire aux cookies. Cette classe offre le partage 
des données en temps réel entre objets de l’ordinateur client. 
Reportez-vous à SharedObject.
Sound
La classe Sound vous permet de contrôler les sons dans un fichier 
SWF. Reportez-vous à Sound.
Stage
La classe Stage fournit des informations sur les dimensions, 
l’alignement et le mode d’échelle du fichier SWF. Elle signale 
également les événements de redimensionnement Stage. 
Reportez-vous à Stage.
String
La classe String est une enveloppe pour le type de données primitif 
chaîne, ce qui vous permet d’utiliser les méthodes et les propriétés de 
l’objet String pour manipuler les valeurs primitives de chaîne. 
Reportez-vous à String.
268
Classes

Classe
Description
System
La classe System fournit des informations sur Flash Player et sur le 
système sur lequel il s’exécute (la résolution d’affichage et la langue 
utilisée, par exemple). Elle vous permet aussi d’afficher ou de masquer 
le panneau Paramètres Flash Player et de modifier les paramètres de 
sécurité du fichier SWF Reportez-vous à System.
TextField
La classe TextField permet de contrôler les champs texte de saisie et 
dynamiques, notamment pour extraire des informations de formatage, 
appeler des gestionnaires d’événement et changer des propriétés 
telles que les valeurs alpha et la couleur d’arrière-plan. Reportez-vous à 
TextField.
TextFormat
La classe TextFormat vous permet d’appliquer des styles de formatage 
aux caractères et aux paragraphes d’un objet TextField. Reportez-vous 
à TextFormat.
TextSnapshot
L’objet TextSnapshot permet d’accéder au texte statique d’un clip et 
de mettre ce texte en forme. Reportez-vous à TextSnapshot.
Video
La classe Video permet d’afficher des objets vidéo dans un fichier 
SWF. Vous pouvez l’utiliser avec Flash Media Server pour afficher un 
contenu vidéo en flux continu dans un fichier SWF ou dans Flash pour 
afficher un fichier Flash Video (FLV). Reportez-vous à Video.
XML
Cette classe contient les méthodes et propriétés réservées aux objets 
XML. Reportez-vous à XML.
XMLNode
La classe XMLNode représente un nœud unique dans une 
arborescence de documents XML. Elle constitue la super-classe de la 
classe XML. Reportez-vous à XMLNode.
XMLSocket
La classe XMLSocket permet de créer une connexion socket durable 
entre un serveur et un client exécutant Flash Player. Les sockets du 
client autorisent un transfert de données à faible temps d’attente, tel 
que celui que requièrent les applications de discussion en ligne en 
temps réel (appelées « chat »). Reportez-vous à XMLSocket.
XMLUI
L’objet XMLUI autorise une communication avec les fichiers SWF 
utilisés comme interfaces utilisateur personnalisées pour les fonctions 
d’extensibilité de l’outil de programmation Flash (telles que 
Comportements, Commandes, Effets et Outils). 
Reportez-vous à XMLUI.
Présentation des classes de niveau supérieur et intégrées
269

Le package flash.display
Le package flash.display contient la classe BitmapData que vous pouvez utiliser pour 
développer des affichages visuels.
Classe
Description
BitmapData
La classe BitmapData permet de créer des images bitmap 
transparentes ou opaques de tailles arbitraires ou des images dans le 
document et de les manipuler de diverses manières à l’exécution. 
Reportez-vous à BitmapData (flash.display.BitmapData). 
Package flash.external 
Le package flash.external permet de communiquer avec le conteneur Flash Player à l’aide de 
code ActionScript. Par exemple, si vous imbriquez un fichier SWF dans une page HTML, 
celle-ci devient le conteneur. Vous pouvez alors communiquer avec la page HTML via la 
classe ExternalInterface et JavaScript. Également appelé External API.
Classe
Description
ExternalInterface
La classe ExternalInterface est l’API External, un sous-système qui 
autorise les communications entre ActionScript et le conteneur Flash 
Player (par exemple une page HTML utilisant JavaScript) ou une 
application de bureau qui utilise Flash Player. Reportez-vous à 
ExternalInterface (flash.external.ExternalInterface).
Le package flash.filters  
Le package flash.filters contient des classes liées aux effets de filtres bitmap disponibles dans 
Flash Player 8. Les filtres permettent d’appliquer de riches effets visuels, tels que le flou, les 
biseaux, le rayonnement et les ombres portées, aux occurrences d’image et de clip. Pour plus 
d’informations sur chaque classe, consultez les références fournies dans le tableau suivant.
Classe
Description
BevelFilter
La classe BevelFilter permet d’ajouter un effet biseauté à une 
occurrence de clip. 
Reportez-vous à BevelFilter 
(flash.filters.BevelFilter).
BitmapFilter
La classe BitmapFilter est une classe de base pour tous les effets 
de filtres. Reportez-vous à BitmapFilter (flash.filters.BitmapFilter).
270
Classes

Classe
Description
BlurFilter
La classe BlurFilter permet d’appliquer un effet flou à des 
occurrences de clip. 
Reportez-vous à BlurFilter 
(flash.filters.BlurFilter).
ColorMatrixFilter
La classe ColorMatrixFilter permet d’appliquer une transformation 
matricielle 4x5 aux valeurs de couleur RGBA et alpha de chaque 
pixel d’une image d’entrée. Après l’application de cette 
transformation, le résultat peut être produit avec un nouveau jeu de 
couleurs RGBA et de valeurs alpha. Reportez-vous à 
ColorMatrixFilter (flash.filters.ColorMatrixFilter).
ConvolutionFilter
La classe ConvolutionFilter permet d’appliquer un filtre de 
convolution de matrice Reportez-vous à ConvolutionFilter 
(flash.filters.ConvolutionFilter).
DisplacementMapFilter
La classe DisplacementMapFilter permet d’utiliser les valeurs des 
pixels d’une image spécifiée (remplacement d’une image) pour 
remplacer dans l’espace l’occurrence d’origine (un clip) auquel le 
filtre est appliqué. Reportez-vous à DisplacementMapFilter 
(flash.filters.DisplacementMapFilter).
DropShadowFilter
La classe DropShadowFilter permet d’ajouter un effet d’ombre 
portée à un clip. Reportez-vous à DropShadowFilter 
(flash.filters.DropShadowFilter).
GlowFilter
La classe GlowFilter permet d’ajouter un effet de rayonnement à 
un clip. Reportez-vous à GlowFilter (flash.filters.GlowFilter).
GradientBevelFilter
La classe GradientBevelFilter permet d’appliquer un effet dégradé 
à un clip. Reportez-vous à GradientBevelFilter 
(flash.filters.GradientBevelFilter).
GradientGlowFilter
La classe GradientGlowFilter permet d’appliquer un effet de 
rayonnement dégradé à un clip. Reportez-vous à 
GradientGlowFilter (flash.filters.GradientGlowFilter).
Présentation des classes de niveau supérieur et intégrées
271

Package  
Le package  contient des classes de géométrie, telles que des points, des rectangles et 
des matrices de transformation. Ces classes prennent en charge la classe BitmapData et la 
fonctionnalité de mise en cache des bitmap. Pour plus d’informations sur chaque classe, 
consultez les références fournies dans le tableau suivant.
Classe
Description
ColorTransform
La classe ColorTransform permet de définir mathématiquement la 
valeur des couleurs RVB et de transformation de couleur d’une 
occurrence. Vous pouvez récupérer ces valeurs après leur définition. 
Reportez-vous à ColorTransform (.ColorTransform).
Matrix
Représente une matrice de transformation qui détermine la façon de 
mapper des points d’un espace de coordonnées à l’autre. Reportez-
vous à Matrix (.Matrix).
Point
L’objet Point représente un emplacement dans un système de 
coordonnées à deux dimensions, dans lequel x est l’axe horizontal et y 
l’axe vertical. Reportez-vous à Point (.Point).
Rectangle
La classe Rectangle permet de créer et de modifier les objets 
Rectangle. Reportez-vous à Rectangle (.Rectangle).
Transform
Rassemble des données sur les transformations de couleurs et les 
manipulations de coordonnées qui s’appliquent à un objet occurrence. 
Reportez-vous à Transform (.Transform).
Package  
Le package  contient des classes qui vous permettent de charger et télécharger un ou 
plusieurs fichiers entre l’ordinateur d’un utilisateur et le serveur. Pour plus d’informations sur 
chaque classe, consultez les références fournies dans le tableau suivant.
Classe
Description
FileReference
La classe FileReference vous permet de charger et télécharger un ou 
plusieurs fichiers entre l’ordinateur d’un utilisateur et le serveur. 
Reportez-vous à FileReference (.FileReference).
FileReferenceList
La classe FileReferenceList permet de charger un ou plusieurs fichiers 
entre l’ordinateur d’un utilisateur et le serveur. Reportez-vous à 
FileReferenceList (.FileReferenceList).
272
Classes

package  
Le package  comporte la classe TextRenderer permettant de travailler avec une 
fonctionnalité d’anti-crénelage avancée dans Flash Player8. 
Classe
Description
TextRenderer
Cette classe fournit une fonctionnalité d’anti-crénelage avancé dans 
Flash Player8. Voir %{TextRenderer (.TextRenderer)}%..
Le package  
Le package  comporte la classe Locale pour travailler avec un texte multilingue.
Classe
Description
Locale
Cette classe vous permet de contrôler la façon dont le texte multilingue 
s’affiche dans un fichier SWF. Reportez-vous à Locale 
(.Locale).
Les packages System et TextField 
Le package System contient les capacités d’IME et des classes de sécurité. Ces classes traitent 
les paramètres du client susceptibles d’affecter le fonctionnement de votre application dans 
Flash Player. Pour plus d’informations sur chaque classe, consultez les références fournies dans 
le tableau suivant.
Classe
Description
capabilities
La classe Capabilities détermine les capacités du système et du Flash 
Player qui héberge le fichier SWF. Elle vous permet de personnaliser le 
contenu pour des formats différents. Reportez-vous à capabilities 
(System.capabilities).
IME
La classe IME permet de manipuler directement l’IME (Input Method 
Editor) du système d’exploitation sous lequel l’application Flash Player 
s’exécute sur l’ordinateur client. Reportez-vous à IME ().
security
La classe security contient des méthodes spécifiant la façon dont les 
fichiers SWF peuvent communiquer entre eux dans différents 
domaines. Reportez-vous à security (System.security).
Présentation des classes de niveau supérieur et intégrées
273

Le package TextField contient la classe StyleSheet qui vous permet d’appliquer des styles CSS 
au texte.
Classe
Description
StyleSheet
La classe StyleSheet permet de créer un objet feuille de style 
contenant les règles de formatage du texte, comme la taille et la 
couleur de la police et d’autres styles de formatage. Reportez-vous à 
StyleSheet (TextField.StyleSheet).
Utilisation des classes intégrées
En programmation orientée objet (OOP), une classe définit une catégorie d’objets. Une classe 
décrit les propriétés (données) et le comportement (méthodes) d’un objet, comme un plan 
d’architecte décrit les caractéristiques d’un immeuble. Pour plus de détails sur les classes et 
autres concepts de programmation orientée objet, consultez les rubriques suivantes :
?
« Bases de la programmation orientée objet. », à la page 204
?
« Ecriture de fichiers de classe personnalisée », à la page 208
Flash comporte de nombreuses classes intégrées que vous pouvez utiliser dans votre code 
(voir « Présentation des classes de niveau supérieur et intégrées », à la page 263), ce qui vous 
aide à rajouter facilement de l’interactivité à vos applications. Pour utiliser les propriétés et 
méthodes définies par une classe, vous devez tout d’abord créer une occurrence de cette classe 
(sauf pour les classes comportant des membres statiques). Le rapport entre une occurrence et 
sa classe est similaire au rapport entre une maison et le plan d’architecte correspondant, 
comme évoqué dans la page 263. 
Pour plus d’informations sur l’utilisation des classes qui sont intégrées à Flash, consultez les 
rubriques suivantes :
?
« Création d’une nouvelle occurrence d’une classe intégrée », à la page 275
?
« Accès aux propriétés intégrées des objets », à la page 275
?
« Appel de méthodes d’objet intégré », à la page 276
?
« Présentation des membres (statiques) de classe », à la page 276
?
« Préchargement de fichiers de classe », à la page 278
?
« Exclusion de classes », à la page 277
274
Classes

Création d’une nouvelle occurrence d’une classe 
intégrée
Pour créer une occurrence de classe ActionScript, utilisez l’opérateur new pour appeler la 
fonction constructeur de la classe. La fonction constructeur porte toujours le même nom que 
la classe dont elle renvoie une occurrence, que vous attribuez généralement à une variable. 
Le code suivant crée par exemple un nouvel objet Sound :
var song_sound:Sound = new Sound();
Dans certains cas, il n’est pas nécessaire de créer une occurrence de classe pour employer ses 
propriétés et ses méthodes. Pour plus d’informations, v(statiques) de classe », à la page 276.
Accès aux propriétés intégrées des objets
Utilisez l’opérateur point (.) pour accéder à la valeur d’une propriété d’objet. Entrez le nom 
de l’objet à gauche du point et le nom de la propriété à droite. Par exemple, dans l’instruction 
suivante, my_obj représente l’objet et firstName la propriété : 
my_obj.firstName
L’exemple de code suivant crée un nouvel objet Array puis affiche sa propriété length :
var my_array:Array = new Array("apples", "oranges", "bananas");
trace(my_array.length); // 3
Vous pouvez également utiliser l’opérateur d’accès tableau ([]) pour accéder aux propriétés 
d’un objet, notamment au cours des processus de débogage. L’exemple suivant passe en boucle 
sur un objet pour afficher toutes ses propriétés :
Pour passer en boucle les contenus d’un objet :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom .
2. Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var results:Object = {firstName:"Tommy", lastName:"G", age:7, avg:0.336, 
b:"R", t:"L"};
for (var i:String in results) {
    trace("the value of [" + i + "] is: " + results[i]);
}
Le code précédent définit un nouvel Objet appelé résultats et définit des valeurs pour 
firstName, lastName, age, avg, b, et t. Un  en boucle suit chaque propriété 
dans l’objet résultat et suit sa valeur au panneau de sortie.
3. Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Utilisation des classes intégrées
275

Pour plus d’informations sur la création de tableaux et leurs opérateurs d’accès, reportez-vous 
à « Présentation des opérateurs », à la page 145. Pour plus d’informations sur les méthodes et 
les propriétés, consultez le Chapitre 5, « Fonctions et méthodes », à la page 171. Pour des 
exemples de l’utilisation des propriétés de la classe intégrée MovieClip, reportez-vous à 
Chapitre 10, « Utilisation des clips », à la page 335, pour des exemples de l’utilisation des 
propriétés des classes TextField, String, TextRenderer, et TextFormat, consultez le 
Chapitre 11, « Utilisation du texte et des chaînes », à la page 367.
Appel de méthodes d’objet intégré
Pour appeler la méthode d’un objet, utilisez l’opérateur point (.), suivi de la méthode. Par 
exemple, le code suivant crée un nouvel objet Sound et appelle sa méthode setVolume() : 
var my_sound:Sound = new Sound(this);
my_sound.setVolume(50);
Pour des exemples de l’utilisation des méthodes de la classe intégrée MovieClip, voir 
Chapitre 10, « Utilisation des clips », à la page 335. Pour des exemples de l’utilisation des 
méthodes de la classe intégrée TextField, String, TextRenderer, et TextFormat, voir 
Chapitre 11, « Utilisation du texte et des chaînes », à la page 367.
Présentation des membres (statiques) de classe
Certaines classes ActionScript intégrées possèdent des membres de classe ( membres statiques). 
Pour invoquer les membres de classe (propriétés et méthodes) ou y accéder, vous utilisez le 
nom de la classe, et non son occurrence. Vous ne devez donc pas créer d’occurrence de la classe 
pour utiliser ces propriétés et méthodes. 
Par exemple, toutes les propriétés de la classe Math sont statiques. Le code suivant appelle la 
méthode max() de la classe Math pour déterminer lequel de deux nombres est le plus grand.
var largerNumber:Number = (10, 20);
trace(largerNumber); // 20
Pour plus d’informations sur les méthodes statiques de la classe Math, et des exemples 
d’utilisation, reportez-vous à Math dans le Guide de référence du langage ActionScript 2.0
276
Classes

Exclusion de classes
Pour réduire la taille d’un fichier SWF, il peut être nécessaire d’exclure des classes de la 
compilation tout en restant capable d’y accéder et de les utiliser pour la vérification du type. 
Par exemple, procédez de cette façon lorsque vous développez une application qui utilise 
plusieurs fichiers SWF ou des bibliothèques partagées, en particulier celles qui accèdent 
souvent aux mêmes classes. Cette exclusion de classes vous aide à éviter la duplication de 
classes dans ces fichiers.
Pour plus d’informations sur l’utilisation des classes, consultez les rubriques suivantes :
?
« Préchargement de fichiers de classe », à la page 278
Pour exclure des classes de la compilation :
1.
Créez un nouveau fichier XML.
2. Nommez le fichier XML FLA_filename, où FLA_filename correspond au 
nom du fichier FLA sans son extension.
Par exemple, si le fichier FLA s’appelle , le nom de fichier XML doit être 
.
3. Enregistrez le fichier dans le même répertoire que le fichier FLA.
4. Placez les balises suivantes dans le fichier XML :
<excludeAssets>
<asset name="className1" />
<asset name="className2" />
</excludeAssets>
Les valeurs spécifiées pour les attributs de nom dans les balises <asset> désignent les 
noms des classes à exclure du fichier SWF. Ajoutez-en autant que nécessaire pour votre 
application. Par exemple, le fichier XML suivant exclut les classes .UIObject et 
mx.screens.Slide du fichier SWF :
<excludeAssets>
<asset name=".UIObject" />
<asset name="mx.screens.Slide" />
</excludeAssets>
Pour plus d’informations sur les classes de préchargement, consultez la section 
« Préchargement de fichiers de classe », à la page 278.
Utilisation des classes intégrées
277

Préchargement de fichiers de classe
Cette section décrit certaines méthodologies de préchargement et d’exportation des classes 
dans Flash (y compris les classes qu’utilisent les composants de la version 2 de l’architecture 
des composants). Le préchargement implique le chargement de certaines des données sur un 
fichier SWF avant que l’utilisateur ne commence à interagir. Flash importe les classes dans la 
première image d’un fichier SWF lorsque vous utilisez des classes externes. Ces données 
constituent le premier élément à charger dans un fichier SWF. Il est similaire aux classes de 
composant, dans la mesure où la structure des composants se charge également dans la 
première image d’un fichier SWF. Lorsque vous créez de grandes applications, le temps de 
chargement peut être considérable lorsque vous devez importer des données. Vous devez donc 
traiter ces données de façon plus technique, comme indiqué dans les procédures suivantes.
Dans la mesure où les classes constituent les premières données à charger, vous risquez d’avoir 
à créer des difficultés à créer une barre de progression ou à charger une animation lorsque les 
classes se chargent avant la barre de progression, car la barre de progression doit rendre compte 
de l’ensemble du processus de chargement, classes incluses. Par conséquent, il est recommandé 
de charger les classes après les autres parties du fichier SWF, mais avant d’utiliser les 
composants.
La procédure suivante indique comment modifier l’image dans laquelle les classes se chargent 
dans un fichier SWF.
Pour sélectionner une autre image pour les classes à charger dans le fichier 
SWF :
1.
Choisissez Fichier > Paramètres de publication. 
2. Sélectionnez l’onglet Flash, puis cliquez sur le bouton Paramètres. 
3. Dans la zone de texte Exporter l’Image pour les Classes, tapez le numéro d’une nouvelle 
image, ce qui va déterminer quand charger les classes. 
4. Cliquez sur OK. 
Vous ne pouvez pas utiliser n’importe quelle classe tant que la tête de lecture n’a pas atteint 
l’image cible du chargement. Par exemple, les composants de la version 2 nécessitent des 
classes pour leur fonctionnalité ; vous devez donc charger des composants après l’image 
exportée pour les classes ActionScript 2.0. Si vous procédez à l’exportation pour l’image 3, 
vous ne pouvez pas exploiter ces classes tant que la tête de lecture n’a pas atteint l’image 3 et 
n’a pas chargé les données.
278
Classes

Si vous devez précharger un fichier utilisant des composants, par exemple les classes de 
composants de la version 2, vous devez les précharger dans le fichier SWF. Pour ce faire, vous 
devez définir vos composants de façon à les exporter pour une autre image dans le fichier 
SWF. Par défaut, les composants UI s’exportent vers l’image 1 du fichier SWF ; assurez-vous 
donc que vous avez désélectionné Export dans First Frame de la boîte de dialogue de liaison 
du composant. 
REMARQUE
Pour ajouter un composant sur la scène à l’aide de code ActionScript, vous devez faire 
glisser une occurrence du composant à ajouter dans le panneau de collage (la zone 
entourant la scène). Ceci indique à Flash que vous utilisez le composant dans votre 
application, et qu’il ne s’agit pas d’un élement inutilisé de la bibliothèque. N’oubliez pas 
que Flash n’ajoute pas d’éléments inutilisés de la bibliothèque aux fichiers SWF.
Lorsque les composants ne se chargent pas sur la première image, vous pouvez créer une barre 
de progression personnalisée pour la première image du fichier SWF. Ne référencez aucun 
composant dans votre code ActionScript ou n’incluez aucun composant sur la scène pendant 
le chargement des classes destinées à l’image spécifiée dans le champ Export Frame for Classes. 
ATTEN
Vous devez exporter les composants après les classes ActionsScript qu’ils utilisent.
T
IO
N
Utilisation des classes intégrées
279

280
Classes

CHAPITRE 7
Héritage
7
Dans le Chapitre 6, « Classes », vous avez appris à écrire des fichiers de classe et à utiliser les 
classes pour organiser le code dans des fichiers externes. Ce chapitre décrivait également 
l’organisation des fichiers de classe dans des packages associés. L’objectif de ce chapitre est de 
vous apprendre à écrire des classes plus complexes, qui étendent les fonctionnalités d’une 
classe existante. Ce sujet est intéressant car vous serez probablement amené à étendre vos 
propres classes personnalisées ou les classes existantes pour pouvoir ajouter des nouvelles 
méthodes et des propriétés.
Pour plus d’informations sur les héritages,la page 281. Pour plus d’informations sur les méthodes et les propriétés, consultez le 
Chapitre 5, « Fonctions et méthodes », à la page 171.
Pour plus d’informations sur l’héritage, consultez les sections suivantes :
Présentation de l’héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Ecriture de sous-classes dans Flash  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .283
Utilisation du polymorphisme dans une application . . . . . . . . . . . . . . . . . . . . . . . . .  290
Présentation de l’héritage
Vous avez découvert dans le Chapitre 6, « Classes » comment créer un fichier de classe pour 
créer vos propres types de données personnalisés. A travers ces fichiers de classe personnalisée, 
vous avez également appris à extraire le code du scénario pour le placer dans des fichiers 
externes. Ce déplacement vers des fichiers externes simplifie l’édition de votre code. 
Maintenant que les bases de la création de classes personnalisées n’ont plus de secrets pour 
vous, vous allez découvrir une technique de programmation orientée objet appelée sous-
classement
 ou extension de classe, qui vous permet de créer de nouvelles classes à partir d’une 
classe existante.
281

L’un des avantages de la programmation orientée objet réside dans la possibilité de créer des 
sous-classes d’une classe. Ces sous-classes héritent alors de toutes les propriétés et méthodes de 
la super-classe. Par exemple, si vous étendez (ou sous-classez) la classe MovieClip, vous créez une 
classe personnalisée qui étend la classe MovieClip. Votre sous-classe hérite donc de toutes les 
propriétés et méthodes de la classe MovieClip. Vous pouvez également créer un ensemble de 
classes étendant une super-classe personnalisée. La classe Laitue, par exemple, peut être une 
extension de la super-classe Légume.
Votre sous-classe définit généralement d’autres méthodes et propriétés utilisables dans votre 
application et, en cela, étend la super-classe. Les sous-classes peuvent également supplanter 
(apporter leurs propres définitions) les méthodes héritées d’une super-classe. Lorsqu’une sous-
classe remplace une méthode héritée de sa super-classe, la définition de la superclasse n’est plus 
accessible depuis la sous-classe. La seule exception à cette règle est la suivante : si vous êtes 
dans la fonction constructeur d’une sous-classe, vous pouvez appeler la fonction de 
constructeur de la superclasse à l’aide de l’instruction super. Pour plus d’informations sur le 
remplacement de méthodes et de propriétés, consultez la section méthodes et des propriétés », à la page 287. 
Par exemple, vous créez une classe Mammifère qui définit certaines propriétés et certains 
comportements communs à tous les mammifères. Vous pouvez alors créer une sous-classe 
Chat qui permet d’étendre la classe Mammifère. L’utilisation de sous-classes permet de 
recycler le code de sorte que, au lieu de recréer le code commun à deux classes, il vous suffit 
d’étendre une classe existante. Une autre sous-classe peut étendre la classe Chat (la classe 
Siamois par exemple), et ainsi de suite. Dans une application complexe, la définition de la 
structure hiérarchique des classes représente une grande partie du processus de création.
L’héritage et le sous-classement se révèlent très utiles dans les grandes applications car ils vous 
permettent de créer une série de classes associées partageant les mêmes fonctionnalités. 
Par exemple, vous pouvez créer une classe Employé définissant les méthodes et les propriétés 
de base d’un employé typique dans une société. Vous pouvez ensuite créer une nouvelle classe 
appelée Fournisseur qui étend la classe Employé et hérite de toutes ses méthodes et propriétés. 
La classe Fournisseur pourrait également ajouter ses propres méthodes et propriétés ou 
supplanter celles de la super-classe Employé. Vous pouvez même créer une classe Dirigeant 
étendant également la classe Employé et définissant d’autres méthodes et propriétés telles que 
recrutement(), licenciement(), augmentation() et promotion(). Vous pouvez encore 
étendre une sous-classe, par exemple la classe Dirigeant, et créer une nouvelle classe appelée 
Directeur, ajoutant à son tour de nouvelles méthodes ou remplaçant les méthodes existantes. 
282
Héritage

Chaque fois que vous étendez une classe existante, la nouvelle classe hérite de toutes les 
méthodes et propriétés de la sous-classe. Si aucune des classes n’était associée, il vous faudrait 
réécrire chaque méthode et propriété dans chaque fichier de classe, même lorsque la 
fonctionnalité ne change pas. Vous perdriez alors du temps, non seulement dans l’écriture du 
code, mais également dans le débogage de votre application et la maintenance du projet 
lorsque le même code doit être modifié dans plusieurs fichiers.
Dans ActionScript, utilisez le mot-clé extends pour établir une relation d’héritage entre une 
classe et sa super-classe, ou pour étendre une interface. Pour plus d’informations sur 
l’utilisation du mot-cléextends, consultez les sections à la page 283 et « Ecriture d’une sous-classe », à la page 284. Pour plus d’informations sur le 
mot-clé extends, consultez la section relative à l’instruction extends dans le Guide de référence 
du langage ActionScript 2.0
.  
Ecriture de sous-classes dans Flash
En programmation orientée objet, une sous-classe peut hériter des propriétés et méthodes 
d’une autre classe, appelée super-classe. Vous pouvez étendre vos propres classes personnalisées 
et la plupart des classes de base et des classes ActionScript de Flash Player. Vous ne pouvez pas 
étendre la classe TextField. 
Pour créer ce type de relation entre deux classes, utilisez la clause extends de l’instruction 
class. Pour spécifier une super-classe, utilisez la syntaxe suivante :
class SubClass extends SuperClass {}
La classe spécifiée dans SubClass hérite de toutes les propriétés et méthodes définies dans la 
super-classe.
Par exemple, vous créez une classe Mammifère qui définit des propriétés et méthodes 
communes à tous les mammifères. Pour créer une variante de cette classe Mammifère 
(Mammal), telle que la classe Marsupial, étendez la classe Mammal, c’est-à-dire créez une 
sous-classe de la classe Mammal, comme suit :
class Marsupial extends Mammal {}
La sous-classe hérite de toutes les propriétés et méthodes de la superclasse, y compris des propriétés 
ou des méthodes que vous avez déclarées comme étant privées en utilisant le mot-clé private. 
Pour plus d’informations sur l’extension des classes, consultez les rubriques suivantes :
?
« Ecriture d’une sous-classe », à la page 284
?
« Remplacement des méthodes et des propriétés », à la page 287
Pour plus d’informations sur les membres privés, consultez la section méthodes et propriétés (membres) publiques, privées et statiques », à la page 221. Pour un 
exemple de création de sous-classe, consultez la section Widget », à la page 285.
Ecriture de sous-classes dans Flash
283

Ecriture d’une sous-classe
Le code suivant définit la classe personnalisée JukeBox, qui étend la classe Sound (Son). 
Il définit un tableau appelé song_arr et une méthode appelée playSong() qui permet de lire 
une chanson et d’invoquer la méthode loadSound(), dont il hérite de la classe Sound.
class JukeBox extends Sound {
  public var song_arr:Array = new Array("beethoven.mp3", "bach.mp3", 
"mozart.mp3");
  public function playSong(songID:Number):Void {
    super.loadSound(song_arr[songID], true);
  }
}
Si vous ne placez pas un appel à super() dans la fonction constructeur d’une sous-classe, le 
compilateur génère automatiquement un appel au constructeur de sa superclasse immédiate, 
sans paramètre, en tant que première instruction de la fonction. Si la super-classe n’a pas de 
constructeur, le compilateur crée une fonction constructeur vide, puis génère un appel à cette 
fonction à partir de la sous-classe. Cependant, si une super-classe prend des paramètres dans sa 
définition, vous devez créer un constructeur dans la sous-classe et appeler la super-classe avec 
les paramètres requis.
L’héritage multiple, ou héritage à partir de plusieurs classes, n’est pas autorisé dans 
ActionScript 2.0. Toutefois, les classes peuvent effectivement hériter de plusieurs classes, si 
vous utilisez des instructions extends individuelles, comme dans l’exemple suivant :
// non autorisé
class C extends A, B {} // **Erreur : Une classe ne peut pas étendre 
// plusieurs classes.
// autorisé
class B extends A {}
class C extends B {}
Vous pouvez également utiliser des interfaces pour mettre en oeuvre une forme limitée 
d’héritage multiple. Pour plus d’informations sur les interfaces, consultez « Interfaces », à la page 295. Pour un exemple de création de sous-classe, consultez la section 
« Exemple : Extension de la classe Widget », à la page 285. Pour plus d’informations sur 
super, consultez la section relative à l’instruction super dans le Guide de référence du langage 
ActionScript 2.0
.
284
Héritage

Exemple : Extension de la classe Widget
Les membres de classe se propagent dans les sous-classes de la super-classe qui définit ces 
membres. L’exemple suivant décrit la création d’une classe Widget, que vous étendez 
(sous-classe) via l’écriture d’une sous-classe SubWidget. 
Pour créer la classe Widget et la sous-classe SubWidget :
1.
Créez un fichier ActionScript et enregistrez-le sous le nom .
2. Ajoutez le code suivant dans le nouveau document :
class Widget {
public static var widgetCount:Number = 0;
public function Widget() {
Widget.widgetCount++;
}
}
3. Enregistrez les modifications apportées au fichier ActionScript.
4. Créez un fichier et enregistrez-le sous le nom  dans le même répertoire que 
la classe Widget.
5. Dans , saisissez le code suivant dans la fenêtre de script :
class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget #" + Widget.widgetCount);
}
}
6. Enregistrez les modifications apportées à .
7. Créez un fichier FLA et enregistrez-le en tant que  dans le même 
répertoire que les fichiers de classe ActionScript précédents.
8. Dans le fichier , saisissez le code suivant dans l’image 1 du scénario 
principal :
var sw1:SubWidget = new SubWidget();
var sw2:SubWidget = new SubWidget();
trace("Widget.widgetCount = " + Widget.widgetCount);
trace("SubWidget.widgetCount = " + SubWidget.widgetCount);
Ecriture de sous-classes dans Flash
285

Le code précédent crée deux occurrences de la classe SubWidget : sw1 et sw2. Chaque 
appel au constructeur du SubWidget affiche la valeur actuelle de la propriété statique de 
Widget.widgetCount. Comme la classe SubWidget est une sous classe de la classe 
Widget, vous pouvez accéder à la propriété widgetCount par l’intermédiaire de la classe 
SubWidget, et le compilateur écrit de nouveau la référence (dans le pseudo-code binaire, 
pas dans votre fichier ActionScript) sous la forme Widget.widgetCount. Si vous tentez 
d’accéder à la propété statique widgetCount par des occurrences de la classe Widget ou 
SubWidget, comme sw1 ou sw2, le compilateur émet une erreur.
9. Enregistrez les modifications apportées au document.
10. Choisissez Contrôle > Tester l’animation pour tester le document Flash. 
Le panneau de sortie affiche les données de sortie suivantes :
Creating subwidget #1
Creating subwidget #2
Widget.widgetCount = 2
SubWidget.widgetCount = 2
Ce résultat est dû au fait que, bien que le constructeur de la classe Widget ne soit jamais 
appelé explicitement, le constructeur de la classe SubWidget l’appelle à votre place. 
Le constructeur de la classe Widget incrémente donc la variable statique widgetCount de 
la classe Widget.
Le compilateur d’ActionScript 2.0 peut résoudre des références à des membres statiques au 
sein des définitions de classe. 
Si vous ne spécifiez pas le nom de classe de la propriété Widget.widgetCount et la 
référencez simplement avec widgetCount, le compilateur d’ActionScript 2.0 la résout en 
Widget.widgetCount et exporte correctement cette propriété. De même, si vous faites 
référence à la propriété en tant que SubWidget.widgetCount, le compilateur écrit de 
nouveau la référence (dans le pseudo-code binaire, pas dans votre fichier ActionScript) 
sous la forme Widget.widgetCount car SubWidget est une sous-classe de la classe 
Widget.
ATTEN
Si vous tentez d’accéder à la variable statique widgetCount à partir de la classe 
Widget à l’aide des occurrences sw1 ou sw2, Flash génère une erreur qui vous 
T
indique que les membres statiques ne peuvent être accédés que via les classes.
ION
Pour améliorer la lisibilité du code, Adobe recommande de toujours employer des références 
explicites aux variables de membres statiques, comme dans l’exemple précédent. 
Ces références explicites facilitent la localisation des définitions des membres statiques.
286
Héritage

Remplacement des méthodes et des propriétés
Lorsqu’une sous-classe étend une super-classe, la sous-classe hérite de toutes les méthodes et 
propriétés de cette super-classe. L’un des avantages de l’utilisation et de l’extension des classes 
réside non seulement dans la possibilité d’apporter une nouvelle fonctionnalité à une classe 
existante, mais également de modifier la fonctionnalité existante. Prenons par exemple la 
classe Widget créée à la section « Exemple : Extension de la classe Widget », à la page 285. 
Vous pouvez maintenant créer une nouvelle méthode dans votre super-classe (Widget), puis 
supplanter la méthode de votre sous-classe (SubWidget), ou simplement utiliser la méthode 
héritée de la classe Widget. L’exemple suivant montre comment supplanter les méthodes 
existantes dans vos classes.
Pour supplanter les méthodes d’une sous-classe :
1.
Créez un document ActionScript, puis enregistrez-le sous le nom .
2. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
Note: Si vous avez créé la classe Widget dans un exemple précédent, modifiez le code 
existant en ajoutant la méthode doSomething(), comme suit :
class Widget {
public static var widgetCount:Number = 0;
public function Widget() {
Widget.widgetCount++;
}
public function doSomething():Void {
trace("Widget::doSomething()");
}
}
3. Enregistrez les modifications apportées au document ActionScript. 
La classe Widget définit maintenant un constructeur et une méthode publique appelée 
doSomething().
4. Créez un fichier ActionScript nommé  et enregistrez-le dans le même 
répertoire que .
REMA
Si vous avez créé la classe SubWidget à la sectionclasse Widget », à la page 285, vous pouvez utiliser ce fichier à la place.
R
Q
UE
Ecriture de sous-classes dans Flash
287

5. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget # " + Widget.widgetCount);
doSomething();
}
}
6. Enregistrez les modifications apportées à .
Notez que le constructeur de la classe SubWidget appelle la méthode doSomething() que 
vous avez définie dans la super-classe.
7. Créez un document Flash et enregistrez-le sous  dans le même répertoire 
que les documents ActionScript.
8. Dans , saisissez le code ActionScript suivant sur l’image 1 du scénario 
principal :
var sw1:SubWidget = new SubWidget();
var sw2:SubWidget = new SubWidget();
9. Enregistrez les modifications apportées au document Flash.
10. Choisissez Contrôle > Tester l’animation pour tester le document Flash. Les données de 
sortie suivantes doivent s’afficher dans le panneau de sortie :
Creating subwidget # 1
Widget::doSomething()
Creating subwidget # 2
Widget::doSomething()
Ce résultat indique que le constructeur de la classe SubWidget appelle le constructeur de 
sa super-classe (Widget), qui incrémente la propriété statique widgetCount. 
Le constructeur de SubWidget suit la propriété statique de la super-classe et appelle la 
méthode doSomething(), qui hérite de la super-classe.
11. Ouvrez la classe SubWidget et ajoutez une nouvelle méthode appelée doSomething(). 
Modifiez votre classe de sorte qu’elle corresponde au code suivant (ajoutez le code présenté 
en gras) : 
class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget # " + Widget.widgetCount);
doSomething();
}
public function doSomething():Void {
trace("SubWidget::doSomething()");
}
}
288
Héritage

12. Enregistrez les modifications apportées au fichier de classe, puis ouvrez de nouveau 
.
13. Choisissez Contrôle > Tester l’animation pour tester le fichier. Les données de sortie 
suivantes doivent s’afficher dans le panneau de sortie :
Creating subwidget # 1
SubWidget::doSomething()
Creating subwidget # 2
SubWidget::doSomething()
Le résultat précédent montre que la méthode doSomething() du constructeur de la classe 
SubWidget appelle la méthode doSomething() de la classe active et non celle de la super-
classe. 
Ouvrez de nouveau la classe SubWidget, et modifiez le constructeur de la classe 
SubWidget pour appeler la méthode doSomething() de la super-classe (ajoutez le code 
présenté en gras) :
public function SubWidget() {
trace("Creating subwidget # " + Widget.widgetCount);
super.doSomething();
}
Comme nous l’avons démontré, vous pouvez ajouter le mot-clé super pour appeler la 
méthode doSomething() de la super-classe plutôt que la méthode doSomething() de la 
classe active. Pour plus d’informations sur le mot-clé super, consultez la section 
correspondante dans le manuel Guide de référence du langage ActionScript 2.0.
14. Enregistrez le fichier de la classe SubWidget et le constructeur modifié, puis choisissez 
Contrôle > Tester l’animation pour republier le document Flash.
Le panneau de sortie affiche le contenu de la méthode doSomething() de la classe Widget.
Ecriture de sous-classes dans Flash
289

Utilisation du polymorphisme dans une 
application
La programmation orientée objet permet d’exprimer les différences entre les classes 
individuelles par une technique appelée polymorphisme. Cette technique permet aux classes 
de supplanter les méthodes de leurs super-classes et de définir des implémentations spécialisées 
de ces méthodes. 
Par exemple, vous pouvez commencer par une classe appelée Mammal qui comporte les 
méthodes play() et sleep(). Vous créez ensuite les sous-classes Chat, Singe et Chien pour 
étendre la classe Mammifère. Les sous-classes supplantent la méthode play() de la classe 
Mammal, de façon à représenter de façon plus réaliste ces types d’animaux. La classe Monkey 
implémente la méthode play() pour se balancer aux arbres ; la classe Cat implémente la 
méthode play() pour courir après une pelote ; la classe Dog implémente la méthode play() 
pour rapporter une balle. Dans la mesure où la fonctionnalité sleep() reste similaire quel que 
soit l’animal, vous utiliseriez l’implémentation de super-classe. La procédure suivante montre 
cet exemple dans Flash.
Pour utiliser le polymorphisme dans une application :
1.
Créez un document ActionScript et enregistrez-le sous le nom 
Ce document est la classe de base des quelques classes d’animaux différentes que vous allez 
créer dans les étapes suivantes.
2. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
class Mammal {
private var _gender:String;
private var _name:String = "Mammal";
// Constructeur
public function Mammal(gender:String) {
this._gender = gender;
}
public function toString():String {
return "[object " + speciesName + "]";
}
public function play():String {
return "Chase another of my kind.";
}
public function sleep():String {
return "Close eyes.";
}
290
Héritage

public function get gender():String {
return this._gender;
}
public function get speciesName():String {
return this._name;
}
public function set speciesName(value:String):Void {
this._name = value;
}
}
La classe précédente définit deux variables privées, _gender et _name, servant à stocker le 
type de mammifère et le sexe de l’animal. Le constructeur de Mammal est ensuite défini. 
Ce constructeur prend un seul paramètre, gender, utilisé pour définir la variable privée 
_gender définie précédemment. Trois méthodes publiques supplémentaires sont 
également spécifiées : toString(), play(), et sleep(), chacune renvoyant des objets de 
chaîne. Les trois méthodes finales sont des méthodes de lecture et de définition pour les 
propriétés _gender et _name de Mammal.
3. Enregistrez le document ActionScript. 
Cette classe sert de super-classe pour les classes Cat, Dog et Monkey, que vous créerez par 
la suite. Vous pouvez utiliser la méthode toString() de la classe Mammal pour afficher 
une représentation de chaîne de n’importe quelle occurrence de Mammal (ou toute 
occurrence qui étendait la classe Mammal).
4. Créez un fichier ActionScript et enregistrez-le sous le nom  dans le même répertoire 
que le fichier de la classe  créé à l’étape 1.
5. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
class Cat extends Mammal {
// Constructeur
public function Cat(gender:String) {
super(gender);
speciesName = "Cat";
}
public function play():String {
return "Pounce a ball of yarn.";
}
}
Notez que vous supplantez la méthode play() de la super-classe Mammal. La classe Cat 
ne définit que deux méthodes : une méthode constructeur et une méthode play(). 
Comme la classe Cat étend la classe Mammal, elle hérite de ses méthodes et de ses 
propriétés. Pour plus d’informations sur le remplacement de méthodes et de propriétés, 
consultez la section « Remplacement des méthodes et des propriétés », à la page 287.
Utilisation du polymorphisme dans une application
291

6. Enregistrez les modifications apportées au document ActionScript.
7. Créez un document et enregistrez-le sous le nom  dans le même répertoire que les 
deux fichiers de classe précédents.
8. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
class Dog extends Mammal {
// Constructeur
public function Dog(gender:String) {
super(gender);
speciesName = "Dog";
}
public function play():String {
return "Fetch a stick.";
}
}
Remarquez que la structure de la classe Dog est très similaire à celle de la classe Cat, seules 
quelques valeurs changent. Là encore, la classe Dog étend la classe Mammal et hérite de 
ses méthodes et propriétés. Le constructeur Dog prend une seule propriété, gender, qu’il 
transmet à la classe parent de la classe Dog, Mammal. La variable speciesName est 
également remplacée et définie sur la chaîne Dog. La méthode play() de la classe parent 
est également supplantée.
9. Enregistrez les modifications apportées au document ActionScript. 
10. Créez un autre document ActionScript dans le même répertoire que vos autres fichiers, puis 
enregistrez-le sous le nom .
11. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
class Monkey extends Mammal {
// Constructeur
public function Monkey(gender:String) {
super(gender);
speciesName = "Monkey";
}
public function play():String {
return "Swing from a tree.";
}
}
Comme les deux classes précédentes, Cat et Dog, la classe Monkey étend la classe 
Mammal. Le constructeur de cette classe appelle le constructeur de la classe Mammal, en 
transmettant le genre au constructeur de Mammal, et en définissant speciesName sur la 
chaîne Monkey. La classe Monkey supplante également le comportement de la méthode 
play().
292
Héritage

12. Enregistrez les modifications apportées au document ActionScript.
13. Maintenant que vous avez créé trois sous-classes de la classe Mammal, créez un document 
Flash appelé .
14. Dans , saisissez le code ActionScript suivant dans l’image 1 du scénario 
principal :
var mammals_arr:Array = new Array();
this.createTextField("info_txt", 10, 10, 10, 450, 80);
= true;
info_txt.multiline = true;
info_txt.border = true;
info_txt.wordWrap = true;
createMammals()
createReport()
function createMammals():Void {
(new Dog("Female"));
(new Cat("Male"));
(new Monkey("Female"));
(new Mammal("Male"));
}
function createReport():Void {
var i:Number;
var len:Number = mammals_arr.length;
// Affichage des infos relatives à Mammal en 4 colonnes de texte HTML 
// et arrêts de tabulation.
info_txt.htmlText = "<textformat tabstops='[110, 200, 300]'>";
info_txt.htmlText += "<b>Mammal\tGender\tSleep\tPlay</b>";
for (i = 0; i < len; i++) {
info_txt.htmlText += "<p>" + mammals_arr[i].speciesName 
+ "\t" + mammals_arr[i].gender 
+ "\t" + mammals_arr[i].sleep()
+ "\t" + mammals_arr[i].play() + "</p>";
// L’instruction trace appelle la méthode Mammal.toString().
trace(mammals_arr[i]); 
}
info_txt.htmlText += "</textformat>";
}
Le code de est un peu plus complexe que celui des classes précédentes. 
Il commence par importer trois classes d’animaux. 
Utilisation du polymorphisme dans une application
293

15. Enregistrez le document Flash, puis choisissez Contrôle > Tester l’animation pour tester le 
document. 
Les informations relatives à la classe Mammal s’affichent dans un champ de texte sur la 
scène, et le texte suivant apparaît dans le panneau de sortie :
[object Dog]
[object Cat]
[object Monkey]
[object Mammal]
294
Héritage

CHAPITRE 8
Interfaces
8
En programmation orientée objet, une interface est un document qui vous permet de déclarer 
(mais pas de définir) les méthodes devant apparaître au sein d’une classe. Si vous faites partie 
d’une équipe de développeurs, ou si vous développez de grandes applications dans Flash, les 
interfaces vous seront certainement très utiles. Grâce à elles, les développeurs peuvent 
facilement identifier les méthodes de base dans les classes ActionScript. Ces méthodes doivent 
être implémentées lorsque les développeurs utilisent chaque interface. 
Ce chapitre présente quelques exemples d’interfaces et, à la fin de sa lecture, vous serez à 
même de développer vos propres fichiers d’interface. Si vous ne maîtrisez pas le 
développement des classes, commencez par lire le Chapitre 6, « Classes », avant d’effectuer les 
didacticiels et d’examiner les exemples de ce chapitre.
Pour plus d’informations sur l’utilisation des interfaces, consultez les rubriques suivantes :
Présentation des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .296
Création d’interfaces comme types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
Fonctionnement des héritages et des interfaces  . . . . . . . . . . . . . . . . . . . . . . . . . . .  303
Exemple : Utilisation des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  305
Exemple : Création d’une interface complexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307
295

Présentation des interfaces
En programmation orientée objet, les interfaces sont comme des classes dont les méthodes ne 
sont pas implémentées (définies), c’est-à-dire que, mis à part cela, elles ne « font » rien. Une 
interface se compose donc de méthodes « vides ». Une autre classe peut ensuite implémenter 
les méthodes déclarées par l’interface. Dans ActionScript, la distinction entre interface et objet 
porte sur la détection des erreurs lors de la compilation et l’application des règles du langage.
Une interface n’est pas une classe. Cependant, ceci n’est pas tout à fait vrai dans ActionScript 
lors de l’exécution du code car une interface est une abstraction. Il est possible d’utiliser des 
interfaces ActionScript pendant l’exécution pour effectuer une attribution de type (attribuer 
un autre type de données à des données existantes). Le modèle d’objet ActionScript 2.0 ne 
prend pas en charge l’héritage multiple. Par conséquent, une classe ne peut hériter que d’une 
classe parent. Cette classe parent peut être soit de base, soit une classe Flash Player, soit une 
classe définie par l’utilisateur (personnalisée). Vous pouvez utiliser les interfaces pour 
appliquer une forme limitée d’héritage multiple, dans laquelle la classe hérite de plusieurs 
classes.
Par exemple, en C++, la classe Chat peut étendre la classe Mammal, ainsi que la classe Playful, 
qui a les méthodes chaseTail() et eatCatNip(). Comme Java, ActionScript 2.0 ne permet 
pas d’étendre directement plusieurs classes, mais permet d’étendre une classe unique et 
d’implémenter plusieurs interfaces. Par conséquent, vous pouvez créer une interface Playful 
qui déclare les méthodes chaseTail() et eatCatNip(). Une classe Chat ou toute autre classe 
peut alors implémenter cette interface et fournir des définitions pour ces méthodes.
Une interface peut également être considérée comme un « contrat de programmation » 
destiné à imposer des relations entre des classes non connexes. Par exemple, supposons que 
vous travailliez avec une équipe de programmeurs et que chacun de vous travaille sur une 
classe différente de la même application. Lors de la réalisation de l’application, vous vous 
mettez d’accord sur un ensemble de méthodes que les différentes classes utiliseront pour 
communiquer. Ainsi, vous créez une interface qui déclare ces méthodes, leurs paramètres et 
leurs types de renvoi. Toute classe qui implémente cette interface doit fournir des définitions 
pour ces méthodes ; dans le cas contraire, une erreur du compilateur se produit. L’interface se 
comporte comme un protocole de communication auquel toutes les classes doivent adhérer.
Pour ce faire, vous pouvez créer une classe qui définit toutes ces méthodes, puis faire en sorte 
que chaque classe étende cette super-classe, ou en hérite. Cependant, l’application étant 
composée de classes n’ayant aucun rapport entre elles, il est inutile de toutes les placer dans 
une hiérarchie de classes communes. Il est préférable de créer une interface qui déclare les 
méthodes que ces classes utilisent pour communiquer, puis que chaque classe implémente ces 
méthodes (en fournissant ses propres définitions).
296
Interfaces

Vous pouvez généralement programmer de façon efficace sans utiliser les interfaces. 
Lorsqu’elles sont utilisées de façon appropriée, cependant, les interfaces peuvent rendre la 
conception de vos applications plus élégante, évolutive et stable.
Les interfaces d’ActionScript existent pendant l’exécution pour autoriser l’attribution de type. 
Reportez-vous à Chapitre 3, « Attribution des objets », à la page 78 Une interface n’est ni 
objet ni une classe, mais son flux de travaux est le même que celui des classes. Pour plus 
d’informations sur le flux de travaux des classes, consultez la section classe personnalisée », à la page 208. Un didacticiel sur la création d’une application avec 
interfaces est à votre disposition à la section la page 305.
Pour plus d’informations sur l’utilisation des interfaces, consultez les sections suivantes : 
?
« Présentation du mot-clé interface », à la page 297
?
« Affectation des noms d’interfaces », à la page 298
?
« Définition et implémentation des interfaces », à la page 298
Présentation du mot-clé interface
Le mot-clé interface définit une interface. Une interface est similaire à une classe. 
Les différences fondamentales sont regroupées ci-dessous : 
?
Les interfaces contiennent uniquement les déclarations des méthodes, pas leur 
implémentation. Ainsi, toute classe qui implémente une interface doit fournir une 
implémentation pour chaque méthode déclarée dans l’interface.
?
Seuls les membres publics sont autorisés dans la définition d’une interface. Les membres 
statiques et les membres de classe ne sont pas permis.
?
Les instructions get et set ne sont pas autorisées dans les définitions d’interface.
?
Pour utiliser le mot-clé interface, vous devez spécifier ActionScript 2.0 et Flash Player 6 
ou une version plus récente dans l’onglet Flash de la boîte de dialogue Paramètres de 
publication de votre fichier FLA.
Le mot-clé interface n’est pris en charge que lorsqu’il est utilisé dans des fichiers de script 
externes, et non dans les scripts écrits dans le panneau Actions.
Présentation des interfaces
297

Affectation des noms d’interfaces
Les noms d’interface doivent commencer par une majuscule, comme les noms de classe. 
Les noms d’interface sont généralement des adjectifs, tels que Imprimable. Le nom 
d’interface suivant, IEmployeeRecords, commence par une majuscule et le mot concaténé 
commence par une majuscule suivie de minuscules :
interface IEmployeeRecords {}
REMARQUE
Certains développeurs font débuter les noms d’interface par un I majuscule pour les 
distinguer des classes. Cette méthode est judicieuse car elle permet de distinguer 
rapidement les interfaces et les classes ordinaires.
Pour plus d’informations sur les conventions d’appellation, consultezpage 715.
Définition et implémentation des interfaces
Le processus de création d’une interface est identique au processus de création d’une classe. 
Comme pour les classes, vous pouvez définir des interfaces uniquement dans des fichiers 
ActionScript externes. Le flux de travaux de création d’une interface implique au minimum 
les étapes suivantes :
?
Définition d’une interface dans un fichier ActionScript externe.
?
Enregistrement du fichier d’interface dans un répertoire de chemin de classe spécifique 
(emplacement où Flash recherche les classes) ou dans le même répertoire que le fichier 
FLA de l’application
?
Création d’une occurrence de la classe dans un autre script, soit dans un document Flash 
(FLA), soit dans un fichier de script externe, soit dans des sous-interfaces basées sur 
l’interface d’origine.
?
Création d’une classe qui implémente l’interface dans un fichier de script externe
Déclarez une interface à l’aide du mot-clé interface, suivi du nom de l’interface et 
d’accolades gauche et droite ({}), qui définissent le corps de l’interface, comme dans l’exemple 
suivant :
interface IEmployeeRecords {
  // déclarations de méthodes d’interface
}
Une interface ne peut contenir que des déclarations de méthodes (fonction), y compris des 
paramètres, des types de paramètres et des types de renvoi de fonction. 
298
Interfaces

Pour plus d’informations sur les conventions de structuration des classes et interfaces, 
consultezActionScript 2.0 », à la page 715. Un didacticiel sur la création d’une application utilisant une 
interface est à votre disposition à la section la page 305.
Par exemple, le code suivant déclare une interface nommée IMyInterface qui contient deux 
méthodes, method1() et method2(). La première méthode, method_1(), ne comporte pas de 
paramètre et spécifie le type Void (ce qui signifie qu’aucune valeur n’est renvoyée). 
La deuxième méthode, method2(), ne prend qu’un seul paramètre de type String et spécifie 
un renvoi de type booléen.
Pour créer une interface simple : 
1.
Créez un fichier ActionScript et enregistrez-le sous le nom d’.
2. Saisissez le code ActionScript suivant dans la fenêtre de script :
interface IMyInterface {
  public function method1():Void;
  public function method2(param:String):Boolean;
}
3. Enregistrez les modifications apportées au fichier ActionScript. 
Pour utiliser la nouvelle interface dans une application, vous devez d’abord créer une classe 
qui l’implémente.
4. Créez un fichier ActionScript et enregistrez-le sous le nom de  dans le même 
répertoire que .
5. Dans le fichier de classe MyClass, saisissez le code ActionScript suivant dans la fenêtre de 
script :
class MyClass {
}
Pour demander à la classe personnalisée (MyClass) d’utiliser votre interface 
(IMyInterface), utilisez le mot-clé implementsqui spécifie qu’une classe doit définir toutes 
les méthodes déclarées dans l’interface (ou les interfaces) que vous implémentez. 
6. Modifiez le code ActionScript dans le fichier  (ajoutez le code présenté en gras) 
de sorte qu’il corresponde au code suivant :
class MyClass implements IMyInterface {
}
Placez le mot-clé implements après le nom de la classe.
7. Cliquez sur le bouton Vérifier la syntaxe.
Présentation des interfaces
299

Flash affiche une erreur dans le panneau de sortie pour signaler que MyClass doit 
implémenter la méthode X de l’interface IMyInterface. Ce message d’erreur apparaît car 
toute classe qui étend une interface doit définir chaque méthode énumérée dans le 
document de l’interface.
8. Modifiez de nouveau le document MyClass (ajoutez le code présenté en gras) et écrivez le 
code ActionScript pour les méthodes method1() et method2(), comme dans l’exemple 
suivant :
class MyClass implements IMyInterface {
public function method1():Void {
//
};
public function method2(param:String):Boolean {

//
return true;

}
}
9. Enregistrez le document  et cliquez sur Vérifier la syntaxe. 
Le panneau de sortie n’affiche plus de message d’erreur ou d’avertissement car les deux 
méthodes sont à présent définies.
Le fichier de classe que vous avez créé n’est pas limité aux méthodes publiques définies dans le 
fichier d’interface. Le fichier d’interface ne présente que les méthodes devant être 
implémentées au minimum, avec leurs propriétés et leurs types de retour. Les classes qui 
implémentent une interface particulière incluent presque toujours d’autres méthodes, 
variables et méthodes de lecture et de définition.
Les fichiers d’interfaces ne peuvent contenir aucune déclaration ni affectation de variable. 
Les fonctions déclarées dans une interface ne doivent pas contenir d’accolades. Par exemple, 
l’interface suivante ne sera pas compilée :
interface IBadInterface {
// Erreur de compilation. Les déclarations de variables ne sont 
// pas autorisées dans les interfaces.
public var illegalVar:String;
// Erreur de compilation. Les corps de fonctions ne sont pas autorisés 
// dans les interfaces.
public function illegalMethod():Void {
}
// Erreur de compilation. Les méthodes privées sont interdites dans 
// les interfaces.
private function illegalPrivateMethod():Void;
// Erreur de compilation. Les méthodes de lecture/définition sont 
// interdites dans les interfaces.
public function get illegalGetter():String;
}
300
Interfaces

Un didacticiel sur la création d’une interface complexe est à votre disposition à la section 
« Exemple : Utilisation des interfaces », à la page 305.
Les règles d’affectation de nom et de stockage des interfaces dans les paquets sont les mêmes 
que celles des classes ; consultez « Appellation des fichiers de classe », à la page 241.
Création d’interfaces comme types de 
données
Tout comme une classe, une interface définit un nouveau type de données. Toute classe qui 
implémente une interface peut être considérée comme relevant du type défini par l’interface. 
Ceci est utile pour déterminer si un objet donné implémente une interface donnée. Prenons 
par exemple l’interface IMovable que vous allez créer dans l’exemple suivant.
Pour créer une interface en tant que type de données :
1.
Créez un document ActionScript et enregistrez-le sur votre disque dur sous le nom 
d’.
2. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
interface IMovable {
public function moveUp():Void;
public function moveDown():Void;
}
3. Enregistrez les modifications apportées au fichier ActionScript.
4. Créez un document ActionScript et enregistrez-le sous le nom de  dans le même 
répertoire que . 
Dans ce document, vous créez une classe Box implémentant l’interface IMovable créée 
précédemment.
5. Dans , tapez le code ActionScript suivant dans la fenêtre de script :
class Box implements IMovable {
public var xPos:Number;
public var yPos:Number;
public function Box() {
}
public function moveUp():Void {
trace("moving up");
// définition de méthode
}
public function moveDown():Void {
trace("moving down");
// définition de méthode
}
}
Création d’interfaces comme types de données
301

6. Enregistrez les modifications apportées au document ActionScript.
7. Créez un document Flash nommé , et enregistrez-le dans le même répertoire 
que les documents ActionScript précédents.
8. Sélectionnez l’image 1 du scénario, ouvrez l’éditeur ActionScript, puis tapez le code suivant 
dans le panneau Actions : 
var newBox:Box = new Box();
Ce code ActionScript crée une occurrence de la classe Box, que vous allez déclarer en tant 
que variable du type Box.
9. Enregistrez les modifications apportées au document Flash, puis choisissez Contrôle > 
Tester l’animation pour tester le fichier SWF.
A l’exécution, dans Flash Player7 et ses versions ultérieures, vous pouvez attribuer une 
expression à un type d’interface ou à un autre type de données lors de l’exécution. 
Contrairement aux interfaces Java, des interfaces ActionScript existent lors de l’exécution 
du script, ce qui autorise l’attribution de type. Si l’expression est un objet qui implémente 
l’interface, ou si elle possède une super-classe qui implémente l’interface, l’objet est 
renvoyé. Dans le cas contraire, null est renvoyé. Cela est particulièrement utile si vous 
souhaitez vous assurer qu’un objet particulier implémente une interface particulière. 
Pour plus d’informations sur l’attribution de type, consultez le des objets », à la page 78.
10. Dans , ajoutez le code suivant à la fin du code ActionScript :
if (IMovable(newBox) != null) {
newBox.moveUp();
} else {
trace("box instance is not movable");
}
Ce code ActionScript contrôle si l’occurrence newBox implémente l’interface IMovable 
avant l’appel de la méthode moveUp() sur l’objet.
11. Enregistrez le document Flash, puis sélectionnez Contrôle > Tester l’animation pour tester 
le fichier SWF. 
Comme l’occurrence Box implémente l’interface IMovable, la méthode Box.moveUp() est 
appelée et le texte « moving up » s’affiche dans le panneau de sortie.
Pour plus d’informations sur l’attribution, consultez le à la page 78.
302
Interfaces

Fonctionnement des héritages et des 
interfaces
Le mot-clé extends vous permet de créer des sous-classes d’une interface. Cela peut se révéler 
très utile pour les vastes projets dans lesquels vous souhaitez étendre (ou sous-classer) une 
interface existante et ajouter d’autres méthodes. Ces méthodes doivent être définies pour 
toutes les classes qui implémentent cette interface.
Lorsque vous étendez des interfaces, vous devez savoir que vous recevez des messages d’erreur 
dans Flash si plusieurs fichiers d’interface déclarent des fonctions portant le même nom mais 
ayant des paramètres ou des types de retour différents.
L’exemple suivant présente le sous-classement d’un fichier d’interface à l’aide du mot-clé 
extends.
Pour étendre une interface :
1.
Créez un fichier ActionScript et enregistrez-le sous le nom de .
2. Dans , saisissez le code ActionScript suivant dans la fenêtre de script : 
interface Ia {
public function f1():Void;
public function f2():Void;
}
3. Enregistrez les modifications apportées au fichier ActionScript.
4. Créez un fichier ActionScript et enregistrez-le sous le nom de , dans le même répertoire 
que le fichier créé à l’étape 1.
5. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
interface Ib extends Ia {
public function f8():Void;
public function f9():Void;
}
6. Enregistrez les modifications apportées au fichier ActionScript.
7. Créez un fichier ActionScript et enregistrez-le sous le nom de  dans le même 
répertoire que les deux fichiers précédents.
Fonctionnement des héritages et des interfaces
303

8. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
class ClassA implements Ib {
// f1() et f2() sont définies dans l’interface Ia.
public function f1():Void {
}
public function f2():Void {
}
// f8() et f9() sont définies dans l’interface lb qui étend Ia.
public function f8():Void {
}
public function f9():Void {
}
}
9. Enregistrez votre fichier de classe, puis cliquez sur le bouton Vérifier la syntaxe sous la 
fenêtre de script. 
Flash ne génère pas de message d’erreur tant que les quatre méthodes sont définies et 
correspondent aux définitions provenant de leurs fichiers d’interface respectifs.
REMARQUE
Dans ActionScript2.0, chaque classe ne peut étendre qu’une classe, même si vous 
pouvez utiliser les classes pour implémenter autant d’interfaces que nécessaire.
Pour que votre classe ClassA implémente plusieurs interfaces dans l’exemple précédent, il vous 
suffit de séparer les interfaces par des virgules. Ou, si l’une de vos classes étend une super-
classe et implémente plusieurs interfaces, servez-vous d’un code semblable au suivant :
class ClassA extends ClassB implements Ib, Ic, Id { }.
304
Interfaces

Exemple : Utilisation des interfaces
Dans cet exemple, vous allez créer une interface simple que vous pourrez ensuite réutiliser 
entre plusieurs classes différentes.
Pour créer une interface :
1.
Créez un fichier ActionScript et enregistrez-le sous le nom de .
2. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
interface IDocumentation {
public function downloadUpdates():Void;
public function checkForUpdates():Boolean;
public function searchHelp(keyword:String):Array;
}
3. Enregistrez les modifications apportées au fichier d’interface ActionScript.
4. Créez un fichier ActionScript dans le même répertoire que , puis 
enregistrez-le sous le nom de .
5. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
class FlashPaper implements IDocumentation {
}
6. Enregistrez les modifications apportées au fichier ActionScript.
7. Cliquez sur le bouton Vérifier la syntaxe pour votre classe ActionScript.
Un message semblable au suivant apparaît :
**Error** path\: Line 1: The class must implement method 
'checkForUpdates' from interface 'IDocumentation'.
     class FlashPaper implements IDocumentation {
Total ActionScript Errors: 1  Reported Errors: 1
Cette erreur est due au fait que la classe FlashPaper active ne définit aucune des méthodes 
publiques que vous avez définies dans l’interface IDocumentation. 
8. Ouvrez de nouveau le fichier de classe  et modifiez le code ActionScript 
existant de sorte qu’il corresponde au suivant :
class FlashPaper implements IDocumentation {
private static var __version:String = "1,2,3,4";
public function downloadUpdates():Void {
};
public function checkForUpdates():Boolean {
return true;
};
public function searchHelp(keyword:String):Array {
return []
};
}
Exemple : Utilisation des interfaces
305

9. Enregistrez les modifications apportées au fichier ActionScript et cliquez de nouveau sur le 
bouton Vérifier la syntaxe.
Aucun message ne s’affiche plus dans le panneau de sortie.
REMARQ
Vous pouvez ajouter autant de méthodes ou variables statiques, publiques ou 
privées supplémentaires que nécessaire dans le fichier de classe FlashPaper. 
Le fichier d’interface ne définit qu’un ensemble minimum de méthodes devant 
UE
apparaître au sein des classes qui implémentent cette interface.
10. Ouvrez de nouveau le document d’interface IDocumentation et ajoutez la ligne de code en 
gras suivante (au-dessous de la méthode searchHelp()) :
interface IDocumentation {
public function downloadUpdates():Void;
public function checkForUpdates():Boolean;
public function searchHelp(keyword:String):Array;
public function addComment(username:String, comment:String):Void;
}
11. Enregistrez les modifications apportées au fichier d’interface et ouvrez de nouveau le 
document .
12. Cliquez sur le bouton Vérifier la syntaxe et un nouveau message d’erreur apparaît dans le 
panneau de sortie :
**Error** path\: Line 1: The class must implement method 
'addComment' from interface 'IDocumentation'.
     class FlashPaper implements IDocumentation {
Total ActionScript Errors: 1  Reported Errors: 1
L’erreur précédente est due au fait que le fichier de classe  ne définit plus 
toutes les classes décrites dans le fichier d’interface. Pour corriger l’erreur, vous devez soit 
ajouter la méthode addComment() à la classe FlashPaper, soit supprimer la définition de la 
méthode du fichier d’interface IDocumentation.
13. Ajoutez la méthode suivante dans la classe FlashPaper :
public function addComment(username:String, comment:String):Void {
/* Envoi de paramètres à la page côté serveur, qui insère un 
commentaire dans la base de données. */
}
14. Enregistrez les modifications apportées à , puis cliquez sur le bouton Vérifier 
la syntaxe. Aucune erreur ne devrait plus apparaître.
Dans la section précédente, vous avez créé une classe basée sur le fichier d’interface 
IDocumentation. Dans cette section, vous allez créer une nouvelle classe qui implémente 
également l’interface IDocumentation, tout en ajoutant d’autres méthodes et propriétés.
306
Interfaces

Ce didacticiel démontre l’utilité des interfaces car si vous souhaitez créer une autre classe 
étendant l’interface IDocumentation, vous pouvez aisément identifier les méthodes 
nécessaires au sein de la nouvelle classe.
Exemple : Création d’une interface 
complexe
L’exemple suivant présente plusieurs façons de définir et d’implémenter des interfaces. 
Dans ce didacticiel, vous allez apprendre à créer un fichier d’interface simple, à écrire une 
classe qui implémente plusieurs interfaces et à utiliser des interfaces qui étendent d’autres 
interfaces pour créer des structures de données plus complexes.
Pour créer une interface complexe :
1.
Créez un document ActionScript, puis enregistrez-le sous le nom d’
2. Créez un dossier appelé complexInterface et enregistrez dans ce répertoire.
Vous enregistrerez ensuite tous les fichiers créés pour ce didacticiel dans ce répertoire.
3. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier :
interface InterfaceA {
public function k():Number;
public function n(z:Number):Number;
}
4. Enregistrez le document ActionScript, puis créez-en un autre appelé  et 
enregistrez-le dans le répertoire complexInterface.
 implémente l’interface InterfaceA créée précédemment.
5. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier :
class ClassB implements InterfaceA {
public function k():Number {
return 25;
}
public function n(z:Number):Number {
return (z + 5);
}
}
6. Enregistrez les modifications apportées au document , puis créez un autre 
document Flash nommé  dans le répertoire complexInterface. 
Ce fichier de classe teste la classe ClassB créée précédemment.
Exemple : Création d’une interface complexe
307

7. Dans , saisissez le code ActionScript suivant dans l’image 1 du scénario :
// Nom de fichier :
import ClassB;
var myB:ClassB = new ClassB();
trace(myB.k()); // 25
trace(myB.n(7)); // 12
8. Enregistrez les modifications apportées au document Flash, puis choisissez Contrôle > 
Tester l’animation pour tester le document Flash. 
Le panneau de sortie affiche deux nombres, 25 et 12, résultats des méthodes k() et n() de 
la classe ClassB.
9. Créez un fichier ActionScript et enregistrez-le sous  dans le répertoire 
complexInterface.
Ce fichier de classe implémente l’interface InterfaceA créée à l’étape 1.
10. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier :
class ClassC implements InterfaceA {
public function k():Number {
return 25;
}
// **Erreur** La classe doit implémenter la méthode ’n’ depuis 
// l’interface ’InterfaceA’.
}
Si vous cliquez sur le bouton Vérifier la syntaxe pour le fichier de classe ClassC, Flash 
affiche un message d’erreur dans le panneau de sortie signalant que la classe active doit 
implémenter la méthode n() définie dans l’interface InterfaceA. Lorsque vous créez des 
classes qui implémentent une interface, il est important de définir des méthodes pour 
chaque entrée de l’interface.
11. Créez un document ActionScript et enregistrez-le sous le nom d’ dans le 
répertoire complexInterface.
12. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier :
interface InterfaceB {
public function o():Void;
}
13. Enregistrez les modifications apportées au document , puis créez un autre 
document ActionScript sous le nom de  dans le répertoire complexInterface. 
Cette classe implémente les interfaces InterfaceA et InterfaceB créées précédemment. 
La classe ClassD doit inclure des implémentations de méthode pour chaque méthode 
énumérée dans chaque fichier d’interface.
308
Interfaces

14. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier :
class ClassD implements InterfaceA, InterfaceB {
public function k():Number {
return 15;
}
public function n(z:Number):Number {
return (z * z);
}
public function o():Void {
trace("o");
}
}
15. Enregistrez les modifications apportées au fichier , puis créez un document Flash 
et enregistrez-le sous le nom de 
Ce document Flash teste la classe ClassD créée précédemment.
16. Dans , saisissez le code ActionScript suivant dans l’image 1 du scénario :
// Nom de fichier :
import ClassD;
var myD:ClassD = new ClassD();
trace(myD.k()); // 15
trace(myD.n(7)); // 49
myD.o(); // o
17. Enregistrez les modifications apportées au fichier , puis choisissez Contrôle > 
Tester l’animation pour tester le fichier. 
Les valeurs 15 et 49 et la lettre o doivent apparaître dans le panneau de sortie. Ces valeurs 
sont les résultats respectifs des méthodes ClassD.k(), ClassD.n() et ClassD.o().
18. Créez un document ActionScript, puis enregistrez-le sous le nom d’.
Cette interface étend l’interface InterfaceA créée précédemment, puis ajoute une nouvelle 
définition de méthode.
19. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier :
interface InterfaceC extends InterfaceA {
public function p():Void;
}
20.Enregistrez les modifications apportées au fichier ActionScript, puis créez-en un autre et 
enregistrez-le sous le nom de  dans le répertoire complexInterface. 
Cette classe implémente deux interfaces, InterfaceB et InterfaceC.
Exemple : Création d’une interface complexe
309

21. Dans , saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier :
class ClassE implements InterfaceB, InterfaceC {
public function k():Number {
return 15;
}
public function n(z:Number):Number {
return (z + 5);
}
public function o():Void {
trace("o");
}
public function p():Void {
trace("p");
}
}
22.Enregistrez les modifications apportées au document ActionScript, puis créez un autre 
document Flash nommé  dans le répertoire complexInterface.
 , saisissez le code ActionScript suivant dans l’image 1 du scénario :
// Nom de fichier :
import ClassE;
var myE:ClassE = new ClassE();
trace(myE.k()); // 15
trace(myE.n(7)); // 12
myE.o(); // o
myE.p(); // p
24.Enregistrez le document Flash, puis sélectionnez Contrôle > Tester l’animation pour tester 
le fichier SWF. 
Les valeurs 15, 12, o et p apparaissent dans le panneau de sortie. Ces valeurs sont 
renvoyées par les méthodes ClassE.k(), ClassE.n(), ClassE.o() et ClassE.p(). 
La classe ClassE implémentant les interfaces InterfaceB et InterfaceC, chaque méthode 
issue des deux fichiers d’interface doit être définie. Bien que les interfaces InterfaceB et 
InterfaceC ne définissent que les méthodes o() et p(), InterfaceC étend InterfaceA. 
Cela signifie que chacune des méthodes définies, k() et n(), doit également être 
implémentée.
310
Interfaces

CHAPITRE 9
Gestion d’événements
9
Les événements sont des actions qui se produisent lors de la lecture d’un fichier SWF. 
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. 
Vous pouvez gérer les événements avec ActionScript de plusieurs façons : 
?
« ActionScript et les événements », à la page 312
?
« Utilisation des écouteurs d’événement », à la page 316
?
« Association de gestionnaires d’événement à des boutons et des clips », à la page 321, plus 
précisément, gestionnaire on et gestionnaire onClipEvent.
?
« Diffusion d’événements à partir d’occurrences de composant », à la page 325
L’utilisation de gestionnaires d’événement avec loadMovie (méthode MovieClip.loadMovie) 
peut donner des résultats imprévisibles. Si vous liez un gestionnaire d’événement à un bouton 
avec on() ou si vous créez un gestionnaire dynamique avec une méthode telle que onPress 
(gestionnaire MovieClip.onPress), puis que vous appelez loadMovie(), le gestionnaire 
d’événement ne sera plus disponible après le chargement du nouveau contenu. Cependant, si 
vous utilisez gestionnaire onClipEvent ou gestionnaire on pour lier un gestionnaire 
d’événement à un clip, puis que vous appelez loadMovie() pour ce clip, le gestionnaire 
d’événement restera disponible après le chargement du nouveau contenu.
311

Pour plus d’informations sur la gestion des événements, consultez les sections suivantes :
ActionScript et les événements  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Utilisation des écouteurs d’événement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
Utilisation d’écouteurs d’événement avec des composants. . . . . . . . . . . . . . . . . . . 319
Association de gestionnaires d’événement à des boutons et des clips . . . . . . . . . 321
Diffusion d’événements à partir d’occurrences de composant  . . . . . . . . . . . . . . . .325
Création de clips avec des états de bouton  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .326
Domaine du gestionnaire d’événement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Domaine du mot-clé this. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Utilisation de la classe Delegate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
ActionScript et les événements
Dans Flash, le code ActionScript est exécuté lorsque survient un événement : par exemple, lors 
du chargement d’un clip, de la saisie d’une image-clé sur le scénario ou lorsque l’utilisateur 
clique sur un bouton. Ces événements peuvent être déclenchés par l’utilisateur ou par le 
système. Les utilisateurs cliquent avec leur souris et appuient sur des touches ; le système 
déclenche des événements lorsque certaines conditions sont remplies ou lorsque des 
traitements sont terminés (le chargement d’un fichier SWF, le scénario atteint une certaine 
image, la fin du téléchargement d’une image, etc). 
Lorsqu’un événement survient, vous écrivez un gestionnaire d’événement pour y répondre par 
une action. Il est important de bien comprendre le moment et l’emplacement où surviennent 
les événements pour mieux identifier comment et où y répondre par une action et quels outils 
ActionScript utiliser dans chaque cas. 
Les événements peuvent être regroupés en un certain nombre de catégories : les événements de 
souris et de clavier, qui surviennent lorsqu’un utilisateur interagit avec votre application Flash 
par l’intermédiaire de la souris et du clavier ; les événements de clip qui surviennent dans des 
clips et les événements d’image qui surviennent dans les images du scénario. 
Evénements de souris et de clavier
Un utilisateur qui interagit avec votre application ou fichier SWF déclenche des événements 
avec sa souris et son clavier. Par exemple, lorsque l’utilisateur survole un bouton, l’événement 
Button.onRollOver ou on(rollOver) survient. Lorsqu’il clique sur un bouton, il déclenche 
l’événement Button.onRelease. S’il appuie sur une touche du clavier, l’événement on 
(keyPress) survient. Vous pouvez écrire du code sur une image ou joindre des scripts à une 
occurrence pour traiter ces événements et ajouter toute l’interactivité nécessaire. 
312
Gestion d’événements

Evénements de clip
Au sein d’un clip, il est possible de réagir à un certain nombre d’événements déclenchés 
lorsque l’utilisateur entre ou quitte la scène ou interagit avec elle par le biais du clavier ou de la 
souris. Vous pouvez, par exemple, charger un fichier JPG ou SWF externe dans le clip lorsque 
l’utilisateur entre dans la scène. Il est également possible de permettre à l’utilisateur de 
déplacer les éléments de la scène par des mouvements de la souris.
Evénements d’image
Dans un scénario principal ou de clip, un événement système survient lorsque la tête de 
lecture arrive dans une image-clé. Cette opération est appelée événement d’image
Les événements d’image sont très utiles pour déclencher des actions en fonction de 
l’écoulement du temps (progression dans le scénario) ou pour interagir avec les éléments 
actuellement visibles sur la scène. Lorsque vous ajoutez un script à une image-clé, il s’exécute 
dès que la lecture atteint cette image-clé. Un script joint à une image est appelé script d’image
L’une des utilisations les plus courantes des scripts d’image consiste à arrêter la lecture dès 
qu’une certaine image-clé est atteinte. Cette opération s’effectue avec la fonction stop(). 
Vous sélectionnez une image-clé, puis ajoutez la fonction stop() en tant qu’élément de script 
dans le panneau Actions.
Après avoir arrêté le fichier SWF à une certaine image-clé, vous devez effectuer certaines 
actions. Vous pouvez par exemple utiliser un script d’image pour mettre à jour dynamiquement 
la valeur d’un intitulé, pour gérer l’interaction entre les éléments de la scène, etc.
ActionScript et les événements
313

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 MovieClip 
définit un gestionnaire d’événement onPress, invoqué lorsque l’utilisateur clique avec le 
bouton de la souris sur un objet clip. Contrairement aux autres méthodes de classe, vous 
n’invoquez pas directement un gestionnaire d’événement ; Flash Player le fait lui-même 
lorsque l’événement concerné se produit. 
Les classes ActionScript suivantes sont des exemples de classes qui 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 Guide de référence du langage 
ActionScript 2.0
. Le terme gestionnaire est ajouté au titre de chaque gestionnaire d’événement. 
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 associé 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 
invoquée automatiquement 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 du 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 () {
// Votre code, répondant à l’événement.
}
Par exemple, supposons que vous ayez un bouton next_btn sur la scène. Le code suivant 
affecte au gestionnaire d’événement onPress du bouton une fonction qui fait avancer la tête 
de lecture jusqu’à l’image suivante dans le scénario actuel :
next_btn.onPress = function () {
nextFrame();
}
314
Gestion d’événements

Affectation d’une référence de fonction
Dans le code précédent, la fonction nextFrame() 
a été affectée à un gestionnaire d’événement pour 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, comme illustré par l’exemple suivant.
// Affecte une référence de fonction au gestionnaire d’événement onPress 
// du bouton.
next_btn.onPress = goNextFrame;
// Définit la fonction goNextFrame().
function goNextFrame() {
nextFrame();
}
Notez que, dans l’exemple suivant, vous affectez la référence de fonction, et non la valeur 
renvoyée, au gestionnaire d’événement onPress :
// Incorrect !
next_btn.onPress = goNextFrame();
// Correct.
next_btn.onPress = goNextFrame;
Réception des paramètres transmis
Certains gestionnaires d’événement reçoivent des 
paramètres qui fournissent 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 :
this.createTextField("my_txt", 99, 10, 10, 200, 20);
my_txt.border = true;
= "input";
this.createTextField("myOther_txt", 100, 10, 50, 200, 20);
myOther_txt.border = true;
= "input";
myOther_txt.onSetFocus = function(my_txt:TextField) {
= "I just lost keyboard focus";
};
Gestionnaires d’événement pour les objets d’exécution
Vous pouvez également affecter 
des fonctions aux gestionnaires d’événement pour les objets créés lors de l’exécution. Le code 
suivant, par exemple, crée une nouvelle occurrence de clip (newclip_mc) et affecte une 
fonction au gestionnaire d’événement onPress du clip :
this.attachMovie("symbolID", "newclip_mc", 10);
newclip_mc.onPress = function () {
trace("You pressed me");

Pour plus d’informations, voir « Création de clips à l’exécution », à la page 344.
Utilisation de méthodes de gestionnaire d’événement
315

Contournement des méthodes de gestionnaire d’événement
En créant une classe qui 
étend une classe ActionScript, vous pouvez supplanter les méthodes du gestionnaire 
d’événement avec les fonctions que vous avez écrites. Vous pouvez définir un gestionnaire 
d’événement dans une nouvelle sous-classe que vous pouvez utiliser de nouveau pour 
différents objets en liant les symboles de la bibliothèque de la classe étendue à la nouvelle 
sous-classe. Le code suivant contourne le gestionnaire d’événement onPress de la classe 
MovieClip par l’intermédiaire d’une fonction qui réduit la transparence du clip :
// Classe FadeAlpha – définit la transparence lorsque vous cliquez 
// sur le clip.
class FadeAlpha extends MovieClip {
  function onPress() {
    this._alpha -= 10;
  }
}
Pour plus d’informations sur l’extension d’une classe ActionScript et sur la liaison avec les 
symboles de la bibliothèque, consultez les exemples de la sectiondes symboles dans Flash », à la page 256. Pour plus d’informations sur l’écriture et l’utilisation 
de classes personnalisées, consultez le Chapitre 6, « Classes »
Utilisation des écouteurs d’événement
Les écouteurs d’événement permettent à un objet, appelé objet écouteur, de recevoir des 
événements diffusés par un autre objet, appelé objet diffuseur. L’objet diffuseur enregistre 
l’objet écouteur 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 écouteurs pour recevoir des événements d’un 
seul diffuseur et vous pouvez enregistrer un seul objet écouteur pour recevoir des événements 
de plusieurs diffuseurs. 
Contrairement aux méthodes de gestion d’erreurs, le modèle écouteur-diffuseur applicable 
aux événements permet d’utiliser plusieurs éléments de code pour écouter un même 
événement sans créer de conflits. Les modèles d’événement qui n’appliquent pas ce modèle, 
tels que XML.onLoad, peuvent devenir une source de problèmes lorsque plusieurs blocs de 
code écoutent un même événement. Ces différents blocs entrent en conflit pour contrôler la 
seule référence de la fonction de rappel XML.onLoad. Avec le modèle écouteur/diffuseur, vous 
pouvez ajouter facilement des écouteurs à un même événement sans avoir à vous soucier des 
blocages.
316
Gestion d’événements

Les classes ActionScript suivantes permettent de diffuser des événements : Key, Mouse, 
MovieClipLoader, Selection, Stage et TextField. Pour identifier les écouteurs disponibles pour 
une classe, consultez chaque entrée de classe dans Guide de référence du langage ActionScript 2.0
Pour plus d’informations sur les écouteurs d’événement, consultez les rubriques suivantes :
?
« Modèle d’écouteur d’événement », à la page 317
?
« Exemple d’écouteur d’événement », à la page 318
Pour un exemple de fichier source, , qui décrit comment la propriété 
Stage.scaleMode affecte les valeurs de Stage.width et Stage.height lorsque la fenêtre du 
navigateur est redimensionnée, consultez la page des exemples Flash à l’adresse 
Téléchargez et décompressez le fichier zip Exemples 
et naviguez jusqu’au dossier ActionScript2.0/StageSize afin d’accéder à l’exemple. 
Modèle d’écouteur d’événement
Le modèle des écouteurs d’événement est similaire à celui des gestionnaires d’événement 
(consultez la section « ActionScript et les événements », à la page 312), à deux différences 
près : 
?
Vous affectez le gestionnaire d’événement à l’objet écouteur et non pas à l’objet qui diffuse 
l’événement.
?
Vous appelez une méthode spéciale de l’objet diffuseur, addListener(), qui enregistre 
l’objet écouteur pour recevoir ses événements. 
Le code suivant présente le modèle d’écouteur d’événement :
var listenerObject:Object = new Object();
listenerObject.eventName = function(eventObj:Object) {
// Votre code ici.
};
broadcasterObject.addListener(listenerObject);
Le code commence par un objet, listenerObject, avec une propriété eventName. L’objet 
écouteur spécifié peut être un objet, tel qu’un objet existant, une occurrence de bouton ou de 
clip sur la scène ou une occurrence de n’importe quelle classe ActionScript. Par exemple, un 
clip personnalisé peut implémenter les méthodes d’écoute pour les écouteurs de la scène. 
Vous pouvez également avoir un objet qui écoute plusieurs types d’écouteurs. 
La propriété eventName est un événement qui se produit sur broadcasterObject, qui 
ensuite diffuse l’événement à listenerObject. Vous pouvez enregistrer plusieurs écouteurs 
sur un diffuseur d’événement.
Affectez ensuite une fonction à l’écouteur d’événement qui répond en quelque sorte à 
l’événement. 
Utilisation des écouteurs d’événement
317

Enfin, appelez la méthode addListener() sur l’objet qui diffuse l’événement, en lui 
transmettant le nom de l’objet écouteur.
Pour désenregistrer un objet écouteur 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’événement à 
supprimer et l’objet écouteur.
broadcasterObject.removeListener(listenerObject);
Exemple d’écouteur d’événement
L’exemple suivant illustre comment utiliser l’écouteur d’événement onSetFocus dans la classe 
Selection 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 cliquez sur le bouton 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. Vous pouvez poursuivre la création de champs texte. 
4. Sélectionnez l’image 1 dans le scénario et ouvrez le panneau Actions (Fenêtre > 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 :
// Crée un objet écouteur, focusListener.
var focusListener:Object = new Object();
// Définit la fonction pour l’objet écouteur.
focusListener.onSetFocus = function(oldFocus_txt:TextField, 
newFocus_txt:TextField) {
oldFocus_txt.border = false;
newFocus_txt.border = true;
}
Ce code crée un objet nommé focusListener qui définit une propriété onSetFocus et 
lui affecte une fonction. La fonction tient compte de 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 sur false 
et la propriété border du champ de texte qui a reçu le focus sur true.
318
Gestion d’événements

6. Pour enregistrer l’objet focusListener pour recevoir des événements de l’objet Selection, 
ajoutez le code suivant au panneau Actions :
// Enregistre focusListener auprès du diffuseur.
Selection.addListener(focusListener);
7. Testez l’application (Contrôle > Tester l’animation), cliquez dans le premier champ de 
texte, puis appuyez sur la touche de tabulation pour passer d’un champ à l’autre.
Utilisation d’écouteurs d’événement avec 
des composants
La syntaxe d’un écouteur d’événement change légèrement lorsque l’on utilise des composants. 
Les composants génèrent des événements, qui doivent être écoutés de façon spécifique par un 
objet écouteur ou par une fonction personnalisée.
L’exemple suivant présente l’utilisation d’écouteurs d’événement pour surveiller la progression 
du téléchargement dynamique d’une image.
Pour écouter les événements du composant Loader :
1.
Faites glisser une occurrence du composant Loader du panneau Composants jusqu’à 
la scène.
2. Sélectionnez la nouvelle occurrence et saisissez my_ldr dans le champ Nom de l’occurrence 
de l’inspecteur des propriétés.
3. Ajoutez le code suivant à l’image 1 du scénario principal :
System.security.allowDomain("");
var loaderListener:Object = new Object();
loaderListener.progress = function(evt_obj:Object):Void {
trace(); // progress
trace("\t" + evt_obj.target.bytesLoaded + " of " + 
evt_obj.target.bytesTotal + " bytes loaded");
}
loaderListener.complete = function(evt_obj:Object):Void {
trace(); // complete
}
my_ldr.addEventListener("progress", loaderListener);
my_ldr.addEventListener("complete", loaderListener);
("");
Ce code ActionScript définit un objet écouteur nommé loaderListener, qui écoute 
deux événements : progress et complete. Lorsque chacun de ces événements est diffusé, 
son code est exécuté et le texte de débogage s’affiche dans le panneau de sortie si vous 
testez le fichier SWF dans l’outil de programmation. 
Utilisation d’écouteurs d’événement avec des composants
319

Vous indiquez ensuite à l’occurrence my_ldr d’écouter chacun des deux événements 
spécifiés (progress et complete) et vous désignez l’objet écouteur ou la fonction à 
exécuter lorsque l’événement est diffusé. Enfin, la méthode () est appelée, ce 
qui déclenche le téléchargement de l’image.
4. Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
L’image est téléchargée dans l’occurrence Loader de la scène, puis plusieurs messages 
s’affichent dans le panneau de sortie. Selon la taille de l’image téléchargée, et si l’image a 
été mise en cache sur l’ordinateur local de l’utilisateur, l’événement progress peut être 
diffusé plusieurs fois, alors que l’événement complete n’est diffusé qu’une fois à la fin du 
téléchargement de l’image.
Lorsque vous utilisez des composants et diffusez des événements, la syntaxe diffère 
légèrement de celle des écouteurs d’événement des exemples précédents. En particulier, 
vous devez utiliser la méthode addEventListener() au lieu d’appeler addListener(). 
Deuxièmement, vous devez désigner l’événement spécifique que vous souhaitez écouter, 
ainsi que l’objet écouteur ou la fonction.
Au lieu d’utiliser un objet écouteur, comme à la sectionavec des composants », à la page 319, vous pouvez également utiliser une fonction 
personnalisée. Le code de l’exemple précédent pourrait être réécrit de la manière suivante :
System.security.allowDomain("");
my_ldr.addEventListener("progress", progressListener);
my_ldr.addEventListener("complete", completeListener);
("");
function progressListener(evt_obj:Object):Void {
trace(); // progress
trace("\t" + evt_obj.target.bytesLoaded + " of " + 
evt_obj.target.bytesTotal + " bytes loaded");
}
function completeListener(evt_obj:Object):Void {
trace(); // complete
}
REMARQUE
Remarquez que, dans les exemples précédents, les écouteurs d’événement sont 
toujours ajoutés avant l’appel de la méthode (). Si vous appelez la 
méthode () avant de spécifier les écouteurs d’événement, il est possible 
que le téléchargement se termine avant que les écouteurs d’événement soient 
entièrement définis. Cela signifie que le contenu peut s’afficher et que l’événement 
complete peut ne pas être intercepté.
320
Gestion d’événements

Association de gestionnaires 
d’événement à des boutons et des clips
Vous pouvez associer des gestionnaires d’événement directement à une occurrence de bouton 
ou de clip sur la scène au moyen des gestionnaires d’événement onClipEvent() et on(). 
Le gestionnaire d’événement onClipEvent() diffuse les événements de clip alors que le 
gestionnaire d’événement on() traite les événements de bouton.
Pour lier un gestionnaire d’événement à une occurrence de bouton ou de clip, cliquez sur cette 
occurrence sur la scène pour lui donner le focus, puis entrez du code dans le panneau Actions. 
Le titre du panneau Actions indique que du code va être lié au bouton ou au clip : panneau 
Actions - panneau Bouton ou Actions - Clip. Pour consulter les recommandations liées à 
l’exploitation de code avec des occurrences de bouton ou de clip, consultez la section 
« Association de code à des objets », à la page 732.
REMARQUE
Ne confondez pas les gestionnaires d’événement de boutons et de clips et les 
événements de composant, tels que SimpleButton.click,  et 
UIObject reveal, qui doivent être liés aux occurrences de composants et sont abordés 
dans le guide Utilisation des composants ActionScript 2.0.
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. 
(Voir « ActionScript et les événements », à la page 312d’événement », à la page 316.) 
REMARQUE
Il n’est pas conseillé de lier les gestionnaires d’événement onClipEvent() et on(). Il est 
préférable d’intégrer votre code à des scripts d’image ou à un fichier de classe, comme 
décrit tout au long de ce manuel. Pour plus d’informations, voévénements », à la page 312 et « Association de code à des objets », à la page 732.
Pour plus d’informations sur les gestionnaires d’événement de boutons et de clips, consultez 
les rubriques suivantes :
?
la page 322
?
« Spécification d’événements pour les méthodes on ou onClipEvent », à la page 323
?
« Ajout ou affectation de plusieurs gestionnaires à un même objet », à la page 324
Association de gestionnaires d’événement à des boutons et des clips
321

Utilisation de on et onClipEvent avec des méthodes 
de gestionnaires d’événement
Vous pouvez, dans certains cas, appliquer différentes techniques pour gérer les événements 
sans provoquer de conflits. L’utilisation des méthodes on() et onClipEvent() ne provoque 
pas de conflit avec les 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 fait pivoter 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 les types d’événement à appeler et le moment auquel ces 
derniers doivent être appelés, vous pouvez utiliser les méthodes 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. Voir « Domaine du gestionnaire d’événement », à la page 327.
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, voir bouton », à la page 326. Pour plus d’informations sur la spécification d’événements pour on() 
et onClipEvent(), consultez la section onClipEvent », à la page 323.
Pour utiliser un gestionnaire on et le gestionnaire d’événements onPress :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom .
2. A l’aide de l’outil Rectangle, dessinez un grand carré sur la scène.
3. A l’aide de l’outil Sélection, double-cliquez sur le carré sur la scène, puis appuyez sur F8 
pour ouvrir la boîte de dialogue Convertir en symbole.
4. Entrez un nom de symbole pour la zone, définissez le type clip et cliquez sur OK.
5. Donnez au clip sur la scène le nom d’occurrence box_mc.
6. Ajoutez le code ActionScript suivant directement au symbole du clip sur la scène :
on (press) {
trace("on (press) { }");
}
7. Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
box_mc.onPress = function() {
trace("box_mc.onPress = function() { };");
};
322
Gestion d’événements

8. Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Lorsque vous cliquez sur le symbole du clip sur la scène, les informations suivantes 
s’affichent dans le panneau de sortie :
on (press) { }
box_mc.onPress = function() { };
REMARQUE
Il n’est pas conseillé de lier les gestionnaires d’événement onClipEvent() et on(). 
Il est préférable d’intégrer votre code à des scripts d’image ou à un fichier de classe, 
comme décrit tout au long de ce manuel. Pour plus d’informations, voir 
« ActionScript et les événements », à la page 312 et objets », à la page 732.
Spécification d’événements pour les méthodes on ou 
onClipEvent
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. Pour obtenir la liste complète des événements pris en charge par 
les gestionnaires d’événement on() et onClipEvent(), consultez les entrées gestionnaire 
on et gestionnaire onClipEvent dans le Guide de référence du langage ActionScript 2.0
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("Thanks for pressing me.");
}
Vous pouvez spécifier plusieurs événements pour chaque gestionnaire on() en les séparant par 
des virgules. Le code ActionScript d’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 du bouton, puis s’en 
écarte :
on (rollOver, rollOut) {
trace("You rolled over, or rolled out");
}
Vous pouvez également ajouter des événements de touche enfoncée à l’aide de gestionnaires 
on(). Par exemple, le code suivant trace une chaîne lorsque vous appuyez sur la touche 3 du 
clavier. Sélectionnez une occurrence de bouton ou de clip, puis ajoutez le code suivant dans le 
panneau Actions : 
on (keyPress "3") {
trace("You pressed 3")
}
Association de gestionnaires d’événement à des boutons et des clips
323

Ou, pour faire un suivi de la chaîne lorsque la touche Entrée est enfoncée par l’utilisateur, 
vous pouvez utiliser le format de code suivant : Sélectionnez une occurrence de bouton ou de 
clip, puis ajoutez le code suivant dans le panneau Actions :
on (keyPress "<Enter>") {
trace("Enter Pressed");
}
Choisissez Contrôle > Tester l’animation, puis appuyez sur la touche Entrée pour visualiser le 
tracé de la chaîne dans le panneau de sortie. Si le tracé n’apparaît pas, sélectionnez Contrôle > 
Désactiver les raccourcis clavier, puis réessayez. Pour plus d’informations sur l’ajout d’une 
interactivité relative à la pression des touches à vos applications, consultez l’entrée Key.
REMARQUE
Il n’est pas conseillé de lier les gestionnaires d’événement onClipEvent() et on(). Il est 
préférable d’intégrer votre code à des scripts d’image ou à un fichier de classe, comme 
décrit tout au long de ce manuel. Pour plus d’informations, voévénements », à la page 312 et « Association de code à des objets », à la page 732.
Ajout ou affectation de plusieurs gestionnaires à un 
même objet  
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 purgé de la scène.
on (press) {
this.unloadMovie()
}
onClipEvent (load) {
trace("I've loaded");
}
onClipEvent (unload) {
trace("I've unloaded");
}
RE
Il n’est pas conseillé de lier les gestionnaires d’événement onClipEvent() et on(). Il est 
M
A
préférable d’intégrer votre code à des scripts d’image ou à un fichier de classe, comme 
R
décrit tout au long de ce manuel. Pour plus d’informations, voir « ActionScript et les 
Q
UE
événements », à la page 312 et « Association de code à des objets », à la page 732.
Pour lier plusieurs gestionnaires à un objet à l’aide du code placé dans le scénario, 
reportez-vous à l’exemple suivant. Le code associe les gestionnaires onPress et onRelease à 
une occurrence de clip.
324
Gestion d’événements

Pour affecter plusieurs gestionnaires à un même objet :
1.
Créez un nouveau document Flash et nommez-le .
2. Sélectionnez l’image 1 du scénario, puis ajoutez le code suivant dans le panneau Actions :
this.createEmptyMovieClip("img_mc", 10); 
var mclListener:Object = new Object(); 
mclListener.onLoadInit = function(target_mc:MovieClip) { 
     target_mc.onPress = function() { 
          target_mc.startDrag(); 
     }; 
     target_mc.onRelease = function() { 
          target_mc.stopDrag(); 
     }; 

mclListener.onLoadError = function(target_mc:MovieClip) { 
     trace("error downloading image"); 

var img_mcl:MovieClipLoader = new MovieClipLoader(); 
img_mcl.addListener(mclListener); 
img_mcl.loadClip("", 
img_mc); 
3. Sélectionnez Contrôle > Tester l’animation pour tester le document.
L’image se charge dans l’occurrence de img_mc et les gestionnaires d’événement 
onPress() et onRelease() vous permettent de faire glisser l’image sur la scène.
Diffusion d’événements à partir 
d’occurrences de composant
Quelle que soit l’occurrence de composant, vous pouvez spécifier le mode de gestion d’un 
événement. Les événements de composant sont traités différemment par rapport aux 
diffusions d’événements en provenance d’objets ActionScript natifs. 
Pour plus d’informations, consultez Utilisation des composants ActionScript 2.0.
Diffusion d’événements à partir d’occurrences de composant
325

Création de clips avec des é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 (Relevé, 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 comportant l’étiquette d’image appropriée. La propriété hitArea 
(propriété MovieClip.hitArea) permet de désigner la zone active d’un clip.
Pour créer des états de bouton dans un clip :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom .
2. A l’aide de l’outil Rectangle, tracez un petit rectangle (d’environ 100 pixels de large et 
20 pixels de haut) sur la scène.
3. A l’aide de l’outil Sélection, double-cliquez sur la forme, puis appuyez sur F8 pour ouvrir 
la boîte de dialogue Convertir en symbole.
4. Entrez le nom de symbole mcbutton, définissez le type de symbole de clip et cliquez 
sur OK.
5. Double-cliquez sur le symbole de clip sur la scène pour activer le mode d’édition de 
symbole.
6. Créez un calque dans le scénario du clip, et nommez-le labels.
7. Entrez l’étiquette d’image _up dans l’inspecteur des propriétés.
8. Créez un nouveau calque sur le calque par défaut et le calque labels.
9. Renommez le nouveau calque actions et ajoutez le code ActionScript suivant à l’image 1 
du scénario du clip :
stop();
10. Sélectionnez l’image 10, les trois calques, puis sélectionnez Insertion > Scénario > 
Image-clé.
11. Ajoutez une action stop() à l’image 10 du calque actions, puis ajoutez l’étiquette d’image 
_over à l’image 10 du calque labels.
12. Sélectionnez le rectangle dans l’image 10 et sélectionnez une nouvelle couleur de 
remplissage à l’aide de l’inspecteur des propriétés.
13. Créez de nouvelles images-clés dans l’image 20 de chacun des trois calques, puis ajoutez 
l’étiquette d’image _down dans l’inspecteur des propriétés.
326
Gestion d’événements

14. Modifiez la couleur du rectangle dans l’image 20 afin que chacun des trois états de bouton 
apparaisse dans une couleur différente.
15. Revenez au scénario principal.
16. Pour que votre clip réponde aux événements souris, effectuez l’une des opérations 
suivantes :
?
Ajoutez un gestionnaire d’événement on() à l’occurrence de clip, comme indiqué dans 
la page 321.
?
Affectez une fonction à l’un des gestionnaires d’événement souris de l’objet du clip 
(onPress, onRelease, etc.), comme indiqué dans la sectioévénements », à la page 312.
17. Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Lorsque vous passez le pointeur de la souris sur une occurrence de clip sur la scène, le clip 
passe automatiquement à l’état _over. Cliquez sur l’occurrence de clip pour que la tête de 
lecture passe automatiquement à l’état _down du clip.
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(). 
Si vous définissez un gestionnaire d’événement dans une nouvelle classe ActionScript  2.0, le 
domaine dépend également du mode de définition du gestionnaire d’événement. Cette 
section regroupe des exemples relatifs à ActionScript 1.0 et à ActionScript 2.0. 
Exemples ActionScript 1.0
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().
Domaine du gestionnaire d’événement
327

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.
// Ajouté au scénario de clip parent de clip_mc :
clip_mc.onPress = function () {
var shoeColor; // Variable de la fonction locale
shoeColor = "blue";
}
// Gestionnaire on() ajouté au clip_mc :
on (press) {
var shoeColor; // aucun domaine de variable locale
shoeColor = "blue";
}
Bien que les deux gestionnaires d’événement contiennent le même code, leurs résultats sont 
différents. Dans le premier cas, la variable color est locale par rapport à la fonction définie 
pour onPress. Dans le second, le gestionnaire on() ne définissant pas de domaine de variable 
locale, la variable est définie dans le domaine du 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 ajouté à 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’elle est associée à un objet bouton, la fonction play() s’applique au 
scénario qui contient le bouton, c’est-à-dire au scénario parent du bouton. En revanche, 
lorsque le gestionnaire on(press) est associé à un objet de clip, la fonction play() s’applique 
au clip qui contient le gestionnaire. Si vous associez le code suivant à un clip, le scénario 
parent est joué :
// Associé à un clip.
on (press) {
(); // Exécute le scénario parent.
}
328
Gestion d’événements

Dans la définition d’un gestionnaire d’événement ou d’écouteur d’événement, la fonction 
play() s’applique au scénario contenant la définition. Imaginons, par exemple, que vous 
déclariez la méthode de gestionnaire d’événement my_mc.onPress suivante dans le scénario 
contenant l’occurrence de clip my_mc. 
// Fonction définie dans le scénario. 
my_mc.onPress = function () {
play(); // Lit le scénario ayant servi à la définition.
};
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 :
// Fonction définie dans le scénario racine.
my_mc.onPress = function () {
(); // Joue le scénario de my_mc clip.
};
Toutefois, le même code placé sur le scénario racine d’une occurrence de bouton lirait le 
scénario racine :
my_btn.onPress = function () {
(); // Exécute le scénario racine
};
Pour plus d’informations sur le domaine du mot-clé this dans les gestionnaires d’événement, 
consultez la section « Domaine du mot-clé this », à la page 331.
Exemple ActionScript 2.0
La classe TextLoader suivante permet de charger un fichier texte 
et d’afficher un texte après avoir chargé le fichier.
//
class TextLoader {
private var params_lv:LoadVars;
public function TextLoader() {
params_lv = new LoadVars();
params_lv.onLoad = onLoadVarsDone;
("");
}
private function onLoadVarsDone(success:Boolean):Void {
_level0.createTextField("my_txt", 999, 0, 0, 100, 20);
_level0.my_txt.autoSize = "left";
= params_lv.monthNames; // non défini
}
}
Domaine du gestionnaire d’événement
329

Ce code ne peut pas fonctionner correctement car il y a un problème de domaine avec les 
gestionnaires d’événement. Par ailleurs, la référence this prête à confusion entre le 
gestionnaire d’événement onLoad et la classe. Le comportement attendu dans cet exemple est 
que la méthode onLoadVarsDone() soit appelée dans le domaine de l’objet TextLoader, alors 
qu’elle est appelée dans le domaine de l’objet LoadVars. En effet, la méthode a été extraite à 
partir de l’objet TextLoader et greffée sur l’objet LoadVars. L’objet LoadVars appelle alors le 
gestionnaire d’événement this.onLoad lorsque le fichier texte a été chargé avec succès et 
lorsque la fonction onLoadVarsDone() appelée par this est définie sur LoadVars et non sur 
TextLoader. L’objet params_lv réside dans le domaine this lorsqu’il est appelé, bien que la 
fonction onLoadVarsDone() repose sur l’objet params_lv par référence. Par conséquent, la 
fonction onLoadVarsDone() attend une occurrence params_lv.params_lv qui n’existe pas.
Pour appeler correctement la méthode onLoadVarsDone() dans le domaine de l’objet 
TextLoader, appliquez la stratégie suivante : utilisez une fonction littérale pour créer une 
fonction anonyme qui appelle la fonction voulue. L’objet owner reste visible dans le domaine 
de la fonction anonyme, ce qui permet de rechercher l’objet TextLoader ayant procédé à 
l’appel.
//
class TextLoader {
private var params_lv:LoadVars;
public function TextLoader() {
params_lv = new LoadVars();
var owner:TextLoader = this;
params_lv.onLoad = function (success:Boolean):Void {
owner.onLoadVarsDone(success);
}
("");
}
private function onLoadVarsDone(success:Boolean):Void {
_level0.createTextField("my_txt", 999, 0, 0, 100, 20);
_level0.my_txt.autoSize = "left";
= params_lv.monthNames; // Janvier, février, 
mars,
}

330
Gestion d’événements

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 à my_mc :
// Gestionnaire d’événement onPress() associé au scénario principal :
my_mc.onPress = function () {
trace(this); // _level0.my_mc
}
Dans un gestionnaire on() associé à un clip, this renvoie au clip auquel le gestionnaire 
on() est associé, comme indiqué dans le code suivant :
// Associé à un clip appelé my_mc sur le scénario principal.
on (press) {
trace(this); // _level0.my_mc
}
Dans un gestionnaire on() associé à un bouton, this renvoie au scénario qui contient le 
bouton, comme dans le code suivant :
// Associé à un bouton du scénario principal.
on (press) {
trace(this); // _level0
}
Utilisation de la classe Delegate 
La classe Delegate permet d’exécuter une fonction dans un domaine spécifique. Elle est 
fournie pour que vous puissiez distribuer le même événement à deux fonctions différentes 
(consultez le guide Utilisation des composants ActionScript 2.0) et appeler des fonctions au sein 
du domaine de la classe qui les contient. 
Lorsque vous transmettez une fonction sous forme de paramètre à la méthode 
EventDispatcher.addEventListener(), la fonction est invoquée dans le domaine de 
l’occurrence de composant diffuseur, pas de l’objet dans lequel elle est déclarée (consultez le 
guide Utilisation des composants ActionScript 2.0). Pour appeler la fonction dans le domaine de 
l’objet dans lequel elle est déclarée, vous pouvez utiliser Delegate.create().
L’exemple suivant présente trois méthodes d’écoute d’événements pour une occurrence de 
composant Button. Chaque méthode d’ajout d’écouteurs d’événement à une occurrence de 
composant Button distribue l’événement vers un domaine différent.
Utilisation de la classe Delegate
331

Pour utiliser la classe Delegate pour écouter des événements : 
1.
Créez un document Flash, puis enregistrez-le sous le nom .
2. Faites glisser un composant Button du dossier Interface utilisateur du panneau 
Composants à la bibliothèque. 
Vous pourrez ajouter et positionner l’occurrence de bouton sur la scène ultérieurement à 
l’aide du code ActionScript.
3. Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
import mx.controls.Button;
import mx.utils.Delegate;
function clickHandler(eventObj:Object):Void {
trace("[" + + "] event on " + eventObj.target + " 
instance.");
trace("\t this -> " + this);
}
var buttonListener:Object = new Object();
buttonListener.click = function(eventObj:Object):Void {
trace("[" + + "] event on " + eventObj.target + " 
instance.");
trace("\t this -> " + this);
};
this.createClassObject(Button, "one_button", 10, {label:"One"});
(10, 10);
one_button.addEventListener(&quo