Cours de programmation avec Actionscript 3.0 pour débutant


Télécharger Cours de programmation avec Actionscript 3.0 pour débutant

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

Télécharger aussi :


Programming ActionScript 3.0 PROGRAMMATION AVEC 
ACTIONSCRIPT™ 3.0

© 2007 Adobe Systems Incorporated. Tous droits réservés.
Programmation avec ActionScript™ 3.0
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. Sauf indication 
expresse dans le contrat de licence, aucune partie de ce guide ne peut être reproduite, stockée dans un système d’extraction ni 
transmise de quelque manière que soit, électronique, mécanique, par enregistrement ou autre, sans l’accord écrit préalable 
d’Adobe Systems Incorporated. Veuillez noter que le contenu de ce guide est protégé par les lois de copyright même s’il n’est pas 
diffusé avec le logiciel comprenant l’accord de licence utilisateur final.
Le contenu de ce guide est fourni à titre d’information uniquement, peut faire l’objet de modifications sans préavis et ne saurait 
être considéré comme un engagement quelconque de la part d’Adobe Systems Incorporated. Adobe Systems Incorporated décline 
toute responsabilité quant aux erreurs ou imprécisions susceptibles d’apparaître dans les informations que présente ce guide.
Rappelez-vous que certaines illustrations ou images que vous souhaitez inclure dans votre projet peuvent être protégées par les lois 
de copyright. L’inclusion sans autorisation de tels éléments dans vos propres travaux peut porter atteinte aux droits du détenteur 
de ce copyright. Veillez à obtenir toutes les autorisations nécessaires auprès de ce dernier.
Toutes les références aux noms de sociétés dans les exemples de modèles sont fournies à titre d’illustration uniquement et ne 
visent aucune entreprise existante.
Adobe, le logo Adobe, Flex, Flex Builder et Flash Player sont des marques déposées ou des marques d’Adobe Systems 
Incorporated aux Etats-Unis et/ou dans d’autres pays.
ActiveX et Windows sont des marques ou des marques déposées de Microsoft Corporation aux Etats-Unis et dans d’autres pays. 
Macintosh est une marque d’Apple Inc., déposée aux Etats-Unis et dans d’autres pays. Toutes les autres marques sont la propriété 
de leurs détenteurs respectifs. 
Technologie de compression et décompression audio discours utilisée sous licence de Nellymoser, Inc. ().
Technologie de compression et décompression vidéo Sorenson™ Spark™ utilisée sous licence de 
Sorenson Media, Inc.
Navigateur Opera® Copyright © 1995-2002 Opera Software ASA et ses fournisseurs. Tous droits réservés.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, Californie 95110, E.-U.
Avis aux utilisateurs finaux dépendant du gouvernement des Etats-Unis. Le logiciel et la documentation sont des « articles 
commerciaux », selon la définition établie par l’article 48 C.F.R. §2.101, composés d’un « logiciel informatique commercial » et 
d’une « documentation de logiciel informatique commercial », tels que définis dans les articles 48 C.F.R. §12.212 ou 48 C.F.R. 
§227.7202, selon le cas. Conformément aux articles 48 C.F.R. §12.212 ou 48 C.F.R. §§227.7202-1 à 227.7202-4, selon le cas, le 
logiciel informatique commercial et la documentation de logiciel informatique commercial sont fournis sous licence aux 
utilisateurs finaux dépendant du gouvernement des Etats-Unis (a) comme articles commerciaux uniquement et (b) avec les seuls 
droits normalement accordés aux utilisateurs finaux, en accord avec les conditions générales applicables. Les droits non publiés 
sont réservés conformément aux lois sur le copyright en vigueur aux Etats-Unis. Adobe Systems Incorporated, 345 Park Avenue, 
San Jose, CA 95110-2704, E.-U. Pour les utilisateurs finaux ne dépendant pas du gouvernement des Etats-Unis, Adobe accepte 
de respecter toutes les lois applicables relatives à l’égalité des chances, y compris, s’il y a lieu, aux dispositions du décret 11246 et 
ses modifications, de la section 402 de la loi sur l’aide à la réhabilitation des vétérans du Vietnam (Vietnam Era Veterans 
Readjustment Assistance Act) de 1974 (38 USC 4212), de la section 503 de la loi de réhabilitation (Rehabilitation Act) de 1973 
et ses modifications, et des règlements des articles 41 CFR 60-1 à 60-60, 60-250 et 60-741. La clause relative à la discrimination 
positive et les régulations énoncées dans la phrase précédente sont incluses par référence.

Table des matières
A propos de ce manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Ressources ActionScript destinées à la formation . . . . . . . . . . . . . . . . . 19
Chapitre 1: Introduction à ActionScript 3.0  . . . . . . . . . . . . . . . . . . 21
Nouveautés d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  23
Fonctions API de Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  25
Compatibilité avec les versions précédentes . . . . . . . . . . . . . . . . . . . . . .27
Chapitre 2: Prise en main d’ActionScript . . . . . . . . . . . . . . . . . . .  29
Concepts de programmation de base . . . . . . . . . . . . . . . . . . . . . . . . . . .  29
Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Utilisation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  33
Evénements  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  35
Exemples de gestion d’événements . . . . . . . . . . . . . . . . . . . . . . . . . 41
Création d’instances d’objets  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  42
Création d’applications avec ActionScript . . . . . . . . . . . . . . . . . . . . . . .  50
Processus de développement ActionScript  . . . . . . . . . . . . . . . . . . .  55
3

Création de vos propres classes  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Suggestions d’organisation des classes  . . . . . . . . . . . . . . . . . . . . . . . 59
Exécution des exemples suivants  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Chapitre 3: Syntaxe et langage ActionScript  . . . . . . . . . . . . . . . .  71
Packages et espaces de nom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Conversions de type. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
Domaine de la fonction  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Chapitre 4: Programmation orientée objet en ActionScript. . . . 147
Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Les classes des éléments incorporés. . . . . . . . . . . . . . . . . . . . . . . . . 169
Exemple : GeometricShapes  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
4

Chapitre 5: Utilisation des dates et heures . . . . . . . . . . . . . . . . .  205
Exemple : une horloge analogique simple. . . . . . . . . . . . . . . . . . . . . . . .213
Chapitre 6: Utilisation des chaînes  . . . . . . . . . . . . . . . . . . . . . . . . 217
Exemple : ASCII art  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231
Chapitre 7: Utilisation de tableaux . . . . . . . . . . . . . . . . . . . . . . . .  239
Exemple : PlayList  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Chapitre 8: Gestion des erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
Gestion des erreurs dans ActionScript 3.0  . . . . . . . . . . . . . . . . . . . . .  277
Stratégies de gestion des erreurs. . . . . . . . . . . . . . . . . . . . . . . . . . . .  279
Réponse à des événements d’erreurs et au statut  . . . . . . . . . . . . . . . 288
5

Comparaison des classes Error . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292
Classes Error du package flash.error . . . . . . . . . . . . . . . . . . . . . . . . .296
Exemple : Application CustomErrors  . . . . . . . . . . . . . . . . . . . . . . . . . . .298
Chapitre 9: Utilisation d’expressions régulières  . . . . . . . . . . . .  305
Syntaxe d’expression régulière  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  309
Indicateurs et propriétés  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .322
Exemple : Un analyseur Wiki. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328
Chapitre 10: Gestion d’événements. . . . . . . . . . . . . . . . . . . . . . .  335
Exemple : un réveil. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  360
Chapitre 11: Utilisation de XML  . . . . . . . . . . . . . . . . . . . . . . . . . . .367
Exemple : Chargement de données RSS depuis Internet  . . . . . . . .  390
6

Chapitre 12: Programmation de l’affichage  . . . . . . . . . . . . . . . .  395
Utilisation des objets d’affichage  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Choix d’une sous-classe de DisplayObject  . . . . . . . . . . . . . . . . . . . .418
Manipulation des objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Redimensionnement et mise à l’échelle des objets . . . . . . . . . . . . 428
Contrôle de la distorsion lors de la mise à l’échelle . . . . . . . . . . 429
Mise en cache des objets d’affichage . . . . . . . . . . . . . . . . . . . . . . . . 432
Définition d’une couleur d’arrière-plan opaque  . . . . . . . . . . . . . 435
Modification des couleurs des objets d’affichage. . . . . . . . . . . . . .  437
Modification par code des effets de couleur et 
de luminosité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Masquage des objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Chargement dynamique de contenu à afficher  . . . . . . . . . . . . . . . . . . 446
Spécification du contexte de chargement . . . . . . . . . . . . . . . . . . . . 449
Exemple : SpriteArranger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .451
Chapitre 13: Utilisation de la géométrie. . . . . . . . . . . . . . . . . . . .  459
à un objet d’affichage  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
7

Chapitre 14: Utilisation de l’API de dessin  . . . . . . . . . . . . . . . . .  475
Exemple : générateur algorithmique d’effets visuels . . . . . . . . . . . . . . 491
Chapitre 15: Filtrage des objets d’affichage . . . . . . . . . . . . . . . .  495
Création et application de filtres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .497
Problèmes potentiels d’utilisation des filtres. . . . . . . . . . . . . . . . . .  500
Filtres d’affichage disponibles  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  502
Filtre mappage de déplacement  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514
Exemple : Filter Workbench . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  520
Chapitre 16: Utilisation des clips  . . . . . . . . . . . . . . . . . . . . . . . . . . 521
Contrôle de la lecture d’un clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  524
Utilisation des séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Création d’objets MovieClip à l’aide d’ActionScript. . . . . . . . . . . . . . .528
Exportation des symboles de bibliothèque pour 
ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .528
Exemple : RuntimeAssetsExplorer  . . . . . . . . . . . . . . . . . . . . . . . . . . . . .533
8

Chapitre 17: Utilisation de texte . . . . . . . . . . . . . . . . . . . . . . . . . .  539
Affichage du texte  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
Défilement du texte dans un champ texte  . . . . . . . . . . . . . . . . . . . . 546
Formatage du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .551
Formatage de plages de texte au sein d’un champ texte . . . . . . . 555
Exemple : formatage du texte dans le style « journal ». . . . . . . . . . . . 560
Modification de la taille de la police en fonction de 
la taille du champ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
Répartition du texte sur plusieurs colonnes . . . . . . . . . . . . . . . . . . .  567
Chapitre 18: Utilisation des graphismes bitmap . . . . . . . . . . . . . . 571
Manipulation des pixels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  577
Détection de collision au niveau des pixels  . . . . . . . . . . . . . . . . . . .  579
bitmap hors écran. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
Chapitre 19: Utilisation de la vidéo. . . . . . . . . . . . . . . . . . . . . . . .  587
Présentation de la classe Video  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
9

Contrôle de la lecture de la vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  594
Détection de la fin d’un flux vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . .  595
d’événements onCuePoint et onMetaData . . . . . . . . . . . . . . . . . . . . . .598
Définir la propriété « client » de l’objet NetStream 
comme Object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  599
Créer une classe et définir des méthodes pour gérer 
les méthodes de rappel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  600
Étendre la classe NetStream et lui ajouter des méthodes 
pour gérer les méthodes de rappel . . . . . . . . . . . . . . . . . . . . . . . . . 601
Définir la propriété « client » de l’objet NetStream 
comme this. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  604
de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  609
Envoi de vidéo à un serveur  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  617
Rubriques avancées : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  617
La configuration de fichier FLV pour l’hébergement sur 
un serveur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
Le ciblage des fichiers FLV locaux sur Macintosh  . . . . . . . . . . . . . 619
Exemple : Video Jukebox  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
Chapitre 20: Utilisation du son  . . . . . . . . . . . . . . . . . . . . . . . . . . .627
Utilisation de fichiers audio de lecture en continu  . . . . . . . . . . . . . . . . 637
10

Lecture de sons  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
Arrêt de sons diffusés en continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
Capture de l’entrée de son . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .651
Acheminement de l’audio du microphone vers des 
haut-parleurs locaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652
Envoi d’audio vers et depuis une passerelle multimédia . . . . . . . . 655
Exemple : Podcast Player. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
Simplification de la lecture et du chargement du son 
à l’aide de la classe SoundFacade  . . . . . . . . . . . . . . . . . . . . . . . .  657
Extension de l’exemple Podcast Player . . . . . . . . . . . . . . . . . . . . . . 663
Chapitre 21: Capture des données saisies par l’utilisateur . . . .  665
Exemple : WordSearch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  675
Chapitre 22: Réseau et communication . . . . . . . . . . . . . . . . . . .  679
Exemple : chargement et téléchargement de fichiers  . . . . . . . . . . . . . 721
11

Chapitre 23: Environnement du système client. . . . . . . . . . . . . . 731
Exemple : détection des capacités du système  . . . . . . . . . . . . . . . . . . 746
Chapitre 24: Impression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751
Exemple : Redimensionnement, recadrage et ajustement . . . . . . . . . 764
Chapitre 25: Utilisation de l’API externe  . . . . . . . . . . . . . . . . . . .767
Utilisation de la classe ExternalInterface  . . . . . . . . . . . . . . . . . . . . . . . . 773
Format XML de l’API externe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777
ActiveX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787
Chapitre 26: La sécurité dans Flash Player . . . . . . . . . . . . . . . . .797
SWF importés dans un domaine de sécurité  . . . . . . . . . . . . . . . . . . . .832
12

à la souris et au clavier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838
Index  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  839
13

14

A propos de ce manuel
Ce manuel peut servir de base au développement d’applications avec ActionScript™ 3.0. 
Il est préférable de maîtriser les concepts de programmation généraux (types de données, 
variables, boucles et fonctions) afin de mieux comprendre les idées et techniques décrites. 
Il est également conseillé de comprendre les concepts de programmation orientés objet (classes 
et héritage). La connaissance d’ActionScript 1.0 ou ActionScript 2.0 est utile mais pas 
nécessaire.
Contenu
Utilisation de ce manuel  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  16
Accès à la documentation ActionScript  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17
Ressources ActionScript destinées à la formation . . . . . . . . . . . . . . . . . . . . . . . . . . . .  19
15

Utilisation de ce manuel
Les chapitres de ce manuel sont structurés en groupes logiques (indiqués ci-dessous) afin de 
faciliter la recherche de sections de documentation ActionScript connexes : 
Chapitres
Description
Chapitres 1 à 4, présentation de la 
Décrit les concepts ActionScript 3.0 de base, y 
programmation avec ActionScript
compris la syntaxe, les instructions et les 
opérateurs du langage, la spécification de 
langage ECMAScript version 4, la 
programmation ActionScript orientée objet et la 
nouvelle façon de gérer des objets d’affichage 
sur la liste d’affichage Adobe® Flash® Player 9.
Chapitres 5 à 10, classes et types de 
Décrit les types de données de niveau supérieur 
données ActionScript 3.0 de base
dans ActionScript 3.0 qui font également partie 
de la spécification ECMAScript.
Chapitres 11 à 26, API de Flash Player
Décrit les fonctions importantes mises en 
œuvre dans des packages et des classes 
propres à Adobe Flash Player 9, notamment 
la gestion d’événements, la mise en réseau et 
les communications, le fichier d’E/S, 
l’interface externe, le modèle de sécurité de 
l’application, etc.
Ce manuel contient également de nombreux fichiers d’exemple qui décrivent des concepts de 
programmation d’applications pour des classes importantes ou couramment utilisées. 
Les fichiers d’exemple sont préparés de façon à ce que vous puissez les charger et les utiliser 
plus facilement avec Adobe® Flash® CS3 Professional. Ils peuvent inclure des fichiers 
enveloppes. Néanmoins, l’exemple de code de base est du code ActionScript 3.0 pur que vous 
pouvez utiliser dans l’environnement de développement de votre choix.
ActionScript 3.0 peut être écrit et compilé de plusieurs façons différentes :
?
En utilisant l’environnement de développement d’Adobe Flex Builder 2
?
En utilisant un éditeur de texte et un compilateur de ligne de commande (celui fourni 
avec Flex Builder 2, par exemple)
?
En utilisant l’outil de programmation Adobe® Flash® CS3 Professional
Pour plus d’informations sur les environnements de développement d’ActionScript, voir 
Chapitre 1, « Introduction à ActionScript 3.0 ».
16
A propos de ce manuel

Pour comprendre les exemples de code fournis dans ce manuel, vous n’avez pas besoin de 
savoir utiliser les environnements de développement intégrés pour ActionScript (Flex Builder 
ou l’outil de création Flash, par exemple). En revanche, vous pouvez consulter la 
documentation relative à ces outils pour savoir comment les utiliser pour écrire et compiler du 
code ActionScript 3.0. Pour plus d’informations, voir ActionScript », à la page 17.
Accès à la documentation ActionScript
Etant donné que ce manuel traite principalement de la description d’ActionScript 3.0 qui est 
un langage de programmation orienté objet riche et puissant, il ne décrit pas de façon détaillée 
le processus de développement de l’application ou le flux de travail au sein d’une architecture 
serveur ou d’un outil particulier. Par conséquent, outre la Programmation avec ActionScript 
3.0
, vous pouvez consulter d’autres sources de documentation lorsque vous concevez, 
développez, testez et déployez des applications ActionScript 3.0.
Documentation ActionScript 3.0
Ce manuel décrit les concepts qui sous-tendent le langage de programmation ActionScript 3.0 
et fournit des détails et des exemples d’implémentation illustrant les fonctions importantes du 
langage. Néanmoins, il ne constitue pas un guide de référence du langage complet. Pour cela, 
consultez la Référence du langage et des composants ActionScript 3.0, qui décrit chaque classe, 
chaque méthode, chaque propriété et chaque événement dans le langage. La Référence du 
langage et des composants ActionScript 3.0
 fournit des informations de référence détaillées sur le 
langage de base, les composants Flash (dans les packages fl) et les API de Flash Player (dans les 
packages flash).
Documentation Flash
Si vous utilisez l’environnement de développement Flash, vous pouvez consulter les manuels 
suivants :
Manuel
Description
Utilisation de Flash
Décrit comment développer vos applications 
Web dynamiques dans l’environnement de 
programmation de Flash
Programmation avec ActionScript 3.0
Décrit l’utilisation spécifique du langage 
ActionScript 3.0 et de l’API de base de 
Flash Player
Accès à la documentation ActionScript
17

Manuel
Description
Référence du langage et des composants 
Fournit des exemples de code, d’utilisation et 
ActionScript 3.0
de syntaxe pour les composants de Flash et 
l’API d’ActionScript 3.0
Utilisation des composants ActionScript 3.0
Explique comment utiliser les composants pour 
développer des applications Flash
Formation à ActionScript 2.0 dans 
Passe en revue les principes généraux de la 
Adobe Flash
syntaxe ActionScript 2.0 et explique comment 
utiliser ce langage pour intervenir sur différents 
types d’objet
Guide de référence du langage 
Fournit des exemples de code, d’utilisation et 
ActionScript 2.0
de syntaxe pour les composants de Flash et 
l’API d’ActionScript 2.0
Utilisation des composants ActionScript 2.0
Explique de façon détaillée comment utiliser les 
composants ActionScript 2.0 pour développer 
des applications Flash
Référence du langage des composants 
Décrit chaque composant disponible dans 
ActionScript 2.0
l’architecture des composants Adobe, version 
2, avec son API
Extension de Flash
Décrit les objets, les méthodes et les propriétés 
disponibles dans l’API de JavaScript
Prise en main de Flash Lite 2.x
Explique comment utiliser Adobe® Flash® Lite™ 
2.x pour développer des applications et fournit 
des exemples de code, d’utilisation et de 
syntaxe pour les fonctions ActionScript 
disponibles avec Flash Lite 2.x
Développement d’applications Flash Lite 2.0 Explique comment développer des applications 
Flash Lite 2.x
Introduction à ActionScript Flash Lite 2.x
Explique comment développer des applications 
avec Flash Lite 2.x et décrit toutes les fonctions 
ActionScript disponibles pour les développeurs 
de Flash Lite 2.x
Référence du langage ActionScript Flash 
Fournit des exemples de code, d’utilisation et 
Lite 2.x
de syntaxe pour l’API d’ActionScript 2.0 
disponible dans Flash Lite 2.x
Prise en main de Flash Lite 1.x
Présente Flash Lite 1.x et décrit comment tester 
votre contenu à l’aide de l’émulateur CS3 
d’Adobe® Device Central
18
A propos de ce manuel

Manuel
Description
Développement d’applications Flash Lite 1.x
Décrit comment développer des applications 
pour des périphériques mobiles à l’aide de 
Flash Lite 1.x
Formation à ActionScript Flash Lite 1.x
Explique comment utiliser ActionScript dans 
des applications Flash Lite 1.x et décrit toutes 
les fonctions ActionScript disponibles avec 
Flash Lite 1.x
Guide de référence du langage ActionScript 
Fournit la syntaxe et l’utilisation d’éléments 
Flash Lite 1.x
ActionScript disponibles avec Flash Lite 1.x
Ressources ActionScript destinées à 
la formation
Outre le contenu de ces manuels, Adobe fournit des articles, des idées de conception et 
des exemples mis à jour régulièrement dans le Pôle de développement et le Pôle de 
création Adobe.
Pôle de développement Adobe
Le Pôle de développement d’Adobe constitue votre ressource pour consulter les dernières 
informations concernant ActionScript, des articles sur le développement d’application et des 
informations sur des problèmes importants. Consultez le Pôle de développement à l’adresse 

Pôle de création Adobe
Consultez les dernières nouveautés en matière de design numérique et d’animations. 
Parcourez les œuvres d’artistes renommés, découvrez les nouvelles tendances de design et 
consolidez vos connaissances à l’aide de didacticiels, de flux de travail clés et de techniques 
avancées. Vérifiez deux fois par mois si de nouveaux didacticiels et articles ainsi que des pièces 
de galerie d’inspiration sont disponibles. Consultez le Pôle de création à l’adresse 

Ressources ActionScript destinées à la formation
19

20
A propos de ce manuel

CHAPITRE 1
Introduction à ActionScript 3.0
1
Ce chapitre offre une présentation générale d’ActionScript 3.0, la version la plus récente et la 
plus révolutionnaire d’ActionScript.
Contenu
A propos d’ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  21
Avantages d’ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Nouveautés d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Compatibilité avec les versions précédentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
A propos d’ActionScript
ActionScript est un langage de programmation destiné à l’environnement d’exécution 
d’Adobe Flash Player. Il assure l’interactivité, le traitement des données et bien d’autres 
fonctions du contenu Flash et dans les applications associées. 
ActionScript est exécuté par la machine virtuelle ActionScript, un composant de Flash Player. 
Le code ActionScript est généralement compilé en pseudo-code binaire (une sorte de langage de 
programmation écrit et compris par les ordinateurs) par un compilateur, par exemple celui 
intégré dans Adobe Flash CS3 Professional ou Adobe® Flex™ Builder™, ou celui fourni dans le 
kit de développement Adobe® Flex™ SDK et les services de données Flex™ Data Services. 
Le pseudo-code binaire est incorporé aux fichiers SWF, qui sont exécuté par Flash Player dans 
l’environnement d’exécution.
ActionScript 3.0 constitue un modèle de programmation solide, bien connu des développeurs 
dotés des connaissances élémentaires de la programmation orientée objet. Les fonctions 
principales d’ActionScript 3.0 sont les suivantes : 
?
Une nouvelle machine virtuelle ActionScript, nommée AVM2, qui exploite un nouveau 
jeu d’instructions de pseudo-code binaire et améliore grandement les performances.
21

?
Une base de code de compilation plus moderne, davantage en accord avec la norme 
ECMAScript (ECMA 262) et qui accomplit de meilleures optimisations que les versions 
antérieures du compilateur.
?
Une interface de programmation (API) étendue et améliorée, avec contrôle de bas niveau 
des objets et un véritable modèle orienté objet.
?
Un langage de base reposant sur la future version 4 de la spécification ECMAScript 
(ECMA-262).
?
Une API XML reposant sur la spécification ECMAScript pour XML (E4X) (ECMA-357 
niveau 2). E4X est une extension de langage d’ECMAScript qui ajoute XML comme type 
de données natif.
?
Un modèle d’événements fondé sur la spécification d’événements du modèle d’objet de 
document (DOM, Document Object Model) niveau 3.
Avantages d’ActionScript 3.0
Les possibilités d’ActionScript 3.0 dépassent largement les fonctions de programmation des 
versions précédentes. Cette version est conçue pour faciliter la création d’applications très 
complexes impliquant d’importants jeux de données et des bases de code orientées objet et 
réutilisables. Si ActionScript 3.0 n’est pas indispensable à l’exécution de contenu dans Adobe 
Flash Player 9, il ouvre néanmoins la voie à des améliorations de performance uniquement 
disponibles dans AVM2, la nouvelle machine virtuelle. Le code d’ActionScript 3.0 peut 
s’exécuter jusqu’à dix fois plus vite que le code des versions antérieures d’ActionScript.
L’ancienne version de la machine virtuelle, AVM1, exécute le code ActionScript 1.0 et 
ActionScript 2.0. Elle est prise en charge par Flash Player 9 pour assurer la compatibilité 
ascendante avec le contenu existant. Pour plus d’informations, voirversions précédentes », à la page 27.
22
Introduction à ActionScript 3.0

Nouveautés d’ActionScript 3.0
Bien que de nombreuses classes et fonctions d’ActionScript 3.0 seront familières aux 
programmeurs d’ActionScript, son architecture et sa conceptualisation diffèrent des versions 
précédentes. Parmi les améliorations d’ActionScript 3.0, on compte de nouvelles fonctions du 
langage de base et une API Flash Player avancée, qui accroît le contrôle des objets de bas 
niveau.
Fonctions du langage de base
Le langage de base définit les éléments de construction fondamentaux du langage de 
programmation, par exemple les arguments, expressions, conditions, boucles et types. 
ActionScript 3.0 contient de nombreuses fonctions qui accélèrent le processus de 
développement.
Exceptions d’exécution
ActionScript 3.0 peut signaler davantage de conditions d’erreur que les versions précédentes 
d’ActionScript. Utilisées pour les conditions d’erreur courantes, les exceptions d’exécution 
améliorent la procédure de débogage et vous permettent de développer des applications 
susceptibles de gérer les erreurs de manière fiable. Les erreurs d’exécution peuvent fournir des 
traces d’empilement qui identifient le fichier source et le numéro de ligne, pour un repérage 
plus rapide des erreurs.
Types d’exécution
Dans ActionScript 2.0, les annotations de type visaient avant tout à aider le développeur ; lors 
de l’exécution, toutes les valeurs étaient typées dynamiquement. Dans ActionScript 3.0, les 
informations de type sont préservées lors de l’exécution et utilisées à plusieurs fins. Flash 
Player 9 effectue une vérification du type d’exécution afin d’améliorer la sécurité du système 
quant aux types. Les informations de type servent également à représenter les variables dans les 
représentations machine natives, ce qui accroît les performances et réduit l’utilisation de la 
mémoire. 
Nouveautés d’ActionScript 3.0
23

Classes scellées
ActionScript 3.0 introduit le concept de classe scellée. Une telle classe possède uniquement un 
jeu fixe de propriétés et de méthodes, définies lors de la compilation. Il est impossible 
d’ajouter d’autres propriétés et méthodes. Ainsi, la vérification effectuée au moment de la 
compilation est plus stricte et garantit une plus grande robustesse des programmes. 
L’utilisation de la mémoire est également optimisée puisque la table de hachage n’est pas 
requise pour chaque instance d’objet. Les classes dynamiques sont également disponibles, par 
le biais du mot-clé dynamic. Bien que scellées par défaut, toutes les classes d’ActionScript 3.0 
peuvent être déclarées dynamiques grâce au mot-clé dynamic.
Fermetures de méthodes
ActionScript 3.0 permet l’utilisation d’une fermeture de méthode qui se rappelle 
automatiquement l’instance de l’objet d’origine. Cette fonction s’avère utile dans le traitement 
des événements. Dans ActionScript 2.0, les fermetures de méthode ne gardaient pas la trace de 
l’instance d’objet à partir de laquelle il était extrait, ce qui provoquait un comportement 
inattendu lors de l’appel de la fermeture de méthode. La classe mx.utils.Delegate était une 
solution prisée, qui n’est désormais plus nécessaire. 
ECMAScript pour XML (E4X)
ActionScript 3.0 intègre ECMAScript pour XML (E4X), récemment normalisé sous le nom 
ECMA-357. E4X offre un jeu d’éléments de langage naturels et courants qui permettent de 
manipuler XML. Contrairement aux API classiques d’analyse XML, XML et E4X 
fonctionnent à la manière d’un type de données natif du langage. E4X simplifie le 
développement d’applications exploitant XML grâce à une réduction drastique du volume de 
code requis. Pour plus d’informations sur l’intégration d’E4X dans ActionScript 3.0, voir 
Chapitre 11, « Utilisation de XML », à la page 367. 
Pour visualiser la spécification E4X d’ECMA, consultez le site .
Expressions régulières
ActionScript 3.0 inclut une prise en charge native des expressions régulières afin d’accélérer la 
recherche et la manipulation des chaînes. Dans ActionScript 3.0, cette prise en charge suit la 
version 3 de la spécification de langage ECMAScript (ECMA-262).
24
Introduction à ActionScript 3.0

Espaces de noms
Les espaces de noms sont semblables aux spécificateurs d’accès classiques qui assurent le 
contrôle de visibilité des déclarations (public, private, protected). Ils fonctionnent 
comme des spécificateurs d’accès personnalisés, qui portent le nom de votre choix. Les espaces 
de noms sont dotés d’un identifiant de ressource universel (URI, Universal Resource 
Identifier) afin d’éviter les collisions. Ils servent également à représenter les espaces de noms 
XML en cas d’utilisation d’E4X. 
Nouveaux types de primitives
ActionScript 2.0 utilise un seul type numérique, Number, un nombre en virgule flottante à 
deux décimales. ActionScript 3.0 comprend les types int et uint. Le type int est un entier signé 
32 bits qui permet au code ActionScript de profiter de la rapidité de traitement mathématique 
de l’unité centrale. Il s’avère pratique pour les compteurs de boucles et les variables utilisant 
des entiers. Le type uint est un type d’entier non signé 32 bits, utile pour les valeurs de 
couleurs RVB, les compteurs d’octets, etc.
Fonctions API de Flash Player
L’API Flash Player d’ActionScript 3.0 contient un grand nombre de nouvelles classes qui vous 
permettent de contrôler les objets de bas niveau. L’architecture du langage est complètement 
nouvelle et plus intuitive. Ces nouvelles classes étant trop nombreuses pour autoriser une 
présentation détaillée à ce stade, les sections ci-après mettent en avant quelques changements 
significatifs.
Modèle d’événements DOM3 
Le modèle d’événements Document Object Model de niveau 3 (DOM3) offre une méthode 
standard de génération et de traitement des messages d’événement, qui permet aux objets 
composant les applications d’interagir et de communiquer tout en conservant leur état et en 
réagissant aux changements. Etabli à partir des spécifications d’événements DOM niveau 3 du 
World Wide Web Consortium, ce modèle fournit un mécanisme plus clair et plus efficace que 
les systèmes d’événement disponibles dans les versions antérieures d’ActionScript. 
Les événements et événements d’erreur se trouvent dans le package flash.events. La structure 
des composants Flash utilise le même modèle d’événements que l’API de Flash Player ; ainsi le 
système d’événements est unifié sur l’ensemble de la plate-forme Flash.
Nouveautés d’ActionScript 3.0
25

API de liste d’affichage
L’API d’accès à la liste d’affichage Flash Player, c’est-à-dire l’arborescence contenant tous les 
éléments visuels d’une application Flash, est constituée de classes permettant de manipuler les 
primitives visuelles dans Flash.
La nouvelle classe Sprite est un élément de construction léger, semblable à la classe MovieClip 
mais plus adaptée à la classe de base des composants d’interface. La nouvelle classe Shape 
représente des formes vectorielles brutes. Il est possible d’instancier ces classes naturellement à 
l’aide de l’opérateur new, mais aussi de les redéfinir dynamiquement comme parent à tout 
moment. 
Grâce à la gestion de profondeur désormais automatique et intégrée à Flash Player, le rendu 
d’affectation de numéros de profondeur n’est plus nécessaire. De nouvelles méthodes 
permettent de spécifier et de gérer l’ordre z des objets.
Gestion des données et contenus dynamiques
ActionScript 3.0 comprend des mécanismes de chargement et de gestion des actifs et des 
données au sein de l’application Flash qui se caractérisent par leur intuitivité et leur cohérence 
dans l’ensemble de l’API. La nouvelle classe Loader propose un unique mécanisme de 
chargement des fichiers SWF et des actifs d’image, et permet d’accéder à des informations 
détaillées sur le contenu chargé. La classe URLLoader offre un mécanisme distinct de 
chargement du texte et des données binaires dans les applications orientées données. La classe 
Socket permet la lecture et l’écriture des données binaires dans les sockets de serveur, quel que 
soit le format.
Accès aux données de bas niveau
De nombreuses API permettent d’accéder à des données de bas niveau jusqu’ici indisponibles 
dans ActionScript. Pour le téléchargement de données, la classe URLStream, mise en oeuvre 
par URLLoader, donne accès aux données sous forme binaire brute pendant le 
téléchargement. Avec la classe ByteArray, vous pouvez optimiser la lecture, l’écriture et la 
manipulation des données binaires. La nouvelle API Sound assure le contrôle précis du son 
par le biais des classes SoundChannel et SoundMixer. De nouvelles API liées à la sécurité 
fournissent des informations sur les droits de sécurité d’un fichier SWF ou du contenu chargé, 
pour une gestion plus efficace des erreurs de sécurité.
26
Introduction à ActionScript 3.0

Utilisation du texte
ActionScript 3.0 contient un package  destiné à l’ensemble des API relatives au texte. 
La classe TextLineMetrics fournit des dimensions détaillées pour les lignes de texte d’un 
champ texte ; elle remplace la méthode TextField.getLineMetrics() dans ActionScript 
2.0. La classe TextField contient plusieurs nouvelles méthodes de bas niveau intéressantes, qui 
peuvent fournir des informations spécifiques sur une ligne de texte ou un simple caractère 
dans un champ texte. Parmi ces méthodes, on compte notamment les suivantes : 
getCharBoundaries(), qui renvoie un rectangle représentant le cadre de sélection d’un 
caractère, getCharIndexAtPoint(), qui renvoie l’index d’un caractère à un point donné et 
getFirstCharInParagraph(), qui renvoie l’index du premier caractère d’un paragraphe. 
Les méthodes de niveau de ligne incluent getLineLength(), qui renvoie le nombre de 
caractères d’une ligne de texte donnée, et getLineText(), qui renvoie le texte de la ligne 
spécifiée. La nouvelle classe Font permet de gérer les polices incorporées des fichiers SWF.
Compatibilité avec les versions 
précédentes
Comme toujours, Flash Player garantit une compatibilité totale avec les versions précédentes 
et les contenus publiés antérieurement. Tous les contenus lisibles dans les anciennes versions 
de Flash Player s’exécutent dans Flash Player 9. L’introduction d’ActionScript 3.0 dans cette 
dernière version présente cependant quelques problèmes d’interopérabilité entre les contenus 
anciens et nouveaux lus dans Flash Player 9. Les problèmes de compatibilité sont les suivants :
?
Un même fichier SWF ne peut combiner du code ActionScript 1.0 ou 2.0 et du code 
ActionScript 3.0.
?
Le code ActionScript 3.0 peut charger un fichier SWF écrit en ActionScript 1.0 ou 2.0, 
mais ne peut accéder aux variables et fonctions de ce fichier.
?
Les fichiers SWF écrits en ActionScript 1.0 ou 2.0 ne peuvent charger des fichiers SWF 
écrits en ActionScript 3.0. Cela a pour conséquence que les fichiers SWF créés dans Flash 
8 ou Flex Builder version 1.5 ou antérieure ne peuvent charger des fichiers SWF 
ActionScript 3.0.
Il existe une seule exception à cette règle : un fichier SWF ActionScript 2.0 peut se 
remplacer par un fichier SWF ActionScript 3.0 à condition que le fichier ActionScript 2.0 
n’est effectué aucun chargement à quelque niveau que ce soit. Pour ce faire, le fichier SWF 
ActionScript 2.0 doit appeler loadMovieNum() et passer la valeur 0 au paramètre level.
Compatibilité avec les versions précédentes
27

?
En général, les fichiers SWF écrits en ActionScript 1.0 ou 2.0 doivent faire l’objet d’une 
migration s’ils sont destinés à fonctionner avec des fichiers SWF écrits en ActionScript 
3.0. Imaginez par exemple que vous ayez créé un lecteur de média avec ActionScript 2.0. 
Ce lecteur peut charger de nombreux contenus également créés à l’aide d’ActionScript 2.0. 
Mais vous ne pouvez pas créer un contenu avec ActionScript 3.0 et le charger dans ce 
lecteur. Vous devez migrer le lecteur vers ActionScript 3.0.
Néanmoins, si vous avez créé un lecteur de média avec ActionScript 3.0, ce lecteur peut 
effectuer de simples chargements de votre contenu ActionScript 2.0.
Le tableau ci-après récapitule les limitations des versions précédentes de Flash Player relatives 
au chargement de nouveaux contenus et à l’exécution de code, ainsi que les restrictions liées à 
la programmation croisée entre les fichiers SWF écrits avec différentes versions d’ActionScript.
Fonctionnalité prise 
Environnement d’exécution
en charge
Flash Player 7
Flash Player 8
Flash Player 9
Peut charger les fichiers 
version 7 et 
version 8 et 
version 9 et antérieure
SWF pour
antérieure
antérieure
Machine virtuelle incluse
AVM1
AVM1
AVM1 et AVM2
Exécute les fichiers SWF 
1.0 et 2.0
1.0 et 2.0
1.0, 2.0 et 3.0
écrits en ActionScript
Fonctionnalité prise 
Contenu créé dans
en charge*
ActionScript 1.0 et 2.0
ActionScript 3.0
Peut charger du contenu 
ActionScript 1.0 et 2.0 et 
et exécuter le code de 
ActionScript 1.0 et 2.0 uniquement
ActionScript 3.0
contenus créé dans
Peut programmer le 
ActionScript 1.0 et 2.0 uniquement†
ActionScript 3.0‡
contenu créé dans 
*
Contenu lisible dans Flash Player version 9 ou ultérieure. Le contenu lisible dans Flash 
Player version 8 ou antérieure peut être chargé, affiché, exécuté et programmé avec 
ActionScript 1.0 et 2.0 uniquement.

ActionScript 3.0 via LocalConnection

ActionScript 1.0 et 2.0 via LocalConnection
28
Introduction à ActionScript 3.0

CHAPITRE 2
Prise en main d’ActionScript
2
Ce chapitre vise à vous familiariser avec la programmation d’ActionScript et à vous offrir les 
informations nécessaires à la compréhension des concepts et des exemples présentés dans le 
reste de ce manuel. Nous commencerons par évoquer les concepts de base de la 
programmation, tels qu’ils s’appliquent à ActionScript. Nous verrons aussi les principes 
fondamentaux qui régissent l’organisation et la construction d’une application ActionScript.
Contenu
Concepts de programmation de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Utilisation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Eléments de programme courants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Exemple : Elément de portfolio d’animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Création d’applications avec ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Création de vos propres classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Exemple : Création d’une application de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Exécution des exemples suivants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Concepts de programmation de base
ActionScript étant un langage de programmation, il vous sera plus facile de l’apprendre si vous 
maîtrisez déjà quelques concepts généraux de programmation.
Quel est le rôle d’un programme informatique
Pour commencer, il est intéressant d’avoir une idée conceptuelle de la nature et du rôle d’un 
programme informatique. Un tel programme présente deux aspects principaux :
?
Il s’agit d’une série d’instructions ou d’étapes que l’ordinateur doit effectuer.
?
Chaque étape implique à terme la manipulation d’informations ou de données.
29

Dans un sens général, un programme informatique n’est rien d’autre qu’une liste d’actions pas 
à pas que vous ordonnez à l’ordinateur, qui les exécute une à une. Chacune de ces actions 
représente une instruction. Comme vous le verrez tout au long de ce manuel, dans 
ActionScript, chaque instruction se termine par un point-virgule.
Par nature, le seul rôle d’une instruction d’un programme consiste à manipuler quelques 
données stockées dans la mémoire de l’ordinateur. Voici un exemple simple : vous pouvez 
demander à l’ordinateur d’ajouter deux nombres et de stoker le résultat dans sa mémoire. 
Dans un cas de figure plus compliqué, imaginez un rectangle dessiné sur l’écran ; vous écrivez 
un programme pour le déplacer à un autre endroit de l’écran. L’ordinateur garde une trace de 
certaines informations relatives au rectangle : les coordonnées x, y de sa position, sa largeur et 
sa longueur, sa couleur, etc. Chacune de ces informations est stockée dans la mémoire de 
l’ordinateur. Un programme qui déplacerait le rectangle vers un autre emplacement 
comprendrait des procédures du type « remplacer la coordonnée x par 200, remplacer la 
coordonnée y par 150 », c’est-à-dire qui spécifieraient de nouvelles valeurs pour les 
coordonnées x et y. Bien entendu, l’ordinateur agit sur ces données pour effectivement 
modifier l’image à l’écran en fonction de ces chiffres. Cependant, pour ce qui nous intéresse, il 
est suffisant de savoir que le déplacement d’un rectangle sur l’écran n’implique réellement que 
la modification de quelques bits de données dans la mémoire de l’ordinateur.
Variables et constantes
La programmation reposant sur la modification d’informations dans la mémoire de 
l’ordinateur, il est nécessaire d’établir une représentation de chaque information au sein du 
programme. Une variable est un nom qui représente une valeur dans la mémoire de 
l’ordinateur. Lorsque l’on écrit des instructions visant à manipuler des valeurs, on écrit le nom 
de la variable plutôt que la valeur. Chaque fois que l’ordinateur rencontre le nom de la variable 
dans le programme, il cherche dans sa mémoire la valeur à utiliser. Si vous disposez par 
exemple de deux variables nommées value1 et value2, chacune contenant un nombre, vous 
pouvez additionner ces deux nombres à l’aide de l’instruction suivante :
value1 + value2
Lorsqu’il exécute véritablement la procédure, l’ordinateur recherche les valeurs correspondant 
à chaque variable et les ajoute.
Dans ActionScript 3.0, une variable se compose de trois éléments :
?
La nom de la variable
?
Le type de données qui peut être stocké dans la variable
?
La valeur réelle stockée dans la mémoire de l’ordinateur
30
Prise en main d’ActionScript

Nous venons de voir comment l’ordinateur utilise le nom comme une balise d’emplacement 
destinée à la valeur. Le type de données a également une importance. Lorsque vous créez une 
variable ActionScript, vous spécifiez le type de données qu’elle contiendra. A partir de là, les 
instructions de votre programme peuvent uniquement stocker ce type de données dans la 
variable considérée et la valeur peut être manipulée selon les caractéristiques associées à ce type 
de données. Dans ActionScript, la création d’une variable (on parle également de déclaration 
de variable) s’effectue à l’aide de l’instruction var :
var value1:Number;
Dans ce cas, nous indiquons à l’ordinateur qu’il doit créer une variable value1, qui 
contiendra uniquement des données Number, un type de données spécialement défini dans 
ActionScript. Il est possible de stocker immédiatement une valeur dans la variable :
var value2:Number = 17;
Adobe Flash CS3 Professional offre une autre méthode de déclaration des variables. Lorsque 
vous placez un symbole de clip, un symbole de bouton ou un champ texte sur la scène, vous 
pouvez lui attribuer un nom d’occurrence dans l’inspecteur Propriétés. Derrière les séquences, 
Flash crée une variable du même nom que le nom d’occurrence, que vous pouvez utiliser dans 
votre code ActionScript pour faire référence à l’élément de la scène. Par exemple, si un 
symbole de clip se trouve sur la scène et que vous lui attribuez le nom d’occurrence 
rocketShip, chaque fois que vous utilisez la variable rocketShip dans votre code 
ActionScript, c’est en fait ce clip que vous manipulez.
Types de données
Dans ActionScript, de nombreux types de données sont à votre disposition pour la création de 
variables. Certains d’entre eux peuvent être considérés comme « simples » ou 
« fondamentaux » :
?
String  : une valeur textuelle, telle qu’un nom ou le texte d’un chapitre de livre
?
Numeric : ActionScript 3.0 inclut trois types de données spécifiques aux valeurs 
numériques :
?
Number : toute valeur numérique, y compris les valeurs avec ou sans fraction
?
int : un nombre entier (sans fraction)
?
uint : un nombre entier « non signé », c’est-à-dire un nombre qui ne peut être négatif
?
Boolean : une valeur vrai/faux, qui indique par exemple si une instruction Switch est 
active ou si deux valeurs sont égales
Concepts de programmation de base
31

Les types de données simples représentent une seule information : par exemple, un seul 
nombre ou une seule séquence de texte. Cependant, la majorité des types de données définis 
dans ActionScript peuvent être considérés comme complexes puisqu’ils représentent un 
ensemble de valeurs regroupées. Par exemple, une variable du type Date représente une valeur 
unique, un point temporel. Néanmoins, la valeur de date est représentée par différentes 
valeurs : le jour, le mois, l’année, les heures, les minutes, les secondes, etc., et toutes 
correspondent à des nombres distincts. Ainsi, bien que nous percevions une date comme une 
valeur unique (et qu’il soit possible de la traiter comme telle en créant une variable Date), 
l’ordinateur, en interne, la considère comme un groupe de valeurs qui, ensemble, définissent 
une seule date.
La plupart des types de données intégrés et ceux créés par les programmeurs, sont des types de 
date complexes. Voici quelques exemples de types de données complexes que vous pourriez 
rencontrer :
?
MovieClip : un symbole de clip
?
TextField : un champ texte dynamique ou saisi
?
SimpleButton : un symbole de bouton
?
Date : une information relative à un point temporel (date et heure)
Deux termes sont souvent utilisés comme synonymes de type de données : classe et objet. 
Une classe est tout simplement la définition d’un type de données. Il s’agit d’un modèle 
applicable à tous les types d’objets du type de données, comme si l’on déclarait : « toutes les 
variables du type de données Exemple présentent les caractéristiques suivantes : A, B et C ». A 
l’inverse, un objet n’est qu’une instance de classe : une variable dont le type de données est 
MovieClip peut être décrite comme un objet MovieClip. Les exemples ci-après décrivent la 
même chose :
?
Le type de données de la variable myVariable est Number.
?
La variable myVariable est une instance de Number.
?
La variable myVariable est un objet Number.
?
La variable myVariable est une instance de la classe Number.
32
Prise en main d’ActionScript

Utilisation des objets
ActionScript constitue ce que l’on appelle un langage de programmation orienté objet. 
Ce terme désigne une simple approche de la programmation, rien d’autre qu’une manière 
d’organiser le code d’un programme à l’aide d’objets.
Nous avons défini plus haut un programme informatique comme une série de procédures ou 
d’instructions que l’ordinateur effectue. Nous pouvons alors considérer qu’un programme 
informatique n’est qu’une longue liste d’instructions. Dans le cas de la programmation 
orientée objet, les instructions du programme se divisent néanmoins en différents objets : le 
code étant rassemblé en groupes de fonctionnalités, un même conteneur réunit des types de 
fonctionnalités et des informations connexes. 
En fait, si vous avez travaillé avec des symboles dans Flash, vous savez déjà manipuler les 
objets. Imaginons que vous ayez défini un symbole de clip, par exemple le dessin d’un 
rectangle, et que vous en ayez placé une copie sur la scène. Ce symbole de clip constitue aussi 
un objet (au sens littéral) dans ActionScript ; il s’agit d’une instance de la classe MovieClip. 
Vous avez la possibilité de modifier plusieurs caractéristiques du clip. S’il est sélectionné, vous 
pouvez par exemple modifier certaines valeurs de l’inspecteur Propriétés, telles que la 
coordonnée x ou la largeur, ou encore différents réglages de couleur comme la transparence 
alpha ou l’application d’un filtre d’ombre portée. D’autres outils Flash vous permettent 
d’effectuer davantage de modifications, par exemple l’outil Transformer librement pour faire 
pivoter le rectangle. Toutes ces actions de transformation du symbole de clip disponibles dans 
l’environnement de programmation de Flash sont également disponibles dans ActionScript. 
Pour les utiliser, vous devez modifier les données réunies dans un ensemble appelé objet 
MovieClip.
Dans la programmation orientée objet que propose ActionScript, chaque classe comprend 
trois types de caractéristiques :
?
Propriétés
?
Méthodes
?
Evénements
Pris ensemble, ces éléments servent à gérer les données que le programme utilise, et à 
déterminer les actions à exécuter ainsi que l’ordre d’exécution.
Utilisation des objets
33

Propriétés
Une propriété représente l’une des données réunies dans un objet. Un objet song, par 
exemple, peut présenter des propriétés nommées artist et title. La classe MovieClip 
possède des propriétés telles que rotation, x, width et alpha. Les propriétés s’utilisent 
comme des variables individuelles ; on pourrait même envisager les propriétés comme les 
variables « enfant » d’un objet. 
Voici des exemples de code ActionScript utilisant des propriétés. Cette ligne de code déplace 
le MovieClip nommé square vers la coordonnée x 100 pixels :
square.x = 100;
Le code ci-après utilise la propriété rotation pour faire pivoter le MovieClip square de 
manière à lui donner la même orientation que le MovieClip triangle :
square.rotation = triangle.rotation;
Ce code altère l’échelle horizontale du MovieClip square pour qu’il soit une fois et demie 
plus large que précédemment :
square.scaleX = 1.5;
Vous remarquerez la structure commune : vous utilisez une variable (square, triangle) pour 
nommer l’objet, suivie d’un point (.), puis le nom de la propriété (x, rotation, scaleX). 
Le point, ou opérateur point, sert à indiquer que vous accédez à l’un des éléments enfant d’un 
objet. La structure dans son ensemble, « nom de variable-point-nom de propriété » est utilisée 
telle une variable, comme le nom d’une valeur unique dans la mémoire de l’ordinateur.
Méthodes
Une méthode est une action qui peut être effectuée par un objet. Par exemple, si vous avez 
élaboré dans Flash un symbole de clip dont le scénario contient plusieurs cadres et 
animations, ce clip peut être lu ou arrêté, ou recevoir l’instruction de placer la tête de 
lecture sur un cadre donné.
Le code ci-dessous indique au MovieClip nommé shortFilm de commencer la lecture :
();
Cette ligne de code arrête la lecture du MovieClip shortFilm (la tête de lecture s’arrête à 
l’endroit où elle se trouve, comme lorsque vous suspendez une vidéo) :
();
Ce code-ci indique au MovieClip shortFilm de placer la tête de lecture sur Frame 1 et 
d’arrêter la lecture (comme si vous rembobiniez une vidéo) :
shortFilm.gotoAndStop(1);
34
Prise en main d’ActionScript

Comme vous pouvez le constater, l’accès aux méthodes, comme pour les propriétés, s’effectue 
en écrivant le nom de l’objet (une variable), suivi d’un point puis du nom de la méthode et de 
parenthèses. Les parenthèses servent à indiquer que vous appelez la méthode , c’est-à-dire que 
vous demandez à l’objet d’effectuer une action. Certaines valeurs (ou variables) sont placées 
dans ces parenthèses de manière à transmettre des informations supplémentaires nécessaires à 
l’exécution de l’action. On appelle ces valeurs des paramètres de méthode. Par exemple, la 
méthode gotoAndStop() doit savoir quel cadre atteindre ; un paramètre est donc requis dans 
les parenthèses. D’autres méthodes, telles play() et stop(), ont une signification univoque et 
ne requièrent donc aucune information complémentaire. Elles sont néanmoins suivies de 
parenthèses.
Contrairement aux propriétés (et aux variables), les méthodes ne servent pas d’espaces 
réservés. Certaines méthodes peuvent cependant effectuer des calculs et renvoyer des résultats 
pouvant servir de variables. Par exemple, la méthode toString() de la classe Number 
convertit une valeur numérique en une représentation textuelle :
var numericData:Number = 9;
var textData:String = numericData.toString();
Par exemple, vous pouvez utiliser la méthode toString() si vous souhaitez afficher la valeur 
d’une variable Number dans un champ texte à l’écran. La propriété text de la classe TextField 
(qui représente le contenu textuel réel affiché à l’écran) se définit comme une chaîne (String), 
de manière qu’elle ne puisse contenir que des valeurs textuelles. Cette ligne de code convertit 
la valeur numérique de la variable numericData en texte, puis la fait apparaître à l’écran dans 
l’objet TextField nommé calculatorDisplay :
= numericData.toString();
Evénements
Tel que nous l’avons décrit, un programme informatique est une série d’instructions que 
l’ordinateur effectue pas à pas. Certains programmes très simples ne sont rien de plus : 
l’ordinateur effectue quelques procédures, puis le programme se termine. Toutefois, les 
programmes ActionScript sont conçus pour poursuivre leur exécution, dans l’attente d’une 
saisie utilisateur, par exemple. Les événements sont des mécanismes qui déterminent quelles 
instructions l’ordinateur doit suivre et quand.
Utilisation des objets
35

Par essence, des événements sont des faits qui surviennent et auxquels ActionScript peut 
répondre parce qu’il les connaît. De nombreux d’événements sont liés à l’interaction de 
l’utilisateur, par exemple un clic sur un bouton ou une pression sur une touche du clavier. 
Il existe néanmoins d’autres types d’événement. Par exemple, si vous utilisez ActionScript 
pour charger une image externe, un événement est capable de vous prévenir lorsque le 
chargement de l’image est terminé. Pendant l’exécution d’un programme ActionScript, Adobe 
Flash Player attend que des événements se produisent et lorsque c’est le cas, il exécute le code 
ActionScript que vous avez spécifié en réponse.
Gestion des événements de base
La gestion des événements est la technique qui permet de spécifier les actions à exécuter en 
réponse à des événements particuliers. Lors de l’écriture de code ActionScript en vue de la 
gestion des événements, trois éléments importants sont à identifier :
?
La source de l’événement : quel objet sera concerné par l’événement ? Par exemple, sur 
quel bouton aura lieu le clic ou quel objet Loader charge-t-il l’image ? La source de 
l’événement est également appelée cible de l’événement car elle représente l’objet où 
l’événement est ciblé par Flash Player (là où l’événement a lieu).
?
L’événement : que doit-il se passer, à quel événement voulez-vous répondre ? Ce point est 
très important, car de nombreux objets déclenchent plusieurs événements.
?
La réponse : quelles actions doivent faire suite à l’occurrence de l’événement ?
Tout code ActionScript de gestion des événements doit contenir ces trois éléments et respecte 
la structure de base suivante (les éléments en gras sont des espaces réservés à remplir selon le 
cas envisagé) :
function eventResponse(eventObject:EventType):void
{
// Les actions exécutées en réponse à l’événement apparaissent ici.
}
eventSource.addEventListener(EventType.EVENT_NAMEeventResponse);
Ce code a deux rôles. Tout d’abord, il définit une fonction, qui est une manière de spécifier les 
actions à exécuter en réponse à l’événement. Ensuite, il appelle la méthode 
addEventListener() de l’objet source, « inscrivant » ainsi la fonction auprès de l’événement 
spécifié de manière que lorsque l’événement survient, les actions de la fonction ont lieu. 
Nous allons étudier chacun de ces rôles en détail.
36
Prise en main d’ActionScript

Une fonction sert à regrouper des actions sous un nom unique, un raccourci qui vous permet 
de les exécuter. La fonction est identique à la méthode, à cette exception près qu’elle n’est pas 
nécessairement associée à une classe particulière (on pourrait d’ailleurs définir la méthode 
ainsi : une fonction associée à une classe donnée). Lorsque vous créez une fonction de gestion 
des événements, vous devez choisir le nom de la fonction (dans ce cas eventResponse) mais 
aussi spécifier un paramètre (eventObject dans cet exemple). La spécification d’un paramètre 
de fonction ressemble à la déclaration de variable ; vous devez dans ce cas aussi indiquer le 
type de données du paramètre. Il existe une classe ActionScript définie pour chaque 
événement, et le type de données que vous spécifiez pour le paramètre de fonction est toujours 
la classe associée à l’événement particulier auquel vous souhaitez répondre. Enfin, entre les 
accolades ouvrantes et fermantes ({   }), vous devez écrire les instructions que l’ordinateur 
doit suivre lorsque l’événement survient.
Une fois que vous avez écrit la fonction de gestion d’événement, vous devez indiquer à l’objet 
source (l’objet qui cause l’événement, par exemple le bouton) que la fonction à appeler lorsque 
l’événement survient est votre fonction. Pour ce faire, appelez la méthode 
addEventListener() de cet objet (tous les objets liés à des événements ont une méthode 
addEventListener()). La méthode addEventListener() réclame deux paramètres :
?
Tout d’abord, le nom de l’événement auquel vous voulez répondre. Comme nous l’avons 
déjà vu, chaque événement est affilié à une classe spécifique pour laquelle est définie une 
valeur spéciale à chaque événement (en quelque sorte le nom unique de l’événement). 
Cette valeur sert de premier paramètre.
?
Vient ensuite le nom de votre fonction de réponse à l’événement. Sachez qu’un nom de 
fonction est écrit sans parenthèses lors du transfert en tant que paramètre.
Description du processus de gestion des événements
Vous trouverez ci-dessous une description détaillée du processus ayant lieu lorsque vous créez 
un écouteur d’événements. Dans ce cas, il s’agit d’un exemple illustrant la création d’une 
fonction d’écouteur appelée lorsque vous cliquez sur un objet myButton.
Le code écrit par le programmeur est le suivant :
function eventResponse(event:MouseEvent):void
{
// Actions performed in response to the event go here.
}
myButton.addEventListener(MouseEvent.CLICK, eventResponse);
Utilisation des objets
37

Voici comment ce code devrait fonctionner lorsqu’il est exécuté dans Flash Player :
1.
Lors du chargement du fichier SWF, Flash Player remarque qu’il existe une fonction 
eventResponse().
2. Flash Player exécute ensuite le code (notamment les lignes de code qui ne sont pas dans une 
fonction). Dans ce cas, il n’y a qu’une ligne de code : l’appel à la méthode 
addEventListener() sur l’objet source (appelé myButton) et le transfert de la fonction 
eventResponse en tant que paramètre.
38
Prise en main d’ActionScript

a. En interne, myButton a une liste de fonctions qui écoutent chaque événement. 
Par conséquent, lorsque sa méthode addEventListener() est appelée, myButton 
stocke la fonction eventResponse() dans sa liste d’écouteurs d’événements.
3. A un certain moment, l’utilisateur clique sur l’objet myButton et déclenche ainsi son 
événement click (identifié comme MouseEvent.CLICK dans le code).
A ce stade, les opérations suivantes ont lieu :
Utilisation des objets
39

a. Flash Player crée un objet, une instance de la classe associée à l’événement en question 
(MouseEvent dans cet exemple). Pour de nombreux événements, il s’agira d’une 
instance de la classe Event ; pour des événements de souris, une instance MouseEvent 
et pour d’autres événements, une instance de la classe associée à cet événement. 
Cet objet créé est appelé l’objet événement. Il contient des informations spécifiques sur 
l’événement qui a eu lieu : le type d’événement, l’endroit où il s’est produit et d’autres 
informations propres à l’événement, le cas échéant.
b. Flash Player consulte ensuite la liste des écouteurs d’événements stockés par myButton. 
Il parcourt ces fonctions l’une après l’autre en les appelant et en transmettant l’objet 
événement à la fonction en tant que paramètre. Etant donné que la fonction 
eventResponse() est l’un des écouteurs de myButton, Flash Player appelle la fonction 
eventResponse() dans le cadre de ce processus.
40
Prise en main d’ActionScript

c. Lorsque la fonction eventResponse() est appelée, le code qu’elle contient est exécuté 
et vos actions spécifiées sont effectuées.
Exemples de gestion d’événements
Voici quelques exemples plus concrets d’événements qui vous donneront une idée des 
éléments les plus courants et des variations que vous pourrez utiliser lors de l’écriture de votre 
propre code de gestion des événements :
?
Clic sur un bouton pour lancer la lecture du clip actif. Dans l’exemple suivant, 
playButton est le nom d’occurrence du bouton et this est un nom spécial qui signifie 
« l’objet actif » :
();
function playMovie(event:MouseEvent):void
{
();
}
playButton.addEventListener(MouseEvent.CLICK, playMovie);
?
Détection de la saisie dans un champ texte. Dans cet exemple, entryText est un champ 
de saisie de texte et outputText est un champ texte dynamique :
function updateOutput(event:TextEvent):void
{
var pressedKey:String = ;
= "You typed: " + pressedKey;
}
entryText.addEventListener(TextEvent.TEXT_INPUT, updateOutput);
Utilisation des objets
41

?
Clic sur un bouton pour atteindre une URL. Dans ce cas, linkButton est le nom 
d’occurrence du bouton :
function gotoAdobeSite(event:MouseEvent):void
{
var adobeURL:URLRequest = new URLRequest(";);
navigateToURL(adobeURL);
}
linkButton.addEventListener(MouseEvent.CLICK, gotoAdobeSite);
Création d’instances d’objets
Bien entendu, pour utiliser un objet dans ActionScript, cet objet doit exister. La création d’un 
objet repose en partie sur la déclaration d’une variable. Néanmoins la variable crée 
uniquement un emplacement vide dans la mémoire de l’ordinateur. Vous devez lui attribuer 
une valeur réelle (c’est-à-dire créer un objet et le stocker dans une variable) avant de pouvoir 
l’utiliser ou le manipuler. Le processus de création d’un objet est appelé instanciation de 
l’objet, soit la création d’une instance d’une classe particulière.
La création d’une instance d’objet peut passer par une méthode simple, qui n’implique pas 
ActionScript. Dans Flash, lorsque vous placez un symbole de clip, un symbole de bouton ou 
un champ texte sur la scène, puis que vous lui attribuez un nom d’occurrence dans 
l’inspecteur Propriétés, l’application déclare une variable dotée de ce nom d’occurrence, crée 
une instance d’objet et stocke cet objet dans la variable. Il en va de même dans Adobe Flex 
Builder : si vous créez un composant dans Macromedia® MXML™ à partir d’Adobe (soit par 
codage d’une balise MXML, soit en plaçant le composant dans l’éditeur en mode Création) et 
lui attribuez un identifiant (dans la balise MXML ou dans la vue des propriétés Flex), cet 
identifiant devient le nom d’une variable ActionScript et une instance du composant est créée 
et stockée dans la variable.
Toutefois, vous ne pourrez pas toujours créer un objet visuellement. Plusieurs méthodes 
permettent donc de créer des instances d’objet à l’aide d’ActionScript uniquement. A partir de 
plusieurs types de données ActionScript, vous pouvez tout d’abord créer une instance en 
utilisant une expression littérale, une valeur écrite directement dans le code ActionScript. 
Voici quelques exemples :
?
Valeur numérique littérale (entrez le nombre directement) :
var someNumber:Number = 17.239;
var someNegativeInteger:int = -53;
var someUint:uint = 22;
?
Valeur de chaîne littérale (placez le texte entre guillemets doubles) :
var firstName:String = "George";
var soliloquy:String = "To be or not to be, that is the question ";
42
Prise en main d’ActionScript

?
Valeur booléenne littérale (utilisez la valeur littérale true ou false) :
var niceWeather:Boolean = true;
var playingOutside:Boolean = false;
?
Valeur XML littérale (entrez le XML directement) :
var employee:XML = <employee>
<firstName>Harold</firstName>
<lastName>Webster</lastName>
</employee>;
ActionScript définit également des expressions littérales pour les types de données Array, 
RegExp, Object et Function. Pour des informations détaillées sur ces classes, voir de tableaux », à la page 239, « Utilisation d’expressions régulières », à la page 305données Object », à la page 104.
Pour tout autre type de données, créez une instance d’objet à l’aide de l’opérateur new et du 
nom de classe, comme suit :
var raceCar:MovieClip = new MovieClip();
var birthday:Date = new Date(2006, 7, 9);
Pour cette méthode de création d’un objet à l’aide de l’opérateur new, on dit souvent « appeler 
le constructeur de classe ». Un constructeur est une méthode spéciale qui est appelée dans le 
cadre de la création d’une instance de classe. Notez que lorsque vous créez une instance de 
cette manière, vous placez des parenthèses après le nom de classe et spécifiez parfois des valeurs 
de paramètres, comme vous le faites lorsque vous appelez une méthode.
REMARQUE
Vous pouvez utiliser l’opérateur new pour créer une instance d’objet même pour les types 
de données qui permettent de créer des instances avec une expression littérale. 
Par exemple, ces deux lignes de code produisent exactement le même résultat :
var someNumber:Number = 6.33;
var someNumber:Number = new Number(6.33);
Il est important de se familiariser avec la méthode new ClassName() de création d’objets. 
Dans le cas d’un type de données ActionScript qui ne dispose pas de représentation visuelle 
(et ne peut donc pas être créé en plaçant un élément sur la scène de Flash ou dans l’éditeur en 
mode Création de Flex Builder), vous pouvez uniquement créer un objet directement dans 
ActionScript à l’aide de l’opérateur new.
Dans Flash, l’opérateur new peut en outre servir à créer une instance d’un symbole de clip 
défini dans la bibliothèque sans être placé sur la scène. Pour plus d’informations à ce sujet, 
voir « Création d’objets MovieClip à l’aide d’ActionScript », à la page 528.
Utilisation des objets
43

Eléments de programme courants
Outre la déclaration des variables, la création d’instances d’objets et la manipulation des objets 
à l’aide des propriétés et des méthodes, d’autres éléments de construction peuvent servir à la 
création d’un programme ActionScript.
Opérateurs
Les opérateurs sont des symboles spéciaux (et parfois des mots) qui permettent d’effectuer des 
calculs. Ils sont surtout utilisés dans les opérations mathématiques et pour la comparaison de 
valeurs. En règle générale, un opérateur utilise une ou plusieurs valeurs et « établit » un 
résultat unique. Voici un exemple :
?
L’opérateur de somme (+) ajoute deux valeurs pour obtenir un nombre unique :
var sum:Number = 23 + 32;
?
L’opérateur de multiplication (*) multiplie une valeur par une autre pour obtenir un 
nombre unique :
var energy:Number = mass * speedOfLight * speedOfLight;
?
L’opérateur d’égalité (==) compare deux valeurs pour vérifier si elles sont égales, afin 
d’obtenir une valeur vrai/faux (booléenne) unique :
if (dayOfWeek == "Wednesday")
{
takeOutTrash();
}
Comme illustré ici, l’opérateur d’égalité et les autres opérateurs de comparaison sont le 
plus souvent utilisés avec l’instruction if afin de déterminer si certaines actions sont à 
effectuer ou non.
Pour plus d’informations et d’exemples sur l’utilisation des opérateurs, voir à la page 118
44
Prise en main d’ActionScript

Commentaires
Lors de la rédaction du code ActionScript, il peut s’avérer utile de conserver des notes 
personnelles, expliquant par exemple le fonctionnement de certaines lignes de code ou la 
raison pour laquelle vous avez fait tel ou tel choix. Les commentaires de code vous permettent 
d’insérer du texte dans votre code que l’ordinateur devra ignorer. ActionScript comprend deux 
types de commentaires :
?
Commentaire sur une ligne : un commentaire sur une ligne est indiqué par l’insertion de 
deux barres obliques en tout point d’une ligne. Tout ce qui apparaît après les barres 
obliques, jusqu’à la fin de la ligne, est ignoré par l’ordinateur :
// Ceci est un commentaire, que l’ordinateur ignore.
var age:Number = 10; // Définir l’âge sur 10 par défaut.
?
Commentaire sur plusieurs lignes : un commentaire sur plusieurs lignes inclut un 
marqueur de début (/*), le contenu du commentaire, puis un marqueur de fin de 
commentaire (*/). L’ordinateur ignore tout ce qui apparaît entre les marqueurs de début 
et de fin, quel que soit le nombre de lignes utilisé par le commentaire :
/*
Ceci peut être une description très longue, qui décrit par exemple ce
à quoi sert une fonction particulière ou qui explique une section du code.
Dans tous les cas, l’ordinateur ignore ces lignes.
*/
Une autre utilité des commentaires est de « désactiver » temporairement une ou plusieurs 
lignes de code, par exemple, si vous testez différentes manières d’aboutir à un résultat ou 
essayez d’identifier pourquoi le code ActionScript ne fonctionne pas comme vous le pensiez.
Contrôle du flux
Dans bien des cas, il vous sera nécessaire de répéter des actions de votre code, d’en effectuer 
certaines et pas d’autres, de réaliser des actions de remplacement selon les conditions 
rencontrées, etc. Le contrôle de flux permet de maîtriser les actions exécutées. ActionScript 
propose plusieurs types d’éléments de contrôle de flux.
?
Fonctions : les fonctions sont comme des raccourcis, elles permettent de regrouper une 
série d’actions sous un même nom, qui serviront à des calculs. Essentielles à la gestion des 
événements, elles constituent en outre un outil générique de regroupement des 
instructions. Pour plus d’informations sur les fonctions, voir « Fonctions », à la page 131.
Eléments de programme courants
45

?
Boucles : les structures en boucle vous permettent de désigner un jeu d’instructions que 
l’ordinateur exécutera un nombre défini de fois ou jusqu’à ce qu’une condition change. 
Souvent, les boucles sont utilisées pour manipuler plusieurs éléments connexes à l’aide 
d’une variable dont la valeur change à chaque fois que l’ordinateur achève une boucle. 
Pour plus d’informations sur les boucles, voir « Boucle », à la page 128.
?
Instructions conditionnelles : les instructions conditionnelles permettent de désigner 
certaines actions à effectuer uniquement dans certaines circonstances ou de définir des 
ensembles d’actions destinés à différentes conditions. L’instruction conditionnelle la plus 
courante est l’instruction if. Cette instruction if vérifie la valeur ou l’expression placée 
dans ses parenthèses. Si le résultat est true, les lignes de code entre accolades sont 
exécutées ; dans le cas contraire, elles sont ignorées. Voici un exemple d’utilisation :
if (age < 20)
{
// show special teenager-targeted content
}
L’instruction if peut s’associer à l’instruction else, qui vous permet de désigner les 
actions à effectuer si la condition n’est pas true :
if (username == "admin")
{
// effectuer des actions réservées à l’administrateur, 
// par exemple afficher des options supplémentaires
}
else
{
// effectuer des actions non réservées à l’administrateur
}
Pour plus d’informations sur les instructions conditionnelles, voir conditionnelles », à la page 126.
Exemple : Elément de portfolio d’animation
Cet exemple indique comment vous pouvez assembler des bits d’ActionScript dans une 
application complète ActionScript. L’élément de portfolio d’animation est un exemple de la 
façon dont vous pourriez prendre une animation linéaire existante (par exemple, un élément 
créé pour un client) et ajouter des éléments interactifs mineurs pour l’incorporer dans un 
portfolio en ligne. Le comportement interactif que nous ajouterons à l’animation comprendra 
deux boutons sur lesquels l’utilisateur pourra cliquer : l’un pour démarrer l’animation, et 
l’autre pour naviguer vers une URL séparée (le menu du portfolio ou la page d’accueil de 
l’auteur, par exemple).
46
Prise en main d’ActionScript

Le processus de création de cet élément peut être divisé en deux sections principales :
1.
Préparer le fichier FLA pour ajouter des éléments ActionScript interactifs.
2. Créer et ajouter les boutons.
3. Ecrire le code ActionScript.
4. Tester l’application.
Préparation à l’ajout de l’interactivité
Avant d’ajouter des éléments interactifs à notre animation, nous devons configurer le fichier 
FLA en créant des emplacements pour ajouter notre nouveau contenu. Ceci comprend la 
création d’un espace sur la scène où les boutons sont placés, et la création d’un « espace » dans 
le fichier FLA pour garder différents éléments séparés.
Pour configurer votre FLA et ajouter des éléments interactifs :
1.
Si vous n’avez pas encore d’animation linéaire à laquelle vous ajouterez de l’interactivité, 
créez un fichier FLA avec une animation simple (une interpolation de mouvement simple 
ou une interpolation de forme, par exemple). Autrement, ouvrez le fichier FLA contenant 
l’animation que vous présentez dans le projet, et enregistrez-le sous un nouveau nom pour 
créer un nouveau fichier de travail.
2. Choisissez l’endroit où vous souhaitez que les deux boutons apparaissent à l’écran (un pour 
démarrer l’animation et l’autre pour effectuer un lien vers le portfolio de l’auteur ou la page 
d’accueil). Si nécessaire, effacez ou ajoutez de l’espace sur la scène pour ce nouveau contenu. 
Si l’animation n’en possède pas, vous pouvez créer une page de garde sur la première image 
(vous pouvez décaler l’animation dessus afin qu’elle démarre sur l’image 2 ou 
ultérieurement).
3. Ajoutez un nouveau calque, au-dessus des autres calques dans le scénario, et renommez-le 
boutons. Il s’agira du calque auquel vous ajouterez les boutons.
4. Ajoutez un nouveau calque, au-dessus du calque boutons, et renommez-le actions. Il s’agira 
du calque auquel vous ajouterez le code ActionScript à votre application.
Exemple : Elément de portfolio d’animation
47

Création et ajout de boutons
Nous allons ensuite créer et positionner les boutons qui constitueront le centre de notre 
application interactive.
Pour créer et ajouter des boutons au FLA :
1.
A l’aide des outils de dessin, créez l’aspect visuel de votre premier bouton (le bouton de 
lecture) sur le calque boutons. Par exemple, vous pouvez dessiner un ovale horizontal avec 
du texte au-dessus.
2. A l’aide de l’outil de sélection, sélectionnez toutes les parties graphiques du bouton.
3. Dans le menu principal, choisissez Modifier > Convertir en symbole.
4. Dans la boîte de dialogue, choisissez le type de symbole de bouton, donnez-lui un nom et 
cliquez sur OK.
5. Lorsque le bouton est sélectionné, dans l’inspecteur Propriétés, affectez-lui le nom 
d’occurrence playButton.
6. Répétez les étapes 1 à 5 afin de créer le bouton qui permettra à l’utilisateur d’accéder à la 
page d’accueil de l’auteur. Nommez ce bouton homeButton.
Ecriture du code
Le code ActionScript pour cette application peut être divisé en trois ensembles de 
fonctionnalités, même s’ils seront tous entrés au même endroit. Le code doit effectuer les trois 
opérations suivantes :
?
Arrêter la tête de lecture dès le chargement du fichier SWF (lorsque la tête de lecture 
atteint l’image 1).
?
Ecouter un événement pour démarrer la lecture du fichier SWF lorsque l’utilisateur clique 
sur le bouton de lecture.
?
Ecouter un événement pour que le navigateur accède à l’URL appropriée lorsque 
l’utilisateur clique sur le bouton de la page d’accueil de l’auteur. 
Pour créer un code qui arrête la tête de lecture lorsqu’elle atteint l’image 1 :
1.
Sélectionnez l’image-clé sur l’image 1 du calque actions.
2. Pour ouvrir le panneau Actions, sélectionnez Fenêtre > Actions dans le menu principal.
3. Dans le panneau Script, entrez le code suivant :
stop();
48
Prise en main d’ActionScript

Pour écrire un code qui démarre l’animation lorsque l’utilisateur clique sur le 
bouton de lecture :
1.
A la fin du code entré aux étapes précédentes, ajoutez deux lignes vides.
2. Entrez le code suivant en bas du script :
function startMovie(event:MouseEvent):void
{
();
}
Ce code définit une fonction appelée startMovie(). Lorsque la fonction startMovie() 
est appelée, elle lance la lecture du scénario principal.
3. Sur la ligne qui suit le code ajouté à l’étape précédente, entrez cette ligne de code :
playButton.addEventListener(MouseEvent.CLICK, startMovie);
Cette ligne de code enregistre la fonction startMovie() comme écouteur pour 
l’événement click de playButton. Ainsi, chaque fois que l’utilisateur clique sur le 
bouton playButton, la fonction startMovie() est appelée.
Pour écrire un code qui permet au navigateur d’accéder à une URL lorsque 
l’utilisateur clique sur le bouton de la page d’accueil :
1.
A la fin du code entré aux étapes précédentes, ajoutez deux lignes vides.
2. Entrez ce code en bas du script :
function gotoAuthorPage(event:MouseEvent):void
{
var targetURL:URLRequest = new URLRequest(";);
navigateToURL(targetURL);
}
Ce code définit une fonction gotoAuthorPage(). Cette fonction crée d’abord une 
instance URLRequest représentant l’URL , puis transmet cette URL 
à la fonction navigateToURL() afin que le navigateur de l’utilisateur l’ouvre.
3. Sur la ligne qui suit le code ajouté à l’étape précédente, entrez cette ligne de code :
homeButton.addEventListener(MouseEvent.CLICK, gotoAuthorPage);
Cette ligne de code enregistre la fonction gotoAuthorPage() comme écouteur pour 
l’événement click de homeButton. Ainsi, chaque fois que l’utilisateur clique sur le 
bouton homeButton, la fonction gotoAuthorPage() est appelée.
Exemple : Elément de portfolio d’animation
49

Test de l’application
A ce stade, l’application devrait fonctionner complètement. Testons-la.
Pour tester l’application :
1.
Dans le menu principal, sélectionnez Contrôle > Tester l’animation. Flash crée le fichier 
SWF et l’ouvre dans une fenêtre Flash Player.
2. Testez les deux boutons pour vérifier qu’ils fonctionnent.
3. Si ce n’est pas le cas, vérifiez les points suivants :
?
Les deux boutons ont-ils des noms d’instance différents ?
?
Les appels à la méthode addEventListener() utilisent-ils les mêmes noms que les 
noms d’instance des boutons ?
?
Les noms d’événement corrects sont-ils utilisés dans les appels à la méthode 
addEventListener() ?
?
Le paramètre correct est-il spécifié pour chacune des fonctions ? (Elles doivent toutes 
les deux avoir un seul paramètre avec le type de données MouseEvent.)
Tous ces points et la plupart des autres erreurs possibles devraient entraîner l’apparition 
d’un message lorsque vous choisissez la commande Tester l’animation ou lorsque vous 
cliquez sur le bouton. Recherchez les erreurs de compilation dans le panneau prévu à cet 
effet (celles qui ont lieu lorsque vous choisissez d’abord Tester l’animation), et recherchez 
les erreurs d’exécution dans le panneau Sortie (erreurs qui ont lieu pendant la lecture du 
fichier SWF - lorsque vous cliquez sur un bouton, par exemple).
Création d’applications avec ActionScript
La création d’une application avec ActionScript requiert d’autres connaissances que la syntaxe 
et les noms de classes à utiliser. Bien que le contenu de ce manuel soit essentiellement axé sur 
ces deux sujets (la syntaxe et l’utilisation des classes ActionScript), d’autres informations 
pourront vous être utiles, notamment quels programmes permettent d’écrire du code 
ActionScript, comment ce code s’organise et s’intègre dans une application et quelles étapes il 
faut respecter dans le développement d’une application ActionScript.
50
Prise en main d’ActionScript

Options d’organisation du code
Le code ActionScript 3.0 peut servir à générer de nombreuses applications, qu’il s’agisse d’une 
simple animation graphique ou d’un système complexe de traitement des transactions client/
serveur. Selon le type d’application envisagé, vous choisirez l’une ou plusieurs des méthodes 
suivantes pour intégrer ActionScript dans votre projet.
Stockage de code dans les images d’un scénario Flash
Dans l’environnement de programmation Flash, vous pouvez ajouter du code ActionScript à 
toute image placée dans un scénario. Ce code sera exécuté pendant la lecture du clip, au 
moment où la tête de lecture atteindra l’image.
L’insertion de code ActionScript dans des images est une manière simple d’ajouter des 
comportements à des applications créées dans l’outil de programmation Flash. Vous pouvez 
placer du code dans n’importe quelle image du scénario principal ou du scénario d’un 
symbole de clip. Cette souplesse a néanmoins un coût. Lorsque vous créez des applications 
assez volumineuses, vous risquez de ne plus savoir quelles images contiennent quels scripts. 
A terme, cela peut compliquer la maintenance de l’application.
Pour simplifier l’organisation de leur code ActionScript, les développeurs placent ce code 
uniquement dans la première image du scénario ou sur un calque spécifique du document 
Flash. Il est ainsi plus facile de localiser et de maintenir le code dans les fichiers FLA Flash. 
Toutefois, la réutilisation du même code dans un autre projet Flash oblige à copier et coller le 
code dans le nouveau fichier.
Si vous voulez continuer à pouvoir utiliser votre code ActionScript dans de futurs projets 
Flash, vous préférerez sans doute stocker ce code dans des fichiers ActionScript externes 
(des fichiers texte dotés de l’extension .as).
Stockage du code dans des fichiers ActionScript
Si votre projet implique une quantité importante de code ActionScript, la meilleure solution 
consiste à stocker le code dans des fichiers source ActionScript (des fichiers texte dotés de 
l’extension .as). Un fichier ActionScript peut suivre deux structures, selon l’utilisation que 
vous prévoyez d’en faire dans votre application.
?
Code ActionScript non structuré : les lignes de code ActionScript, y compris les 
instructions et les définitions de fonction, sont écrites comme si elles étaient saisies 
directement dans un script de scénario, un fichier MXML, etc.
Création d’applications avec ActionScript
51

Ecrit de cette façon, le code est accessible par le biais de l’instruction ActionScript 
include ou de la balise <mx:Script> dans Adobe Flex MXML. L’instruction 
ActionScript include provoque l’insertion du contenu d’un fichier ActionScript externe à 
un endroit particulier d’un script et sur une étendue donnée, comme s’il avait été saisi 
directement. Dans le langage Flex MXML, la balise <mx:Script> vous permet de spécifier 
l’attribut source qui identifie le fichier ActionScript externe à charger à cet endroit de 
l’application. Par exemple, la balise suivante charge un fichier ActionScript externe 
nommé  :
<mx:Script source=“” />
?
Définition de la classe ActionScript : la définition d’une classe ActionScript, y compris ses 
définitions de méthode et de propriété.
Lorsque vous définissez une classe, vous pouvez accéder au code ActionScript 
correspondant en créant une instance de cette classe et en utilisant ses propriétés, 
méthodes et événements, comme vous le feriez avec toute classe ActionScript intégrée. 
Cela implique deux opérations :
?
Utilisez l’instruction import pour spécifier le nom complet de la classe, de manière à 
ce que le compilateur ActionScript sache où la trouver. Par exemple, pour utiliser la 
classe MovieClip dans ActionScript, vous devez commencer par importer cette classe à 
l’aide de son nom complet, en incluant le package et la classe.
import flash.display.MovieClip;
Une autre solution consiste à importer le paquet contenant la classe MovieClip, ce qui 
revient à écrire des instructions import pour chaque classe du package :
import flash.display.*;
Cette obligation d’importer les classes auxquelles vous faites référence dans votre code 
ne s’applique pas aux classes de niveau supérieur, qui ne sont pas définies dans le 
package.
REMAR
Dans Flash, pour les scripts joints à des images du scénario, les classes 
intégrées (dans les packages flash.*) sont automatiquement importées. 
Cependant, si vous écrivez vos propres classes, travaillez avec des composants 
Q
UE
de programmation de Flash (les packages fl.*) ou travaillez dans Flex, vous 
devez importer explicitement toutes les classes dont vous souhaitez créer des 
instances avec votre code.
52
Prise en main d’ActionScript

?
Ecrivez le code qui fait spécifiquement référence au nom de classe (normalement par 
déclaration d’une variable dont le type de données est cette classe et par création d’une 
instance de la classe à stocker dans la variable). Lorsque vous faites référence à un autre 
nom de classe dans le code ActionScript, vous indiquez au compilateur de charger la 
définition de cette classe. Par exemple, si l’on considère une classe externe nommée 
Box, l’instruction suivante provoque la création d’une nouvelle instance de la classe 
Box :
var smallBox:Box = new Box(10,20);
Lorsque le compilateur rencontre pour la première fois la référence de la classe Box, il 
effectue une recherche dans le code source chargé afin de localiser la définition de la 
classe Box. 
Choix de l’outil approprié
Selon les contraintes qu’impose votre projet et les ressources dont vous disposez, vous pouvez 
avoir le choix entre plusieurs outils (à utiliser individuellement ou en combinaison) pour 
l’écriture et la modification de votre code ActionScript.
Outil de programmation Flash
Outre ses capacités de création graphique et d’animation, Adobe Flash CS3 Professional 
comprend des outils qui permettent de manipuler le code ActionScript, qu’il soit joint à des 
éléments d’un fichier FLA ou regroupé dans des fichiers ActionScript externes. L’outil de 
programmation Flash s’avère idéal pour les projets impliquant des animations ou vidéos 
conséquentes, ou lorsque vous désirez créer la plupart des actifs graphiques vous-même, et 
tout particulièrement lorsque l’interaction utilisateur ou la fonctionnalité assurée par 
ActionScript est minimale. Cet outil peut également vous paraître adapté au développement 
de votre projet ActionScript si vous préférez créer les actifs visuels et écrire le code dans une 
seule et même application. Enfin, cet outil Flash peut vous convenir si vous souhaitez utiliser 
des composants d’interface préintégrés et que la réduction de la taille du fichier SWF et la 
facilité d’enveloppement visuel sont des aspects essentiels de votre projet.
Adobe Flash CS3 Professional inclut deux outils permettant l’écriture de code ActionScript :
?
Panneau action : disponible lorsque vous manipulez un fichier FLA, ce panneau vous 
permet d’écrire du code ActionScript associé aux images d’un scénario.
?
Fenêtre de script : la fenêtre de script est un éditeur de texte dédié permettant de 
travailler sur des fichiers de code ActionScript (.as).
Création d’applications avec ActionScript
53

Flex Builder
Adobe Flex Builder est le principal outil de création de projets avec le cadre d’application Flex. 
Au-delà de ses outils de présentation visuelle et d’édition MXML, Flex Builder comprend un 
éditeur ActionScript complet, qui permet de créer des projets Flex ou ActionScript. 
Les applications Flex présentent de nombreux avantages, notamment un large éventail de 
commandes d’interface préintégrées et de commandes de disposition dynamique souples, ainsi 
que des mécanismes intégrés permettant de manipuler des sources de données externes et de 
lier des données externes aux éléments d’interface utilisateur. Toutefois, ces fonctions 
nécessitant davantage de code, les applications Flex se caractérisent par une taille de fichier 
supérieure et leur enveloppe ne peut être remaniée aussi facilement que leurs homologues Flash.
Utilisez Flex Builder si vous voulez créer avec Flex, dans un seul et même outil, des 
applications de données sur Internet riches en fonctions, tout en modifiant du code 
ActionScript et MXLM et en disposant les éléments de manière visuelle.
Editeur ActionScript tiers
Les fichiers ActionScript (.as) étant stockés comme de simples fichiers texte, tout programme 
susceptible de modifier des fichiers texte brut peut servir à écrire des fichiers ActionScript. 
Outre les produits ActionScript d’Adobe, plusieurs programmes tiers d’édition de texte ont 
été créés avec des fonctions propres à ActionScript. Vous pouvez écrire un fichier MXML ou 
des classes ActionScript à l’aide de tout éditeur de texte. A partir de ces fichiers, vous pouvez 
ensuite créer une application SWF (une application Flex ou ActionScript seul) à l’aide du kit 
SDK Flex, qui comprend les classes d’application Flex ainsi que le compilateur Flex. Pour de 
nombreux développeurs, une autre solution consiste à écrire les classes ActionScript dans un 
éditeur ActionScript tiers, en combinaison avec l’outil de programmation Flash pour la 
création du contenu graphique.
Vous pouvez choisir un éditeur ActionScript tiers dans les cas suivants :
?
Vous préférez écrire le code ActionScript dans un programme distinct, tout en concevant 
les éléments visuels dans Flash.
?
Vous utilisez une application de programmation non ActionScript (par exemple pour la 
création de pages HTML ou l’élaboration d’application dans un autre langage de 
programmation) et vous souhaitez l’utiliser pour le code ActionScript également.
?
Vous voulez créer des projets ActionScript seul ou Flex à l’aide du kit SDK Flex sans avoir 
à acquérir Flash ou Flex Builder.
54
Prise en main d’ActionScript

Les principaux éditeurs de code prenant en charge ActionScript sont les suivants :
?
Adobe Dreamweaver® CS3 
?
ASDT 
?
FDT 
?
FlashDevelop 
?
PrimalScript 
?
SE|PY 
?
XCode (avec modèle ActionScript et fichiers conseil de code). 
Processus de développement ActionScript
Quelle que soit la taille de votre projet ActionScript, l’utilisation d’un processus de conception et 
de développement vous aidera à travailler plus efficacement. Les étapes ci-après forment le 
processus de développement de base pour la conception d’une application avec ActionScript 3.0 :
1.
Concevez votre application.
Avant de commencer à construire votre application, vous devez la décrire d’une manière 
ou d’une autre.
2. Composez votre code ActionScript 3.0.
Vous pouvez créer du code ActionScript dans Flash, Flex Builder, Dreamweaver ou un 
éditeur de texte. 
3. Créez un fichier application Flash ou Flex pour exécuter votre code. 
Dans l’outil de programmation Flash, cela implique la création d’un nouveau fichier FLA, 
la définition des paramètres de publication, l’ajout de composants d’interface à 
l’application et le référencement du code ActionScript. Dans l’environnement de 
développement Flex, la création d’un nouveau fichier d’application requiert la définition 
de l’application et l’ajout de composants d’interface à l’aide de MXML, puis le 
référencement du code ActionScript.
4. Publiez et testez votre application ActionScript. 
Cela implique que vous exécutiez votre application au sein de l’environnement de 
programmation Flash ou de développement Flex, et que vous vérifiiez qu’elle effectue 
toutes les opérations voulues.
Création d’applications avec ActionScript
55

Il n’est pas indispensable de suivre ces étapes dans cet ordre ou d’achever l’une d’elle avant de 
passer à la suivante. Par exemple, vous pouvez concevoir un écran de votre application 
(étape 1), puis créer les graphiques, boutons, etc. (étape 3), avant d’écrire le code ActionScript 
(étape 2) et de le tester (étape 4). Vous pouvez tout aussi bien concevoir une partie de l’écran, 
puis ajouter un bouton ou un élément d’interface à la fois, écrire le code ActionScript 
correspondant et le tester dès qu’il est prêt. Bien qu’il soit judicieux de garder à l’esprit ces 
quatre stades du processus de développement, il est en pratique plus efficace d’aller et venir 
entre ces étapes en fonction des besoins.
Création de vos propres classes
Le processus de création des classes destinées à vos projets peut paraître rébarbatif. Cependant, 
la partie la plus difficile de la création d’une classe est sa conception, c’est-à-dire 
l’identification des méthodes, des propriétés et des événements qu’elle comprend.
Stratégies de conception d’une classe
La conception orientée objet est un sujet complexe ; des carrières entières ont été consacrées à 
l’étude académique et à la pratique professionnelle de cette discipline. Voici tout de même 
quelques suggestions d’approches qui vous aideront à démarrer votre projet.
1.
Réfléchissez au rôle que les instances de la classe auront à jouer dans l’application. En règle 
générale, les objets servent l’un des objectifs suivants :
?
Objet de valeur : ces objets constituent avant tout des conteneurs de données, c’est-à-
dire qu’ils possèdent plusieurs propriétés et peu de méthodes (parfois aucune). Il s’agit 
en général d’une représentation dans le code d’éléments clairement définis, tels qu’une 
classe Song (représentant une seule chanson) ou une classe Playlist (représentant un 
groupe conceptuel de chansons) dans une application musicale.
?
Objet d’affichage : ce type correspond à des objets qui s’affichent réellement à l’écran, 
par exemple des éléments d’interface, tels que des listes déroulantes ou des libellés 
d’état, des éléments graphiques tels que des créatures dans un jeu vidéo, etc.
?
Structure d’application : ces objets jouent un large éventail de rôles dans la logique ou 
le traitement effectué par les applications. Il s’agit par exemple d’un objet réalisant des 
calculs dans une simulation de biologie, un objet chargé de synchroniser les valeurs 
entre une commande physique et le volume de sortie d’une application musicale, un 
objet que gère les règles d’un jeu vidéo ou un objet qui charge une image enregistrée 
dans une application de dessin.
56
Prise en main d’ActionScript

2. Décidez de la fonctionnalité requise pour la classe. Les différentes fonctionnalités 
constituent souvent les méthodes de la classe.
3. Si la classe est destinée à servir d’objet de valeur, choisissez les données que les instances 
pourront inclure. Ces éléments peuvent facilement devenir des propriétés.
4. Puisque que vous concevez la classe spécialement pour votre projet, le plus important est 
que vous établissiez la fonctionnalité nécessaire à votre application. Pour vous aider, vous 
pouvez répondre à ces questions :
?
Quel type d’informations l’application stockera, surveillera et manipulera ? Vous 
pourrez alors identifier les objets de valeurs et les propriétés qui vous serviront.
?
Quels jeux d’actions devront être exécutés, par exemple lors du premier chargement de 
l’application, lorsque l’utilisateur clique sur un bouton donné, lorsque la lecture de la 
séquence s’arrête, etc. ? Ces éléments constituent souvent des méthodes (ou des 
propriétés, si les actions consistent uniquement à modifier des valeurs isolées).
?
Pour chaque action considérée, quelles informations seront nécessaires à la classe pour 
son exécution ? Ces éléments deviennent les paramètres de la méthode.
?
Pendant le fonctionnement de l’application, quelles modifications surviendront dans 
la classe qui devront être communiquées à d’autres parties de l’application ? Ces 
éléments forment en général des événements.
5. Si un objet existant est semblable à l’objet dont vous avez besoin mais qu’il lui manque 
certaines fonctionnalités que vous souhaitez ajouter, envisagez de créer une sous-classe (une 
classe qui repose sur la fonctionnalité d’une classe existante plutôt que de définir l’ensemble 
de sa fonctionnalité propre). Par exemple, si vous voulez créer une classe correspondant à 
un objet affiché à l’écran, vous pouvez créer votre classe en vous appuyant sur le 
comportement de l’un des objets d’affichage existants (par exemple, Sprite ou MovieClip). 
Dans ce cas, MovieClip (ou Sprite) constituerait la classe de base, que votre classe viendrait 
étendre. Pour plus d’informations sur la création d’une sous-classe, la page 173.
Ecriture du code d’une classe
Une fois que vous avez conçu votre classe ou au moins identifié les informations qu’elle 
manipulera et les actions qu’elle devra effectuer, l’écriture et la syntaxe à utiliser sont 
relativement simples.
Voici la procédure minimale de création d’une classe ActionScript :
1.
Ouvrez un nouveau document texte dans un programme ActionScript tel que Flex Builder 
ou Flash, dans un outil de programmation générique tel que Dreamweaver ou dans toute 
application vous permettant de manipuler des documents en texte brut.
Création de vos propres classes
57

2. Saisissez une instruction class afin de définir le nom de la classe. Pour ce faire, entrez les 
mots public class, puis le nom de la classe suivi d’une paire d’accolades qui entoureront 
le contenu de la classe (les définitions de méthode et de propriété). Voici un exemple 
d’utilisation :
public class MyClass
{
}
Le mot public indique que la classe est accessible par tout autre code. Pour d’autres 
possibilités, voir « Attributs d’espace de nom pour le contrôle d’accès », à la page 154.
3. Entrez une instruction de package, qui indique le nom du package dans lequel le vôtre 
apparaîtra. La syntaxe est le mot package suivi du nom complet du package, puis d’une 
paire d’accolages (qui entoureront l’élément structurel class). Par exemple, nous pouvons 
modifier le code précédent comme suit :
package mypackage 
{ 
public class MyClass
{
}
}
4. Définissez chaque propriété de la classe à l’aide de l’instruction var ajoutée dans le corps 
de la classe. Utilisez la même syntaxe que pour la déclaration de variable (en y ajoutant le 
qualificatif public). Par exemple, les lignes suivantes ajoutées entre les accolages de la 
définition de classe permettent de créer des propriétés nommées textVariable, 
numericVariable et dateVariable :
public var textVariable:String = "some default value";
public var numericVariable:Number = 17;
public var dateVariable:Date;
5. Définissez chaque méthode de la classe à l’aide de la syntaxe utilisée pour définir une 
fonction. Voici un exemple :
?
Pour créer une méthode myMethod(), saisissez :
public function myMethod(param1:String, param2:Number):void
{
// utiliser les paramètres
}
58
Prise en main d’ActionScript

?
Pour créer un constructeur (la méthode spéciale appelée pendant la création d’une 
instance de classe), créez une méthode dont le nom correspond exactement au nom de 
la classe :
public function MyClass()
{
// définir les valeurs initiales pour les propriétés
// et autrement définit l’objet
textVariable = "Hello there!";
dateVariable = new Date(2001, 5, 11);
}
Si vous n’incluez aucune méthode constructeur dans votre classe, le compilateur crée 
automatiquement un constructeur vide (sans paramètres ni instructions) dans votre 
classe.
D’autres éléments de classe peuvent être définis, mais avec plus d’implication.
?
Les accesseurs constituent un croisement spécial entre une méthode et une propriété. 
Lorsque vous écrivez le code de définition d’une classe, l’accesseur s’écrit comme une 
méthode, de manière à ce que vous puissiez accomplir plusieurs actions, et pas seulement 
la lecture ou l’attribution d’une valeur, seules actions disponibles lors de la définition 
d’une propriété. Toutefois, lorsque vous créez une instance de votre classe, vous traitez 
l’accesseur comme une propriété, en utilisant uniquement son nom pour lire ou attribuer 
la valeur. Pour plus d’informations, voir définition », à la page 163.
?
Dans ActionScript, les événements ne sont pas définis à l’aide d’une syntaxe spécifique. 
Pour définir les événements de votre classe, vous utilisez la fonctionnalité de la classe 
EventDispatcher qui permet de suivre les écouteurs d’événements et de notifier les 
événements qui surviennent. Pour plus d’informations sur la création d’événements dans 
vos propres classes, voir Chapitre 10, « Gestion d’événements », à la page 335.
Suggestions d’organisation des classes
Contrairement aux versions précédentes d’ActionScript, ActionScript 3.0 ne vous impose pas 
d’utiliser uniquement une classe par fichier. Avec ActionScript 3.0, vous pouvez enregistrer le 
code source de plusieurs classes dans un même fichier .as. Dans certains cas, il semblera plus 
pratique de réunir plusieurs classes dans un seul fichier source ; cela constitue pourtant une 
pratique de programmation peu recommandé, pour deux raisons :
?
Il est difficile de réutiliser les classes de manière individuelle si elles sont toutes stockées 
dans un seul fichier volumineux.
?
Il est difficile de localiser le code source d’une classe déterminée si le nom du fichier ne 
correspond pas au nom de la classe.
Ainsi, Adobe vous recommande de toujours enregistrer le code source de chaque classe dans 
un fichier distinct et de nommer ce fichier comme la classe.
Création de vos propres classes
59

Exemple : Création d’une application 
de base
Il est possible de créer des fichiers source ActionScript externes, dotés de l’extension .as, dans 
plusieurs applications : Flash, Flex Builder, Dreamweaver ou tout éditeur de texte.
ActionScript 3.0 peut s’utiliser dans divers environnements de développement d’application, 
notamment l’outil de programmation Flash et Flex Builder. 
Cette section étudie les différentes étapes de la création et de l’amélioration d’une simple 
application ActionScript 3.0 à l’aide de l’outil de programmation Flash ou de l’outil Flex 
Builder 2. L’application à élaborer présente une manière simple d’utiliser les fichiers de classe 
externes ActionScript 3.0 dans Flash et Flex. Cette méthode peut s’appliquer à tous les autres 
exemples d’application proposés dans ce manuel.
Conception d’une application ActionScript
Vous devez avoir une idée de l’application à élaborer avant de commencer.
La représentation de cette conception peut être très simple (le nom de l’application et une 
brève description de son utilité) ou très compliquée (un ensemble de cahiers des charges 
contenant de nombreux diagrammes UML). Le but de ce manuel n’est pas de discuter en 
détail des principes de conception d’un logiciel. Il est toutefois important de garder à l’esprit 
que la conception de l’application est une étape essentielle du développement dans 
ActionScript.
Notre premier exemple d’application ActionScript est une application standard de salutation, 
du type « Hello World ». Sa conception est donc très simple :
?
L’application se nommera HelloWorld. 
?
Elle affichera un seul champ texte contenant les termes « Hello World! ».
?
Pour qu’elle soit facilement réutilisable, elle utilisera une seule classe orientée objet, 
nommée Greeter, qui pourra être exploitée dans un document Flash ou une 
application Flex.
?
Une fois la version de base créée, vous pourrez ajouter d’autres fonctionnalités, par 
exemple inviter l’utilisateur à saisir son nom et comparer ce nom à une liste d’utilisateurs 
reconnus.
Cette définition bien établie, vous pouvez commencer à créer l’application elle-même.
60
Prise en main d’ActionScript

Création du projet HelloWorld et de la classe Greeter
Selon les décisions de conception, le code de l’application Hello World doit être facilement 
réutilisable. Pour satisfaire à cette exigence, l’application utilise une seule classe orientée objet, 
nommée Greeter, qui est exploitée au sein de l’application que vous allez créer dans Flex 
Builder ou l’outil de programmation Flash.
Pour créer la classe Greeter dans l’outil de programmation Flash :
1.
Dans l’outil de programmation Flash, choisissez Fichier > Nouveau.
2. Dans la boîte de dialogue Nouveau document, sélectionnez un fichier ActionScript et 
cliquez sur OK.
Une nouvelle fenêtre de modification ActionScript s’affiche.
3. Choisissez Fichier > Enregistrer. Sélectionnez un dossier pour votre application, nommez 
le fichier ActionScript , puis cliquez sur OK.
Passez à « Ajout de code à la classe Greeter », à la page 61.
Ajout de code à la classe Greeter
La classe Greeter définit un objet, Greeter, que vous pourrez utiliser dans votre application 
HelloWorld.
Pour ajouter du code à la classe Greeter :
1.
Tapez le code suivant dans le nouveau fichier :
package 
{
public class Greeter 
{
public function sayHello():String 
{
var greeting:String;
greeting = "Hello World!";
return greeting;
}
}
}
La classe Greeter inclut une seule méthode sayHello()  ; celle-ci renvoie une chaîne qui 
dit « Hello » au nom d’utilisateur indiqué.
2. Sélectionnez Fichier > Enregistrer pour enregistrer ce fichier ActionScript. 
Vous pouvez maintenant utiliser la classe Greeter dans une application Flash ou Flex.
Exemple : Création d’une application de base
61

Création d’une application utilisant votre code 
ActionScript
La classe Greeter que vous avez créée définit un ensemble autonome de fonctions logicielles, 
mais ne constitue pas pour autant une application complète. Pour l’utiliser, vous devez créer 
un document Flash ou une application Flex.
L’application HelloWorld crée une nouvelle instance de la classe Greeter. Voici la procédure 
d’association de la classe Greeter à votre application.
Pour créer une application ActionScript à l’aide de l’outil de programmation 
Flash :
1.
Sélectionnez Fichier > Nouveau.
2. Dans la boîte de dialogue Nouveau document, sélectionnez Document Flash et cliquez 
sur OK.
Une nouvelle fenêtre Flash apparaît.
3. Choisissez Fichier > Enregistrer. Sélectionnez le même dossier qui contient le fichier de la 
classe , nommez le document Flash , puis cliquez sur OK.
4. Dans la palette des outils de Flash, sélectionnez l’outil Texte et faites-le glisser sur la scène 
pour définir un nouveau champ texte d’environ 300 pixels de largeur et 100 pixels de 
hauteur.
5. Dans la fenêtre Propriétés, sélectionnez le champ texte sur la scène et tapez mainText 
comme nom d’instance du champ texte. 
6. Cliquez sur la première image du scénario principal.
7. Dans le panneau Actions, tapez le script suivant :
var myGreeter:Greeter = new Greeter();
= myGreeter.sayHello("Bob");
8. Enregistrez le fichier.
Passez à « Publication et test de votre application ActionScript », à la page 63.
62
Prise en main d’ActionScript

Publication et test de votre application ActionScript
Le développement logiciel est un processus itératif. Vous écrivez du code, essayez de le 
compiler, puis modifiez ce code jusqu’à ce que la compilation soit réussie. Vous exécutez, puis 
testez l’application compilée, pour voir si elle répond aux intentions de conception. Si ce n’est 
pas le cas, vous modifiez à nouveau le code, jusqu’à obtenir satisfaction. Les environnements 
de développement Flash et Flex Builder offrent plusieurs manières de publier, tester et 
déboguer vos applications. 
Voici une liste de base des étapes de test de l’application HelloWorld dans chacun de ces 
environnements.
Pour publier et tester une application ActionScript à l’aide de l’outil de 
programmation Flash :
1.
Publiez votre application et recherchez les erreurs de compilation. Dans l’outil de 
programmation Flash, sélectionnez Contrôle > Tester l’animation pour compiler votre 
code ActionScript et exécutez l’application HelloWorld. 
2. Si des erreurs ou des avertissements s’affichent dans la fenêtre Sortie lorsque vous testez 
votre application, résolvez-les dans les fichiers  ou , puis 
essayez de nouveau de tester l’application.
3. S’il n’existe aucune erreur de compilation, une fenêtre Flash Player affiche l’application 
Hello World. Le texte « Hello, Bob » s’affiche.
Vous venez de créer une application orientée objet simple mais complète qui utilise 
ActionScript 3.0. Passez à « Amélioration de l’application HelloWorld », à la page 63.
Amélioration de l’application HelloWorld
Pour rendre l’application un peu plus attrayante, vous allez maintenant faire en sorte qu’elle 
demande le nom de l’utilisateur et le compare à une liste prédéfinie de noms.
Tout d’abord, vous devez mettre à jour la classe Greeter de manière à ajouter cette 
fonctionnalité. Vous devez ensuite mettre à jour l’application Flex ou Flash afin d’exploiter 
cette fonctionnalité.
Pour mettre à jour le fichier  :
1.
Ouvrez le fichier .
Exemple : Création d’une application de base
63

2. Remplacez son contenu par le suivant (les lignes nouvelles et modifiées sont indiquées en 
gras) :
package
{
public class Greeter
{
/**
 * Defines the names that should receive a proper greeting.
 */
public static var validNames:Array = ["Sammy", "Frank", "Dean"];

/**
 * Builds a greeting string using the given name.
 */
public function sayHello(userName:String = ""):String 
{
var greeting:String;
if (userName == "") 
{

greeting = "Hello. Please type your user name, and then press 
the Enter key.";

else if (validName(userName)) 
{

greeting = "Hello, " + userName + ".";

else 
{

greeting = "Sorry, " + userName + ", you are not on the list.";
}
return greeting;
}
/**
 * Checks whether a name is in the validNames list.
 */
public static function validName(inputName:String = ""):Boolean 
{

if (validNames.indexOf(inputName) > -1) 
{

return true;

else 
{

return false;
}
}
}
}
64
Prise en main d’ActionScript

La classe Greeter présente maintenant plusieurs fonctions nouvelles :
?
Le tableau validNames répertorie les noms d’utilisateurs valables. Lors du chargement 
de la classe Greeter, ce tableau contient trois noms.
?
La méthode sayHello() accepte désormais un nom d’utilisateur et modifie la 
salutation en fonction de certaines conditions. Si le nom d’utilisateur userName est 
une chaîne vide (""), la propriété greeting permet de demander le nom de 
l’utilisateur. Si le nom d’utilisateur est valable, la salutation devient "Hello, 
userName." Enfin, si l’une de ces deux conditions n’est pas satisfaite, la variable 
greeting renvoie la valeur "Sorry, userName, you are not on the list." 
(Désolé, nom d’utilisateur, vous n’êtes pas sur la liste).
?
La méthode validName() renvoie la valeur true si le nom entré inputName se trouve 
dans le tableau validNames, et la valeur false s’il ne s’y trouve pas. L’instruction 
validNames.indexOf(inputName) compare toutes les chaînes du tableau 
validNames à la chaîne inputName. La méthode Array.indexOf() renvoie la 
position d’index de la première instance d’un objet dans un tableau ou la valeur -1 si 
l’objet ne s’y trouve pas.
Ensuite, vous devez modifier le fichier Flash ou Flex qui référence cette classe ActionScript.
Pour modifier l’application à l’aide de l’outil de programmation Flash :
1.
Ouvrez le fichier . 
2. Modifiez le script dans l’image 1 de façon à ce qu’une chaîne vide ("") soit transmise à la 
méthode sayHello() de la classe Greeter : 
var myGreeter:Greeter = new Greeter();
= myGreeter.sayHello("");
3. Sélectionnez l’outil Texte dans la palette des outils, puis créez deux champs texte sur la 
scène, l’un à côté de l’autre, et directement sous le champ texte mainText existant.
4. Dans le premier nouveau champ texte, tapez le texte Nom d’utilisateur : comme libellé.
5. Sélectionnez l’autre nouveau champ texte et dans l’inspecteur Propriétés, sélectionnez 
InputText comme type de champ texte. Tapez textIn comme nom d’instance.
6. Cliquez sur la première image du scénario principal.
Exemple : Création d’une application de base
65

7. Dans le panneau Actions, ajoutez les lignes suivantes à la fin du script existant :
mainText.border = true;
textIn.border = true;
textIn.addEventListener(KeyboardEvent.KEY_UP, keyPressed);
function keyPressed(event:Event):void
{
if (event.keyCode == Keyboard.ENTER)
{
= myGreeter.sayHello();
}
}
Le nouveau code ajoute la fonctionnalité suivante :
?
Les deux premières lignes définissent les bordures de deux champs texte.
?
Un champ texte d’entrée tel que le champ textIn a un ensemble d’événements qu’il 
peut envoyer. La méthode addEventListener() vous permet de définir une fonction 
exécutée lorsqu’un type d’événement se produit. Dans ce cas, cet événement est le fait 
d’appuyer sur la touche Entrée du clavier.
?
La fonction personnalisée keyPressed() appelle la méthode sayHello() de l’objet 
myGreeter, en transmettant le texte du champ texte textIn comme paramètre. Cette 
méthode renvoie une chaîne greeting en fonction de la valeur transmise. La chaîne 
renvoyée est ensuite affectée à la propriété text du champ texte mainText.
Le script complet pour l’image 1 est le suivant :
mainText.border = true;
textIn.border = true;
var myGreeter:Greeter = new Greeter();
= myGreeter.sayHello("");
textIn.addEventListener(KeyboardEvent.KEY_UP, keyPressed);
function keyPressed(event:Event):void
{
if (event.keyCode == Keyboard.ENTER)
{
= myGreeter.sayHello();
}
}
8. Enregistrez le fichier.
9. Choisissez Contrôle > Tester l’animation pour exécuter l’application. 
Lorsque vous exécutez l’application, il vous est demandé d’entrer un nom d’utilisateur. S’il est 
valide (Sammy, Frank, ou Dean), l’application affiche le message de confirmation « hello ».
66
Prise en main d’ActionScript

Exécution des exemples suivants
Maintenant que vous avez développé et exécuté l’application ActionScript 3.0 « HelloWorld », 
vous devez disposer des connaissances suffisantes pour exécuter les autres exemples de code 
proposés dans ce manuel.
Test des exemples de code contenus dans un 
chapitre
Au fur et à mesure que vous avancez dans ce manuel, vous pouvez tester les exemples de code 
utilisés pour illustrer les différentes rubriques. Ce test peut impliquer l’affichage de la valeur 
des variables à certains stades du programme, ou bien l’affichage ou l’interaction avec un 
contenu à l’écran. Pour tester le contenu visuel ou l’interaction, les éléments nécessaires seront 
décrits avant ou dans le code—il vous suffira de créer un document avec les éléments comme 
indiqué pour tester le code. Si vous souhaitez afficher la valeur d’une variable à un certain 
stade du programme, vous disposez de différentes façons pour le faire. Vous pouvez utiliser un 
débogueur tel que ceux intégrés dans Flex Builder et Flash. Pour un test simple, néanmoins, il 
peut être plus facile d’imprimer les valeurs des variables pour les visualiser.
Les étapes suivantes vous aideront à créer un document Flash que vous pouvez utiliser pour 
tester un code et afficher des valeurs de variables :
Pour créer un document Flash afin de tester des exemples contenus dans un 
chapitre :
1.
Créez un document Flash et enregistrez-le sur votre disque dur.
2. Pour afficher des valeurs de test dans un champ texte sur la scène, activez l’outil Texte et 
créez un champ texte dynamique sur la scène. Un champ texte haut et large avec le type de 
ligne défini sur Multiligne et la bordure activée sera très utile. Dans l’inspecteur Propriétés, 
donnez un nom d’instance au champ texte (par exemple « outputText »). Pour écrire des 
valeurs dans le champ texte, vous ajouterez un code qui appelle la méthode appendText() 
sur l’exemple de code (décrit ci-dessous).
3. Vous pouvez également ajouter un appel de la fonction trace() au code (comme décrit ci-
dessous) pour afficher les résultats de l’exemple.
4. Pour tester un exemple donné, copiez le code dans le panneau Actions ; si nécessaire, 
ajoutez un appel de la fonction trace() ou ajoutez une valeur au champ texte à l’aide de 
sa méthode appendText().
5. Dans le menu principal, choisissez Contrôle > Tester l’animation pour créer un fichier 
SWF et afficher les résultats.
Exécution des exemples suivants
67

Etant donné que cette approche sert à afficher les valeurs de variables, vous disposez de deux 
façons pour effectuer cette opération pendant que vous testez les exemples : écrire des valeurs 
dans une instance de champ texte sur la scène, ou utiliser la fonction trace() pour imprimer 
des valeurs sur le panneau Sortie.
?
La fonction trace() : La fonction trace() d’ActionScript écrit les valeurs des paramètres 
qui lui sont transmis (variables ou expressions littérales) sur le panneau Sortie. Un grand 
nombre des exemples fournis dans ce manuel comprend déjà un appel de la fonction 
trace(). Par conséquent, pour ces exemples, il vous suffit de copier le code dans votre 
document et de tester le projet. Si vous souhaitez utiliser trace() pour tester la valeur 
d’une variable dans un code qui ne la contient pas encore, ajoutez un appel trace() au 
code en transmettant la variable comme paramètre. Par exemple, si vous avez rencontré un 
code tel que celui-ci dans le chapitre,
var albumName:String = "Three for the money";
vous pouvez copier le code dans le panneau Actions, ajoutez ensuite un appel à la fonction 
trace() tel que celui-ci pour tester le résultat du code :
var albumName:String = "Three for the money";
trace("albumName =", albumName);
Lorsque vous exécuterez le programme, cette ligne sera imprimée :
albumName = Three for the money
Chaque appel de la fonction trace() peut prendre plusieurs paramètres, qui se suivent 
tous et forment une unité représentée par une ligne imprimée. Un saut de ligne est ajouté 
à la fin de chaque appel de la fonction trace(). Par conséquent, des appels trace() 
séparés sont imprimés sur des lignes séparées.
?
Un champ texte sur la scène : Si vous préférez ne pas utiliser la fonction trace(), vous 
pouvez ajouter un champ texte dynamique sur la scène à l’aide de l’outil Texte et écrire les 
valeurs dans ce champ texte de façon à afficher les résultats d’un code. La méthode 
appendText() de la classe TextField peut être utilisée pour ajouter une valeur String à la 
fin du contenu du champ texte. Pour accéder au champ texte à l’aide d’ActionScript, vous 
devez lui donner un nom d’instance dans l’inspecteur Propriétés. Par exemple, si votre 
champ texte a le nom d’instance outputText, le code suivant peut être utilisé pour vérifier 
la valeur de la variable albumName :
var albumName:String = "Three for the money";
outputText.appendText("albumName = ");
outputText.appendText(albumName);
Ce code écrit le texte suivant dans le champ texte outputText :
albumName = Three for the money
68
Prise en main d’ActionScript

Comme le montre l’exemple, la méthode appendText() ajoutera le texte sur la même 
ligne que le contenu précédent. Par conséquent, il est possible d’ajouter plusieurs valeurs 
sur la même ligne de texte à l’aide de plusieurs appels appendText(). Pour que le texte 
continue sur la ligne suivante, vous pouvez ajouter un caractère de nouvelle ligne ("\n") :
outputText.appendText("\n"); // adds a line break to the text field
Contrairement à la fonction trace(), la méthode appendText() accepte une seule valeur 
comme paramètre. Cette valeur doit être une chaîne (une instance String ou un littéral de 
chaîne). Pour imprimer la valeur d’une variable qui n’est pas une chaîne, vous devez 
d’abord convertir la valeur en une chaîne. Pour cela, la meilleure façon est d’appeler la 
méthode toString() de l’objet :
var albumYear:int = 1999;
outputText.appendText("albumYear = ");
outputText.appendText(albumYear.toString());
Utilisation des exemples de fin de chapitre
A l’instar de ce chapitre, la plupart des chapitres de ce manuel contient un exemple de fin de 
chapitre qui reprend un grand nombre des concepts traités. Néanmoins, contrairement à 
l’exemple Hello World de ce chapitre, ces exemples ne seront pas présentés avec des 
explications détaillées. Dans chaque exemple, le code ActionScript 3.0 considéré sera mis en 
évidence et étudié, mais aucune instruction ne sera fournie sur son exécution dans un 
environnement de développement spécifique. Néanmoins, les fichiers exemple fournis avec ce 
manuel incluent tous les fichiers nécessaires à la compilation et à l’exécution des exemples, 
selon l’environnement que vous aurez choisi.
Exécution des exemples suivants
69

70
Prise en main d’ActionScript

CHAPITRE 3
Syntaxe et langage 
3
ActionScript
ActionScript 3.0 comprend le langage ActionScript de base et l’interface de programmation 
d’application d’Adobe Flash Player (API). Le langage de base est la partie d’ActionScript qui 
implémente la spécification de langage ECMAScript (ECMA-262), version 4. L’API de Flash 
Player fournit un accès par programme à Flash Player.
Ce chapitre fournit une brève introduction à la syntaxe et au langage ActionScript de base. 
Il explique comment utiliser des types de données, des variables et la syntaxe appropriée et 
comment contrôler le flux de données entrant dans votre programme.
Contenu
Présentation du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Objets et classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Packages et espaces de nom  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Types de données  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Syntaxe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  111
Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .118
Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Boucle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
71

Présentation du langage
Les objets sont au centre du langage ActionScript 3.0 : ils constituent ses éléments 
fondamentaux. Chaque variable que vous déclarez, chaque fonction que vous écrivez et 
chaque instance de classe que vous créez est un objet. Un programme ActionScript 3.0 peut 
être comparé à un groupe d’objets qui effectuent des tâches, répondent à des événements et 
communiquent entre eux. 
Les programmeurs qui maîtrisent la programmation orientée objet dans Java ou C++ peuvent 
considérer les objets comme des modules contenant deux types de membres : les données 
enregistrées dans des variables de membre ou des propriétés, et le comportement accessible via 
des méthodes. La version 4 d’ECMAScript, la norme sur laquelle est basée ActionScript 3.0, 
définit des objets de façon presque identique. Dans la version d’ECMAScript, les objets sont 
simplement des ensembles de propriétés. Ces propriétés sont des conteneurs pouvant contenir 
non seulement des données, mais également des fonctions ou d’autres objets. Si une fonction 
est associée à un objet de cette façon, il s’agit d’une méthode. 
Alors qu’en théorie, la définition préliminaire d’ECMAScript peut paraître un peu étrange 
pour les programmeurs ayant l’habitude d’utiliser le langage Java ou C++, en pratique, la 
définition de types d’objets avec des classes ActionScript 3.0 est très semblable à la façon dont 
les classes sont définies dans Java ou C++. Il est important de distinguer les deux définitions 
d’objet lors de la présentation du modèle d’objet ActionScript et d’autres rubriques plus 
techniques, mais généralement, le terme propriétés fait référence à des variables de membre de 
classe, par opposition aux méthodes. La Référence du langage et des composants ActionScript 3.0
par exemple, utilise le terme propriétés pour des variables ou des propriétés de lecture/
définition. Il utilise le terme méthodes pour des fonctions faisant partie d’une classe.
Une légère différence entre les classes dans ActionScript et les classes dans Java ou C++ réside 
dans le fait que dans ActionScript, elles ne sont pas que des entités abstraites. Les classes 
ActionScript sont représentées par des objets de classe qui stockent les méthodes et les 
propriétés de la classe. Ainsi, des techniques pouvant sembler étranges pour les programmeurs 
de Java et C++ comme l’insertion d’instructions ou de code exécutable au niveau supérieur 
d’une classe ou d’un package sont autorisées.
72
Syntaxe et langage ActionScript

Une autre différence entre les classes ActionScript et les classes Java ou C++ réside dans le fait 
que chaque classe ActionScript possède un objet prototype. Dans les versions précédentes 
d’ActionScript, les objets prototypes, liés les uns aux autres en chaînes de prototypes, servaient 
de base à l’ensemble de la hiérarchie d’héritage de classe. Dans ActionScript 3.0, néanmoins, 
les objets prototypes ne jouent qu’un rôle mineur dans le système d’héritage. Cependant, 
l’objet prototype peut toujours être utile comme solution de rechange aux méthodes et aux 
propriétés statiques si vous souhaitez partager une propriété et sa valeur parmi toutes les 
instances d’une classe.
Auparavant, les programmeurs ActionScript expérimentés pouvaient manipuler directement 
la chaîne du prototype avec des éléments de langage intégrés spéciaux. Maintenant que le 
langage fournit une implémentation plus avancée d’une interface de programmation basée sur 
des classes, un grand nombre de ces éléments de langage spéciaux (__proto__ et __resolve,, 
par exemple) ne font plus partie du langage. De plus, les optimisations du mécanisme 
d’héritage interne qui améliorent nettement les performances de Flash Player empêchent 
d’accéder directement au mécanisme. 
Objets et classes
Dans ActionScript 3.0, chaque objet est défini par une classe. Une classe peut être considérée 
comme un modèle pour un type d’objet. Les définitions de classe peuvent inclure des variables 
et des constantes, qui comprennent des valeurs de données, et des méthodes, qui sont des 
fonctions encapsulant le comportement lié à la classe. Les valeurs stockées dans les propriétés 
peuvent être des valeurs primitives ou d’autres objets. Les valeurs primitives sont des nombres, 
des chaînes ou des valeurs booléennes. 
ActionScript contient de nombreuses classes intégrées faisant partie du langage de base. 
Certaines de ces classes intégrées (Number, Boolean et String, par exemple), représentent les 
valeurs primitives disponibles dans ActionScript. D’autres (Array, Math et XML, par exemple) 
définissent des objets plus complexes faisant partie de la norme ECMAScript. 
Toutes les classes, qu’elles soient intégrées ou définies par l’utilisateur, dérivent de la classe 
Object. Pour les programmeurs ayant une expérience avec ActionScript, il est important de 
noter que le type de données Object n’est plus le type de données par défaut, même si toutes 
les autres classes en dérivent. Dans ActionScript 2.0, les deux lignes de code suivantes étaient 
équivalentes car l’absence d’une annotation de type signifiait qu’une variable aurait été de type 
Object :
var someObj:Object;
var someObj;
Objets et classes
73

ActionScript 3.0, néanmoins, présente le concept de variables non typées, qui peuvent être 
désignées des deux façons suivantes :
var someObj:*;
var someObj;
Une variable non typée est différente d’une variable de type Object. La différence majeure est 
que les variables non typées peuvent contenir la valeur spéciale undefined, alors qu’une 
variable de type Object ne le peut pas. 
Vous pouvez définir vos propres classes à l’aide du mot-clé class. Vous pouvez déclarer des 
propriétés de classe de trois façons différentes : vous pouvez définir des constantes avec le mot-
clé const, des variables avec le mot-clé var et des propriétés de lecture et de définition au 
moyen des attributs get et set dans une déclaration de méthode. Vous pouvez déclarer des 
méthodes avec le mot-clé function. 
Vous créez une instance d’une classe à l’aide de l’opérateur new. L’exemple suivant crée une 
instance de la classe Date appelée myBirthday.
var myBirthday:Date = new Date();
Packages et espaces de nom
Les packages et les espaces de noms sont des concepts associés. Les packages vous permettent 
de regrouper des définitions de classe de façon à faciliter le partage de code et à réduire les 
conflits de noms. Les espaces de nom vous permettent de contrôler la visibilité des identifiants 
(noms de méthode et de propriété, par exemple) et peuvent être appliqués à un code se 
trouvant à l’intérieur ou à l’extérieur d’un package. Utilisez des packages pour organiser vos 
fichiers de classe et des espaces de nom pour gérer la visibilité des méthodes et des propriétés 
individuelles. 
Packages
Les packages dans ActionScript 3.0 sont mis en œuvre avec des espaces de nom, mais ils ne 
sont pas synonymes. Lorsque vous déclarez un package, vous créez implicitement un type 
d’espace de nom spécial qui est sûr d’être connu lors de la compilation. Les espaces de nom, 
lorsque vous les créez explicitement, ne sont pas nécessairement connus au moment de la 
compilation. 
74
Syntaxe et langage ActionScript

L’exemple suivant utilise la directive package pour créer un simple package contenant une 
classe : 
package samples
{
public class SampleCode
{
public var sampleGreeting:String;
public function sampleFunction()
{
trace(sampleGreeting + " from sampleFunction()");
}
}
}
Le nom de la classe dans cet exemple est SampleCode. Etant donné que la classe se trouve à 
l’intérieur du package samples, le compilateur qualifie automatiquement le nom de classe lors 
de la compilation sous la forme de son nom qualifié : samples.SampleCode. Le compilateur 
qualifie également les noms des propriétés ou des méthodes, de façon à ce que 
sampleGreeting et sampleFunction() deviennent respectivement 
samples.SampleCode.sampleGreeting et samples.SampleCode.sampleFunction().
Un grand nombre de développeurs (notamment ceux ayant une expérience de programmation 
Java) placent uniquement des classes au niveau supérieur d’un package. ActionScript 3.0, 
cependant, prend non seulement en charge des classes au niveau supérieur d’un package, mais 
également des variables, des fonctions et même des instructions. Une utilisation avancée de 
cette fonction consiste à définir un espace de nom au niveau supérieur d’un package de façon 
à ce que toutes les classes contenues dans ce dernier puissent l’utiliser. Il convient néanmoins 
de noter que seuls deux spécificateurs d’accès, public et internal, sont autorisés au niveau 
supérieur d’un package. Contrairement à Java qui vous permet de déclarer des classes 
imbriquées privées, ActionScript 3.0 ne prend en charge ni les classes imbriquées, ni les classes 
privées.
Néanmoins, les packages ActionScript 3.0 et les packages du langage de programmation Java 
présentent d’autres ressemblances. Comme vous pouvez l’observer dans l’exemple précédent, 
des références de package entièrement qualifiées sont exprimées à l’aide de l’opérateur point 
(.), comme dans Java. Vous pouvez utiliser des packages pour organiser votre code dans une 
structure hiérarchique intuitive que d’autres programmeurs peuvent utiliser. Ceci facilite le 
partage de code en vous permettant de créer votre propre package et de le partager avec 
d’autres personnes, et d’utiliser des packages créés par d’autres personnes dans votre code. 
Packages et espaces de nom
75

L’utilisation de packages vous permet également de vérifier que les noms d’identifiant que 
vous utilisez sont uniques et qu’ils ne sont pas incompatibles avec d’autres noms d’identifiant. 
Pour certaines personnes, il s’agit d’ailleurs de l’avantage principal des packages. Par exemple, 
deux programmeurs qui souhaitent partager leur code peuvent chacun avoir créé une classe 
appelée SampleCode. Sans packages, il y aurait un conflit de noms, et la seule façon de 
résoudre le problème serait de renommer l’une des classes. Mais avec des packages, vous 
pouvez éviter le conflit de noms en plaçant l’une des classes (ou de préférence les deux) dans 
des packages avec des noms uniques.
Vous pouvez également inclure des points intégrés dans le nom de votre package afin de créer 
des packages imbriqués. Ceci vous permet de créer une organisation hiérarchique des 
packages. Le package fourni par l’API de Flash Player illustre très bien ceci. 
Le package  est imbriqué dans le package Flash. 
Le package contient le programme d’analyse XML hérité utilisé dans les versions 
précédentes d’ActionScript. Il se trouve maintenant dans le package car le nom de la 
classe XML héritée est incompatible avec celui de la nouvelle classe XML qui met en œuvre 
l’XML pour la fonctionnalité de la spécification ECMAScript (E4X) disponible dans 
ActionScript 3.0. 
Même s’il est judicieux de commencer par déplacer la classe XML héritée dans un package, la 
plupart des utilisateurs des classes XML héritées importent le package , ce qui 
provoque le même conflit de noms à moins que vous utilisiez toujours le nom entièrement 
qualifié de la classe XML héritée (). Pour éviter cela, la classe XML héritée est 
maintenant appelée XMLDocument, comme l’indique l’exemple suivant : 
package
{
class XMLDocument {}
class XMLNode {}
class XMLSocket {}
}
La plus grande partie de l’API de Flash Player est organisée sous le package Flash. Par exemple, 
le package flash.display contient l’API de la liste d’affichage, et le package flash.events contient 
le nouveau modèle d’événement.
76
Syntaxe et langage ActionScript

Création de packages
ActionScript 3.0 vous permet d’organiser vos packages, classes et fichiers source avec une 
grande souplesse. Les versions précédentes d’ActionScript autorisaient uniquement une classe 
par fichier source et exigeaient que le nom du fichier source corresponde au nom de la classe. 
ActionScript 3.0 vous permet d’inclure plusieurs classes dans un fichier source, mais une seule 
classe dans chaque fichier peut être utilisée par le code externe à ce fichier. En d’autres termes, 
une seule classe dans chaque fichier peut être déclarée à l’intérieur d’une déclaration de 
package. Vous devez déclarer toute classe supplémentaire à l’extérieur de votre définition de 
package pour que ces classes soient invisibles pour le code externe à ce fichier source. Le nom 
de la classe déclarée à l’intérieur de la définition de package doit correspondre au nom du 
fichier source.
ActionScript 3.0 permet également de déclarer des packages avec davantage de flexibilité. 
Dans les versions précédentes d’ActionScript, les packages représentaient simplement des 
répertoires dans lesquels vous placiez des fichiers source, et vous ne déclariez pas les packages 
avec l’instruction package mais incluiez plutôt le nom du package dans le nom de classe 
complet dans votre déclaration de classe. Même si les packages continuent à représenter des 
répertoires dans ActionScript 3.0, leur contenu n’est pas limité aux seules classes. Dans 
ActionScript 3.0, vous utilisez l’instruction package pour déclarer un package, ce qui signifie 
que vous pouvez également déclarer des variables, des fonctions et des espaces de nom au 
niveau supérieur d’un package. Vous pouvez également y inclure des instructions exécutables. 
Si vous déclarez des variables, des fonctions ou des espaces de nom à ce niveau, les seuls 
attributs disponibles sont public et internal, et une seule déclaration au niveau du package 
par fichier peut utiliser l’attribut public, que cette déclaration soit une classe, une variable, 
une fonction ou un espace de nom. 
Les packages sont utiles pour organiser votre code et éviter les conflits de noms. Vous ne devez 
pas confondre le concept de packages avec le concept distinct d’héritage de classe. Deux classes 
se trouvant dans le même package ont un espace de nom en commun mais elles ne sont pas 
nécessairement liées l’une à l’autre. De même, il se peut qu’un package imbriqué n’ait aucun 
lien sémantique avec son package parent.
Packages et espaces de nom
77

Importation de packages
Si vous souhaitez utiliser une classe se trouvant à l’intérieur d’un package, vous devez importer 
soit le package soit la classe en question. Ceci diffère d’ActionScript 2.0 où l’importation de 
classes était facultatif. 
Par exemple, revenons à l’exemple de classe SampleCode fourni précédemment dans ce 
chapitre. Si la classe se trouve dans un package appelé samples, vous devez utiliser l’une des 
instructions d’importation suivantes avant d’utiliser la classe SampleCode :
import samples.*;
ou
import samples.SampleCode;
En général, les instructions import doivent être aussi spécifiques que possible. Si vous 
envisagez d’utiliser uniquement la classe SampleCode issue du package samples, importez 
uniquement la classe SampleCode au lieu du package entier auquel elle appartient. 
L’importation des packages entiers peut provoquer des conflits de noms inattendus.
Vous devez également placer le code source qui définit le package ou la classe dans votre 
chemin de classe. Le chemin de classe est une liste définie par l’utilisateur de chemins de 
répertoire locaux qui détermine l’endroit où le compilateur recherche des classes et des 
packages importés. Le chemin de classe est parfois appelé chemin de création ou chemin source
Une fois que vous avez importé correctement la classe ou le package, vous pouvez utiliser le 
nom entièrement qualifié de la classe (samples.SampleCode) ou simplement le nom de la 
classe (SampleCode).
Les noms entièrement qualifiés sont utiles lorsque des classes, des méthodes ou des propriétés 
ayant le même nom génèrent un code ambigu mais ils peuvent être difficiles à gérer si vous les 
utilisez pour tous les identifiants. Par exemple, l’utilisation du nom entièrement qualifié 
génère un code détaillé lorsque vous instanciez une instance de classe SampleCode :
var mySample:samples.SampleCode = new samples.SampleCode();
Plus les niveaux de packages imbriqués augmentent, moins votre code est lisible. Lorsque vous 
pensez que des identifiants ambigus ne sont pas un problème, vous pouvez rendre votre code 
plus lisible en utilisant des identifiants simples. Par exemple, l’instanciation d’une nouvelle 
instance de la classe SampleCode est beaucoup moins longue si vous utilisez uniquement 
l’identifiant de classe :
var mySample:SampleCode = new SampleCode();
Si vous tentez d’utiliser des noms d’identifiant sans importer au préalable la classe ou le 
package approprié, il est impossible pour le compilateur de trouver les définitions de classe. 
D’un autre côté, si vous importez un package ou une classe, toute tentative de définition d’un 
nom qui provoque un conflit avec un nom importé génère une erreur.
78
Syntaxe et langage ActionScript

Lors de la création d’un package, le spécificateur d’accès par défaut pour tous les membres de 
ce package est internal, ce qui signifie que, par défaut, les membres du package ne sont 
visibles que pour d’autres membres de ce package. Si vous souhaitez qu’une classe soit 
disponible pour un code externe au package, vous devez la déclarer public. Par exemple, le 
package suivant contient deux classes, SampleCode et CodeFormatter : 
// fichier
package samples
{
public class SampleCode {}
}
// fichier
package samples
{
class CodeFormatter {}
}
La classe SampleCode est visible en dehors du package car elle est déclarée comme classe 
public. La classe CodeFormatter, cependant, est visible uniquement dans le package samples. 
Si vous tentez d’accéder à la classe CodeFormatter en dehors du package samples, vous générez 
une erreur, comme l’indique l’exemple suivant :
import samples.SampleCode;
import samples.CodeFormatter;
var mySample:SampleCode = new SampleCode(); // okay, classe public
var myFormatter:CodeFormatter = new CodeFormatter(); // erreur
Si vous souhaitez que les deux classes soient disponibles en dehors du package, vous devez les 
déclarer public. Vous ne pouvez pas appliquer l’attribut public à la déclaration de package. 
Les noms entièrement qualifiés sont utiles pour résoudre les conflits de noms pouvant se 
produire lors de l’utilisation de packages. Un tel scénario peut se produire si vous importez 
deux packages qui définissent des classes ayant le même identifiant. Par exemple, prenez en 
compte le package suivant, qui possède également une classe appelée SampleCode :
package langref.samples
{
public class SampleCode {}
}
Si vous importez les deux classes, comme suit, vous avez un conflit de noms lorsque vous vous 
référez à la classe SampleCode :
import samples.SampleCode;
import langref.samples.SampleCode;
var mySample:SampleCode = new SampleCode(); // conflit de noms
Packages et espaces de nom
79

Le compilateur n’a aucun moyen de savoir quelle classe SampleCode il doit utiliser. Pour 
résoudre ce conflit, vous devez utiliser le nom entièrement qualifié de chaque classe, comme 
suit :
var sample1:samples.SampleCode = new samples.SampleCode();
var sample2:langref.samples.SampleCode = new langref.samples.SampleCode();
REMARQUE
Les programmeurs ayant une expérience C++ confondent souvent l’instruction import 
avec l’instruction #include. La directive #include est nécessaire dans C++ car les 
compilateurs C++ traitent un fichier à la fois et ne cherchent pas de définitions de classe 
dans d’autres fichiers, à moins qu’un fichier d’en-tête soit inclus explicitement. 
ActionScript 3.0 a une directive include, mais elle n’est pas conçue pour importer des 
classes et des packages. Pour importer des classes ou des packages dans ActionScript 
3.0, vous devez utiliser l’instruction import et placer le fichier source qui contient le 
package dans le chemin de classe.
Espaces de noms
Les espaces de nom vous permettent de contrôler la visibilité des propriétés et des méthodes 
que vous créez. Considérez les spécificateurs de contrôle d’accès public, private, 
protected, et internal comme des espaces de nom intégrés. Si ces spécificateurs de 
contrôle d’accès prédéfinis ne répondent pas à vos besoins, vous pouvez créer vos propres 
espaces de nom. 
Si vous avez l’habitude d’utiliser des espaces de nom XML, cette section ne vous fournira pas 
de nouvelles informations, bien que la syntaxe et les détails de l’implémentation 
d’ActionScript soient légèrement différents de ceux d’XML. Si vous n’avez jamais travaillé 
avec des espaces de nom, le concept est simple, mais l’implémentation possède une 
terminologie particulière que vous devrez apprendre. 
Pour comprendre comment fonctionnent les espaces de nom, il convient de savoir que le nom 
d’une propriété ou d’une méthode contient deux parties : un identifiant et un espace de nom. 
L’identifiant est ce que vous considérez généralement comme un nom. Par exemple, les 
identifiants dans la définition de classe suivante sont sampleGreeting et sampleFunction():
class SampleCode
{
var sampleGreeting:String;
function sampleFunction () {
trace(sampleGreeting + " from sampleFunction()");
}
}
80
Syntaxe et langage ActionScript

Lorsque les définitions ne sont pas précédées d’un attribut d’espace de nom, leurs noms sont 
qualifiés par l’espace de nom internal par défaut, ce qui signifie qu’ils sont visibles 
uniquement aux appelants du même package. Si le compilateur est défini sur le mode strict, il 
génère un avertissement indiquant que l’espace de nom internal s’applique à tout identifiant 
sans attribut d’espace de nom. Pour vérifier qu’un identifiant est disponible partout, vous 
devez spécifiquement faire précéder le nom de l’identifiant de l’attribut public. Dans 
l’exemple de code précédent, sampleGreeting et sampleFunction() ont une valeur d’espace 
de nom d’internal.
Vous devez suivre trois étapes de base lorsque vous utilisez des espaces de nom. Premièrement, 
vous devez définir l’espace de nom à l’aide du mot-clé namespace. Par exemple, le code 
suivant définit l’espace de nom version1 : 
namespace version1;
Deuxièmement, vous appliquez votre espace de nom en l’utilisant à la place d’un spécificateur 
de contrôle d’accès dans une déclaration de méthode ou de propriété. L’exemple suivant place 
une fonction appelée myFunction() dans l’espace de nom version1 :
version1 function myFunction() {}
Troisièmement, une fois que vous avez appliqué l’espace de nom, vous pouvez le référencer à 
l’aide de la directive use ou en qualifiant le nom d’un identifiant avec un espace de nom. 
L’exemple suivant fait référence à la fonction myFunction() à l’aide de la directive use :
use namespace version1;
myFunction();
Vous pouvez également utiliser un nom qualifié pour référencer la fonction myFunction(), 
comme l’indique l’exemple suivant :
version1::myFunction();
Définition d’espaces de nom
Les espaces de nom contiennent une valeur, l’URI (Uniform Resource Identifier), parfois 
appelée nom d’espace de nom. Un URI vous permet de vérifier que votre définition d’espace de 
nom est unique. 
Vous créez un espace de nom en déclarant une définition d’espace de nom de deux façons 
différentes. Vous pouvez soit définir un espace de nom avec un URI explicite, comme vous 
définiriez un espace de nom XML, soit omettre l’URI. L’exemple suivant indique comment 
un espace de nom peut être défini à l’aide d’un URI :
namespace flash_proxy = “”;
Packages et espaces de nom
81

L’URI sert de chaîne d’identification unique pour cet espace de nom. Si vous omettez l’URI, 
comme dans l’exemple suivant, le compilateur crée une chaîne d’identification interne unique 
à la place de l’URI. Vous n’avez pas accès à cette chaîne d’identification interne.
namespace flash_proxy;
Une fois que vous avez défini un espace de nom (avec ou sans URI), vous ne pouvez pas le 
redéfinir dans le même domaine. Une tentative de définition d’un espace de nom ayant été 
défini dans le même domaine génère une erreur du compilateur. 
Si un espace de nom est défini dans un package ou une classe, il risque de ne pas être visible au 
code externe à ce package ou à cette classe, à moins que vous utilisez le spécificateur de 
contrôle d’accès approprié. Par exemple, le code suivant indique l’espace de nom 
flash_proxy défini dans le package flash.utils. Dans l’exemple suivant, l’absence de 
spécificateur de contrôle d’accès signifie que l’espace de nom flash_proxy est visible 
uniquement au code dans le package flash.utils et non au code externe au package :
package flash.utils
{
namespace flash_proxy;
}
Le code suivant utilise l’attribut public pour rendre l’espace de nom flash_proxy visible au 
code externe au package :
package flash.utils
{
public namespace flash_proxy;
}
Application d’espaces de nom
Appliquer un espace de nom signifie placer une définition dans un espace de nom. 
Les définitions que vous pouvez placer dans des espaces de nom peuvent être des fonctions, 
des variables et des constantes (vous ne pouvez pas placer une classe dans un espace de nom 
personnalisé). 
82
Syntaxe et langage ActionScript

Supposez, par exemple, que vous avez une fonction déclarée à l’aide de l’espace de nom de 
contrôle d’accès public. L’utilisation de l’attribut public dans une définition de fonction 
place la fonction dans l’espace de nom public et rend la fonction visible à tout le code. 
Une fois que vous avez défini un espace de nom, vous pouvez l’utiliser de la même façon que 
vous utiliseriez l’attribut public, et la définition est disponible au code pouvant référencer 
votre espace de nom personnalisé. Par exemple, si vous définissez un espace de nom 
example1, vous pouvez ajouter une méthode appelée myFunction() à l’aide de example1 
comme attribut, tel que l’indique l’exemple suivant :
namespace example1;
class someClass
{
example1 myFunction() {}
}
Déclarer la méthode myFunction() à l’aide de l’espace de nom example1 comme attribut 
signifie que la méthode appartient à l’espace de nom example1. 
Tenez compte des points suivants lorsque vous appliquez des espaces de nom :
?
Vous pouvez appliquer un espace de nom uniquement à chaque déclaration. 
?
Il n’existe aucun moyen d’appliquer un attribut d’espace de nom à plusieurs définitions 
simultanément. En d’autres termes, si vous souhaitez appliquer votre espace de nom à dix 
fonctions différentes, vous devez ajouter votre espace de nom comme attribut à chacune 
des dix définitions de fonction. 
?
Si vous appliquez un espace de nom, vous ne pouvez pas spécifier un spécificateur de 
contrôle d’accès car les espaces de nom et les spécificateurs de contrôle d’accès s’excluent 
mutuellement. En d’autres termes, vous ne pouvez pas déclarer une fonction ou une 
propriété comme public, private, protected, ou internal si vous appliquez votre 
espace de nom.
Référence d’espaces de nom
Il est inutile de référencer explicitement un espace de nom lorsque vous utilisez une méthode 
ou une propriété déclarée avec l’un des espaces de nom de contrôle d’accès (public, private, 
protected et internal, par exemple). En effet, l’accès à ces espaces de nom spéciaux dépend 
du contexte. Par exemple, les définitions placées dans l’espace de nom private sont 
automatiquement disponibles pour le code dans la même classe. Pour les espaces de nom que 
vous définissez, cependant, le contexte ne compte pas. Pour utiliser une méthode ou une 
propriété que vous avez placée dans un espace de nom personnalisé, vous devez référencer 
l’espace de nom.
Packages et espaces de nom
83

Vous pouvez référencer des espaces de nom avec la directive use namespace ou qualifier le 
nom avec l’espace de nom à l’aide du ponctuateur de qualificatif de nom (::). Le fait de 
référencer un espace de nom avec la directive use namespace « ouvre » l’espace de nom, ce 
qui permet de l’appliquer à n’importe quel identifiant non qualifié. Par exemple, si vous avez 
défini l’espace de nom example1, vous pouvez accéder aux noms dans cet espace de nom en 
utilisant use namespace example1 :
use namespace example1;
myFunction();
Vous pouvez ouvrir plusieurs espaces de nom simultanément. Une fois que vous avez ouvert 
un espace de nom avec use namespace, il reste ouvert dans le bloc de code dans lequel il a été 
ouvert. Il n’existe aucun moyen pour fermer explicitement un espace de nom.
Néanmoins, le fait d’avoir plusieurs espaces de nom ouverts augmente la probabilité que des 
conflits de noms se produisent. Si vous préférez ne pas ouvrir d’espace de nom, vous pouvez 
éviter la directive use namespace en qualifiant le nom de la propriété ou de la méthode avec 
l’espace de nom et le ponctuateur de qualificatif de nom. Par exemple, le code suivant indique 
comment vous pouvez qualifier le nom myFunction() avec l’espace de nom example1 :
example1::myFunction();
Utilisation d’espaces de nom
Vous pouvez trouver un exemple concret d’espace de nom utilisé pour empêcher les conflits de 
nom dans la classe flash.utils.Proxy qui fait partie de l’API de Flash Player. La classe Proxy, qui 
remplace la propriété Object.__resolve d’ActionScript 2.0, vous permet d’intercepter des 
références vers des méthodes ou des propriétés non définies avant qu’une erreur se produise. 
Toutes les méthodes de la classe Proxy se trouvent dans l’espace de nom flash_proxy afin 
d’empêcher les conflits de noms.
Pour mieux comprendre comment l’espace de nom flash_proxy est utilisé, vous devez savoir 
comment utiliser la classe Proxy. La fonctionnalité de la classe Proxy est disponible 
uniquement aux classes qui héritent d’elle. En d’autres termes, si vous souhaitez utiliser les 
méthodes de la classe Proxy d’un objet, la définition de classe de l’objet doit étendre la classe 
Proxy. Par exemple, si vous souhaitez intercepter des tentatives d’appel d’une méthode non 
définie, vous devez étendre la classe Proxy puis remplacer la méthode callProperty() de la 
classe Proxy. 
84
Syntaxe et langage ActionScript

L’implémentation des espaces de nom est généralement un processus en trois étapes 
(définition, application et référence d’un espace de nom). Etant donné que vous n’appelez 
jamais explicitement une méthode de la classe Proxy, cependant, l’espace de nom 
flash_proxy est défini et appliqué uniquement, jamais référencé. L’API de Flash Player 
définit l’espace de nom flash_proxy et l’applique dans la classe Proxy. Votre code doit 
uniquement appliquer l’espace de nom flash_proxy à des classes qui étendent la classe Proxy. 
L’espace de nom flash_proxy est défini dans le package flash.utils d’une manière semblable à 
la suivante :
package flash.utils
{
public namespace flash_proxy;
}
L’espace de nom est appliqué aux méthodes de la classe Proxy comme indiqué dans l’extrait 
suivant issu de la classe Proxy :
public class Proxy
{
flash_proxy function callProperty(name:*, rest):*
flash_proxy function deleteProperty(name:*):Boolean

}
Comme l’indique le code suivant, vous devez d’abord importer la classe Proxy et l’espace de 
nom flash_proxy. Vous devez ensuite déclarer votre classe de façon à ce qu’elle étende la 
classe Proxy (vous devez également ajouter l’attribut dynamic si vous compilez en mode 
strict). Lorsque vous remplacez la méthode callProperty(), vous devez utiliser l’espace de 
nom flash_proxy.
package
{
import flash.utils.Proxy;
import flash.utils.flash_proxy;
dynamic class MyProxy extends Proxy
{
flash_proxy override function callProperty(name:*, rest):*
{
trace("method call intercepted: " + name);
}
}
}
Packages et espaces de nom
85

Si vous créez une instance de la classe MyProxy et appelez une méthode non définie 
(la méthode testing() appelée dans l’exemple suivant, par exemple), votre objet Proxy 
intercepte l’appel de méthode et exécute les instructions se trouvant dans la méthode 
callProperty() remplacée (dans ce cas, une instruction trace() simple).
var mySample:MyProxy = new MyProxy();
mySample.testing(); // appel de méthode intercepté : test
Le fait que les méthodes de la classe Proxy se trouvent dans l’espace de nom flash_proxy 
présente deux avantages. Premièrement, le fait d’avoir un espace de nom séparé réduit 
l’encombrement dans l’interface publique des classes qui étendent la classe Proxy (il existe 
environ douze méthodes dans la classe Proxy que vous pouvez remplacer. Elles ne sont pas 
conçues pour être appelées directement. Le fait de toutes les placer dans l’espace de nom 
public peut prêter à confusion). Deuxièmement, le fait d’utiliser l’espace de nom 
flash_proxy évite les conflits de nom si votre sous-classe Proxy contient des méthodes 
d’instance avec des noms correspondant à l’une des méthodes de la classe Proxy. Par exemple, 
vous pouvez nommer l’une de vos méthodes callProperty(). Le code suivant est acceptable 
car votre version de la méthode callProperty() se trouve dans un espace de nom différent :
dynamic class MyProxy extends Proxy
{
public function callProperty() {}
flash_proxy override function callProperty(name:*, rest):*
{
trace("method call intercepted: " + name);
}
}
Vous pouvez également utiliser des espaces de nom pour accéder à des méthodes ou à des 
propriétés autrement qu’avec les quatre spécificateurs de contrôle d’accès (public, private, 
internal et protected). Par exemple, vous pouvez avoir des méthodes d’utilitaire éparpillées 
sur plusieurs packages. Vous souhaitez que ces méthodes soient disponibles pour tous vos 
packages, mais vous ne souhaitez pas qu’elles soient publiques. Pour cela, vous pouvez créer un 
espace de nom et l’utiliser comme spécificateur de contrôle d’accès spécial. 
L’exemple suivant utilise un espace de nom défini par l’utilisateur pour regrouper deux 
fonctions se trouvant dans différents packages. En les regroupant dans le même espace de 
nom, vous pouvez rendre les deux fonctions visibles à une classe ou à un package au moyen 
d’une seule instruction use namespace.
86
Syntaxe et langage ActionScript

Cet exemple utilise quatre fichiers pour démontrer la technique. Tous les fichiers doivent se 
trouver dans votre chemin de classe. Le premier fichier, , sert à définir l’espace de 
nom myInternal. Etant donné que le fichier se trouve dans un package appelé example, vous 
devez placer le fichier dans un dossier appelé example. L’espace de nom est marqué comme 
public pour pouvoir être importé dans d’autres packages. 
// dans le dossier example
package example
{
public namespace myInternal = "
examples";
}
Le deuxième et le troisième fichiers,  et , définissent les classes qui 
contiennent des méthodes devant être disponibles pour d’autres packages. La classe Utility se 
trouve dans le package example.alpha, ce qui signifie que le fichier doit être placé dans un 
dossier appelé alpha qui est un sous-dossier du dossier example. La classe Helper se trouve 
dans le package , ce qui signifie que le fichier doit être placé dans un dossier 
appelé beta qui est également un sous-dossier du dossier example. Ces deux packages, 
example.alpha et , doivent importer l’espace de nom avant de l’utiliser.
// dans le dossier example/alpha
package example.alpha
{
import example.myInternal;
public class Utility
{
private static var _taskCounter:int = 0;
public static function someTask()
{
_taskCounter++;
}
myInternal static function get taskCounter():int
{
return _taskCounter;
}
}
}
Packages et espaces de nom
87

// dans le dossier example/beta
package
{
import example.myInternal;
public class Helper
{
private static var _timeStamp:Date;
public static function someTask()
{
_timeStamp = new Date();
}
myInternal static function get lastCalled():Date
{
return _timeStamp;
}
}
}
Le quatrième fichier, , est la classe de l’application principale et doit être 
un frère pour le dossier example. Dans Adobe Flash CS3 Professional, cette classe serait 
utilisée comme classe Document pour le FLA. La classe NamespaceUseCase importe 
également l’espace de nom myInternal et l’utilise pour appeler deux méthodes statiques qui 
résident dans les autres packages. L’exemple utilise des méthodes statiques pour simplifier le 
code uniquement. Les méthodes statiques et d’instance peuvent être placées dans l’espace de 
nom myInternal.
//
package
{
import flash.display.MovieClip;
import example.myInternal;       // importation de l’espace de nom
import example.alpha.Utility;    // importation de la classe Utility
import .Helper;      // importation de la classe Helper
public class NamespaceUseCase extends MovieClip
{
public function NamespaceUseCase()
{
use namespace myInternal;
Utility.someTask();
Utility.someTask();
trace(Utility.taskCounter); // 2
Helper.someTask();
trace(Helper.lastCalled);   // [heure de dernier appel de someTask()]
}
}
}
88
Syntaxe et langage ActionScript

Variables
Les variables vous permettent de stocker des valeurs que vous utilisez dans votre programme. 
Pour déclarer une variable, vous devez utiliser l’instruction var avec le nom de variable. Dans 
ActionScript 2.0, l’utilisation de l’instruction var est nécessaire uniquement si vous utilisez 
des annotations de type. Dans ActionScript 3.0, l’utilisation de l’instruction var est toujours 
nécessaire. Par exemple, la ligne d’ActionScript suivante déclare une variable appelée i : 
var i;
Si vous omettez l’instruction var lors de la déclaration d’une variable, vous obtenez une erreur 
de compilateur en mode strict et une erreur d’exécution en mode standard. Par exemple, la 
ligne de code suivante provoque une erreur si la variable i n’a pas été définie précédemment :
i; // erreur si i n’a pas été définie précédemment
Vous devez associer une variable à un type de données lorsque vous déclarez la variable. 
La déclaration d’une variable sans désigner son type est autorisée mais provoque un 
avertissement du compilateur en mode strict. Vous désignez le type d’une variable en ajoutant 
le nom de variable avec deux-points (:), suivi par le type de variable. Par exemple, le code 
suivant déclare une variable i de type int :
var i:int;
Vous pouvez affecter une valeur à une variable à l’aide de l’opérateur d’affectation (=). 
Par exemple, le code suivant déclare une variable i et lui affecte la valeur 20 :
var i:int;
i = 20;
Il peut être plus pratique d’affecter une valeur à une variable au moment où vous déclarez 
cette dernière, comme dans l’exemple suivant :
var i:int = 20;
La technique d’affectation d’une valeur à une variable au moment de sa déclaration est 
couramment utilisée non seulement lors de l’affectation de valeurs primitives (nombres entiers 
et chaînes) mais également lors de la création d’un tableau ou de l’instanciation de l’instance 
d’une classe. L’exemple suivant illustre un tableau déclaré auquel est affecté une valeur à l’aide 
d’une ligne de code.
var numArray:Array = ["zero", "one", "two"];
Vous pouvez créer une instance d’une classe à l’aide de l’opérateur new. L’exemple suivant crée 
une instance d’une classe appelée CustomClass, et affecte une référence à l’instance de classe 
nouvellement créée sur la variable appelée customItem :
var customItem:CustomClass = new CustomClass();
Variables
89

Si vous avez plusieurs variables à déclarer, vous pouvez le faire sur une ligne de code à l’aide de 
l’opérateur virgule (,) pour séparer les variables. Par exemple, le code suivant déclare trois 
variables sur une ligne de code :
var a:int, b:int, c:int;
Vous pouvez également affecter des valeurs à chacune des valeurs sur la même ligne de code. 
Par exemple, le code suivant déclare trois variables (a, b, et c) et affecte une valeur à chacune 
d’entre elles :
var a:int = 10, b:int = 20, c:int = 30;
Bien que vous puissiez utiliser l’opérateur virgule pour regrouper des déclarations de variable 
dans une instruction, ceci risque de rendre votre code moins lisible.
Présentation du domaine de variable
Le domaine d’une variable est la partie de votre code dans laquelle une référence lexicale peut 
accéder à la variable. Une variable globale est une variable définie dans toutes les parties de 
votre code, alors qu’une variable locale est une variable définie dans une seule partie de votre 
code. Dans ActionScript 3.0, le domaine des variables est toujours limité à la fonction ou à la 
classe dans laquelle elles sont déclarées. Une variable globale est une variable que vous 
définissez en dehors de toute définition de classe ou de fonction. Par exemple, le code suivant 
crée une variable globale strGlobal en la déclarant en dehors de toute fonction. L’exemple 
indique qu’une variable globale est disponible à la fois à l’intérieur et à l’extérieur de la 
définition de fonction. 
var strGlobal:String = "Global";
function scopeTest()
{
trace(strGlobal); // Globale
}
scopeTest();
trace(strGlobal); // Globale
Vous déclarez une variable locale en déclarant la variable à l’intérieur d’une définition de 
fonction. La plus petite partie de code pour laquelle vous pouvez définir une variable locale est 
une définition de fonction. Une variable locale déclarée dans une fonction existe uniquement 
dans cette fonction. Par exemple, si vous déclarez une variable nommée str2 dans une 
fonction appelée localScope(), cette variable ne sera pas disponible en dehors de cette 
fonction.
function localScope()
{
var strLocal:String = "local";
}
localScope();
trace(strLocal); // erreur car strLocal n’est pas définie globalement
90
Syntaxe et langage ActionScript

Si le nom utilisé pour votre variable locale est déjà déclaré en tant que variable globale, la 
définition locale masque la définition globale alors que la variable locale est dans le domaine. 
La variable globale persiste en dehors de la fonction. Par exemple, le code suivant crée une 
variable globale 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 valeur locale de 
la variable, tandis que celle qui est placée en dehors de la fonction génère la valeur globale de 
la variable.
var str1:String = "Global";
function scopeTest ()
{
var str1:String = "Local";
trace(str1); // Locale
}
scopeTest();
trace(str1); // Globale
Les variables ActionScript, contrairement aux variables dans C++ et Java, n’ont pas de 
domaine de niveau bloc. Un bloc de code est un groupe d’instructions placé entre une 
accolade d’ouverture ( { ) et une accolade de fermeture ( } ). Dans certains langages de 
programmation tels que C++ et Java, les variables déclarées dans un bloc de code ne sont pas 
disponibles en dehors de ce bloc de code. Cette restriction de domaine est appelée domaine de 
niveau bloc et n’existe pas dans ActionScript. Si vous déclarez une variable à l’intérieur d’un 
bloc de code, elle est disponible non seulement dans ce bloc de code mais également dans 
d’autres parties de la fonction à laquelle le bloc de code appartient. Par exemple, la fonction 
suivante contient des variables définies dans différents domaines de bloc. Toutes les variables 
sont disponibles dans la fonction. 
function blockTest (testArray:Array)
{
var numElements:int = testArray.length;
if (numElements > 0)
{
var elemStr:String = "Element #";
for (var i:int = 0; i < numElements; i++)
{
var valueStr:String = i + ": " + testArray[i];
trace(elemStr + valueStr);
}
trace(elemStr, valueStr, i);   // toutes toujours définies
}
trace(elemStr, valueStr, i); // toutes définies si numElements > 0
}
blockTest(["Earth", "Moon", "Sun"]);
Variables
91

Une implication intéressante de l’absence de domaine de niveau bloc est que vous pouvez lire 
ou écrire dans une variable avant de la déclarer, tant qu’elle est déclarée avant que la fonction 
se termine. Ceci est dû à une technique appelée hissage, qui signifie que le compilateur déplace 
toutes les déclarations de variable en haut de la fonction. Par exemple, le code suivant compile 
même si la fonction trace() initiale pour la variable num se produit avant la déclaration de la 
variable num :
trace(num); // NaN
var num:Number = 10;
trace(num); // 10
Néanmoins, le compilateur ne hisse aucune instruction d’affectation. Ceci explique pourquoi 
la fonction trace() initiale de num fournit NaN (pas un nombre), qui est la valeur par défaut 
pour des variables du type de données Number. Cela signifie que vous pouvez affecter des 
valeurs à des variables même avant leur déclaration, comme indiqué dans l’exemple suivant :
num = 5;
trace(num); // 5
var num:Number = 10;
trace(num); // 10
Valeurs par défaut
Une 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 d’une variable non 
initialisée dépend de son type de données. Le tableau suivant décrit les valeurs par défaut des 
variables, organisées par type de données :
Type de données
Valeur par défaut
Boolean
false
int
0
Number
NaN
Object
null
String
null
uint
0
Non déclaré (équivalent à l’annotation de type *)
undefined
Toutes les autres classes, y compris celles définies par 
null
l’utilisateur.
92
Syntaxe et langage ActionScript

Pour les variables de type Number, la valeur par défaut est NaN (pas un nombre), qui est une 
valeur spéciale définie par la norme IEEE-754 pour indiquer une valeur qui ne représente pas 
un nombre. 
Si vous déclarez une variable sans déclarer son type de données, le type de données par défaut 
* s’applique, ce qui signifie que la variable n’est pas typée. Si vous n’initialisez pas non plus de 
variable non typée avec une valeur, sa valeur par défaut est undefined.
Pour les types de données autres que Boolean, Number, int, et uint, la valeur par défaut d’une 
variable non initialisée est null. Ceci s’applique à toutes les classes définies par l’API de Flash 
Player, ainsi qu’aux classes personnalisées que vous créez. 
La valeur null n’est pas une valeur valide pour des variables de type Boolean, Number, int, ou 
uint. Si vous tentez d’affecter une valeur null à une telle variable, la valeur est convertie à la 
valeur par défaut pour ce type de données. Pour les variables de type Object, vous pouvez 
affecter une valeur null. Si vous tentez d’affecter la valeur undefined à une variable de type 
Object, la valeur est convertie en null. 
Pour les variables de type Number, il existe une fonction de niveau supérieur spéciale appelée 
isNaN() qui renvoie la valeur Boolean true si la variable n’est pas un nombre, et false 
autrement.
Types de données
Un type de données définit un ensemble de valeurs. Par exemple, le type de données Boolean 
est l’ensemble de deux valeurs exactement : true et false. Outre le type de données Boolean, 
ActionScript 3.0 définit plusieurs autres types de données couramment utilisés tels que String, 
Number et Array. Vous pouvez définir vos types de donnés en utilisant des classes ou des 
interfaces afin de définir un ensemble de valeurs personnalisé. Toutes les valeurs dans 
ActionScript 3.0, qu’elles soient primitives ou complexessont des objets. 
Une valeur primitive est une valeur qui appartient à l’un des types de données suivants : 
Boolean, int, Number, String, et uint. L’utilisation de valeurs primitives est généralement plus 
rapide que l’utilisation de valeurs complexes car ActionScript stocke les valeurs primitives de 
façon à permettre des optimisations de vitesse et de mémoire. 
RE
Pour les lecteurs intéressés par les détails techniques, ActionScript stocke les valeurs 
M
A
primitives en tant qu’objets inaltérables. Le fait qu’elles soient stockées en tant qu’objets 
R
inaltérables signifie que le transfert par référence est identique au transfert par valeur. 
Q
UE
Ceci réduit l’utilisation de la mémoire et augmente la vitesse d’exécution car les références 
sont généralement beaucoup plus petites que les valeurs elles-mêmes.
Types de données
93

Une valeur complexe est une valeur qui n’est pas une valeur primitive. Les types de données qui 
définissent des ensembles de valeurs complexes comprennent Array, Date, Error, Function, 
RegExp, XML, et XMLList. 
De nombreux langages de programmation font la distinction entre les valeurs primitives et 
leurs enveloppes. Java, par exemple, a une valeur primitive int et la classe .Integer qui 
l’enveloppe. Les valeurs primitives de Java ne sont pas des objets, mais leurs enveloppes le 
sont, ce qui rend les valeurs primitives utiles pour certaines opérations et les enveloppes pour 
d’autres. Dans ActionScript 3.0, les valeurs primitives et leurs enveloppes sont 
indifférenciables, à des fins pratiques. Toutes les valeurs, même les valeurs primitives, sont des 
objets. Flash Player traite ces types primitifs comme des cas spéciaux qui se comportent 
comme des objets n’exigeant pas le temps normal associé à la création d’objets. Cela signifie 
que les deux lignes de code suivantes sont équivalentes :
var someInt:int = 3;
var someInt:int = new int(3);
Tous les types de données primitifs et complexes répertoriés ci-dessus sont définis par les 
classes de base d’ActionScript 3.0. Les classes de base vous permettent de créer des objets à 
l’aide de valeurs littérales au lieu d’utiliser l’opérateur new. Par exemple, vous pouvez créer un 
tableau à l’aide d’une valeur littérale ou du constructeur de classe Array, comme suit :
var someArray:Array = [1, 2, 3]; // valeur littérale
var someArray:Array = new Array(1,2,3); // constructeur Array
Vérification des types
La vérification des types peut être effectuée lors de la compilation ou de l’exécution. 
Les langages typés statiquement (C++ et Java, par exemple) effectuent la vérification des types 
lors de la compilation. Les langages typés dynamiquement (Smalltalk et Python, par exemple) 
effectuent la vérification des types lors de l’exécution. En tant que langage typé 
dynamiquement, ActionScript 3.0 effectue la vérification des types lors de l’exécution mais 
également lors de la compilation, avec un mode de compilateur spécial appelé mode strict
En mode strict, la vérification des types a lieu à la fois lors de la compilation et de l’exécution, 
mais en mode standard, elle a lieu lors de l’exécution.
Les langages typés dynamiquement vous permettent de structurer votre code avec une grande 
souplesse, mais des erreurs de type risquent de se produire lors de l’exécution. Les langages 
typés statiquement signalent des erreurs de type lors de la compilation mais des informations 
de type sont requises à ce moment-là.
94
Syntaxe et langage ActionScript

Vérification des types lors de la compilation
La vérification des types lors de la compilation est souvent favorisée dans les projets plus 
importants car au fur et à mesure que la taille du projet augmente, la flexibilité du type de 
données devient généralement moins importante que la capture d’erreurs de type aussitôt que 
possible. C’est pourquoi le compilateur d’ActionScript dans Adobe Flash CS3 Professional et 
dans Adobe Flex Builder 2 est exécuté en mode strict, par défaut.
Pour que la vérification des types lors de la compilation soit exécutée, le compilateur doit 
connaître les informations de type de données pour les variables ou les expressions dans votre 
code. Pour déclarer explicitement un type de données pour une variable, ajoutez l’opérateur 
deux points (:) suivi par le type de données comme suffixe au nom de variable. Pour associer 
un type de données à un paramètre, utilisez l’opérateur deux points suivi par le type de 
données. Par exemple, le code suivant ajoute des informations de type de données au 
paramètre xParam, et déclare une variable myParam avec un type de données explicite :
function runtimeTest(xParam:String)
{
trace(xParam);
}
var myParam:String = “hello”;
runtimeTest(myParam);
En mode strict, le compilateur d’ActionScript signale des incompatibilités de type comme 
erreurs de compilateur. Par exemple, le code suivant déclare un paramètre de fonction xParam, 
de type Object, mais tente ensuite d’affecter des valeurs de type String et Number à ce 
paramètre. Ceci produit une erreur de compilateur en mode strict.
function dynamicTest(xParam:Object)
{
if (xParam is String)
{
var myStr:String = xParam; // erreur de compilateur en mode strict
trace("String: " + myStr);
}
else if (xParam is Number)
{
var myNum:Number = xParam; // erreur de compilateur en mode strict
trace("Number: " + myNum);
}
}
Types de données
95

Même en mode strict, cependant, vous pouvez choisir d’abandonner la vérification des types 
lors de la compilation en laissant la partie droite d’une instruction d’affectation non typée. 
Vous pouvez marquer une variable ou une expression comme non typée soit en omettant une 
annotation de type, soit à l’aide de l’annotation de type astérisque spéciale (*). Par exemple, si 
le paramètre xParam dans l’exemple précédent est modifié de façon à ne plus avoir 
d’annotation de type, le code compile en mode strict :
function dynamicTest(xParam)
{
if (xParam is String)
{
var myStr:String = xParam;
trace("String: " + myStr);
}
else if (xParam is Number)
{
var myNum:Number = xParam;
trace("Number: " + myNum);
}
}
dynamicTest(100)            
dynamicTest("one hundred");
Vérification des types lors de l’exécution
La vérification des types lors de l’exécution s’applique dans ActionScript 3.0 quel que soit le 
mode, strict ou standard. Imaginez la situation dans laquelle la valeur 3 est transmise en tant 
qu’instruction à une fonction qui attend un tableau. En mode strict, le compilateur génère 
une erreur car la valeur 3 n’est pas compatible avec le type de données Array. Si vous désactivez 
le mode strict et exécutez en mode standard, le compilateur ne signale pas l’incompatibilité de 
type mais la vérification des types lors de l’exécution effectuée par Flash Player provoque une 
erreur d’exécution. 
L’exemple suivant présente une fonction appelée typeTest() qui attend une instruction 
Array mais qui reçoit une valeur de 3. Ceci provoque une erreur d’exécution en mode 
standard car la valeur 3 n’est pas un membre du type de données déclaré (Array) du paramètre.
function typeTest(xParam:Array)
{
trace(xParam);
}
var myNum:Number = 3;
typeTest(myNum); 
// erreur d’exécution dans ActionScript 3.0 en mode standard
96
Syntaxe et langage ActionScript

Il se peut également que vous obteniez une erreur de type lors de l’exécution alors que vous 
êtes en mode strict. Ceci est possible si vous utilisez le mode strict mais que vous abandonnez 
la vérification des types lors de la compilation à l’aide d’une variable non typée. Lorsque vous 
utilisez une variable non typée, vous n’éliminez pas la vérification des types mais la remettez à 
plus tard, au moment de l’exécution. Par exemple, si la variable myNum dans l’exemple 
précédent n’a pas de type de données déclaré, le compilateur ne peut pas détecter 
l’incompatibilité de type, mais Flash Player génère une erreur d’exécution car il compare la 
valeur d’exécution de myNum (définie sur 3 en raison de l’instruction d’affectation), avec le type 
de xParam (défini sur le type de données Array).
function typeTest(xParam:Array)
{
trace(xParam);
}
var myNum = 3;
typeTest(myNum); 
// erreur d’exécution dans ActionScript 3.0
La vérification des types lors de l’exécution permet également d’utiliser l’héritage avec 
davantage de souplesse que la vérification lors de la compilation. En remettant la vérification 
des types au moment de l’exécution, le mode standard vous permet de référencer des 
propriétés d’une sous-classe même si vous effectuez un upcast. Un upcast a lieu lorsque vous 
utilisez une classe de base pour déclarer le type d’une instance de classe mais une sous-classe 
pour l’instancier. Par exemple, vous pouvez créer une classe appelée ClassBase qui peut être 
étendue (les classes avec l’attribut final ne peuvent pas être étendues) :
class ClassBase
{
}
Vous pouvez ensuite créer une sous-classe de ClassBase appelée ClassExtender, qui possède 
une propriété nommée someString, comme suit :
class ClassExtender extends ClassBase
{
var someString:String;
}
Vous pouvez utiliser les deux classes pour créer une instance de classe déclarée à l’aide du type 
de données ClassBase mais instanciée avec le constructeur ClassExtender. Un upcast est 
considéré comme une opération sûre car la classe de base ne contient aucune propriété ni 
méthode ne se trouvant pas dans la sous-classe.
var myClass:ClassBase = new ClassExtender();
Types de données
97

Une sous-classe, néanmoins, ne contient aucune propriété ni méthode que sa classe de base ne 
contient pas. Par exemple, la classe ClassExtender contient la propriété someString qui 
n’existe pas dans la classe ClassBase. Dans ActionScript 3.0 en mode standard, vous pouvez 
référencer cette propriété à l’aide de l’instance myClass sans générer d’erreur d’exécution, 
comme indiqué dans l’exemple suivant : 
var myClass:ClassBase = new ClassExtender();
myClass.someString = "hello";
// aucune erreur dans ActionScript 3.0 en mode standard
L’opérateur is
L’opérateur is (nouveau pour ActionScript 3.0), vous permet de tester si une variable ou une 
expression est membre d’un type de données. Dans les versions précédentes d’ActionScript, 
l’opérateur instanceof offrait cette fonctionnalité, mais dans ActionScript 3.0, l’opérateur 
instanceof ne doit pas être utilisé pour tester l’appartenance à un type de données. 
L’opérateur is doit être utilisé à la place de l’opérateur instanceof pour la vérification des 
types manuelle car l’expression x instanceof y vérifie simplement la chaîne de prototype de 
x pour voir si y existe (et dans ActionScript 3.0, la chaîne de prototype ne fournit pas une 
image complète de la hiérarchie d’héritage). 
L’opérateur is examine sa hiérarchie d’héritage et peut être utilisé pour vérifier non seulement 
si un objet est une instance d’une classe particulière mais également si un objet est une 
instance d’une classe qui met en oeuvre une interface particulière. L’exemple suivant crée une 
instance de la classe Sprite nommée mySprite et utilise l’opérateur is pour tester si mySprite 
est une instance des classes Sprite et DisplayObject, et si elle met en oeuvre l’interface 
IEventDispatcher : 
var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite);                   // true
trace(mySprite is DisplayObject);            // true
trace(mySprite is IEventDispatcher);         // true
L’opérateur is vérifie la hiérarchie d’héritage et signale correctement que mySprite est 
compatible avec les classes Sprite et DisplayObject (la classe Sprite est une sous-classe de la 
classe DisplayObject). L’opérateur is vérifie également si mySprite hérite d’une classe qui 
met en oeuvre l’interface IEventDispatcher. Etant donné que la classe Sprite hérite de la classe 
EventDispatcher, qui met en oeuvre l’interface IEventDispatcher, l’opérateur is signale 
correctement que mySprite met en oeuvre la même interface. 
98
Syntaxe et langage ActionScript

L’exemple suivant présente les mêmes tests que l’exemple précédent, mais avec instanceof au 
lieu de l’opérateur is. L’opérateur instanceof identifie correctement que mySprite est une 
instance de Sprite ou de DisplayObject, mais il renvoie false lorsqu’il est utilisé pour tester si 
mySprite met en oeuvre l’interface IEventDispatcher.
trace(mySprite instanceof Sprite);           // true
trace(mySprite instanceof DisplayObject);    // true
trace(mySprite instanceof IEventDispatcher); // false
L’opérateur as
L’opérateur as (nouveau dans ActionScript 3.0), vous permet également de vérifier si une 
expression est membre d’un type de données. Contrairement à l’opérateur is, cependant, 
l’opérateur as ne renvoie pas de valeur booléenne. A la place, l’opérateur as renvoie la valeur 
de l’expression eu lieu de true, et null au lieu de false. L’exemple suivant indique les 
résultats obtenus lors de l’utilisation de l’opérateur as au lieu de l’opérateur is lors de la 
simple vérification qu’une instance Sprite est un membre des types de données DisplayObject, 
IEventDispatcher, et Number ou non.
var mySprite:Sprite = new Sprite();
trace(mySprite as Sprite); // [objet Sprite]
trace(mySprite as DisplayObject); // [objet Sprite]
trace(mySprite as IEventDispatcher); // [objet Sprite]
trace(mySprite as Number);   // null
Lorsque vous utilisez l’opérateur as, l’opérande à droite doit être un type de données. 
Vous obtenez une erreur si vous tentez d’utiliser une expression autre qu’un type de données 
comme opérande à droite.
Classes dynamiques
Une classe dynamique définit un objet qui peut être modifié lors de l’exécution en ajoutant ou 
en modifiant des propriétés et des méthodes. Une classe qui n’est pas dynamique (la classe 
String, par exemple), est une classe scellée. Vous ne pouvez pas ajouter de propriétés ni de 
méthodes à une classe scellée lors de l’exécution. 
Vous créez des classes dynamiques en utilisant l’attribut dynamic lorsque vous déclarez une 
classe. Par exemple, le code suivant crée une classe dynamique nommée Protean : 
dynamic class Protean
{
private var privateGreeting:String = "hi";
public var publicGreeting:String = "hello";
function Protean()
{
trace("Protean instance created");
}
}
Types de données
99

Si vous instanciez ensuite une instance de la classe Protean, vous pouvez lui ajouter des 
propriétés ou des méthodes en dehors de la définition de classe. Par exemple, le code suivant 
crée une instance de la classe Protean et ajoute une propriété nommée aString et une autre 
appelée aNumber à l’instance :
var myProtean:Protean = new Protean();
myProtean.aString = "testing";
myProtean.aNumber = 3;
trace(myProtean.aString, myProtean.aNumber); // test 3
Les propriétés que vous ajoutez à une instance d’une classe dynamique sont des entités 
d’exécution. Par conséquent, toute vérification des types est effectuée lors de l’exécution. Vous 
ne pouvez pas ajouter une annotation de type à une propriété que vous ajoutez de cette façon.
Vous pouvez également ajouter une méthode à l’instance myProtean en définissant une 
fonction et en l’associant à une propriété de l’instance myProtean. Le code suivant déplace 
l’instruction trace dans une méthode nommée traceProtean():
var myProtean:Protean = new Protean();
myProtean.aString = "testing";
myProtean.aNumber = 3;
myProtean.traceProtean = function ()
{
trace(this.aString, this.aNumber);
};
myProtean.traceProtean(); // test 3
Cependant, les méthodes créées de cette manière n’ont pas accès à des méthodes ou à des 
propriétés privées de la classe Protean. De plus, même les références à des méthodes ou à des 
propriétés publiques de la classe Protean doivent être qualifiées avec le mot-clé this ou le 
nom de classe. L’exemple suivant présente la méthode traceProtean() tentant d’accéder aux 
variables privées et publiques de la classe Protean. 
myProtean.traceProtean = function ()
{
trace(myProtean.privateGreeting); // non défini
trace(myProtean.publicGreeting); // bonjour
};
myProtean.traceProtean();
100
Syntaxe et langage ActionScript

Descriptions des types de données
Les types de données primitifs peuvent être Boolean, int, Null, Number, String, uint, et void. 
Les classes ActionScript essentielles définissent également les types de données complexes 
suivants : Object, Array, Date, Error, Function, RegExp, XML, et XMLList. 
Type de données Boolean 
Le type booléen est composé de deux valeurs : true et false. Les variables du type booléen 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.
Type de données int
Le type de données int est stocké en interne en tant que nombre entier 32 bits et comprend 
l’ensemble des entiers allant de 
-2,147,483,648 (-231) à 2,147,483,647 (231 - 1), compris. Les versions précédentes 
d’ActionScript offraient uniquement le type de données Number, qui était utilisé à la fois 
pour les nombres entiers et les nombres en virgule flottante. Dans ActionScript 3.0, vous avez 
maintenant accès à des types machine de bas niveau pour les nombres entiers 32 bits signés et 
non signés. Si votre variable ne doit pas utiliser de nombres en virgule flottante, l’utilisation 
du type de données int au lieu du type de données Number est plus rapide et plus efficace. 
Pour les valeurs entières en dehors de la plage des valeurs int minimum et maximum, utilisez 
le type de données Number, qui peut gérer des valeurs positives et négatives 
9,007,199,254,740,992 (valeurs entières 53 bits). La valeur par défaut pour des variables du 
type de données int est 0.
Type de données Null
Le type de données Null contient une seule valeur, null. Il s’agit de la valeur par défaut pour 
le type de données String et toutes les classes qui définissent des types de données complexes, 
y compris la classe Object. Aucun des autres types de données primitifs (Boolean, Number, int 
et uint) ne contient la valeur null. Flash Player convertit la valeur null en la valeur par défaut 
appropriée si vous tentez d’affecter null à des variables de type Boolean, Number, int, ou 
uint. Vous ne pouvez pas utiliser ce type de donnés comme annotation de type.
Types de données
101

Type de données Number
Dans ActionScript 3.0, le type de données Number peut représenter des entiers, des entiers 
non signés et des nombres en virgule flottante. Néanmoins, pour optimiser les performances, 
utilisez le type de données Number uniquement pour des valeurs entières supérieures à ce que 
les types int et uint 32 bits peuvent stocker ou pour des nombres en virgule flottante. Pour 
stocker un nombre en virgule flottante, vous devez y insérer une virgule. Si vous omettez la 
virgule, le nombre est stocké comme nombre entier.
Le type de données Number utilise le format à deux décimales (64 bits) conformément à la 
norme IEEE 754. Cette norme dicte comment les nombres en virgule flottante sont stockés à 
l’aide des 64 bits disponibles. Un bit est utilisé pour désigner si le nombre est positif ou 
négatif. Onze bits sont utilisés pour l’exposant, qui est stocké comme base 2. Les 52 bits 
restants sont utilisés pour stocker le significande (également appelé mantisse), qui correspond 
au nombre élevé à la puissance indiqué par l’exposant.
En utilisant certains de ses bits pour stocker un exposant, le type de données Number peut 
stocker des nombres en virgule flottante beaucoup plus grands que s’il utilisait tous ses bits 
pour le significande. Par exemple, si le type de données Number a utilisé les 64 bits pour 
stocker le significande, il pourrait stocker un nombre aussi grand que 265 - 1. En utilisant 
11 bits pour stocker un exposant, le type de données Number peut élever son significande à 
une puissance de 21023. 
Les valeurs maximum et minimum que le type Number peut représenter sont stockées dans 
des propriétés statiques de la classe Number appelées Number.MAX_VALUE et 
Number.MIN_VALUE.
Number.MAX_VALUE == 1.79769313486231e+308
Number.MIN_VALUE == 4.940656458412467e-324
Bien que cette plage de nombres soit énorme, elle est d’une grande précision. Le type de 
données Number utilise 52 bits pour stocker le significande. Par conséquent, les nombres 
nécessitant plus de 52 bits pour une représentation précise (la fraction 1/3, par exemple), ne 
sont que des approximations. Si votre application exige une précision absolue avec des 
nombres décimaux, vous devez utiliser le logiciel qui met en oeuvre l’arithmétique flottante 
décimale plutôt que l’arithmétique flottante binaire.
Lorsque vous stockez des valeurs entières avec le type de données Number, seuls les 52 bits du 
significande sont utilisés. Le type de données Number utilise ces 52 bits et un bit masqué 
spécial pour représenter des nombres entiers de -9,007,199,254,740,992 (-253) à 
9,007,199,254,740,992 (253).
102
Syntaxe et langage ActionScript

Flash Player utilise la valeur NaN non seulement comme valeur par défaut pour des variables de 
type Number, mais également comme résultat de toute opération devant renvoyer un nombre 
mais ne le faisant pas. Par exemple, si vous tentez de calculer la racine carrée d’un nombre 
négatif, le résultat est NaN. D’autres valeurs Number spéciales comprennent l’infini positif et 
l’infini négatif.
REMARQUE
Le résultat de la division par 0 n’est que NaN si le diviseur est également 0. La division par 
0 produit infinity lorsque le dividende est positif ou -infinity lorsqu’il est négatif.
Type de données String
Le type de données String représente une séquence de caractères 16 bits. Les chaînes sont 
stockées en interne sous forme de caractères Unicode, au format UTF-16. Les chaînes sont des 
valeurs inaltérables, comme dans le langage de programmation Java. Toute opération effectuée 
sur une valeur String renvoie une nouvelle instance de la chaîne. La valeur par défaut d’une 
variable déclarée avec le type de données String est null. La valeur null n’est pas identique à 
la chaîne vide (""), même si elles représentent toutes les deux l’absence de caractères.
Type de données uint
Le type de données uint est stocké en interne sous la forme d’un entier non signé 32 bits et est 
constitué de l’ensemble d’entiers compris entre 0 et 4,294,967,295 (232-1), inclus. Utilisez le 
type de données uint dans des situations spéciales nécessitant des entiers non négatifs. 
Par exemple, vous devez utiliser le type de données uint pour représenter les valeurs de couleur 
des pixels car le type de données int a un bit de signe interne non approprié pour la gestion 
des valeurs de couleur. Pour les valeurs d’entiers supérieures à la valeur uint maximale, utilisez 
le type de données Number qui peut gérer des valeurs d’entiers 53 bits. La valeur par défaut 
pour des variables du type de données uint est 0.
Types de données
103

Type de données void
Le type de données void contient une seule valeur, undefined. Dans les versions précédentes 
d’ActionScript, undefined était la valeur par défaut pour les instances de la classe Object. 
Dans ActionScript 3.0, la valeur par défaut pour les instances Object est null. Si vous tentez 
d’affecter la valeur undefined à une instance de la classe Object, Flash Player convertit la 
valeur en null. Vous pouvez affecter uniquement une valeur de undefined à des variables 
non typées. Les variables non typées sont des variables dépourvues de toute annotation de 
type, ou qui utilisent l’astérisque (*) pour l’annotation de type. Vous pouvez utiliser void 
uniquement comme annotation de type renvoyé.
Type de données Object
Le type de données Object est défini par la classe Object. La classe Object sert de classe de 
base pour toutes les définitions de classe dans ActionScript. La version d’ActionScript 3.0 du 
type de données Object diffère de celle des versions précédentes de trois façons. 
Premièrement, le type de données Object n’est plus le type de données par défaut affecté aux 
variables sans annotation de type. Deuxièmement, le type de données Object ne comprend 
plus la valeur undefined, qui était la valeur par défaut des instances Object. Troisièmement, 
dans ActionScript 3.0, la valeur par défaut pour les instances de la classe Object est null.
Dans les versions précédentes d’ActionScript, une variable sans annotation de type a été 
affectée automatiquement au type de données Object. Ceci n’est plus valable dans 
ActionScript 3.0, qui inclut maintenant la notion de variable parfaitement non typée. 
Les variables sans annotation de type sont désormais considérées comme non typées. Si vous 
souhaitez faire comprendre aux lecteurs de votre code que vous souhaitez laisser une variable 
non typée, vous pouvez utiliser le nouvel astérisque (*) pour l’annotation de type, ce qui 
revient à omettre une annotation de type. L’exemple suivant présente deux instructions 
équivalentes qui déclarent une variable non typée x :
var x
var x:*
Seules les variables non typées peuvent contenir la valeur undefined. Si vous tentez d’affecter 
la valeur undefined à une variable ayant un type de données, Flash Player convertit la valeur 
undefined en la valeur par défaut pour ce type de données. Pour des instances du type de 
données Object, la valeur par défaut est null, ce qui signifie que Flash Player convertit la 
valeur undefined en null si vous tentez d’affecter undefined à une instance Object.
104
Syntaxe et langage ActionScript

Conversions de type
Une conversion de type a lieu lorsqu’une valeur est transformée en une valeur d’un type de 
données différent. Les conversions de type peuvent être implicites ou explicites. Les conversions 
implicites (ou coercition) sont parfois effectuées par Flash Player lors de l’exécution. 
Par exemple, si la valeur 2 est affectée à une variable du type de données Boolean, Flash Player 
convertit la valeur 2 en la valeur booléenne true avant d’affecter la valeur à la variable. 
Les conversions explicites (ou associationà ont lieu lorsque votre code demande au compilateur 
de traiter une variable d’un type de données comme si elle appartenait à un type de données 
différent. Lorsque des valeurs primitives sont impliquées, l’association convertit les valeurs 
d’un type de données en un autre. Pour associer un objet à un autre type de données, 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 l’associe à un entier numérique :
var myBoolean:Boolean = true;
var myINT:int = int(myBoolean);
trace(myINT); // 1
Conversions implicites
Les conversions implicites ont lieu lors de l’exécution dans plusieurs contextes :
?
Dans des instructions d’affectation
?
Lorsque des valeurs sont transmises en tant qu’arguments de fonction
?
Lorsque des valeurs sont renvoyées à partir de fonctions
?
Dans les expressions utilisant certains opérateurs tels que l’opérateur d’addition (+)
Pour les types définis par l’utilisateur, les conversions implicites ont lieu lorsque la valeur à 
convertir est une instance de la classe de destination ou d’une classe qui dérive de cette 
dernière. En cas d’échec de la conversion implicite, une erreur se produit. Par exemple, le code 
suivant contient une conversion implicite ayant réussi et une conversion implicite ayant 
échoué :
class A {}
class B extends A {}
var objA:A = new A();
var objB:B = new B();
var arr:Array = new Array();
objA = objB; // Succès de la conversion.
objB = arr; // Echec de la conversion.
Pour les types primitifs, les conversions implicites sont gérées en appelant les mêmes 
algorithmes de conversion internes appelés par les fonctions de conversion explicite. 
La section suivante traite de ces conversions de type primitif dans les détails.
Types de données
105

Conversions explicites
Les conversions explicites, ou association, sont utiles lorsque vous compilez en mode strict et 
que vous ne souhaitez pas qu’une incompatibilité de types génère une erreur de compilation. 
Ceci peut se produire lorsque vous savez que la coercition convertira vos valeurs correctement 
lors de l’exécution. Par exemple, lorsque vous utilisez des données reçues d’un formulaire, 
vous pouvez utiliser la coercition pour convertir certaines valeurs de chaîne en valeurs 
numériques. Le code suivant génère une erreur de compilation même si le code s’exécute 
correctement en mode standard :
var quantityField:String = "3";
var quantity:int = quantityField; // erreur de compilation en mode strict
Si vous souhaitez continuer à utiliser le mode strict, mais que vous souhaitez que la chaîne soit 
convertie en nombre entier, vous pouvez utiliser la conversion explicite, comme suit :
var quantityField:String = "3";
var quantity:int = int(quantityField); // Succès de la conversion 
// explicite.
Association à int, uint, et Number
Vous pouvez associer tout type de données à l’un des trois types de nombre suivants : int, uint, 
et Number. Si Flash Player ne peut pas convertir le nombre, la valeur par défaut 0 est affectée 
pour les types de données int et uint, et la valeur par défaut NaN est affectée pour le type de 
données Number. Si vous convertissez une valeur booléenne en un nombre, true devient la 
valeur 1 et false devient la valeur 0.
var myBoolean:Boolean = true;
var myUINT:uint = uint(myBoolean);
var myINT:int = int(myBoolean);
var myNum:Number = Number(myBoolean);
trace(myUINT, myINT, myNum); // 1 1 1
myBoolean = false;
myUINT = uint(myBoolean);
myINT = int(myBoolean);
myNum = Number(myBoolean);
trace(myUINT, myINT, myNum); // 0 0 0
106
Syntaxe et langage ActionScript

Les valeurs de chaîne qui contiennent des chiffres uniquement peuvent être converties en l’un 
des types de nombre. Les types de nombre peuvent également convertir des chaînes 
ressemblant à des nombres négatifs ou des chaînes représentant une valeur hexadécimale 
(par exemple, 0x1A). Le processus de conversion ignore les espaces blancs à gauche ou à droite 
dans la valeur de chaîne. Vous pouvez également associer des chaînes qui ressemblent à des 
nombres en virgule flottante à l’aide de Number(). Le fait d’inclure une virgule fait que 
uint() et int() renvoient un entier avec les caractères suivant la virgule ayant été tronqués. 
Par exemple, les valeurs de chaîne suivantes peuvent être associées à des nombres :
trace(uint("5"));     // 5
trace(uint("-5"));    // 4294967291. Renvoi depuis MAX_VALUE
trace(uint(" 27 "));  // 27
trace(uint("3.7"));   // 3
trace(int("3.7"));    // 3
trace(int("0x1A"));   // 26
trace(Number("3.7")); // 3.7
Les valeurs de chaîne qui contiennent des caractères non numériques renvoient 0 lors de 
l’association à int() ou uint() et NaN lors de l’association à Number(). Le processus de 
conversion ignore les espaces blancs à gauche et à droite mais renvoie 0 ou NaN si une chaîne a 
un espace blanc séparant deux nombres.
trace(uint("5a"));    // 0
trace(uint("ten"));   // 0
trace(uint("17 63")); // 0
Dans ActionScript 3.0, la fonction Number() ne prend plus en charge les nombres octaux, ou 
de base 8. Si vous fournissez une chaîne avec un zéro à gauche à la fonction Number() 
d’ActionScript 2.0, le nombre est interprété comme un nombre octal et converti en son 
équivalent décimal. Ceci ne s’applique pas à la fonction Number() dans ActionScript 3.0, qui 
ignore le zéro à gauche. Par exemple, le code suivant génère un résultat différent lorsqu’il est 
compilé à l’aide de différentes versions d’ActionScript :
trace(Number("044")); 
// ActionScript 3.0 44
// ActionScript 2.0 36
Types de données
107

L’association n’est pas nécessaire lorsqu’une valeur d’un type numérique est affectée à une 
variable d’un type numérique différent. Même en mode strict, les types numériques sont 
convertis de façon implicite en d’autres types numériques. Ceci signifie que dans certains cas, 
des valeurs inattendues peuvent être renvoyées lorsque la plage d’un type est dépassée. 
Les exemples suivants compilent tous en mode strict, même si certains génèrent des valeurs 
inattendues :
var myUInt:uint = -3; // Affectation de la variable int/Number à la 
// variable uint
trace(myUInt); // 4294967293
var myNum:Number = sampleUINT; // Affectation de la variable int/uint 
// à la variable Number
trace(myNum) // 4294967293
var myInt:int = uint.MAX_VALUE + 1; // Affectation de la variable Number 
// à la variable uint
trace(myInt); // 0
myInt = int.MAX_VALUE + 1; // Affectation de la variable uint/Number 
// à la variable int
trace(myInt); // -2147483648
Le tableau suivant récapitule les résultats de l’association au type de données Number, int, ou 
uint à partir d’autres types de données.
Valeur ou type de 
Résultat de la conversion en Number, int ou uint
données
Boolean
Si la valeur est true, 1 ; sinon, 0.
Date
La représentation interne de l’objet Date, qui est le nombre de 
millisecondes depuis le 1er janvier 1970, à minuit, heure universelle.
null
0
Object
Si l’instance est null et convertie en Number, NaN ; sinon, 0.
String
Un nombre si Flash Player peut convertir la chaîne en un nombre ; 
autrement, NaN si converti en Number ou 0 si converti en int ou uint.
undefined
Si converti en Number, NaN ; si converti en int ou uint, 0.
108
Syntaxe et langage ActionScript

Association à Boolean
L’association à Boolean à partir de n’importe quel type de données numériques (uint, int, et 
Number) donne false si la valeur numérique est 0, et true autrement. Pour le type de 
données Number, la valeur NaN donne également false. L’exemple suivant indique les 
résultats de l’association des nombres -1, 0, et 1 :
var myNum:Number;
for (myNum = -1; myNum<2; myNum++)
{
trace("Boolean(" + myNum +") is " + Boolean(myNum));
}
Le résultat de l’exemple indique que sur les trois nombres, seul 0 renvoie une valeur false :
Boolean(-1) is true
Boolean(0) is false
Boolean(1) is true
L’association à Boolean à partir d’une valeur String renvoie false si la chaîne est null ou une 
chaîne vide (""). Sinon, elle renvoie true.
var str1:String;       // La chaîne non initialisée est null.
trace(Boolean(str1));  // false
var str2:String = "";  // chaîne vide
trace(Boolean(str2));  // false
var str3:String = " "; // espace blanc uniquement
trace(Boolean(str3));  // true
L’association à Boolean à partir d’une instance de la classe Object renvoie false si l’instance 
est null, et true autrement :
var myObj:Object;      // L’objet non initialisé est null.
trace(Boolean(myObj)); // false
myObj = new Object();  // instanciation 
trace(Boolean(myObj)); // true
Types de données
109

Les variables booléennes bénéficient d’un traitement particulier en mode strict car vous 
pouvez affecter des valeurs de tout type de données à une variable booléenne sans association. 
La coercition implicite de tous les types de données au type de données Boolean a lieu même 
en mode strict. En d’autres termes, contrairement à la plupart de tous les autres types de 
données, l’association à Boolean n’est pas nécessaire pour éviter des erreurs en mode strict. 
Les exemples suivants compilent tous en mode strict et se comportent comme prévu lors de 
l’exécution :
var myObj:Object = new Object();  // instanciation 
var bool:Boolean = myObj;
trace(bool); // true
bool = "random string";
trace(bool); // true
bool = new Array();
trace(bool); // true
bool = NaN;
trace(bool); // false
Le tableau suivant récapitule les résultats de l’association au type de données Boolean à partir 
d’autres types de données :
Valeur ou type de 
Résultat de la conversion en Boolean
données
String
false si la valeur est null ou la chaîne vide (""); true autrement.
null
false
Number, int ou uint
false si la valeur est NaN ou 0 ; true autrement.
Object
false si l’instance est null ; true autrement.
Association à String
L’association au type de données String à partir de n’importe quel type de données numérique 
renvoie une représentation sous forme de chaîne du nombre. L’association au type de données 
String à partir d’une valeur booléenne renvoie la chaîne "true" si la valeur est true, et 
renvoie la chaîne "false" si la valeur est false.
L’association au type de données String à partir d’une instance de la classe Object renvoie la 
chaîne "null" si l’instance est null. Autrement, l’association au type String à partir de la 
classe Object renvoie la chaîne "[object Object]".
110
Syntaxe et langage ActionScript

L’association à String à partir d’une instance de la classe Array renvoie une chaîne comprenant 
une liste séparée par des virgules de tous les éléments du tableau. Par exemple, l’association 
suivante au type de données String renvoie une chaîne contenant les trois éléments du 
tableau :
var myArray:Array = ["primary", "secondary", "tertiary"];
trace(String(myArray)); // primaire,secondaire,tertiaire
L’association à String à partir d’une instance de la classe Date renvoie une représentation sous 
forme de chaîne de la date que l’instance contient. Par exemple, l’exemple suivant renvoie une 
représentation sous forme de chaîne de l’instance de la classe Date (le résultat indiqué 
correspond à l’heure d’été de la côte ouest des Etats-Unis) :
var myDate:Date = new Date(2005,6,1);
trace(String(myDate)); // vendredi 1er juillet 00:00:00 GMT-0700 2005
Le tableau suivant récapitule les résultats de l’association au type de données String à partir 
d’autres types de données.
Valeur ou type de 
Résultat de la conversion en chaîne
données
Array
Une chaîne comprenant tous les éléments de tableau.
Boolean
"true" ou "false"
Date
Une représentation sous forme de chaîne de l’objet Date.
null
"null"
Number, int ou uint
Une représentation sous forme de chaîne du nombre.
Object
Si l’instance est null, "null" ; sinon, "[object Object]".
Syntaxe
La syntaxe d’un langage définit un ensemble de règles à suivre lors de l’écriture du code 
exécutable.
Respect de la casse 
ActionScript 3.0 est un langage qui fait la distinction entre les majuscules et les minuscules. 
Les identifiants qui diffèrent au niveau de la casse uniquement sont considérés comme 
différents. Par exemple, le code suivant créé deux variables différentes :
var num1:int;
var Num1:int;
Syntaxe
111

Syntaxe à point
L’opérateur point (.) permet d’accéder aux propriétés et aux méthodes d’un objet. La syntaxe 
à point vous permet de vous rapporter à une méthode ou à une propriété de classe à l’aide 
d’un nom d’instance, suivi par l’opérateur point et le nom de la méthode ou de la propriété. 
Par exemple, considérez la définition de classe suivante :
class DotExample
{
public var prop1:String;
public function method1():void {}
}
La syntaxe à point vous permet d’accéder à la propriété prop1 et à la méthode method1() à 
l’aide du nom d’instance créé dans le code suivant :
var myDotEx:DotExample = new DotExample();
myDotEx.prop1 = “hello”;
myDotEx.method1();
Vous pouvez utiliser la syntaxe à point lorsque vous définissez des packages. Vous utilisez 
l’opérateur point pour référencer des packages imbriqués. Par exemple, la classe 
EventDispatcher se trouve dans un package appelé events qui est imbriqué dans le package 
nommé flash. Vous pouvez référencer le package events à l’aide de l’expression suivante :
flash.events
Vous pouvez également référencer la classe EventDispatcher au moyen de cette expression :
flash.events.EventDispatcher
Syntaxe à barre oblique
La syntaxe à barre oblique n’est pas prise en charge dans ActionScript 3.0. La syntaxe à barre 
oblique était utilisée dans des versions précédentes d’ActionScript pour indiquer le chemin 
d’un clip ou d’une variable.
112
Syntaxe et langage ActionScript

Littéraux
Un littéral est une valeur qui apparaît directement dans votre code. Voici quelques exemples 
de littéraux :
17
"hello"
-3
9.4
null
undefined
true
false
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 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 instances des classes de base 
ActionScript : Object, Array, String, Number, int, uint, XML, XMLList et Boolean.
// 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 
instance 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’instance déclarée. L’exemple suivant crée un objet générique et l’initialise avec trois 
propriétés (propA, propB, et propC), chacune avec des valeurs définies sur 1, 2, et 3, 
respectivement :
// 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};
Pour plus d’informations, voir « Principes de base des chaînes », à la page 218, base des expressions régulières », à la page 306 et la page 378.
Syntaxe
113

Points-virgules
Vous pouvez utiliser le point-virgule (;) à la fin d’une instruction. Si vous omettez ce 
caractère, le compilateur suppose que chaque ligne de code représente une instruction 
distincte. Etant donné que de nombreux programmeurs ont l’habitude d’utiliser le point-
virgule pour marquer la fin d’une instruction, vous pouvez faciliter la lecture de votre code en 
procédant de la sorte.
L’ajout d’un point-virgule à la fin d’une instruction permet de placer plusieurs instructions sur 
une même ligne, mais rend la lecture de votre code plus difficile.
Parenthèses 
Vous pouvez utiliser des parenthèses (()) de trois façons dans ActionScript 3.0. Premièrement, 
vous pouvez utiliser des parenthèses pour modifier l’ordre des opérations dans une expression. 
Les opérations regroupées à l’intérieur de parenthèses sont toujours exécutées en premier lieu. 
Par exemple, vous pouvez utiliser des parenthèses pour modifier l’ordre des opérations dans le 
code suivant :
trace(2 + 3 * 4);    // 14
trace( (2 + 3) * 4); // 20
Deuxièmement, vous pouvez utiliser des parenthèses avec l’opérateur virgule (,) pour évaluer 
une série d’expressions et renvoyer le résultat de l’expression finale, comme indiqué dans 
l’exemple suivant :
var a:int = 2;
var b:int = 3;
trace((a++, b++, a+b)); // 7
Troisièmement, vous pouvez utiliser des parenthèses pour transmettre un ou plusieurs 
paramètres à des fonctions ou à des méthodes, comme indiqué dans l’exemple suivant, qui 
transmet une valeur String à la fonction trace() :
trace("hello"); // bonjour
114
Syntaxe et langage ActionScript

Commentaires 
Le code ActionScript 3.0 prend en charge deux types de commentaires : les commentaires 
d’une ligne et les commentaires de plusieurs lignes. Ces mécanismes de commentaire sont 
semblables aux mécanismes de commentaire de C++ et Java. Le compilateur ignore le texte 
marqué comme commentaire. 
Les commentaires d’une ligne commencent par deux barres obliques (//) et continuent 
jusqu’à la fin de la ligne. Par exemple, le code suivant contient un commentaire d’une ligne : 
var someNumber:Number = 3; // commentaire d’une seule ligne
Les commentaires de plusieurs lignes commencent par une barre oblique et un astérisque (/*) 
et se terminent pas un astérisque et une barre oblique (*/). 
/* Il s’agit d’un commentaire de plusieurs lignes qui peut s’étendre sur
plus d’une ligne de code. */
Mots-clés et 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. Les mots réservés comprennent les mots lexicaux qui sont supprimés 
de l’espace de nom du programme par le compilateur. Le compilateur signale une erreur si 
vous utilisez un mot-clé lexical comme identifiant. Le tableau suivant répertorie les mots 
lexicaux d’ActionScript 3.0. 
 
as
break
case
catch
class
const
continue
default
delete
do
else
extends
false
finally
for
function
if
implements
import
in
instanceof
interface
internal
is
native
new
null
package
private
protected
public
return
super
switch
this
throw
to
true
try
typeof
use
var
void
while
with
Syntaxe
115

Il existe un petit ensemble de mots-clés, appelés mots-clés syntaxiques qui peuvent servir 
d’identifiants, mais qui possèdent une signification spéciale dans certains contextes. 
Le tableau suivant répertorie les mots syntaxiques d’ActionScript 3.0.
each
get
set
namespace
include
dynamic
final
native
override
static
Il existe également plusieurs identifiants auxquels il est parfois fait référence sous le terme mots 
réservés pour une utilisation future
. Ces identifiants ne sont pas réservés par ActionScript 3.0, 
mais certains d’entre eux peuvent être traités comme des mots-clés par des logiciels qui 
intègrent ActionScript 3.0. Vous pouvez utiliser un grand nombre de ces identifiants dans 
votre code, mais Adobe vous le déconseille car ils risquent d’apparaître sous la forme de mots-
clés dans une version ultérieure du langage. 
abstract
boolean
byte
cast
char
debugger
double
enum
export
float
goto
intrinsic
long
prototype
short
synchronized
throws
to
transient
type
virtual
volatile
Constantes
ActionScript 3.0 prend en charge l’instruction const que vous pouvez utiliser pour créer des 
constantes. Les constantes sont des propriétés dont la valeur est fixe et non modifiable. Vous 
pouvez affecter une valeur à une constante une seule fois, et l’affectation doit avoir lieu à 
proximité de la déclaration de la constante. Par exemple, si une constante est déclarée en tant 
que membre d’une classe, vous pouvez lui affecter une valeur uniquement dans la déclaration 
ou dans le constructeur de classe. 
116
Syntaxe et langage ActionScript

Le code suivant déclare deux constantes. La première constante, MINIMUM, a une valeur 
affectée dans l’instruction de déclaration. La seconde constante, MAXIMUM, a une valeur 
affectée dans le constructeur.
class A
{
public const MINIMUM:int = 0;
public const MAXIMUM:int;
public function A()
{
MAXIMUM = 10;
}
}
var a:A = new A();
trace(a.MINIMUM); // 0
trace(a.MAXIMUM); // 10
Une erreur se produit si vous tentez d’affecter une valeur initiale à une constante de l’une des 
deux façons. Par exemple, si vous tentez de définir la valeur initiale de MAXIMUM en dehors de 
la classe, une erreur d’exécution se produit.
class A
{
  public const MINIMUM:int = 0;
  public const MAXIMUM:int;
}
var a:A = new A();
a["MAXIMUM"] = 10; // erreur d’exécution
L’API de Flash Player API définit un grand nombre de constantes que vous pouvez utiliser. 
Par convention, les constantes dans ActionScript utilisent toutes des majuscules, avec des mots 
séparés par le caractère de soulignement ( _ ). Par exemple, la définition de classe MouseEvent 
utilise cette convention d’appellation pour ses constantes. Chacune d’entre elles représente un 
événement lié à une action de la souris :
package flash.events
{
  public class MouseEvent extends Event
  {
    public static const CLICK:String               = "click";
    public static const DOUBLE_CLICK:String        = "doubleClick";
    public static const MOUSE_DOWN:String          = "mouseDown";
    public static const MOUSE_MOVE:String          = "mouseMove";
   
  }
}
Syntaxe
117

Opérateurs
Les opérateurs sont des fonctions spéciales qui utilisent un ou plusieurs opérandes et renvoient 
une valeur. Un opérande est une valeur (généralement un littéral, une variable ou une 
expression) utilisée par l’opérateur comme entrée. Par exemple, dans le code suivant, les 
opérateurs d’addition (+) et de multiplication (*) sont utilisés avec trois opérandes littéraux 
(2, 3, et 4) pour renvoyer une valeur. Cette valeur est ensuite utilisée par l’opérateur 
d’affectation (=) pour attribuer la valeur renvoyée, 14, à la variable sumNumber.
var sumNumber:uint = 2 + 3 * 4; // uint = 14
Les opérateurs peuvent être unaires, binaires ou ternaires. Un opérateur unaire utilise un 
opérande. Par exemple, l’opérateur d’incrémentation (++) est un opérateur unaire car il utilise 
un seul opérande. Un opérateur binaire utilise deux opérandes. Par exemple, l’opérateur de 
division (/) utilise deux opérandes. Un opérateur ternaire utilise trois opérandes. Par exemple, 
l’opérateur conditionnel (?:) utilise trois opérandes.
Certains opérateurs sont surchargés, ce qui signifie qu’ils se comportent différemment selon le 
type ou la quantité d’opérandes qui leur est transmis. L’opérateur d’addition (+) est un 
exemple d’opérateur surchargé qui se comporte différemment selon le type de données des 
opérandes. Si les deux opérandes sont des nombres, l’opérateur d’addition renvoie la somme 
des valeurs. Si les deux opérandes sont des chaînes, l’opérateur d’addition renvoie la 
concaténation des deux opérandes. L’exemple de code suivant indique comment l’opérateur se 
comporte différemment selon les opérandes :
trace(5 + 5);     // 10
trace("5" + "5"); // 55
Les opérateurs peuvent également se comporter différemment selon le nombre d’opérandes 
fourni. L’opérateur de soustraction (-) est un opérateur à la fois unaire et binaire. Lorsqu’il est 
fourni avec un seul opérande, l’opérateur de soustraction le nie et renvoie le résultat. Lorsqu’il 
est fourni avec deux opérandes, l’opérateur de soustraction renvoie la différence entre les 
opérandes. L’exemple suivant présente l’opérateur de soustraction utilisé d’abord comme 
opérateur unaire, puis comme opérateur binaire.
trace(-3);  // -3
trace(7-2); // 5
118
Syntaxe et langage ActionScript

Priorité et associativité des opérateurs
La priorité et l’associativité des opérateurs déterminent leur ordre de traitement. Bien qu’il soit 
évident, pour ceux qui connaissent bien l’arithmétique, 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. ActionScript définit une priorité par défaut que l’opérateur 
parenthèses (()) permet de modifier. Par exemple, le code suivant modifie la priorité par 
défaut dans l’exemple précédent pour forcer le compilateur à traiter l’opérateur d’addition 
avant l’opérateur de multiplication :
var sumNumber:uint = (2 + 3) * 4; // uint == 20
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.
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, ce qui donne une valeur true car l’opérande 3 est 
supérieur à l’opérande 2. La valeur true est ensuite transmise à l’opérateur inférieur à, avec 
l’opérande 1. Le code suivant représente cet état intermédiaire : 
trace((true) < 1); 
L’opérateur Inférieur à convertit la valeur true en la valeur numérique 1 et compare cette 
valeur numérique au second opérande 1 pour renvoyer la valeur false (la valeur n’est pas 
inférieure à 1).
trace(1 < 1); // false
Vous pouvez modifier l’associativité gauche par défaut avec l’opérateur parenthèses. Vous 
pouvez demander au compilateur de traiter l’opérateur inférieur à en premier lieu en plaçant 
cet opérateur et son opérande entre parenthèses. L’exemple suivant utilise l’opérateur 
parenthèses pour produire un résultat différent en utilisant les mêmes nombres que l’exemple 
précédent :
trace(3 > (2 < 1)); // true
Opérateurs
119

L’opérateur Inférieur à est traité en premier, ce qui donne une valeur false car l’opérande 2 
n’est pas inférieur à l’opérande 1. La valeur false est ensuite transmise à l’opérateur Supérieur 
à, avec l’opérande 3. Le code suivant représente cet état intermédiaire : 
trace(3 > (false)); 
L’opérateur Supérieur à convertit la valeur false en la valeur numérique 0 et compare cette 
valeur numérique à l’autre opérande 3 pour renvoyer la valeur true (la valeur 3 est supérieure 
à 0).
trace(3 > 0); // true
Le tableau suivant répertorie les opérateurs pour ActionScript 3.0 par ordre de priorité 
décroissant. Chaque ligne du tableau contient des opérateurs ayant la même priorité. Chaque 
ligne d’opérateurs a une priorité supérieure à la ligne située au-dessous dans le tableau.
Groupe
Opérateurs
Principal
[] {x:y} () f(x) new x.y x[y] <></> @ :: ..
Suffixe
x++ x--
Unaire
++x --x + - ~ ! delete typeof void
De multiplication
* / %
D’ajout
+ -
Décalage au niveau du  << >> >>>
bit
Relationnel
< > <= >= as in instanceof is
Egalité
== != === !==
AND au niveau du bit
&
XOR au niveau du bit
^
OR au niveau du bit
|
AND logique
&&
OR logique
||
Conditionnelle 
?:
Affectation
= *= /= %= += -= <<= >>= >>>= &= ^= |=
Virgule
,
120
Syntaxe et langage ActionScript

Opérateurs principaux 
Les opérateurs principaux comprennent ceux utilisés pour créer des littéraux Array et Object, 
regrouper des expressions, appeler des fonctions, instancier des instances de classe et accéder à 
des propriétés. 
Tous les opérateurs principaux, comme répertoriés dans le tableau suivant, ont la même 
priorité. (E4X) apparaît en regard des opérateurs qui font partie de la spécification E4X.
 
Opérateur
Opération effectuée
[]
Initialise un tableau
{x:y}
Initialise un objet
()
Regroupe des expressions
f(x)
Appelle une fonction
new
Appelle un constructeur
x.y x[y]
Accède à une propriété
<></>
Initialise un objet XMLList (E4X)
@
Accède à un attribut (E4X)
::
Qualifie un nom (E4X)
..
Accède à un élément XML descendant (E4X)
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. 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
Tous les opérateurs de suffixe, comme répertoriés dans le tableau suivant, ont la même 
priorité :
Opérateur
Opération effectuée
++
Incrémentation (suffixe)
--
Décrémentation (suffixe)
Opérateurs
121

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. 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 unaires, comme répertoriés dans le tableau suivant, ont la même priorité :
Opérateur
Opération effectuée
++
Incrémentation (préfixe)
--
Décrémentation (préfixe)
+
Unaire +
-
Unaire - (négation)
!
NOT logique
~
NOT au niveau du bit
delete
Supprime une propriété
typeof
Renvoie les informations de type
void
Renvoie une valeur non définie
Opérateurs de multiplication 
Les opérateurs de multiplication prennent deux opérandes et effectuent des multiplications, 
des divisions ou des calculs de modulo.
Tous les opérateurs de multiplication, comme répertoriés dans le tableau suivant, ont la même 
priorité :
Opérateur
Opération effectuée
*
Multiplication
/
Division
%
Modulo
122
Syntaxe et langage ActionScript

Opérateurs d’ajout
Les opérateurs d’ajout prennent deux opérandes et effectuent des calculs d’addition ou de 
soustraction. Tous les opérateurs d’ajout, comme répertoriés dans le tableau suivant, ont la 
même priorité :
Opérateur
Opération effectuée
+
Addition
-
Soustraction
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 décalage au niveau du bit, comme répertoriés 
dans le tableau suivant, ont la même 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
Opérateurs relationnels
Les opérateurs relationnels prennent deux opérandes, comparent leur valeurs et renvoient une 
valeur booléenne. Tous les opérateurs relationnels, comme répertoriés dans le tableau suivant, 
ont la même priorité :
Opérateur
Opération effectuée
<
Inférieur à
>
Supérieur à
<=
Inférieur ou égal à
>=
Supérieur ou égal à
as
Vérifie le type de données
in
Vérifie les propriétés des objets
instanceof
Vérifie la chaîne prototype
is
Vérifie le type de données
Opérateurs
123

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 d’égalité, comme répertoriés dans le tableau suivant, ont 
la même priorité :
Opérateur
Opération effectuée
==
Egalité
!=
Inégalité
===
Egalité stricte
!==
Inégalité stricte
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
Opérateurs logiques 
Les opérateurs logiques prennent deux opérandes et renvoient une valeur booléenne. 
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 logique
||
OR logique
124
Syntaxe et langage ActionScript

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
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 d’affectation, comme répertoriés dans le 
tableau suivant, ont la même 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
Opérateurs
125

Instructions conditionnelles
ActionScript 3.0 fournit trois instructions conditionnelles de base que vous pouvez utiliser 
pour contrôler le flux du programme.

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 fonction 
trace() dans l’affirmative ou une autre fonction trace() dans le cas contraire :
if (x > 20)
{
trace("x is > 20");
}
else
{
trace("x is <= 20");
}
Si vous ne souhaitez pas exécuter un autre bloc de code, vous pouvez utiliser l’instruction if 
sans l’instruction else.
if
L’instruction conditionnelle  if permet de tester plusieurs conditions. Par exemple, 
le code suivant teste 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");
}
Si une instruction if ou else est suivie d’une seule instruction, elle n’a pas besoin d’être 
placée entre accolades. Par exemple, le code suivant n’utilise pas d’accolades :
if (x > 0)
trace("x is positive”);
else if (x < 0) 
trace("x is negative");
else
trace("x is 0");
126
Syntaxe et langage ActionScript

Néanmoins, Adobe conseille de toujours utiliser des accolades car un comportement 
inattendu peut se produire si des instructions sont ajoutées ultérieurement à une instruction 
conditionnelle sans accolades. Par exemple, dans le code suivant, la valeur de positiveNums 
augmente de 1 que la condition renvoie true ou non :
var x:int;
var positiveNums:int = 0;
if (x > 0)
trace("x is positive");
positiveNums++;
trace(positiveNums); // 1
switch
L’instruction switch est utile si vous avez plusieurs chemins d’exécution sur la même 
expression de condition. Elle offre une fonctionnalité semblable à une longue série 
d’instructions  if mais est un peu plus facile à lire. Au lieu de tester une condition 
pour une valeur booléenne, l’instruction switch évalue une expression et utilise le résultat 
pour déterminer le bloc de code à exécuter. Les blocs de code commencent par une 
instruction case et se terminent par une instruction break. Par exemple, l’instruction switch 
suivante imprime le jour de la semaine en fonction du numéro du jour renvoyé par la 
méthode Date.getDay() :
var someDate:Date = new Date();
var dayNum:uint = someDate.getDay();
switch(dayNum)
{
case 0:
trace("Sunday");
break;
case 1:
trace("Monday");
break;
case 2:
trace("Tuesday");
break;
case 3:
trace("Wednesday");
break;
case 4:
trace("Thursday");
break;
case 5:
trace("Friday");
break;
Instructions conditionnelles
127

case 6:
trace("Saturday");
break;
default:
trace("Out of range");
break;
}
Boucle
Les instructions de bouclage vous permettent d’exécuter un bloc de code spécifique de façon 
répétée à l’aide d’une série de valeurs ou de variables. Adobe vous recommande de toujours 
placer le bloc de code entre accolades ({}). Bien que vous puissiez omettre les accolades si le 
bloc de code contient une seule instruction, cette pratique est déconseillée pour la même 
raison que celle qui s’applique aux instructions conditionnelles : elle augmente la probabilité 
que les instructions ajoutées ultérieurement soient exclues du bloc de code par inadvertance. 
Si vous ajoutez ultérieurement une instruction à inclure dans le bloc de code mais que vous 
oubliez d’ajouter les accolades nécessaires, l’instruction n’est pas exécutée dans la boucle.
for
La boucle for vous permet de faire une itération sur une variable pour une plage de valeurs 
spécifique. 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 avec chaque boucle. 
Par exemple, le code suivant boucle à cinq reprises. La valeur de la variable i commence à 0 et 
prend fin à 4, et le résultat est constitué par les nombres compris entre 0 et 4, chacun sur sa 
propre ligne.
var i:int;
for (i = 0; i < 5; i++)
{
trace(i);
}
128
Syntaxe et langage ActionScript


La boucle  vous permet de faire une itération sur les propriétés d’un objet ou les 
éléments d’un tableau. Par exemple, utilisez une boucle  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 peuvent apparaître dans un ordre imprévisible) :
var myObj:Object = {x:20, y:30};
for (var i:String in myObj)
{
trace(i + ": " + myObj[i]);
}
// résultat :
// 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]);
}
// résultat :
// un
// deux
// trois
Vous ne pouvez pas itérer sur les propriétés d’un objet lorsqu’il s’agit d’une instance de classe 
définie par l’utilisateur, 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.
for
La boucle for  vous permet de faire une itération sur les éléments d’une collection 
(balises dans un objet XML ou XMLList, valeurs des propriétés d’un objet ou éléments d’un 
tableau). Par exemple, comme le montre l’extrait suivant, vous pouvez utiliser une boucle for 
 pour itérer sur les propriétés d’un objet générique, mais contrairement à la boucle 
, la variable d’itérateur dans une boucle for  contient la valeur de la 
propriété au lieu de son nom :
var myObj:Object = {x:20, y:30};
for each (var num in myObj)
{
trace(num);
}
// résultat :
// 20
// 30
Boucle
129

Vous pouvez faire une itération sur un objet XML ou XMLList, comme l’indique l’exemple 
suivant :
var myXML:XML = <users>
                   <fname>Jane</fname>
                   <fname>Susan</fname>
                   <fname>John</fname>
                </users>;
for each (var item in myXML.fname)
{
trace(item);
}
/* résultat
Jane
Susan
John
*/
Vous pouvez également faire une itération sur les éléments d’un tableau, comme l’indique cet 
exemple :
var myArray:Array = ["one", "two", "three"];
for each (var item in myArray)
{
trace(item);
}
// résultat :
// un
// deux
// trois
Vous ne pouvez pas faire une itération sur les propriétés d’un objet si ce dernier est une 
instance d’une classe scellée. Même pour les instances de classes dynamiques, vous ne pouvez 
pas faire une itération sur des propriétés fixes qui sont des propriétés définies comme faisant 
partie d’une définition de classe.
while
La boucle while est semblable à une instruction if qui se répète tant que la condition est 
true. Par exemple, le code suivant produit le même résultat que l’exemple de boucle for :
var i:int = 0;
while (i < 5)
{
trace(i);
i++;
}
130
Syntaxe et langage ActionScript

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 passe pas la compilation si vous omettez l’expression qui 
incrémente la variable du compteur, alors que le code qui utilise la boucle while est compilé. 
Et sans l’expression qui incrémente i, la boucle se poursuit sans fin.
do..while
La boucle do..while est une boucle while qui garantit que le bloc de code est exécuté au 
moins une fois, car la condition est vérifiée une fois que le bloc de code est exécuté. 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:int = 5;
do
{
trace(i);
i++;
} while (i < 5);
// résultat : 5
Fonctions
Les fonctions sont des blocs de code qui effectuent des tâches spécifiques et qui peuvent être 
réutilisés dans votre programme. Il existe deux types de fonctions dans ActionScript 3.0 : les 
méthodes et les fonctions closures. Une fonction est appelée méthode ou fonction closure selon 
le contexte dans lequel elle est définie. Une fonction est appelée méthode si vous la définissez 
comme partie d’une définition de classe ou l’associez à l’instance d’un objet. Une fonction est 
appelée fonction closure si elle est définie de l’une ou l’autre façon. 
Les fonctions ont toujours été très importantes dans ActionScript. Dans ActionScript 1.0, par 
exemple, le mot-clé class n’existait pas. Par conséquent, des « classes » ont été définies par des 
fonctions constructeurs. Même si le mot-clé class a depuis été ajouté au langage, une solide 
compréhension des fonctions reste importante si vous souhaitez bénéficier de tous les 
avantages du langage. Ceci peut être un défi pour les programmeurs qui s’attendent à ce que 
les fonctions ActionScript se comportent de façon identique à celles des langages tels que C++ 
ou Java. Même si l’appel et la définition des fonctions de base ne devraient pas constituer un 
défi pour les programmeurs expérimentés, certaines des fonctions ActionScript les plus 
avancées nécessitent une explication.
Fonctions
131

Concepts de fonction de base
Cette section décrit les techniques d’appel et de définition des fonctions de base.
Appel de fonctions
Vous appelez une fonction en utilisant son identifiant suivi par l’opérateur parenthèses (()). 
Vous placez les paramètres de fonction que vous souhaitez envoyer à la fonction entre 
parenthèses à l’aide de l’opérateur parenthèses. Par exemple, la fonction trace() (qui est une 
fonction de niveau supérieur dans l’API de Flash Player) est utilisée dans ce manuel :
trace(“Use trace to help debug your script”);
Si vous appelez une fonction sans paramètres, vous devez utiliser une paire de parenthèses 
vide. Par exemple, vous pouvez utiliser la méthode Math.random(), qui ne prend aucun 
paramètre, pour générer un nombre aléatoire :
var randomNum:Number = Math.random();
Définition de vos fonctions
Il existe deux façons de définir une fonction dans ActionScript 3.0 : avec une instruction de 
fonction ou une expression de fonction. La technique que vous choisissez dépend du style de 
programmation que vous préférez, plus statique ou dynamique. Définissez vos fonctions à 
l’aide d’instructions de fonction si vous préférez une programmation en mode strict, ou 
statique. Définissez vos fonctions à l’aide d’expressions de fonction si vous en avez vraiment 
besoin. Les expressions de fonction sont utilisées plus souvent dans la programmation en 
mode standard, ou dynamique.
Instructions de fonction
Les instructions de fonction représentent la technique privilégiée pour définir des fonctions en 
mode strict. Une instruction de fonction commence par le mot-clé function, suivi de :
?
le nom de la fonction ;
?
les paramètres, dans une liste séparée par des virgules, placée entre parenthèses ;
?
le corps de la fonction, c’est-à-dire le code ActionScript à exécuter lorsque la fonction est 
invoquée, placé entre accolades.
Par exemple, le code suivant crée une fonction qui définit un paramètre puis invoque la 
fonction à l’aide de la chaîne "hello" comme valeur de paramètre :
function traceParameter(aParam:String)
{
trace(aParam);
}
traceParameter("hello"); // bonjour
132
Syntaxe et langage ActionScript

Expressions de fonction
La deuxième façon de déclarer une fonction est d’utiliser une instruction d’affectation avec 
une expression de fonction, parfois appelée littéral de fonction ou fonction anonyme. Il s’agit 
d’une méthode plus détaillée largement utilisée dans les versions précédentes d’ActionScript. 
Une instruction d’affectation avec une expression de fonction commence par le mot-clé var, 
suivi de :
?
le nom de la fonction ;
?
l’opérateur deux points (.) ;
?
la classe Function pour indiquer le type de données ;
?
l’opérateur d’affectation (=) ;
?
le mot-clé function ;
?
les paramètres, dans une liste séparée par des virgules, placée entre parenthèses ;
?
le corps de la fonction, c’est-à-dire le code ActionScript à exécuter lorsque la fonction est 
invoquée, placé entre accolades.
Par exemple, le code suivant déclare la fonction traceParameter à l’aide d’une expression de 
fonction :
var traceParameter:Function = function (aParam:String)
{
trace(aParam);
};
traceParameter("hello"); // bonjour
Vous remarquerez que vous ne spécifiez pas de nom de fonction, comme dans une instruction 
de fonction. Une autre différence importante entre les expressions de fonction et les 
instructions de fonction est qu’une expression de fonction est plus une expression qu’une 
instruction. Ceci signifie qu’une expression de fonction ne peut pas être utilisée seule, 
contrairement à une instruction de fonction. Une expression de fonction peut être utilisée 
uniquement en tant que partie d’une instruction, généralement une instruction d’affectation. 
L’exemple suivant représente une expression de fonction affectée à un élément de tableau :
var traceArray:Array = new Array();
traceArray[0] = function (aParam:String)
{
trace(aParam);
};
traceArray[0]("hello");
Fonctions
133

Choix d’instructions ou d’expressions
En règle générale, utilisez une instruction de fonction, à moins que des circonstances 
spécifiques exigent l’utilisation d’une expression. Les instructions de fonction sont moins 
détaillées et fournissent une expérience plus cohérente entre le mode strict et le mode standard 
que les expressions de fonction. 
Les instructions de fonction sont plus lisibles que les instructions d’affectation qui 
contiennent des expressions de fonction. Les instructions de fonction rendent votre code plus 
concis ; elles prêtent moins à confusion que les expressions de fonction, qui exigent 
l’utilisation des mots-clés var et function. 
Les instructions de fonction fournissent une expérience plus cohérente entre les deux modes 
de compilateur car vous pouvez utiliser la syntaxe à point en mode strict et en mode standard 
pour appeler une méthode déclarée à l’aide d’une instruction de fonction. Ceci ne s’applique 
pas nécessairement aux méthodes déclarées avec une expression de fonction. Par exemple, le 
code suivant définit une classe appelée Example avec deux méthodes : methodExpression(), 
qui est déclarée avec une expression de fonction, et methodStatement(), qui est déclarée avec 
une instruction de fonction. En mode strict, vous ne pouvez pas utiliser la syntaxe à point 
pour invoquer la méthode methodExpression().
class Example
{
  var methodExpression = function() {}
  function methodStatement() {}
}
var myEx:Example = new Example();
myEx.methodExpression(); // erreur en mode strict ; okay en mode standard
myEx.methodStatement(); // okay en modes strict et standard
Les expressions de fonction sont plus adaptées à la programmation ciblée sur un 
comportement d’exécution ou dynamique. Si vous préférez utiliser le mode strict mais que 
vous souhaitez également appeler une méthode déclarée avec une expression de fonction, vous 
pouvez utiliser l’une des deux techniques. Premièrement, vous pouvez appeler la méthode à 
l’aide de l’opérateur crochets ([]) au lieu de l’opérateur point (.). L’appel de méthode suivant 
a lieu à la fois en mode strict et en mode standard :
myExample["methodLiteral"]();
Deuxièmement, vous pouvez déclarer la classe entière comme classe dynamique. Même si ceci 
vous permet d’appeler la méthode à l’aide de l’opérateur point, l’inconvénient est que vous 
sacrifiez une fonctionnalité de mode strict pour toutes les instances de cette classe. 
Par exemple, le compilateur ne génère pas d’erreur si vous tentez d’accéder à une propriété 
non définie sur une instance d’une classe dynamique. 
134
Syntaxe et langage ActionScript

Les expressions de fonction peuvent être utiles dans certains cas. Les expressions de fonction 
sont couramment utilisées pour des fonctions qui sont utilisées une seule fois. Elles peuvent 
être utilisées également pour associer une fonction à une propriété de prototype. Pour plus 
d’informations, voir « L’objet prototype », à la page 189.
Il existe deux légères différences entre les instructions de fonction et les expressions de 
fonction à prendre en compte lorsque vous choisissez la technique à utiliser. La première 
différence réside dans le fait que les expressions de fonction n’existent pas indépendamment 
en tant qu’objets en ce qui concerne la gestion de la mémoire et le nettoyage. En d’autres 
termes, lorsque vous affectez une expression de fonction à un autre objet (un élément de 
tableau ou une propriété d’objet, par exemple) vous créez l’unique référence à cette expression 
de fonction dans votre code. Si le tableau ou l’objet auquel est associée l’expression de 
fonction n’est plus disponible, vous n’avez plus accès à l’expression de fonction. Si le tableau 
ou l’objet est supprimé, la mémoire que l’expression de fonction utilise peut être nettoyée, ce 
qui signifie que la mémoire peut être réutilisée à d’autres fins.
L’exemple suivant indique que pour une expression de fonction, la fonction n’est plus 
disponible une fois que la propriété à laquelle l’expression est affectée est supprimée. La classe 
Test est dynamique, ce qui signifie que vous pouvez ajouter une propriété appelée 
functionExp qui contient une expression de fonction. La fonction functionExp() peut être 
appelée avec l’opérateur point, mais une fois que la propriété functionExp est supprimée, la 
fonction n’est plus accessible.
dynamic class Test {}
var myTest:Test = new Test();
// expression de fonction 
myTest.functionExp = function () { trace("Function expression") };
myTest.functionExp();   // expression de fonction
delete myTest.functionExp;
myTest.functionExp();   // erreur
Si, d’un autre côté, la fonction est d’abord définie avec une instruction de fonction, elle existe 
comme son propre objet et continue à exister, même une fois que vous avez supprimé la propriété 
à laquelle elle est associée. L’opérateur delete fonctionne uniquement sur les propriétés d’objets, 
donc même un appel à supprimer la fonction stateFunc() ne fonctionne pas.
dynamic class Test {}
var myTest:Test = new Test();
// instruction de fonction
function stateFunc() { trace("Function statement") }
myTest.statement = stateFunc;
myTest.statement(); // Instruction de fonction
delete myTest.statement;
delete stateFunc;   // pas d’effet
stateFunc();        // Instruction de fonction
myTest.statement(); // erreur
Fonctions
135

La deuxième différence entre les instructions de fonction et les expressions de fonction réside 
dans le fait que les instructions de fonction existent dans le cadre dans lequel elles sont 
définies, notamment les instructions qui apparaissent avant l’instruction de fonction. 
Les expressions de fonction, en revanche, sont définies uniquement pour les instructions 
ultérieures. Par exemple, le code suivant appelle la fonction scopeTest() avant qu’elle soit 
définie :
statementTest(); // statementTest
function statementTest():void
{
trace("statementTest");
}
Les expressions de fonction ne sont pas disponibles avant d’être définies. Par conséquent, le 
code suivant provoque une erreur d’exécution :
expressionTest(); // erreur d’exécution
var expressionTest:Function = function ()
{
trace("expressionTest");
}
Renvoi de valeurs des fonctions
Pour renvoyer une valeur de votre fonction, utilisez l’instruction return suivie de l’expression 
ou de la valeur littérale que vous souhaitez renvoyer. Par exemple, le code suivant renvoie une 
expression représentant le paramètre : 
function doubleNum(baseNum:int):int
{
return (baseNum * 2);
}
Vous remarquerez que l’instruction return termine la fonction, de façon à ce que les 
instructions sous une instruction return ne soient pas exécutées, comme suit :
function doubleNum(baseNum:int):int {
return (baseNum * 2);
trace("after return"); // Cette instruction trace n’est pas exécutée.
}
En mode strict, vous devez renvoyer une valeur du type approprié si vous choisissez de 
spécifier un type de renvoi. Par exemple, le code suivant génère une erreur en mode strict car il 
ne renvoie pas de valeur valide :
function doubleNum(baseNum:int):int
{
trace("after return");
}
136
Syntaxe et langage ActionScript

Fonctions imbriquées
Vous pouvez imbriquer des fonctions, ce qui signifie que vous pouvez déclarer des fonctions 
avec d’autres fonctions. Une fonction imbriquée est disponible uniquement dans sa fonction 
parent, à moins qu’une référence à la fonction soit transmise à un code externe. Par exemple, 
le code suivant déclare deux fonctions imbriquées à l’intérieur de la fonction 
getNameAndVersion() :
function getNameAndVersion():String
{
function getVersion():String
{
return "9";
}
function getProductName():String
{
return "Flash Player";
}
return (getProductName() + " " + getVersion());
}
trace(getNameAndVersion()); // Flash Player 9
Lorsque des fonctions imbriquées sont transmises à un code externe, elles le sont en tant que 
fonctions closures, ce qui signifie que la fonction conserve les définitions se trouvant dans le 
domaine au moment de la définition de la fonction. Pour plus d’informations, voir 
« Fonctions closures », à la page 145.
Paramètres de fonction
ActionScript 3.0 permet d’exploiter des paramètres de fonction qui peuvent sembler nouveaux 
pour les programmeurs qui découvrent le langage. Bien que la majorité des programmeurs 
devrait maîtriser le transfert de paramètres par valeur ou par référence, l’objet arguments et le 
paramètre (rest) peut être nouveau pour un grand nombre d’entre vous.
Fonctions
137

Transfert d’arguments par valeur ou par référence
Dans de nombreux langages de programmation, il est important de comprendre la différence 
entre le transfert d’arguments par valeur ou par référence car elle peut affecter la façon dont le 
code est conçu. 
Transférer par valeur signifie que la valeur de l’argument est copiée dans une variable locale 
pour être utilisée dans la fonction. Transférer par référence signifie que seule une référence à 
l’argument est transmise, au lieu de la valeur réelle. Aucune copie de l’argument réel n’est 
effectuée. A la place, une référence à la variable transférée en tant qu’argument est créée et 
affectée à une variable locale pour être utilisée dans la fonction. En tant que référence à une 
variable en dehors de la fonction, la variable locale vous permet de modifier la valeur de la 
variable d’origine.
Dans ActionScript 3.0, tous les arguments sont transférés par référence car toutes les valeurs 
sont stockées en tant qu’objets. Néanmoins, les objets qui appartiennent aux types de données 
primitifs (Boolean, Number, int, uint, et String) possèdent des opérateurs spéciaux qui font 
qu’ils se comportent comme s’ils étaient transférés par valeur. Par exemple, le code suivant crée 
une fonction appelée passPrimitives() qui définit deux paramètres appelés xParam et 
yParam de type int. Ces paramètres sont identiques aux variables locales déclarées dans le corps 
de la fonction passPrimitives(). Lorsque la fonction est appelée avec les arguments xValue 
et yValue, les paramètres xParam et yParam sont initialisés avec des références aux objets int 
représentés par xValue et yValue. Les arguments se comportent comme s’ils étaient transférés 
par valeur car ils sont primitifs. Bien que xParam et yParam contiennent initialement des 
références aux objets xValue et yValue uniquement, toute modification apportée aux variables 
dans le corps de fonction génère de nouvelles copies des valeurs dans la mémoire.
function passPrimitives(xParam:int, yParam:int):void
{
xParam++;
yParam++;
trace(xParam, yParam);
}
var xValue:int = 10;
var yValue:int = 15;
trace(xValue, yValue);          // 10 15
passPrimitives(xValue, yValue); // 11 16
trace(xValue, yValue);          // 10 15
Dans la fonction passPrimitives(), les valeurs de xParam et yParam sont incrémentées, 
mais ceci n’affecte pas les valeurs de Value et yValue, comme indiqué dans la dernière 
instruction trace. Ceci s’applique même si les paramètres portent les mêmes noms que les 
variables, xValue et yValue, car les xValue et yValue se trouvant dans la fonction 
pointeraient vers de nouveaux emplacements dans la mémoire qui existent indépendamment 
des variables du même nom en dehors de la fonction.
138
Syntaxe et langage ActionScript

Tous les autres objets (c’est-à-dire les objets qui n’appartiennent pas aux types de données 
primitifs) sont toujours transférés par référence. Ceci vous permet de modifier la valeur de la 
variable d’origine. Par exemple, le code suivant crée un objet appelé objVar avec deux 
propriétés, x et y. L’objet est transféré en tant qu’argument à la fonction passByRef(). Etant 
donné que l’objet n’est pas un type primitif, non seulement il est transféré par référence mais il 
reste également une référence. Ceci signifie que les changements effectués sur les paramètres 
dans la fonction affectent les propriétés d’objet en dehors de la fonction.
function passByRef(objParam:Object):void
{
objParam.x++;
objParam.y++;
trace(objParam.x, objParam.y);
}
var objVar:Object = {x:10, y:15};
trace(objVar.x, objVar.y); // 10 15
passByRef(objVar);         // 11 16
trace(objVar.x, objVar.y); // 11 16
Le paramètre objParam référence le même objet que la variable globale objVar. Comme vous 
pouvez le constater dans les instructions trace de l’exemple, les modifications apportées au 
propriétés x et y de l’objet objParam sont visibles dans l’objet objVar.
Valeurs de paramètre par défaut
Dans ActionScript 3.0, il est à présent possible de déclarer des valeurs de paramètre par défaut 
pour une fonction. Si un appel à une fonction avec des valeurs de paramètre par défaut omet 
un paramètre avec des valeurs par défaut, la valeur spécifiée dans la définition de fonction 
pour ce paramètre est utilisée. Tous les paramètres avec des valeurs par défaut doivent être 
placés à la fin de la liste des paramètres. Les valeurs affectées comme valeurs par défaut doivent 
être des constantes de compilation. L’existence d’une valeur par défaut pour un paramètre le 
rend facultatif. Un paramètre sans valeur par défaut est considéré comme un paramètre 
obligatoire
.
Par exemple, le code suivant crée une fonction avec trois paramètres, dont deux possèdent des 
valeurs par défaut. Lorsque la fonction est appelée avec un seul paramètre, les valeurs par 
défaut pour les paramètres sont utilisées. 
function defaultValues(x:int, y:int = 3, z:int = 5):void
{
trace(x, y, z);
}
defaultValues(1); // 1 3 5
Fonctions
139

L’objet arguments
Lorsque les paramètres sont transférés à une fonction, vous pouvez utiliser l’objet arguments 
pour accéder aux informations concernant les paramètres transférés à votre fonction. 
Voici certains aspects importants de l’objet arguments :
?
L’objet arguments est un tableau qui comprend tous les paramètres transférés à la 
fonction.
?
La propriété arguments.length indique le nombre de paramètres transmis à la fonction.
?
La propriété arguments.callee fournit une référence à la fonction elle-même, ce qui est 
utile pour les appels récursifs à des expressions de fonction.
REMARQUE
L’objet arguments n’est pas disponible si un paramètre est appelé arguments ou si vous 
utilisez le paramètre   paramètre (rest).
ActionScript 3.0 permet aux appels de fonction d’inclure plus de paramètres que ceux définis 
dans la définition de fonction mais génère une erreur de compilateur en mode strict si le 
nombre de paramètres est inférieur au nombre de paramètres obligatoires. Vous pouvez 
utiliser l’aspect de tableau de l’objet arguments pour accéder aux paramètres transférés à la 
fonction, que ces paramètres soient définis ou non dans la définition de fonction. L’exemple 
suivant utilise le tableau arguments et la propriété arguments.length pour suivre tous les 
paramètres transférés à la fonction traceArgArray() :
function traceArgArray(x:int):void
{
for (var i:uint = 0; i < arguments.length; i++)
{
trace(arguments[i]);
}
}
traceArgArray(1, 2, 3);
// résultat :
// 1
// 2
// 3
140
Syntaxe et langage ActionScript

La propriété arguments.callee est souvent utilisée dans des fonctions anonymes pour créer 
une récursivité. Vous pouvez l’utiliser pour ajouter de la flexibilité à votre code. Si le nom de la 
fonction récursive change pendant votre cycle de développement, il est inutile de modifier 
l’appel récursif dans le corps de votre fonction si vous utilisez arguments.callee au lieu du 
nom de fonction. La propriété arguments.callee est utilisée dans l’expression de fonction 
suivante pour activer la récursivité :
var factorial:Function = function (x:uint)
{
if(x == 0)
{
return 1;
}
else
{
return (x * arguments.callee(x - 1));
}
}
trace(factorial(5)); // 120
Si vous utilisez le paramètre   (rest) dans votre déclaration de fonction, l’objet arguments 
n’est pas disponible. Vous devez accéder aux paramètres à l’aide des noms de paramètre que 
vous avez déclarés. 
N’utilisez pas la chaîne "arguments" comme nom de paramètre car elle masque l’objet 
arguments. Par exemple, si la fonction traceArgArray() est réécrite de façon à ce qu’un 
paramètre arguments soit ajouté, les références à arguments dans le corps de la fonction se 
réfèrent au paramètre plutôt qu’à l’objet arguments. Le code suivant donne le résultat :
function traceArgArray(x:int, arguments:int):void
{
for (var i:uint = 0; i < arguments.length; i++)
{
trace(arguments[i]);
}
}
traceArgArray(1, 2, 3);
// aucun résultat
L’objet arguments dans les versions précédentes d’ActionScript contenait également une 
propriété appelée caller, qui est une référence à la fonction qui appelait la fonction actuelle. 
La propriété caller n’existe pas dans ActionScript 3.0, mais si vous avez besoin d’une 
référence à la fonction d’appel, vous pouvez modifier la fonction d’appel de façon à ce qu’elle 
transfère un paramètre supplémentaire qui en soit une référence.
Fonctions
141

Le paramètre (rest)
ActionScript 3.0 présente une nouvelle déclaration de paramètre appelée le paramètre   
(rest). Ce paramètre vous permet de spécifier un paramètre de tableau qui accepte n’importe 
quel nombre d’arguments séparés par des virgules. Veillez à ne pas inclure un mot réservé dans 
le nom du paramètre. Cette déclaration de paramètre doit être le dernier paramètre spécifié. 
Ce paramètre rend l’objet arguments non disponible. Bien que le paramètre  (rest) offre la 
même fonctionnalité que le tableau arguments et la propriété arguments.length, il ne 
fournit pas la même fonctionnalité que arguments.callee. Vérifiez que vous n’avez pas 
besoin d’utiliser arguments.callee avant d’utiliser le paramètre  (rest).
L’exemple suivant réécrit la fonction traceArgArray() à l’aide du paramètre (rest) au lieu 
de l’objet arguments :
function traceArgArray( args):void
{
for (var i:uint = 0; i < args.length; i++)
{
trace(args[i]);
}
}
traceArgArray(1, 2, 3);
// résultat :
// 1
// 2
// 3
Le paramètre  (rest) peut également être utilisé avec d’autres paramètres, à partir du moment 
où il est le dernier paramètre de la liste. L’exemple suivant modifie la fonction 
traceArgArray() de façon à ce que son premier paramètre, x, soit de type int, et que le 
second utilise le paramètre   (rest). Le résultat ignore la première valeur car le premier 
paramètre ne fait plus partie du tableau créé par le paramètre  (rest).
function traceArgArray(x: int, args)
{
for (var i:uint = 0; i < args.length; i++)
{
trace(args[i]);
}
}
traceArgArray(1, 2, 3);
// résultat :
// 2
// 3
142
Syntaxe et langage ActionScript

Fonctions comme objets
Dans ActionScript 3.0, les fonctions sont des objets. Lorsque vous créez une fonction, vous 
créez un objet qui peut non seulement être transféré en tant que paramètre à une autre 
fonction, mais qui a également des propriétés et des méthodes qui lui sont associées.
Les fonctions transférées en tant qu’arguments à une autre fonction sont transmises par 
référence et non par valeur. Lorsque vous transférez une fonction en tant qu’argument, vous 
utilisez un seul identifiant et non l’opérateur parenthèses que vous utilisez pour appeler la 
méthode. Par exemple, le code suivant transfère une fonction appelée clickListener() en 
tant qu’argument à la méthode addEventListener() :
addEventListener(MouseEvent.CLICK, clickListener);
La méthode () définit également un paramètre qui accepte une fonction. Pour 
consulter un exemple de fonction de tri personnalisée transférée en tant qu’argument à la 
fonction (), voir « Tri d’un tableau », à la page 246.
Même si cela peut sembler étrange pour les programmeurs découvrant ActionScript, les 
fonctions peuvent avoir des propriétés et des méthodes, comme les objets. Chaque fonction a 
en réalité une propriété en lecture seule appelée length qui stocke le nombre de paramètres 
définis pour la fonction. Ceci est différent de la propriété arguments.length qui indique le 
nombre d’arguments envoyés à la fonction. Dans ActionScript, le nombre d’arguments 
envoyés à une fonction peut dépasser le nombre de paramètres définis pour cette dernière. 
L’exemple suivant (qui compile uniquement en mode standard car le mode strict exige une 
correspondance exacte entre le nombre d’arguments transférés et le nombre de paramètres 
définis) indique la différence entre les deux propriétés :
function traceLength(x:uint, y:uint):void
{
trace("arguments received: " + arguments.length);
trace("arguments expected: " + traceLength.length);
}
traceLength(3, 5, 7, 11);
/* résultat :
arguments reçus : 4
arguments attendus : 2 */
Fonctions
143

Vous pouvez définir vos propriétés en dehors du corps de votre fonction. Les propriétés de 
fonction peuvent servir de propriétés quasi statiques vous permettant de sauvegarder l’état 
d’une variable liée à la fonction. Par exemple, vous pouvez suivre le nombre de fois qu’une 
fonction particulière est appelée. Une telle fonctionnalité peut être utile si vous écrivez un jeu 
et souhaitez suivre le nombre de fois qu’un utilisateur se sert d’une certaine commande 
(vous pouvez également utiliser une propriété de classe statique). Le code suivant crée une 
propriété de fonction en dehors de la déclaration de fonction et incrémente la propriété 
chaque fois que la fonction est appelée :
someFunction.counter = 0;
function someFunction():void
{
someFunction.counter++;
}
someFunction();
someFunction();
trace(someFunction.counter); // 2
Domaine de la fonction
Le domaine d’une fonction détermine non seulement l’endroit où cette fonction peut être 
appelée dans un programme, mais également les définitions auxquelles la fonction peut 
accéder. Les mêmes règles de domaine qui s’appliquent aux identifiants de variable 
s’appliquent aux identifiants de fonction. Une fonction déclarée dans le domaine global est 
disponible à travers votre code. Par exemple, ActionScript 3.0 contient des fonctions globales 
(isNaN() et parseInt(), par exemple) disponibles n’importe où dans votre code. 
Une fonction imbriquée (une fonction déclarée dans une autre fonction) peut être utilisée 
n’importe où dans la fonction dans laquelle elle a été déclarée.
144
Syntaxe et langage ActionScript

La chaîne de domaine
Chaque fois qu’une fonction commence une exécution, des objets et des propriétés sont créés. 
Premièrement, un objet spécial appelé objet d’activation est créé. Il stocke les paramètres et les 
variables locales ou fonctions déclarées dans le corps de la fonction. Vous ne pouvez pas accéder 
directement à l’objet d’activation car il s’agit d’un mécanisme interne. Deuxièmement, une 
chaîne de domaine est créée. Elle contient une liste ordonnée d’objets que Flash Player vérifie, à 
la recherche de déclarations d’identifiant. Chaque fonction qui exécute a une chaîne de 
domaine stockée dans une propriété interne. Dans le cas d’une fonction imbriquée, la chaîne de 
domaine commence avec son objet d’activation, suivi par l’objet d’activation de sa fonction 
parent. La chaîne continue de cette façon jusqu’à ce que l’objet global soit atteint. L’objet global 
est créé lorsqu’un programme ActionScript commence, et contient toutes les fonctions et les 
variables globales. 
Fonctions closures
Une fonction closure est un objet qui contient un instantané d’une fonction et de son 
environnement lexical. L’environnement lexical d’une fonction comprend toutes les variables, 
propriétés, méthodes et les objets dans la chaîne de domaine de la fonction, ainsi que leurs 
valeurs. Les fonctions closures sont créées chaque fois qu’une fonction est exécutée à part d’un 
objet ou d’une classe. Le fait que les fonctions closures conservent le domaine dans lequel elles 
ont été définies crée des résultats intéressants lorsqu’une fonction est transférée en tant 
qu’argument ou valeur de renvoi dans un domaine différent. 
Par exemple, le code suivant créé deux fonctions : foo(), qui renvoie une fonction imbriquée 
appelée rectArea() qui calcule la surface d’un rectangle, et bar(), qui appelle foo() et 
stocke la fonction closure renvoyée dans une variable nommée myProduct. Même si la 
fonction bar() définit sa propre variable locale x (avec une valeur de 2), lorsque la fonction 
closure myProduct() est appelée, elle conserve la variable x (avec une valeur de 40) définie 
dans la fonction foo(). La fonction bar() renvoie par conséquent la valeur 160 au lieu de 8.
function foo():Function
{
var x:int = 40;
function rectArea(y:int):int // fonction closure définie
{
return x * y

return rectArea;
}
Fonctions
145

function bar():void
{
var x:int = 2;
var y:int = 4;
var myProduct:Function = foo();
trace(myProduct(4)); // fonction closure appelée
}
bar(); // 160
Les méthodes se comportent de la même façon car elles conservent également les informations 
concernant l’environnement lexical dans lequel elles ont été créées. Cette caractéristique n’est 
pas visible lorsqu’une méthode est extraite de son instance, ce qui crée une méthode liée. 
La différence principale entre une fonction closure et une méthode liée est que la valeur du 
mot-clé this dans une méthode liée se réfère toujours à l’instance à laquelle elle était associée 
à l’origine, alors que dans une fonction closure, la valeur du mot-clé this peut changer. Pour 
plus d’informations, voir « Les méthodes liées », à la page 165.
146
Syntaxe et langage ActionScript

CHAPITRE 4
Programmation orientée 
4
objet en ActionScript
Ce chapitre décrit les éléments du langage ActionScript qui prennent en charge la 
programmation orientée objet (POO). Il ne décrit pas les principes généraux de la POO tels 
que la conception des objets, l’abstraction, l’encapsulation, l’héritage et le polymorphisme. 
Ce chapitre porte sur l’application de ces principes en ActionScript 3.0.
Dans la mesure où ActionScript découle d’un langage de script, la prise en charge de la 
programmation orientée objet est facultative en ActionScript 3.0. Les programmeurs peuvent 
ainsi choisir l’approche qui leur convient le mieux, en fonction de la portée et de la complexité 
de chaque projet. Pour les petites tâches, il peut être préférable d’utiliser ActionScript suivant 
le paradigme de la programmation par procédures. Pour les projets importants, l’application 
des principes de la POO permettra de rendre le code plus facile à lire, gérer et étendre. 
Sommaire
Principes de la programmation orientée objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Héritage  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  173
Rubriques avancées  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Exemple : GeometricShapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
147

Principes de la programmation 
orientée objet
Introduction à la programmation orientée objet
La programmation orientée objet est une technique d’organisation du code d’un programme 
en le groupant en objets — les objets étant ici des éléments individuels comportant des 
informations (valeurs de données) et des fonctionnalités. L’approche orientée objet permet de 
regrouper des éléments particuliers d’informations (par exemple, les informations d’un 
enregistrement musical : titre de l’album, titre de la piste ou nom de l’artiste) avec des 
fonctionnalités ou des actions communes associées à ces informations (comme l’ajout de la 
piste à une liste de lecture, ou la lecture de tous les enregistrement de cet artiste). Ces éléments 
sont combinés en un seul, l’objet (par exemple, un « Album » ou une « piste »). La possibilité 
de regrouper ainsi ces valeurs et ces fonctions offre divers avantages. Ainsi, il est possible de ne 
suivre qu’une seule variable au lieu de plusieurs, d’organiser ensemble des fonctionnalités 
apparentées, et de structurer le programme d’une manière beaucoup plus proche du 
fonctionnement humain.
Tâches courantes en programmation orientée objet
En pratique, la programmation orientée objet se décompose en deux parties. La première 
partie est l’ensemble des stratégies et des techniques de conception d’un programme (c’est 
pourquoi elle est fréquemment appelée conception orientée objet). Ce vaste sujet ne sera pas 
abordé dans le présent chapitre. L’autre partie de la programmation orientée objet est 
l’ensemble des structures de programmation qui sont disponibles dans un langage donné pour 
faciliter la construction d’un programme selon une approche orientée objet. Ce chapitre 
aborde les tâches suivantes, qui sont fréquentes en POO :
?
Définition des classes
?
Création de propriétés, méthodes et accesseurs de lecture et de définition (méthodes 
accesseurs)
?
Contrôle de l’accès aux classes, propriétés, méthodes et accesseurs
?
Création de propriétés et de méthodes statiques
?
Création de structures d’énumération
?
Définition et utilisation d’interfaces
?
Utilisation de l’héritage, y compris lors de la redéfinition des éléments des classes
148
Programmation orientée objet en ActionScript

Concepts et termes importants
La liste de référence suivante énumère les termes importants que vous rencontrerez dans ce 
chapitre :
?
Attribut : caractéristiques affectée à un élément d’une classe (une propriété ou une 
méthode) dans la définition de cette classe. Les attributs sont couramment utilisés pour 
définir le niveau d’accès à cette propriété ou cette méthode par du code situé dans d’autres 
parties du programme. Par exemple, private et public sont des attributs. Une méthode 
privée ne peut être appelée que par le code résidant dans sa classe, alors qu’une méthode 
publique peut être appelée par du code résidant n’importe où dans le programme.
?
Classe : définition de la structure et du comportement des objets d’un certain type 
(l’équivalent d’un modèle ou d’une matrice pour les objets de ce type de données).
?
Hiérarchie des classes : structure de plusieurs classes apparentées, qui indique quelles 
classes héritent de fonctionnalités des autres classes.
?
Constructeur : méthode spéciale pouvant être définie dans une classe et qui est appelée 
lors de la création d’une instance de cette classe. Un constructeur est fréquemment utilisé 
pour spécifier des valeurs par défaut ou effectuer des opérations de configuration pour 
l’objet.
?
Type de données : type d’informations qui peut être stocké dans une variable particulière. 
En général, type de données a le même sens que classe.
?
Opérateur point : en ActionScript et dans de nombreux autres langages de 
programmation, le signe point (.) indique qu’un nom réfère à un élément enfant 
(propriété ou méthode) d’un objet. Par exemple, dans l’expression 
monObjet.maPropriété, l’oprateur point indique que le terme maPropriété fait 
référence à une valeur qui est un élément de l’objet monObjet.
?
Énumération : ensemble de valeurs constantes apparentées, regroupées pour des raisons 
pratiques sous forme de propriétés d’une même classe.
?
Héritage : mécanisme de la programmation orientée objet qui permet à la définition d’une 
classe de comporter toutes les fonctionnalités de la définition d’une autre classe 
(en général, en y ajoutant de nouvelles fonctionnalités).
?
Instance : objet réel créé dans le cadre d’un programme.
?
Espace de nom : essentiellement, attribut personnalisé qui autorise plus de contrôle pour 
définir le code qui est autorisé à accéder à un autre code.
Principes de la programmation orientée objet
149

Utilisation des exemples des chapitres
Au fur et à mesure que vous avancez dans le chapitre, vous pouvez tester des exemples de code. 
Etant donné que les exemples de code de ce chapitre traitent principalement de la définition 
et de la manipulation des types de données, le test des exemples impliquera la création d’une 
instance de la classe définie, la manipulation de cette instance à l’aide de ses propriétés ou de 
ses méthodes et l’affichage des valeurs des propriétés de cette instance. Pour afficher ces 
valeurs, écrivez des valeurs dans une instance de champ texte sur la scène, ou utilisez la 
fonction trace() pour imprimer des valeurs sur le panneau Sortie. Ces techniques sont 
décrites dans la section « Test des exemples de code contenus dans un chapitre », à la page 67.
Classes
Une classe est une représentation abstraite d’un objet. Une classe conserve des informations 
sur les types de données contenues par un objet et sur les comportements possibles de cet 
objet. L’utilité de ce niveau d’abstraction peut ne pas être évidente dans le cas de petits scripts 
ne contenant que quelques objets destinés à interagir les uns avec les autres. Toutefois, à 
mesure que le programme croît en ampleur et que le nombre d’objets à gérer augmente, vous 
découvrirez probablement que les classes autorisent un meilleur contrôle sur la création des 
objets et sur leurs interactions.
Dès la première version d’ActionScript, les programmeurs en ActionScript pouvaient utiliser 
des objets Function pour créer des éléments ressemblant à des classes. ActionScript 2.0 a 
ensuite ajouté une prise en charge formelle des classes, avec des mots-clés tels que class et 
extends. ActionScript 3.0 préserve la prise en charge des mots-clés introduits avec 
ActionScript 2.0, tout en ajoutant de nouvelles possibilités, par exemple un meilleur contrôle 
d’accès avec les attributs protected et internal, et un meilleur contrôle de l’héritage avec les 
mots-clés final et override.
Si vous avez déjà créé des classes dans des langages de programmation tels que Java, C++ ou 
C#, vous ne serez pas dépaysés par ActionScript. ActionScript partage avec ces langages de 
nombreux mots-clés et noms d’attributs, par exemple class, extends et public, qui sont 
présentés dans les sections suivantes.
REMA
Dans ce chapitre, le terme propriété désigne tout membre d’un objet ou d’une classe 
(variables, constantes et méthodes). De plus, bien que les termes classe et statique 
R
soient fréquemment utilisés de façon interchangeable, nous ferons une distinction entre 
Q
UE
ces termes dans ce chapitre. Par exemple, dans le présent chapitre, l’expression 
propriétés de classe désigne tous les membres d’une classe, et non pas seulement ses 
membres statiques.
150
Programmation orientée objet en ActionScript

Définitions de classe
En ActionScript 3.0, les définitions de classe utilisent la même syntaxe qu’en ActionScript 2.0. 
La syntaxe correcte d’une définition de classe utilise le mot-clé class suivi du nom de la 
classe. Le corps de la définition de classe est inséré entre des accolades ({}) après le nom de la 
classe. Par exemple, le code suivant crée une classe nommée Shape et contenant une seule 
variable, nommée visible : 
public class Shape
{
var visible:Boolean = true;
}
Notez que la syntaxe est différente dans le cas des définitions de classe faisant partie d’un 
paquet. En ActionScript 2.0, si une classe fait partie d’un paquet, le nom de ce dernier doit 
figurer dans la déclaration de classe. Comme l’instruction package a été introduite en 
ActionScript 3.0, le nom du paquet doit figurer dans la déclaration de paquet et non pas dans 
la déclaration de classe. Par exemple, les déclarations de classe suivantes montrent comment 
définir la classe BitmapData, qui fait partie du paquet flash.display, respectivement en 
ActionScript 2.0 et en ActionScript 3.0 :
// ActionScript 2.0
class flash.display.BitmapData {}
// ActionScript 3.0
package flash.display
{
public class BitmapData {}
}
Attributs de classe
ActionScript 3.0 permet de modifier les définitions de classe à l’aide de l’un des quatre 
attributs suivants :
Attribut
Définition
dynamic
Permet d’ajouter des propriétés aux instances lors de l’exécution.
final
Ne doit pas être étendue par une autre classe.
internal (par défaut)
Visible pour les références à partir du paquet actuel.
public
Visible pour les références à partir de n’importe quel point du code.
Classes
151

Pour chacun de ces attributs, à l’exception de internal, vous devez inclure l’attribut 
explicitement pour obtenir le comportement qui lui est associé. Par exemple, faute d’inclure 
l’attribut dynamic lors de la définition d’une classe, vous ne pourrez pas ajouter des propriétés 
à une instance d’une classe lors de son exécution. Pour affecter explicitement un attribut, 
placez-le au début de la définition de la classe, comme dans le code ci-dessous :
dynamic class Shape {}
Notez que cette liste ne comprend pas l’attribut nommé abstract. En effet, les classes 
abstraites ne sont pas prises en charge en ActionScript 3.0. Notez également que cette liste ne 
comprend pas non plus les attributs private et protected. Ces attributs n’ont de sens qu’à 
l’intérieur d’une définition de classe et ne peuvent pas être appliqués aux classes elles-mêmes. 
Si vous ne souhaitez pas qu’une classe soit visible à l’extérieur de son paquet, placez cette classe 
dans un paquet et affectez-lui l’attribut internal. Vous pouvez aussi omettre les attributs 
internal et public. Dans ce cas, le compilateur ajoutera automatiquement l’attribut 
internal. Si vous ne souhaitez pas qu’une classe soit visible à l’extérieur du fichier source 
dans lequel elle est définie, placez-la à la fin de ce fichier source, après l’accolade de fin de la 
définition de paquet.
Corps de la classe
Le corps de la définition de classe, qui est inséré entre des accolades, permet de définir les 
variables, constantes et méthodes de la classe. L’exemple suivant montre la déclaration de la 
classe Accessibility dans l’API d’Adobe Flash Player :
public final class Accessibility
{
public static function get active():Boolean;
public static function updateProperties():void;
}
Il est également possible de définir un espace de nom dans le corps d’une classe. L’exemple 
suivant montre la définition d’un espace de nom dans le corps d’une classe et son utilisation 
comme attribut d’une méthode de cette classe :
public class SampleClass
{
public namespace sampleNamespace;
sampleNamespace function doSomething():void;
}
152
Programmation orientée objet en ActionScript

ActionScript 3.0 permet d’inclure dans le corps d’une classe non seulement les définitions, 
mais aussi des instructions. Les instructions qui figurent dans le corps d’une classe, mais hors 
d’une définition de méthode, sont exécutées une seule fois, lors de la première apparition de la 
définition de classe et de la création de l’objet class qui lui est associé. L’exemple suivant 
comporte un appel à une fonction externe, hello(), et une instruction trace qui affiche un 
message de confirmation lors de la définition de la classe :
function hello():String
{
trace("hola");
}
class SampleClass
{
hello();
trace("class created");
}
// affichage lorsque la classe est créée.
hola
class created
Contrairement aux versions antérieures d’ActionScript, en ActionScript 3.0 il est permis de 
définir une propriété static et une propriété d’instance ayant le même nom dans le corps de la 
même classe. Par exemple, le code suivant déclare une variable statique message et une 
variable d’instance ayant le même nom : 
class StaticTest
{
static var message:String = "static variable";
var message:String = "instance variable";
}
// dans le script
var myST:StaticTest = new StaticTest();
trace(StaticTest.message); // résultat : variable statique
trace(myST.message);       // résultat : variable de l’instance
Classes
153

Attributs de propriété de classe
Dans le cadre du modèle d’objet ActionScript, le terme propriété représente tout ce qui peut 
être membre d’une classe : variables, constantes et méthodes. Ce terme n’est pas utilisé dans le 
même sens dans le manuel Référence du langage et des composants ActionScript 3.0, où il est 
utilisé avec un sens plus étroit et ne désigne alors que les membres d’une classe qui soit sont 
des variables, soit sont définis par une méthode de lecture/définition. En ActionScript 3.0, un 
jeu d’attributs peut être utilisé avec n’importe quelle propriété d’une classe. Le tableau suivant 
présente ce jeu d’attributs.
Attribut
Définition
internal (par défaut)
Visible pour les références à partir du paquet actuel.
private
Visible pour les références à partir de la même classe.
protected
Visible pour les références à partir de la même classe et des 
classes dérivées.
public
Visible pour les références à partir de n’importe quel point 
du code.
static
Spécifie qu’une propriété appartient à la classe, et non pas aux 
instances de celle-ci.
UserDefinedNamespace
Nom d’espace de nom défini par l’utilisateur.
Attributs d’espace de nom pour le contrôle d’accès
ActionScript 3.0 comporte quatre attributs spéciaux qui contrôlent l’accès aux propriétés 
définies dans une classe : public, private, protected et internal. 
Avec l’attribut public, une propriété est visible de n’importe quel point du script. 
Par exemple, si vous souhaitez qu’une méthode soit disponible pour du code externe au 
paquet, vous devez la déclarer avec l’attribut public. Ceci est vrai pour toutes les propriétés, 
qu’elles soient déclarées à l’aide des mots-clés var, const ou function.
Avec l’attribut private, une propriété n’est visible qu’à partir de la classe où cette propriété est 
définie. Ce comportement est différent de celui de l’attribut private en ActionScript 2.0, où 
une sous-classe pouvait accéder à une propriété déclarée private d’une super-classe. 
Le comportement lors de l’exécution présente un autre changement important. 
En ActionScript 2.0, la restriction d’accès introduite par le mot-clé private ne portait que 
sur la compilation, et il était facile de la contourner lors de l’exécution. Ce n’est plus le cas en 
ActionScript 3.0. Les propriétés marquées comme private sont indisponibles aussi bien à 
l’exécution qu’à la compilation. 
154
Programmation orientée objet en ActionScript

Par exemple, le code ci-dessous crée une classe simple nommée PrivateExample avec une 
variable ayant l’attribut private, puis tente d’accéder à cette variable à partir de l’extérieur de 
cette classe. En ActionScript 2.0, l’accès à cette variable était interdit lors de la compilation, 
mais il était facile de contourner cette restriction à l’aide de l’opérateur d’accès aux propriétés 
([]), qui recherche celles-ci lors de l’exécution, et non pas lors de la compilation.
class PrivateExample
{
private var privVar:String = "private variable";
}
var myExample:PrivateExample = new PrivateExample();
trace(myExample.privVar);    // erreur de compilation en mode strict
trace(myExample["privVar"]); 
// ActionScript 2.0 autorise l’accès, mais ActionScript 3.0 déclenche 
// une erreur d’exécution. 
En ActionScript 3.0, toute tentative d’accéder à une propriété private à l’aide de l’opérateur 
point (myExample.privVar) déclenche une erreur de compilation en mode strict. Sinon, 
l’erreur est signalée lors de l’exécution, tout comme lors de l’utilisation de l’opérateur d’accès 
aux propriétés (myExample["privVar"]). 
Le tableau suivant présente les divers résultats d’une tentative d’accès à une propriété déclarée 
comme privée, appartenant à une classe scellée (non dynamique) : 
Mode strict
Mode standard
opérateur point (.)
erreur de compilation
erreur d’exécution
opérateur crochets ([])
erreur d’exécution
erreur d’exécution
Dans les classes déclarées avec l’attribut dynamic, une tentative d’accéder à une variable 
private ne provoquera pas d’erreur d’exécution. Cette variable ne sera simplement pas visible, 
si bien que Flash Player renverra la valeur undefined. Une erreur de compilation se produit 
toutefois si vous utilisez l’opérateur point en mode strict. L’exemple suivant est identique à 
l’exemple précédent, si ce n’est que cette fois la classe PrivateExample est déclarée comme 
classe dynamique : 
dynamic class PrivateExample
{
private var privVar:String = "private variable";
}
var myExample:PrivateExample = new PrivateExample();
trace(myExample.privVar);    // erreur de compilation en mode strict
trace(myExample["privVar"]); // résultat : undefined
Classes
155

En général, lorsque du code extérieur à une classe tente d’accéder à une propriété déclarée 
comme private, les classes dynamiques renvoient la valeur undefined au lieu de générer une 
erreur. Le tableau suivant montre qu’une erreur n’est générée que lorsque l’opérateur point est 
utilisé pour accéder à une propriété privée en mode strict :
Mode strict
Mode standard
opérateur point (.)
erreur de compilation
undefined
opérateur crochets ([])
undefined
undefined
Avec l’attribut protected, qui apparaît avec ActionScript 3.0, une propriété n’est visible qu’à 
partir de sa propre classe ou d’une sous-classe de celle-ci. Autrement dit, une propriété 
déclarée protected n’est disponible qu’à partir de sa propre classe ou des classes qui lui sont 
inférieures dans sa hiérarchie d’héritage, que la sous-classe se trouve dans le même paquet ou 
dans un autre. 
Pour les programmeurs familiers d’ActionScript 2.0, cette fonctionnalité est similaire à 
l’attribut private en ActionScript 2.0. En ActionScript 3.0, l’attribut protected est 
également similaire à l’attribut protected en Java, à la différence près que la version Java 
autorise également l’accès à partir du même paquet. L’attribut protected est utile pour créer 
une variable ou une méthode nécessaire aux sous-classes, mais qui ne doit pas être visible à 
partir du code extérieur à la hiérarchie d’héritage.
Avec l’attribut internal, qui apparaît avec ActionScript 3.0, une propriété n’est visible qu’à 
partir de son propre paquet. C’est l’attribut par défaut du code contenu par un paquet, et il 
s’applique à toute propriété n’ayant pas l’un des attributs suivants :
?
public 
?
private 
?
protected 
?
un espace de nom défini par l’utilisateur
L’attribut internal est similaire au contrôle d’accès par défaut en Java, bien que dans ce 
dernier langage ce niveau d’accès ne porte pas de nom explicite et ne puisse être obtenu qu’en 
omettant de déclarer un autre modificateur d’accès. Avec l’attribut internal, qui apparaît 
avec ActionScript 3.0, il est possible de signifier explicitement votre intention de ne rendre 
une propriété visible qu’à partir de son propre paquet. 
156
Programmation orientée objet en ActionScript

Attribut static
L’attribut static, qui peut être utilisé avec les propriétés déclarées à l’aide des mots-clés var, 
const ou function, il est possible d’affecter une propriété à la classe elle-même, plutôt qu’à 
ses instances. Le code externe à cette classe doit appeler les propriétés statiques à l’aide du nom 
de la classe, et non pas à partir du nom d’une instance.
Les sous-classes n’héritent pas des propriétés statiques, ces dernières font partie de leur chaîne 
de portée. En d’autres termes, dans le corps d’une sous-classe, une méthode ou une variable 
statique ne peuvent pas être utilisées sans référencer la classer dans laquelle elles ont été 
définies. Pour plus d’informations, consultez la page 180.
Attributs d’espace de nom définis par l’utilisateur
À la place des attributs de contrôle d’accès prédéfinis, vous pouvez créer un espace de nom 
personnalisé pour l’utiliser comme attribut. Un seul attribut d’espace de nom peut être utilisé 
par définition, et il est impossible d’utiliser un attribut d’espace de nom en combinaison avec 
l’un des attributs de contrôle d’accès (public, private, protected, internal). Pour plus 
d’informations sur l’utilisation des espaces de nom, consultez la section la page 80.
Les variables
Pour déclarer une variable, utilisez les mots-clés var ou const. La valeur des variables 
déclarées à l’aide du mot-clé var peut être modifiée à plusieurs reprises pendant l’exécution du 
script. Les variables déclarées à l’aide du mot-clé const sont appelées des constantes, et leur 
valeur est définie lors de leur création. Une erreur se produit si vous tentez d’affecter une 
nouvelle valeur à une constante initialisée. Pour plus d’informations, consultez la section 
« Constantes », à la page 116.
Classes
157

Les variables statiques
Les variables statiques sont déclarées à l’aide du mot-clé static et de l’instruction var ou 
const. Les variables statiques sont affectées à une classe, plutôt qu’à une instance de classe. 
Elles permettent de stocker et renvoyer des informations propres à une classe entière d’objets. 
Par exemple, une variable statique permet d’enregistrer le nombre de fois où une classe a été 
instanciée, ou le nombre maximal d’instances autorisées pour une classe. 
L’exemple ci-dessous crée une variable totalCount qui permet d’enregistrer le nombre total 
d’instanciations d’une classe, et une constante MAX_NUM dont la valeur est le nombre maximal 
d’instanciations autorisées. Les variables totalCount et MAX_NUM sont statiques car elles 
contiennent des valeurs qui s’appliquent à la classe elle-même, plutôt qu’à une instance 
particulière.
class StaticVars
{
public static var totalCount:int = 0;
public static const MAX_NUM:uint = 16;
}
Tout code externe à la classe StaticVars et à ses sous-classes ne peut référencer les propriétés 
totalCount et MAX_NUM que par le biais de la classe elle-même. Par exemple, le code suivant 
fonctionne :
trace(StaticVars.totalCount); // résultat : 0
trace(StaticVars.MAX_NUM); // résultat : 16
Comme il est impossible d’accéder à des variables statiques via une instance de la classe, le 
code suivant renvoie des erreurs :
var myStaticVars:StaticVars = new StaticVars();
trace(myStaticVars.totalCount); // Erreur
trace(myStaticVars.MAX_NUM); // Erreur
Les variables qui sont déclarées à l’aide des mots-clés static et const doivent être initialisées 
au moment de la déclaration de la constante, tout comme la classe StaticVars le fait pour 
MAX_NUM. Il est impossible d’affecter une valeur à MAX_NUM à partir du constructeur ou d’une 
méthode d’une instance. Le code suivant génèrera une erreur, car ce n’est pas une façon valide 
d’initialiser une constante statique :
// !! C’est une erreur d’initialiser une constant statique de cette façon
class StaticVars2
{
public static const UNIQUESORT:uint;
function initializeStatic():void
{
UNIQUESORT = 16;
}
}
158
Programmation orientée objet en ActionScript

Variables d’instance
Les variables d’instance sont des propriétés déclarées à l’aide des mots-clés var et const mais 
sans le mot-clé static. Les variables d’instance, qui sont affectées à des instances de classe 
plutôt qu’à la classe elle-même, sont utiles pour conserver des valeurs spécifiques à une instance. 
Par exemple, la classe Array dispose d’une propriété d’instance nommée length qui conserve le 
nombre d’éléments du tableau appartenant à une instance particulière de la classe Array.
Qu’elles soient déclarées avec le mot-clé var ou const, les variables d’instance ne peuvent pas 
être redéfinies dans une sous-classe. Il est toutefois possible d’obtenir un effet similaire à la 
redéfinition de variables, en redéfinissant des méthodes de lecture et de définition. Pour plus 
d’informations, consultez la section la page 163.
Les méthodes
Les méthodes sont des fonctions associées à la définition d’une classe. Lorsqu’une instance de 
la classe est créée, une méthode est liée à cette instance. Contrairement aux fonctions déclarées 
hors d’une classe, les méthodes ne peuvent pas être utilisées en dehors de l’instance à laquelle 
elles sont affectées.
Pour déclarer une méthode, utilisez le mot-clé function. Vous pouvez utiliser une instruction 
function comme ci-dessous :
public function sampleFunction():String {}
Vous pouvez aussi utiliser une variable à laquelle vous affecterez ensuite une expression de 
fonction, comme ci-dessous :
public var sampleFunction:Function = function () {}
Dans la plupart des cas, il est préférable d’utiliser une instruction function au lieu d’une 
expression de fonction pour les raisons suivantes :
?
Les instructions function sont plus concises et plus faciles à lire.
?
Les instructions function permettent d’utiliser les mots-clés override et final. Pour plus 
d’informations, consultez la section « Redéfinition des méthodes », à la page 178.
?
Les instructions function créent une liaison plus robuste entre l’identifiant (le nom de la 
fonction) et le code dans le corps de la méthode. La valeur d’une variable pouvant être 
modifiée à l’aide d’une opération d’affectation, le lien entre une variable et son expression de 
fonction peut être rompu à tout moment. Bien qu’il soit possible de résoudre ce problème en 
déclarant la variable avec const au lieu de var, cette technique n’est pas recommandée car 
elle rend le code difficilement lisible et empêche d’utiliser les mots-clés override et final.
Il existe toutefois un cas dans lequel une expression de fonction doit être utilisée : si vous 
choisissez d’affecter une fonction à l’objet prototype. Pour plus d’informations, consultez la 
section « L’objet prototype », à la page 189.
Classes
159

Les méthodes constructeur
Les méthodes constructeur, parfois appelées simplement constructeurs, sont des fonctions qui 
portent le nom de la classe dans laquelle elles sont définies. Tout code figurant dans une 
méthode constructeur est executé lorsqu’une instance de la classe est créée à l’aide du mot-clé 
new. Par exemple, le code suivant définit une classe simple nommée Example et contenant une 
seule propriété, nommée status : La valeur initiale de la variable status est fixée dans la 
fonction constructeur.
class Example
{
public var status:String;
public function Example()
{
status = "initialized";
}
}
var myExample:Example = new Example();
trace(myExample.status); // résultat : initialisation
Les méthodes constructeur sont obligatoirement publiques, mais l’attribut public est 
facultatif. Il est impossible d’utiliser l’un des autres spécificateurs de contrôle d’accès 
(private, protected ou internal) avec un constructeur. De même, il est impossible 
d’utiliser avec un constructeur un espace de nom défini par l’utilisateur.
Un constructeur peut appeler explicitement le constructeur de sa super-classe directe, à l’aide 
de l’instruction super(). Si le constructeur de la super-classe n’est pas explicitement appelé, le 
compilateur insère automatiquement un appel avant la première instruction dans le corps du 
constructeur. Vous pouvez aussi appeler des méthodes de la super-classe à l’aide du préfixe 
super en référence à la super-classe. Si vous choisissez d’utiliser à la fois super() et super 
dans le corps du même constructeur, veillez à appeler d’abord super(). Sinon, la référence 
super ne fonctionnera pas comme prévu. Le constructeur super() doit également être appelé 
avant toute instruction throw ou return. 
160
Programmation orientée objet en ActionScript

L’exemple suivant montre ce qui se produit si vous tentez d’utiliser la référence super avant 
d’avoir appelé le constructeur super(). Une nouvelle classe, ExampleEx, étend la classe 
Example. Le constructeur ExampleEx tente d’accéder à la variable d’état définie dans sa super-
classe, mais avant un appel à super(). L’instruction trace() du constructeur ExampleEx 
produit la valeur null car la variable status n’est pas disponible tant que le constructeur 
super() n’a pas été exécuté.
class ExampleEx extends Example
{
public function ExampleEx()
{
trace(super.status);
super();
}
}
var mySample:ExampleEx = new ExampleEx(); // résultat : null
Bien qu’il soit permis d’utiliser l’instruction return dans un constructeur, il n’est pas possible 
de lui faire renvoyer une valeur. Autrement dit, aucune expression ou valeur ne peut être 
associée à l’instruction return. En conséquence, les constructeurs ne peuvent pas renvoyer de 
valeurs, ce qui signifie qu’aucun type de valeur renvoyée ne peut être spécifié.
Si vous ne définissez pas de méthode constructeur dans votre classe, le compilateur crée 
automatiquement un constructeur vide. Si votre classe étend une autre classe, le compilateur 
insère un appel super() dans le constructeur qu’il génère.
Les méthodes statiques
Les méthodes statiques, également appelées parfois méthodes de classe, sont déclarées avec le mot-
clé static. Les méthodes statiques sont affectées à une classe, plutôt qu’à une instance de classe. 
Elles permettent d’encapsuler des fonctionnalités qui ont une portée plus étendue que l’état 
d’une instance individuelle. Comme les méthodes statiques sont affectées à une classe en tant 
que telle, elles ne sont accessibles que via une classe, et non pas par une instance de la classe. 
Les méthodes statiques permettent d’encapsuler des fonctionnalités qui ne sont pas limitées à 
la modification d’état des instances de classe. Ainsi, une méthode doit être statique si elle offre 
des fonctionnalités qui n’affectent pas directement la valeur d’une instance de classe. 
Par exemple, la classe Date possède une méthode statique nommée parse(), qui reçoit une 
chaîne et la convertit en nombre. Cette méthode est statique parce qu’elle n’affecte pas une 
instance individuelle de sa classe. La méthode parse() reçoit une chaîne représentant une 
valeur de date, l’analyse et renvoie un nombre dans un format compatible avec la 
représentation interne d’un objet Date. Cette méthode n’est pas une méthode d’instance, 
puisqu’il n’y aurait aucun intérêt à l’appliquer à une instance de la classe Date. 
Classes
161

Comparons la méthode statique parse() à l’une des méthodes d’instance de la classe Date, 
telle que getMonth(). La méthode getMonth() est une méthode d’instance parce qu’elle agit 
directement sur la valeur d’une instance en récupérant un composant spécifique, le mois, 
d’une instance de Date.
Dans la mesure où les méthodes statiques ne sont pas liées à des instances individuelles, il n’est 
pas possible d’utiliser les mots-clés this ou super dans le corps d’une méthode statique. 
Les références this et super n’ont de signification que dans le contexte d’une méthode 
d’instance.
À l’inverse d’autres langages de programmation basés sur des classes, en ActionScript 3.0 les 
méthodes statiques ne sont pas héritées. Pour plus d’informations, consultez la section 
« Propriétés statiques non héritées », à la page 180.
Les méthodes d’instance
Les méthodes d’instance sont déclarées sans le mot-clé static. Les méthodes d’instance, qui 
sont affectées aux instances d’une classe et non pas à la classe elle-même, permettent 
d’implémenter des fonctionnalités qui affectent des instances individuelles d’une classe. 
Par exemple, la classe Array contient une méthode d’instance nommée sort(), qui opère 
directement sur les instances d’Array.
Dans le corps d’une méthode d’instance, les variables statiques et d’instance sont de même 
portée, ce qui signifie que les variables définies dans la même classe peuvent être référencées à 
l’aide d’un identificateur simple. Par exemple, la classe suivante, CustomArray, étend la classe 
Array. La classe CustomArray définit une variable statique nommée arrayCountTotal et 
destinée à contenir le nombre total d’instances de la classe, une variable d’instance nommée 
arrayNumber qui enregistre l’ordre dans lequel les instances ont été créées, et une méthode 
d’instance nommée getPosition() qui renvoie les valeurs de ces variables. 
public class CustomArray extends Array
{
public static var arrayCountTotal:int = 0;
public var arrayNumber:int;
public function CustomArray()
{
arrayNumber = ++arrayCountTotal;
}
public function getArrayPosition():String
{
 return ("Array " + arrayNumber + " of " + arrayCountTotal);
}
}
162
Programmation orientée objet en ActionScript

Pour faire référence à la variable statique arrayCountTotal, du code externe à cette classe doit 
passer par l’objet class (CustomArray.arrayCountTotal), mais le code qui réside dans le 
corps de la méthode getPosition() peut directement faire référence à la variable statique 
arrayCountTotal. C’est également le cas pour les variables statiques des super-classes. Bien 
que les propriétés statiques ne soient pas héritées en ActionScript 3.0, les propriétés statiques 
des super-classes sont dans la portée. Par exemple, la classe Array possède quelques variables 
statiques, dont l’une est une constante nommée DESCENDING. Le code qui réside dans une 
sous-classe d’Array peut faire référence à la constante statique DESCENDING à l’aide d’un 
identificateur simple :
public class CustomArray extends Array
{
public function testStatic():void
{
trace(DESCENDING); // résultat : 2
}
}
Dans le corps d’une méthode d’instance, la valeur de la référence this est une référence à 
l’instance à laquelle la méthode est affectée. Le code suivant montre que la référence this 
pointe sur l’instance qui contient la méthode :
class ThisTest
{
function thisValue():ThisTest
{
return this;
}
}
var myTest:ThisTest = new ThisTest();
trace(myTest.thisValue() == myTest); // résultat : true
Il est possible de contrôler l’héritage des méthodes d’instance à l’aide des mots-clés override 
et final. Vous pouvez utiliser l’attribut override pour redéfinir une méthode héritée, et 
l’attribut final pour empêcher les sous-classes de redéfinir une méthode. Pour plus 
d’informations, consultez la section « Redéfinition des méthodes », à la page 178.
Les méthodes accesseurs de lecture et de définition
Les méthodes accesseurs de lecture et de définition, également appelées getters et setters
permettent d’adhérer aux principes de programmation du masquage et de l’encapsulation 
d’informations tout en offrant une interface de programmation d’emploi facile pour vos classes. 
Les fonctions de lecture et de définition (get et set) permettent de garder privées les propriétés 
d’une classe, tout en permettant à l’utilisateur de cette classe d’accéder à ces propriétés comme 
s’ils accédaient à une variable de classe au lieu d’appeler une méthode de classe. 
Classes
163

L’avantage de cette approche est qu’elle permet d’éviter les traditionnelles fonctions accesseurs 
aux noms peu maniables, telles que getPropertyName() et setPropertyName(). Leur autre 
avantage est qu’elles évitent d’avoir deux fonctions exposées publiquement pour chaque 
propriété accessible en lecture et en écriture.
Dans l’exemple suivant, la classe nommée GetSet possède des fonctions accesseurs de lecture 
et de définition nommées publicAccess() qui permettent d’accéder à la variable privée 
privateProperty :
class GetSet
{
private var privateProperty:String;
public function get publicAccess():String
{
return privateProperty;
}
public function set publicAccess(setValue:String):void
{
privateProperty = setValue;
}
}
Si vous tentez d’accéder à la propriété privateProperty directement, une erreur se produira :
var myGetSet:GetSet = new GetSet();
trace(myGetSet.privateProperty); // erreur
Par contre, si vous utilisez la classe GetSet, vous ferez appel à quelque chose qui semble être 
une propriété nommée publicAccess, mais il s’agira en réalité d’une paire de fonctions 
accesseurs de lecture et de définition opérant sur la propriété privée nommée 
privateProperty. L’exemple suivant instancie la classe GetSet, puis définit la valeur de la 
propriété privateProperty à l’aide de l’accesseur public nommée publicAccess :
var myGetSet:GetSet = new GetSet();
trace(myGetSet.publicAccess); // résultat : null
myGetSet.publicAccess = "hello";
trace(myGetSet.publicAccess); // résultat : hello
Les fonctions de lecture et de définition permettent également de forcer des propriétés héritées 
d’une super-classe, ce qui n’est pas possible avec des variables régulières membres de classes. 
Les variables membres de classes qui sont déclarées avec le mot-clé var ne peuvent pas être 
forcées dans une sous-classe. Toutefois, cette restriction ne concerne pas les propriétés créées à 
l’aide des fonctions de lecture et de définition. Vous pouvez utiliser l’attribut override sur 
des fonctions de lecture et de définition héritées d’une super-classe.
164
Programmation orientée objet en ActionScript

Les méthodes liées
Une méthode liée, parfois appelée fermeture de méthode, est tout simplement une méthode 
extraite de son instance. On peut citer comme exemple les méthodes passées en arguments à 
une fonction ou renvoyées comme valeurs par une fonction. La méthode liée, qui est une 
nouveauté d’ActionScript 3.0, est semblable à une fermeture de fonction dans la mesure où 
elle conserve son environnement lexical, même après avoir été extraite de son instance. 
Toutefois, la différence entre une méthode liée et une fermeture de fonction réside dans le fait 
que la référence this d’une méthode liée reste liée à l’instance qui implémente cette méthode. 
Autrement dit, la référence this d’une méthode liée pointe toujours sur l’objet original qui a 
implémenté la méthode. Pour les fermetures de fonction, la référence this est générique, ce 
qui signifie qu’elle pointe sur l’objet auquel est associée la fonction lorsqu’elle est appelée.
Il est important de comprendre les méthodes liées pour utiliser le mot-clé this à bon escient. 
N’oubliez pas que this représente une référence à l’objet parent d’une méthode. La plupart 
des programmeurs en ActionScript s’attendent à ce que le mot-clé this réfère toujours à 
l’objet ou à la classe qui contient la définition d’une méthode. Ce n’est pas toujours le cas sans 
méthode liée. Par exemple, dans les versions précédentes d’ActionScript, la référence this ne 
pointait pas toujours sur l’instance qui implémentait la méthode. En ActionScript 2.0, lorsque 
les méthodes sont extraites d’une instance, non seulement la référence this n’est pas liée à 
l’instance originale, mais les variables et les méthodes de la classe de cette instance ne sont pas 
disponibles. Toutefois, ce problème n’existe plus avec ActionScript 3.0, car les méthodes liées 
sont automatiquement créées lorsque la méthode est passée en paramètre. Avec les méthodes 
liées, le mot-clé this référence toujours l’objet ou la classe dans laquelle la méthode est 
définie.
Le code suivant définit une classe nommée ThisTest, qui contient une méthode nommée 
foo() définissant la méthode liée, et une méthode nommée bar() qui renvoie cette méthode 
liée. Le code extérieur à la classe crée une instance de la classe ThisTest, appelle la méthode 
bar() et enregistre la valeur à renvoyer dans la variable myFunc. 
class ThisTest
{
private var num:Number = 3;
function foo():void définition de la méthode liée
{
trace("foo's this: " + this);
trace("num: " + num);
}
function bar():Function
{
return foo; //renvoi de la méthode liée
}
}
Classes
165

var myTest:ThisTest = new ThisTest();
var myFunc:Function = ();
trace(this); // résultat : [object global]
myFunc();    
/* Sortie : 
foo’s this: [object ThisTest]
output: num: 3 */
Les deux dernières lignes de code montrent que la référence this dans la méthode liée foo() 
pointe encore sur une instance de la classe ThisTest, bien que la référence this de la ligne 
précédente pointe sur l’objet global. De plus, la méthode liée stockée dans la variable myFunc 
peut encore accéder aux variables membres de la classe ThisTest. Si ce code est exécuté en 
ActionScript 2.0, les références this seront identiques et la variable num sera undefined.
Les gestionnaires d’événement sont un domaine dans lequel l’ajout des méthodes liées est le 
plus notable, car la méthode addEventListener() nécessite de passer une fonction ou une 
méthode en argument. Pour plus d’informations, consultez la section définie comme méthode de classe », à la page 353.
Les énumérations et les classes
Les énumérations sont des types de données que vous pouvez créer pour encapsuler un petit 
ensemble de valeur. Contrairement à C++ avec le mot-clé enum et à Java avec l’interface 
d’énumération, ActionScript 3.0 ne dispose pas d’un mécanisme d’énumération spécifique. 
Il est toutefois possible de créer des énumérations à l’aide de classes et de constantes statiques. 
Par exemple, la classe PrintJob de l’API de Flash Player utilise une énumération nommée 
PrintJobOrientation pour enregistrer les ensembles de valeurs des modes "landscape" et 
"portrait", comme le montre le code ci-dessous : 
public final class PrintJobOrientation
{
public static const LANDSCAPE:String = "landscape";
public static const PORTRAIT:String = "portrait";
}
166
Programmation orientée objet en ActionScript

Par convention, une classe d’énumération est déclarée avec l’attribut final, car il n’est pas 
nécessaire d’étendre cette classe. Cette classe étant composée uniquement de membres 
statiques, il n’est pas possible d’en créer des instances. En effet, les valeurs de l’énumération 
sont accédées directement via l’objet classe, comme le montre l’extrait de code suivant :
var pj:PrintJob = new PrintJob();
if(pj.start())
{                
if (pj.orientation == PrintJobOrientation.PORTRAIT)
{

}

}
Toutes les classes d’énumération de l’API de Flash Player contiennent uniquement des 
variables de type String, int ou uint. L’avantage de l’utilisation d’énumérations au lieu de 
chaînes littérales ou de nombres est que les fautes de frappe sont plus faciles à détecter avec les 
énumérations. Si vous faites une erreur dans le nom d’une énumération, le compilateur 
ActionScript génère une erreur. Si vous utilisez des valeurs littérales, le compilateur acceptera 
un nom mal épelé ou un chiffre erroné. Dans l’exemple ci-dessus, le compilateur génère une 
erreur si le nom de la constante d’énumération est incorrect, comme dans l’extrait suivant :
if (pj.orientation == PrintJobOrientation.PORTRAI) // erreur de 
// compilation.
Toutefois, le compilateur ne génère pas d’erreur si vous faites une faute de frappe dans le nom 
d’une chaîne littérale :
if (pj.orientation == "portrai") // pas d’erreur de compilation.
Une autre technique de création d’énumérations consiste à créer une classe séparée avec des 
propriétés statiques pour l’énumération. Toutefois, cette technique est différente dans la 
mesure où chacune des propriétés statiques contient une instance de la classe au lieu d’une 
valeur chaîne ou d’un entier. Par exemple, le code suivant crée une classe d’énumération pour 
les jours de la semaine :
public final class Day
{
public static const MONDAY:Day = new Day();
public static const TUESDAY:Day = new Day();
public static const WEDNESDAY:Day = new Day();
public static const THURSDAY:Day = new Day();
public static const FRIDAY:Day = new Day();
public static const SATURDAY:Day = new Day();
public static const SUNDAY:Day = new Day();
}
Classes
167

Cette technique n’est pas utilisée par l’API de Flash Player, mais de nombreux développeurs 
préfèrent le meilleur type de vérification qu’elle autorise. Par exemple, une méthode qui 
renvoie une valeur d’énumération peut restreindre la valeur renvoyée au type de données de 
l’énumération. Le code suivant illustre non seulement une fonction qui renvoie un jour de la 
semaine, mais aussi un appel de fonction qui utilise le type énumération comme annotation 
de type :
function getDay():Day
{
var date:Date = new Date();
var retDay:Day;
switch ()
{
case 0:
retDay = Day.MONDAY;
break;
case 1:
retDay = Day.TUESDAY;
break;
case 2:
retDay = Day.WEDNESDAY;
break;
case 3:
retDay = Day.THURSDAY;
break;
case 4:
retDay = Day.FRIDAY;
break;
case 5:
retDay = Day.SATURDAY;
break;
case 6:
retDay = Day.SUNDAY;
break;
}
return retDay;
}
var dayOfWeek:Day = getDay();
Il est possible d’améliorer la classe Day afin qu’elle associe un entier à chaque jour de la 
semaine, et comporte une méthode toString() renvoyant une représentation du jour sous 
forme de chaîne. Il est conseillé de créer cette amélioration comme exercice.
168
Programmation orientée objet en ActionScript

Les classes des éléments incorporés
ActionScript 3.0 utilise des classes spéciales, appelées classes des éléments incorporés, pour 
représenter les éléments incorporés. Un élément incorporé est un élément (son, image ou 
police) qui est incorporé au fichier SWF lors de la compilation. Contrairement au chargement 
dynamique, l’incorporation des éléments les rend disponibles immédiatement lors de 
l’exécution, mais cette méthode augmente la taille des fichiers SWF. 
Utilisation de classes d’éléments incorporés avec Flash
Pour incorporer un élement, placez-le d’abord dans la bibliothèque d’un fichier FLA. 
Utilisez ensuite la propriété de liaison de l’élément pour fournir un nom à la classe de 
l’élément incorporé. S’il n’existe pas de classe de ce nom dans le chemin de classe indiqué, une 
classe est automatiquement créée. Vous pouvez alors créer une instance de la classe d’éléments 
incorporés et utiliser les propriétés et méthodes définies ou héritées par cette classe. 
Par exemple, le code suivant permet de lire un son intégré lié à une classe d’éléments 
incorporés nommée PianoMusic :
var piano:PianoMusic = new PianoMusic();
var sndChannel:SoundChannel = ();
Interfaces
Une interface est une collection de déclarations de méthodes qui autorise les communications 
entre des objets différents. Par exemple, l’API de Flash Player définit l’interface 
IEventDispatcher, qui contient les déclarations des méthodes qu’une classe peut utiliser pour 
gérer les objets événements. L’interface IEventDispatcher établit une technique standard 
permettant aux objets de s’échanger les événements. Le code suivant représente la définition 
de l’interface IEventDispatcher :
public interface IEventDispatcher
{
function addEventListener(type:String, listener:Function, 
useCapture:Boolean=false, priority:int=0,
useWeakReference:Boolean = false):void;
function removeEventListener(type:String, listener:Function, 
useCapture:Boolean=false):void;
function dispatchEvent(event:Event):Boolean;
function hasEventListener(type:String):Boolean;
function willTrigger(type:String):Boolean;
}
Interfaces
169

Les interfaces sont basées sur la distinction entre l’interface d’une méthode et l’implémentation 
de celle-ci. L’interface d’une méthode comprend toutes les informations nécessaires pour 
appeler cette méthode (le nom de la méthode, l’ensemble des paramètres qu’elle reçoit et le type 
de données qu’elle renvoie). L’implémentation d’une méthode comprend non seulement les 
informations de l’interface, mais aussi les instructions exécutables qui caractérisent le 
comportement de la méthode. La définition d’une interface ne contient que les interfaces de la 
méthode, et toute classe qui implémente l’interface doit donc définir les implémentations de la 
méthode.
Dans l’API de Flash Player, la classe EventDispatcher implémente l’interface IEventDispatcher 
en définissant toutes les méthodes de l’interface IEventDispatcher et en ajoutant le corps de 
chacune de ces méthodes. Le code suivant est extrait de la définition de la classe 
EventDispatcher :
public class EventDispatcher implements IEventDispatcher
{
function dispatchEvent(event:Event):Boolean
{
/* instructions d’implémentation */
}

}
L’interface IEventDispatcher fait office de protocole utilisé par les instances d’EventDispatcher 
pour traiter les objets événements et les passer aux autres objets qui ont également implémenté 
l’interface IEventDispatcher. 
Il est aussi possible de décrire une interface en disant qu’elle définit un type de données, au 
même titre qu’une classe. En conséquence, une interface peut être utilisée comme annotation 
de type, tout comme une classe. En tant que type de données, une interface peut également 
être utilisée avec des opérateurs, par exemple les opérateurs is et as, qui nécessitent un type 
de données. Toutefois, à l’inverse d’une classe, il n’est pas possible d’instancier une interface. 
C’est en raison de cette distinction que de nombreux programmeurs voient les interfaces 
comme des types de données abstraites et les classes comme des types de données concrètes.
170
Programmation orientée objet en ActionScript

La définition d’une interface
La structure de la définition d’une interface est similaire à celle de la définition d’une classe, à 
ceci près qu’une interface ne peut pas contenir les corps des méthodes. Les interfaces ne 
peuvent pas comporter des variables ou des constantes, mais elles peuvent contenir des 
méthodes de lecture et de définition. Pour définir une interface, on utilise le mot-clé 
interface. Par exemple, l’interface IExternalizable fait partie du paquet flash.utils de l’API de 
Flash Player API. L’interface IExternalizable définit un protocole de sérialisation d’un objet 
(conversion d’un objet dans un format adapté à l’enregistrement sur un périphérique ou à la 
transmission en réseau). 
public interface IExternalizable
{
function writeExternal(output:IDataOutput):void;
function readExternal(input:IDataInput):void;
}
Notez que l’interface IExternalizable est déclarée avec le modificateur d’accès public. 
Les définitions d’interfaces ne peuvent être modifiées qu’à l’aide des spécificateur de contrôle 
d’accès public et internal. Dans une définition d’interface, les déclarations de méthodes ne 
peuvent pas comporter de spécificateur de contrôle d’accès.
L’API de Flash Player respecte la convention de nom selon laquelle les noms des interfaces 
débutent par un I majuscule, mais vous pouvez utiliser tout identificateur autorisé comme 
nom d’interface. Les définitions d’interfaces sont souvent placées au niveau supérieur d’un 
paquet. Les définitions d’interfaces ne peuvent pas être placées dans une définition de classe 
ou dans une autre définition d’interface.
Une interface peut étendre une ou plusieurs autres interfaces. Par exemple, l’interface 
IExample étend l’interface IExternalizable :
public interface IExample extends IExternalizable
{
function extra():void;
}
Toute classe qui implémente l’interface IExample doit comporter non seulement les 
implémentations de la méthode extra(), mais aussi celles des méthodes writeExternal() et 
readExternal() héritées de l’interface IExternalizable.
Interfaces
171

Implémentation d’une interface dans une classe
La classe est le seul élément du langage ActionScript 3.0 qui puisse implémenter une interface. 
Pour implémenter une ou plusieurs interfaces, on utilise le mot-clé implements dans une 
déclaration de classe. L’exemple suivant définit deux interfaces, IAlpha et IBeta, ainsi qu’une 
classe, Alpha, qui les implémente toutes deux :
interface IAlpha
{
function foo(str:String):String;
}
interface IBeta
{
function bar():void;
}
class Alpha implements IAlpha, IBeta
{
public function foo(param:String):String {}
public function bar():void {}
}
Dans une classe qui implémente une interface, les méthodes implémentées doivent :
?
utiliser l’identificateur de contrôle d’accès public, 
?
utiliser le même nom que la méthode de l’interface,
?
avoir le même nombre de paramètres, chacun étant du type de données correspondant au 
type de données du paramètre équivalent dans la méthode de l’interface,
?
utiliser le même type de retour.
Vous disposez toutefois d’une certaines flexibilité pour le nom des paramètres des méthodes 
que vous implémentez. Bien que le nombre et le type de données des paramètres de la 
méthode implémentée doivent correspondre à ceux de la méthode de l’interface, il n’est pas 
obligatoire que les noms des paramètres soient identiques. Par exemple, dans l’exemple ci-
dessus, le paramètre de la méthode () est nommé param :
public function foo(param:String):String {}
Par contre, le paramètre correspondant est nommé str dans la méthode de l’interface 
() :
function foo(str:String):String;
172
Programmation orientée objet en ActionScript

Les valeurs par défaut des paramètres offrent également une certaine flexibilité. La définition 
d’une interface peut comporter des déclarations de fonctions avec des valeurs par défaut pour 
les paramètres. Une méthode implémentant l’une de ces déclarations de fonction doit disposer 
d’une valeur par défaut pour le ou les paramètres, et cette valeur doit être du même type de 
données que celle qui est spécifiée dans la définition de l’interface, mais ce n’est pas forcément 
le cas pour la valeur réelle. Par exemple, le code suivant définit une interface contenant une 
méthode dont le paramètre a la valeur 3 par défaut :
interface IGamma
{
function doSomething(param:int = 3):void;
}
La définition de classe suivante implémente l’interface Igamma, mais utilise une autre valeur 
par défaut pour le paramètre :
class Gamma implements IGamma
{
public function doSomething(param:int = 4):void {}
}
Cette flexibilité est due au fait que les règles d’implémentation d’une interface sont 
spécifiquement conçues afin d’assurer une compatibilité des types de données, et il n’est pas 
nécessaire, pour ce faire, d’exiger des noms et des valeurs par défaut identiques pour les 
paramètres.
Héritage
L’héritage est une forme de réutilisation du code qui permet aux programmeurs de développer 
de nouvelles classes à partir de classes existantes. Les classes existantes sont alors fréquemment 
appelées classes de base ou super-classes, alors que les nouvelles classes sont généralement 
appelées sous-classes. L’un des principaux avantages de l’héritage est qu’il permet de réutiliser le 
code d’une classe de base sans modifier le code existant. De plus, l’héritage ne nécessite pas de 
modifier les modes d’interaction des autres classes avec la classe de base. Plutôt que de 
modifier une classe existante, qui est peut-être soigneusement testée et déjà utilisée, l’héritage 
permet de traiter cette classe comme un module intégré qui peut être étendu à l’aide de 
propriétés et de méthodes supplémentaires. C’est pourquoi on utilise le mot-clé extends pour 
indiquer qu’une classe hérite d’une autre classe.
Héritage
173

L’héritage permet également de tirer parti du polymorphisme du code. Le polymorphisme est la 
possibilité d’utiliser un nom de méthode unique pour une méthode qui se comporte 
différemment en fonction des types de données qu’elle reçoit. Par exemple, supposons une 
classe de base nommée Shape, avec deux sous-classes nommées Circle et Square. La classe 
Shape définit une méthode nommée area(), qui renvoie la surface de Shape. Si vous avez 
implémenté le polymorphisme, vous pouvez appeler la méthode area() pour les objets de 
type Circle ou Square et lui faire exécuter le calcul correct. L’héritage autorise le 
polymorphisme en permettant aux sous-classes d’hériter et redéfinir, ou override les méthodes 
de la classe de base. Dans l’exemple suivant, la méthode area() est redéfinie par les classes 
Circle et Square :
class Shape
{
public function area():Number
{
return NaN;
}
}
class Circle extends Shape
{
private var radius:Number = 1;
override public function area():Number
{
return ( * (radius * radius));
}
}
class Square extends Shape
{
private var side:Number = 1;
override public function area():Number
{
return (side * side);
}
}
var cir:Circle = new Circle();
trace(()); // résultat : 3.141592653589793
var sq:Square = new Square();
trace(()); // résultat : 1
174
Programmation orientée objet en ActionScript

Dans la mesure où chaque classe définit un type de données, l’utilisation de l’héritage crée une 
relation spéciale entre une classe de base et une classe qui l’étend. Une sous-classe possède 
obligatoirement toutes les propriétés de sa classe de base, ce qui signifie qu’il est toujours 
possible de substituer une instance d’une sous-classe à une instance de la classe de base. 
Par exemple, si une méthode définit un paramètre du type Shape, il est parfaitement autorisé 
de lui passer un argument du type Circle, car Circle étend Shape, comme on le voit 
ci-dessous :
function draw(shapeToDraw:Shape) {}
var myCircle:Circle = new Circle();
draw(myCircle);
Propriétés et héritage des instances
Qu’elle soit définie à l’aide du mot-clé function, var ou const, une propriété d’une instance 
est héritée par toutes les sous-classes tant que cette propriété n’est pas déclarée avec l’attribut 
private dans la classe de base. Par exemple, la classe Event de l’API de Flash Player possède 
de nombreuses sous-classes qui héritent de propriétés communes à tous les objets événements. 
Pour certains types d’événements, la classe Event contient toutes les propriétés nécessaires 
pour définir l’événement. Ces types d’événements ne nécessitent pas de propriétés d’instance 
au-delà de celles qui sont définies dans la classe Event. L’événement complete, qui est 
déclenché lorsque des données ont été chargées avec succès, et l’événement connect, qui se 
produit lorsqu’une connexion réseau a été établie, sont des exemples de ce type d’événement. 
L’exemple suivant est extrait de la classe Event. Il montre certaines propriétés et méthodes 
dont les sous-classes héritent. Étant héritées, ces propriétés sont accessibles par une instance de 
n’importe quelle sous-classe.
public class Event
{
public function get type():String;
public function get bubbles():Boolean;

public function stopPropagation():void {}
public function stopImmediatePropagation():void {}
public function preventDefault():void {}
public function isDefaultPrevented():Boolean {}

}
Héritage
175

D’autres types d’événements nécessitent des propriétés uniques qui ne sont pas disponibles 
dans la classe Event. Ces événements sont définis à l’aide de sous-classes de la classe Event, ce 
qui permet d’ajouter de nouvelles propriétés à celles de cette classe Event. La classe 
MouseEvent est un exemple de sous-classe de ce type. Elle ajoute des propriétés uniques aux 
événements associés à un mouvement ou à un clic de souris, tels que les événements 
mouseMove et click. L’exemple suivant est extrait de la classe MouseEvent. Il montre la 
définition des propriétés inhérente à la sous-classe parce qu’absentes de la classe de base.
public class MouseEvent extends Event
{
public static const CLICK:String      = "click";
public static const MOUSE_MOVE:String = "mouseMove";

public function get stageX():Number {}
public function get stageY():Number {}

}
Contrôle d’accès et héritage
Si une propriété est déclarée avec le mot-clé public, elle est visible de n’importe quel point du 
code. Cela signifie que contrairement aux mots-clés private, protected et internal, le 
mot-clé public n’introduit aucune restriction sur l’héritage des propriétés.
Si une propriété est déclarée avec le mot-clé private, elle n’est visible qu’à partir de la classe 
qui la définit, autrement dit les sous-classes n’en héritent pas. Ce comportement est différent 
de celui des versions antérieures d’ActionScript, où le mot-clé private se comportait plutôt 
comme le mot-clé protected en ActionScript 3.0.
Le mot-clé protected indique qu’une propriété est visible non seulement à partir de la classe 
qui la définit, mais aussi à partir de toutes les sous-classes de celle-ci. Contrairement au mot-
clé protected en Java, en ActionScript 3.0 le mot-clé protected ne rend pas une propriété 
visible à partir de toutes les autres classes du même paquet. En ActionScript 3.0, seules les 
sous-classes peuvent accéder à une propriété déclarée avec le mot-clé protected. De plus, une 
propriété protégée est visible à partir d’une sous-classe même si celle-ci ne se trouve pas dans le 
même paquet que sa classe de base.
Pour limiter la visibilité d’une propriété au paquet dans lequel elle est définie, vous pouvez soit 
utiliser le mot-clé internal, soit n’utiliser aucun spécificateur de contrôle d’accès. 
Le spécificateur de contrôle d’accès internal est appliqué par défaut si vous n’en indiquez 
aucun. Seule une sous-classe résidant dans le même paquet pourra hériter d’une propriété 
marquée comme internal.
176
Programmation orientée objet en ActionScript

L’exemple suivant montre comment chaque spécificateur de contrôle d’accès affecte l’héritage 
dans et au-delà des paquets. Le code ci-dessous définit une classe principale d’application 
nommée AccessControl et deux autres classes, Base et Extender. La classe Base se trouve dans 
un paquet nommé foo et la classe Extender, qui est une sous-classe de la classe Base, dans un 
paquet nommé bar. La classe AccessControl n’importe que la classe Extender et crée une 
instance de celle-ci qui tente d’accéder à une variable nommée str, définie dans la classe Base. 
La variable str est déclarée comme public, si bien que le code est compilé et exécuté comme 
ci-dessous :
// dans un dossier nommé foo
package foo
{
public class Base
{
public var str:String = "hello"; // cette ligne change public
}
}
// dans un dossier nommé bar
package bar
{
import ;
public class Extender extends Base
{
public function getString():String {
return str;
}
}
}
// classe principale de l’application dans le fichier
import flash.display.MovieClip;
import bar.Extender;
public class AccessControl extends MovieClip
{
public function AccessControl()
{
var myExt:Extender = new Extender();
trace(myExt.testString);  // erreur si str n’est pas publique
trace(myExt.getString()); // erreur si str est privée ou interne
}
}
}
Pour voir l’effet des autres spécificateurs de contrôle d’accès lors de la compilation et de 
l’exécution de cet exemple, changez le spécificateur de contrôle d’accès de str en private, 
protected ou internal après avoir supprimé ou mis en commentaire la ligne suivante dans 
la classe AccessControl :
trace(myExt.testString);  // erreur si str n’est pas publique
Héritage
177

Redéfinition des variables impossible
Les propriétés déclarées à l’aide des mots-clés var ou const sont héritées mais ne peuvent pas 
être redéfinies. Redéfinir, ou forcer, une propriété au sens de « override » signifie redéfinir cette 
propriété dans une sous-classe. Les méthodes (c’est à dire les propriétés déclarées avec le mot-
clé function) sont le seul type de propriété qu’il est possible de redéfinir. Bien qu’il soit 
impossible de redéfinir une variable d’instance, vous pouvez obtenir le même résultat en 
créant des méthodes de lecture et de définition pour cette variable d’instance et en forçant ces 
méthodes. Pour plus d’informations, consultez la sectionlecture et de définition », à la page 180.
Redéfinition des méthodes
Redéfinir, ou forcer, une méthode au sens de « override » signifie redéfinir le comportement 
d’une méthode héritée. Les méthodes statiques ne sont pas héritées et ne peuvent donc pas 
être redéfinies. Toutefois, les sous-classes héritent des méthodes d’instance et il est donc 
possible de redéfinir celles-ci sous réserve de deux conditions :
?
la méthode d’instance ne doit pas être déclarée avec le mot-clé final dans la classe de 
base. Lorsqu’il est utilisé avec une méthode d’instance, le mot-clé final indique que le 
programmeur veut empêcher les sous-classes de redéfinir cette méthode.
?
la méthode d’instance ne doit pas être déclarée avec le spécificateur de contrôle d’accès 
private dans la classe de base. Si une méthode est marquée comme private dans la 
classe de base, il n’est pas nécessaire d’utiliser le mot-clé override lors de la définition 
d’une méthode portant le même nom dans la sous-classe, puisque la méthode de la classe 
de base n’est pas visible à partir de la sous-classe.
Pour redéfinir une méthode d’instance correspondant à ces critères, la définition de la 
méthode dans la sous-classe doit utiliser le mot-clé override et correspondre comme défini 
ci-dessous à la version de cette méthode dans la super-classe :
?
la méthode de redéfinition doit avoir le même niveau de contrôle d’accès que celle de la 
classe de base. Les méthodes définies comme internes doivent avoir le même niveau de 
contrôle d’accès que celles qui n’ont pas de spécificateur de contrôle d’accès. 
?
la méthode de redéfinition doit avoir le même nombre de paramètres que celle de la classe 
de base.
?
les paramètres de la méthode de redéfinition doivent avoir les mêmes annotations de type 
de données que ceux de la méthode de la classe de base.
?
la méthode de redéfinition doit avoir le même type de renvoi que celle de la classe de base.
Toutefois, il n’est pas nécessaire que les noms des paramètres de la méthode de redéfinition 
correspondent à ceux des paramètres de la classe de base, tant que le nombre de paramètres et 
leurs types de données correspondent.
178
Programmation orientée objet en ActionScript

L’instruction super
Il arrive fréquemment que les programmeurs souhaitent compléter le comportement de la 
méthode de super-classe qu’ils redéfinissent, plutôt que remplacer ce comportement. Il est 
donc nécessaire de disposer d’un mécanisme permettant à une méthode d’une sous-classe 
d’appeler sa « méthode mère » dans la super-classe. Ce mécanisme est assuré par l’instruction 
super, qui contient une référence à la super-classe immédiate. L’exemple suivant définit une 
classe nommée Base, qui contient la méthode thanks(), et une sous-classe de Base nommée 
Extender, qui redéfinit la méthode thanks(). La méthode Extender.thanks() utilise 
l’instruction super pour appeler Base.thanks().
package {
import flash.display.MovieClip;
public class SuperExample extends MovieClip
{
public function SuperExample()
{
var myExt:Extender = new Extender()
trace(myExt.thanks()); // résultat : Mahalo nui loa
}
}
}
class Base {
public function thanks():String
{
return "Mahalo";
}
}
class Extender extends Base
{
override public function thanks():String
{
return super.thanks() + " nui loa";
}
}
Héritage
179

Redéfinition des méthodes de lecture et de définition
Bien qu’il soit impossible de redéfinir les variables définies dans une super-classe, il est possible 
de redéfinir les méthodes de lecture et de définition. Par exemple, le code suivant redéfinit une 
méthode de lecture appelée currentLabel, définie dans la classe MovieClip de l’API de Flash 
Player.
package
{
import flash.display.MovieClip;
public class OverrideExample extends MovieClip
{
public function OverrideExample()
{
trace(currentLabel)
}
override public function get currentLabel():String
{
var str:String = "Override: ";
str += super.currentLabel;
return str;
}
}
}
Le résultat de l’instruction trace() dans le constructeur de la classe OverrideExample est 
Override: null, ce qui montre que cet exemple a réussi à redéfinir la propriété héritée 
currentLabel.
Propriétés statiques non héritées
Les sous-classes n’héritent pas des propriétés statiques. Ces dernières ne sont donc pas 
accessibles via une instance d’une sous-classe. Une propriété statique n’est accessible que par le 
biais de l’objet classe dans lequel elle est définie. Par exemple, le code suivant définit une classe 
de base nommée Base et une sous-classe nommée Extender, qui étend la classe Base. Une 
variable statique nommée test est définie dans la classe Base. Le code de l’extrait ci-dessous 
ne peut être compilé en mode strict et génère une erreur d’exécution en mode standard.
package {
import flash.display.MovieClip;
public class StaticExample extends MovieClip
{
public function StaticExample()
{
var myExt:Extender = new Extender();
trace();  // Erreur
}
}
}
180
Programmation orientée objet en ActionScript

class Base {
public static var test:String = "static";
}
class Extender extends Base { }
La seule façon d’accéder à la variable statique test est via l’objet classe, comme le montre le 
code suivant :
;
Il est toutefois permis de définir une propriété d’instance ayant le même nom qu’une 
propriété statique. Cette propriété d’instance peut être définie dans la même classe que la 
propriété statique, ou dans une sous-classe. Par exemple, la classe Base de l’exemple précédent 
peut comporter une propriété d’instance nommée test. Le code suivant peut être compilé et 
exécuté normalement, car la classe Extender hérite de la propriété d’instance. Ce code peut 
aussi être compilé et exécuté normalement si la définition de la variable d’instance test est 
déplacée (mais non copiée) dans la classe Extender.
package
{
import flash.display.MovieClip;
public class StaticExample extends MovieClip
{
public function StaticExample()
{
var myExt:Extender = new Extender();
trace();  // résultat : instance
}
}
}
class Base
{
public static var test:String = "static";
public var test:String = "instance";
}
class Extender extends Base {}
Héritage
181

Les propriétés statiques et la chaîne de portée
Bien que les propriétés statiques ne soient pas héritées, elles figurent dans la chaîne de portée 
de la classe qui les définit et de toute sous-classe de celle-ci. C’est pourquoi on dit que les 
propriétés statiques sont dans la portée de la classe dans laquelle elles sont définies et des sous-
classes de celle-ci. Cela signifie qu’une propriété statique est directement accessible à partir du 
corps de la classe qui la définit et de toute sous-classe de celle-ci. 
L’exemple suivant modifie les classes définies dans l’exemple précédent pour montrer que la 
variable statique test, définie dans la classe Base, est dans la portée de la classe Extender. 
Autrement dit, la classe Extender peut accéder à la variable statique test sans qu’il soit 
nécessaire de faire précéder le nom de celle-ci du nom de la classe qui définit test.
package
{
import flash.display.MovieClip;
public class StaticExample extends MovieClip
{
public function StaticExample()
{
var myExt:Extender = new Extender();
}
}
}
class Base {
public static var test:String = "static";
}
class Extender extends Base
{
public function Extender()
{
trace(test); // résultat : static
}
}
182
Programmation orientée objet en ActionScript

Si une propriété d’instance est définie avec le même nom qu’une propriété statique de la 
même classe ou d’une super-classe, la propriété d’instance est prioritaire dans la chaîne de 
portée. On dit alors que la propriété d’instance fait de l’ombre à la propriété statique, ce qui 
signifie que la valeur de la propriété d’instance est utilisée à la place de celle de la propriété 
statique. Par exemple, le code suivant montre que si la classe Extender définit une variable 
d’instance nommée test, l’instruction trace() utilise la valeur de la variable d’instance au 
lieu de celle de la variable statique.
package
{
import flash.display.MovieClip;
public class StaticExample extends MovieClip
{
public function StaticExample()
{
var myExt:Extender = new Extender();
}
}
}
class Base
{
public static var test:String = "static";
}
class Extender extends Base
{
public var test:String = "instance";
public function Extender()
{
trace(test); // résultat : instance
}
}
Héritage
183

Rubriques avancées
Cette section débute par un bref historique d’ActionScript et de la programmation orientée 
objet, puis se poursuit par une présentation du modèle d’objet d’ActionScript 3.0 et de la 
façon dont il permet à la nouvelle machine virtuelle d’ActionScript (AVM2, ActionScript 
Virtual Machine 2) d’être nettement plus rapide que les versions antérieures de Flash Player, 
basées sur la première version de la machine virtuelle d’ActionScript, AVM1.
Historique de la prise en charge de la programmation 
orientée objet en ActionScript
ActionScript 3.0 est une évolution des versions antérieures d’ActionScript, c’est pourquoi il 
peut être utile de comprendre l’évolution du modèle d’objet en ActionScript. ActionScript 
était à l’origine un simple mécanisme de script pour les premières versions de Flash. 
Les programmeurs Flash ont alors commencé à développer des applications de plus en plus 
complexes avec ActionScript. En réponse aux besoins de ces programmeurs, le langage de 
chaque nouvelle version a connu des ajouts destinés à faciliter la création d’applications 
complexes.
ActionScript 1.0
ActionScript 1.0 est le langage utilisé dans les versions 6 et antérieures de Flash Player. Même 
à ce stade précoce de développement, le modèle d’objet d’ActionScript était basé sur le 
concept de l’objet comme type fondamental de données. Un objet ActionScript est un type de 
données composite doté d’un groupe de propriétés. Dans le contexte d’un modèle d’objet, le 
terme propriétés désigne tout ce qui est affecté à un objet (variables, fonctions ou méthodes). 
Bien que cette première génération d’ActionScript ne prenne pas en charge la définition de 
classes avec le mot-clé class, elle permet de définir une classe à l’aide d’un type spécial d’objet 
appelé objet prototype. Au lieu d’utiliser un mot-clé class pour créer une définition de classe 
abstraite qui sera ensuite instanciée en objets concrets (à l’instar des langages reposant sur des 
classes, comme Java ou C++), les langages basés sur le prototypage, tel qu’ActionScript 1.0, 
utilisent un objet existant comme modèle (ou prototype) d’autres objets. Alors que les objets 
des langages basés sur la notion de classes peuvent pointer sur une classe qui leur sert de 
modèle, les objets des langages basés sur la notion de prototypes pointent sur un autre objet, 
leur prototype, qui leur sert de modèle. 
184
Programmation orientée objet en ActionScript

Pour créer une classe en ActionScript 1.0, il est nécessaire de définir une fonction constructeur 
pour cette classe. En ActionScript, les fonctions sont des objets réels et non pas de simples 
définitions abstraites. La fonction constructeur sert alors d’objet prototype pour les instances 
de cette classe. Le code suivant crée une classe nommée Shape et définit une propriété 
nommée visible, qui a la valeur true par défaut :
//classe de base
function Shape() {}
// création d’une propriété nommée ‘visible’.
Shape.prototype.visible = true;
Cette fonction constructeur définit une classe Shape qui va être instanciée à l’aide de 
l’opérateur new, comme suit :
myShape = new Shape();
Just as the Shape() constructor function object serves as the prototype for instances of the 
Shape class, it can also serve as the prototype for subclasses of Shape—that is, other classes 
that extend the Shape class.
La création d’une classe qui est une sous-classe de la classe Shape est un processus en deux 
étapes. D’abord, créer la classe en définissant une fonction constructeur pour cette classe :
// classe enfant
function Circle(id, radius)
{
    = id;
    this.radius = radius;
}
Ensuite, utiliser l’opérateur new pour déclarer que la classe Shape est le prototype de la classe 
Circle. Par défaut, toute nouvelle classe créée utilise la classe Object comme prototype, si bien 
que Circle.prototype contient alors un objet générique (une instance de la classe Object). 
Pour spécifier que le prototype de Circle est Shape et non pas Object, utilisez le code suivant 
pour changer la valeur de Circle.prototype afin qu’elle contienne un objet Shape et non 
plus un objet générique :
// faire de Circle une sous-classe de Shape.
Circle.prototype = new Shape();
Rubriques avancées
185

La classe Shape et la classe Circle sont maintenant liées par une relation d’héritage 
communément appelée chaînage du prototype. Le diagramme représente la relation au sein 
d’un chaînage de prototype :
Object.prototype
Shape.prototype
Circle.prototype
La classe de base, à la fin de chaque chaînage de prototype, est la classe Object. La classe 
Object contient une propriété statique nommée Object.prototype qui pointe sur l’objet 
prototype de base pour tous les objets créés en ActionScript 1.0. Dans notre exemple de 
chaînage de prototype, l’objet suivant est l’objet Shape. En effet, la propriété 
Shape.prototype n’a jamais été explicitement définie, si bien qu’elle contient encore un 
objet générique (une instance de la classe Object). Le lien final de ce chaînage est la classe 
Circle, qui est liée à son prototype, la classe Shape (la propriété Circle.prototype contient 
un objet Shape).
Si nous créons une instance de la classe Circle, comme dans l’exemple ci-dessous, l’instance 
hérite du chaînage de prototype de la classe Circle : 
//créer une instance de la classe Circle.
myCircle = new Circle();
Vous vous souvenez sans doute que nous avons créé une propriété nommée visible comme 
membre de la classe Shape. Dans notre exemple, la propriété visible n’existe pas comme 
partie de l’objet myCircle, mais uniquement comme membre de l’objet Shape, et pourtant la 
ligne de code suivit produit true :
trace(myCircle.visible); // résultat : true
En remontant le chaînage du prototype, Flash Player est en mesure de vérifier que l’objet 
myCircle hérite de la propriété visible. Lorsque ce code est exécuté, Flash Player recherche 
d’abord dans les propriétés de l’objet myCircle une propriété nommée visible, mais ne la 
trouve pas. Flash Player recherche alors dans l’objet Circle.prototype, mais ne trouve 
toujours pas de propriété nommée visible. En continuant à remonter le chaînage du 
prototype, Flash Player trouve enfin la propriété visible, définie dans l’objet 
Shape.prototype, et affiche la valeur de cette propriété.
Pour des raisons de simplicité, cette section omet un grand nombre de détails et de 
complexités du chaînage de prototype, puisqu’il s’agit simplement de vous aider à comprendre 
le modèle d’objet en ActionScript 3.0.
186
Programmation orientée objet en ActionScript

ActionScript 2.0
Avec ActionScript 2.0 ont été introduits de nouveaux mots-clés tels que class, extends, 
public et private, qui permettaient de définir des classes selon une méthode familière à 
toute personne connaissant les langages basés sur des classes, comme Java et C++. Il est 
important de comprendre que le mécanisme sous-jacent d’héritage n’a pas changé entre 
ActionScript 1.0 et ActionScript 2.0. La nouveauté d’ActionScript 2.0 consistait simplement 
en une nouvelle syntaxe pour la définition des classes. Le chaînage du prototype fonctionne de 
la même façon dans ces deux versions du langage.
La nouvelle syntaxe introduite par ActionScript 2.0 est représentée dans l’exemple ci-dessous. 
Elle permet de définir des classes d’une façon que la plupart des programmeurs considèrent 
comme plus intuitive :
//classe de base
class Shape
{
    var visible:Boolean = true;
}
Notez qu’ActionScript 2.0 a également introduit les annotations de type destinées à une 
vérification des types à la compilation. Elles permettent de déclarer que la propriété visible 
de l’exemple précédent ne doit contenir qu’une valeur booléenne. Le nouveau mot-clé 
extends simplifie lui aussi le processus de création d’une sous-classe. Dans l’exemple suivant, 
ce qui nécessitait deux étapes en ActionScript 1.0 est accompli en une seule étape, à l’aide du 
mot-clé extends :
// classe enfant
class Circle extends Shape
{
var id:Number;
var radius:Number;
function Circle(id, radius)
{
= id;
this.radius = radius;
  }
}
Le constructeur est maintenant déclaré dans le cadre de la définition de classe, et les propriétés 
id et radius de la classe doivent elles aussi être déclarées explicitement.
ActionScript 2.0 a également ajouté la prise en charge de la définition des interfaces, qui 
permet de rendre plus sophistiqués des programmes orientés objet à l’aide de protocoles 
formellement définis pour la communication entre les objets.
Rubriques avancées
187

L’objet de classe en ActionScript 3.0
Un paradigme courant en programmation orientée objet, en particulier avec Java et C++, fait 
appel à des classes pour définir des types d’objets. Les langages de programmation qui 
adoptent ce paradigme ont aussi tendance à utiliser des classes pour construire des instances 
du type de données défini par la classe. ActionScript utilise des classes pour ces deux buts, 
mais ses origines de langage basé sur des prototypes lui confèrent une caractéristique 
intéressante. Pour chaque définition de classe, ActionScript crée un objet de classe spécial qui 
autorise le partage du comportement et de l’état. Pour de nombreux programmeurs en 
ActionScript, toutefois, cette distinction n’aura aucune implication pratique sur le codage. 
En effet, ActionScript 3.0 est conçu de telle sorte qu’il est possible de créer des applications 
sophistiquées orientées objet sans utiliser, et sans même comprendre, ces objets de classe 
spéciaux. Cette section étudie en détail les problèmes que rencontreront les programmeurs 
avancés qui souhaitent tirer parti des objets de classe.
Le diagramme suivant montre la structure d’un objet de classe représentant une classe simple 
nommée A, définie par l’instruction class A {}:
T
Class.prototype
Object.prototype
CA
delegate
delegate
type
prototype constructor
A
PA
traits
TA
Chaque rectangle du diagramme représente un objet. Chaque objet du diagramme est marqué 
d’un caractère en indice A pour signaler qu’il appartient à la classe A. L’objet de classe (CA) 
contient des références à un certain nombre d’autres objets importants. L’objet traits des 
instances (TA) enregistre les propriétés des instances qui sont définies dans une définition de 
classe. Un objet traits de la classe (TCA) représente le type interne de la classe et enregistre les 
propriétés statiques définies par la classe (le caractère C en indice signifie « classe »). L’objet 
prototype (PA) fait toujours référence à l’objet de classe auquel il était attaché à l’origine via la 
propriété constructeur.
188
Programmation orientée objet en ActionScript

L’objet traits
L’objet traits est une nouveauté d’ActionScript 3.0 qui a été implémentées pour des raisons de 
performances. Dans les versions précédentes d’ActionScript, la recherche d’un nom pouvait 
nécessiter beaucoup de temps pendant que Flash Player remontait le chaînage du prototype. 
En ActionScript 3.0, la recherche d’un nom est beaucoup plus rapide et efficace, car les 
propriétés héritées sont copiées des super-classes dans l’objet traits des sous-classes.
L’objet traits n’est pas directement accessible par code, mais sa présence se manifeste par 
l’amélioration des performances et de l’utilisation mémoire. L’objet traits fournit à la machine 
virtuelle AVM2 des informations détaillées sur la disposition et le contenu d’une classe. 
Ces informations permettent à AVM2 de réduire nettement le temps d’exécution, car elle peut 
fréquemment générer des instructions machine directes pour accéder à des propriétés ou 
appeler des méthodes directement, sans effectuer au préalable une longue recherche de nom.
Grâce à l’objet traits, l’espace occupé en mémoire par un objet peut être nettement moins 
importante qu’avec les versions antérieures d’ActionScript. Par exemple, si une classe est 
scellée (c’est-à-dire si cette classe n’est pas déclarée comme dynamique), une instance de la 
classe ne nécessite pas de recherche par calcul d’adresse pour les propriétés ajoutées 
dynamiquement, et il lui suffit d’un pointeur sur l’objet traits et de quelques emplacements 
pour les propriétés fixes définies dans la classe. En conséquence, pour un objet qui nécessitait 
100 octets en mémoire avec ActionScript 2.0, 20 octets suffiront avec ActionScript 3.0.
REMARQUE
L’objet traits est un élément d’implémentation interne et il n’est pas garanti qu’il ne 
changera pas, ou même qu’il ne disparaîtra pas, dans les versions futures d’ActionScript.
L’objet prototype
En ActionScript, chaque objet de classe possède une propriété nommée prototype, qui est 
une référence à l’objet prototype de cette classe. L’objet prototype est un héritage des 
premières versions d’ActionScript, basées sur des prototypes. Pour plus d’informations, 
consultez la section « ActionScript 1.0 », à la page 184.
La propriété prototype est en lecture seule et ne peut donc pas être modifiée pour pointer 
sur d’autres objets. À l’inverse, dans les anciennes versions d’ActionScript, la propriété 
prototype pouvait être réaffectée pour pointer sur une autre classe. Bien que la propriété 
prototype soit en lecture seule, ce n’est pas le cas de l’objet prototype qu’elle référence. 
De nouvelles propriétés peuvent donc être ajoutées à l’objet prototype. Les propriétés ajoutées 
à l’objet prototype sont partagées avec toutes les autres instances de la classe.
Rubriques avancées
189

Le chaînage de prototype, qui était le seul mécanisme d’héritage des versions antérieures 
d’ActionScript, n’a plus qu’un rôle secondaire en ActionScript 3.0. Le principal mécanisme 
d’héritage, l’héritage des propriétés fixes, est géré de façon interne par l’objet traits. 
Une propriété fixe est une variable ou une méthode définie dans le cadre d’une définition de 
classe. L’héritage des propriétés fixes est également appelé héritage des classes, car c’est le 
mécanisme d’héritage qui est associé aux mots-clés class, extends et override. 
Le chaînage de prototype représente un autre mécanisme d’héritage qui est plus dynamique 
que l’héritage des propriétés fixes. Il est possible d’ajouter des propriétés à l’objet prototype 
d’une classe non seulement dans le cadre de la définition de classe, mais aussi lors de 
l’exécution, via la propriété prototype de l’objet de classe. Notez toutefois que si le 
compilateur est en mode strict, il peut être impossible d’accéder aux propriétés ajoutées à un 
objet prototype, sauf si vous déclarez une classe avec le mot-clé dynamic. 
La classe Object est un bon exemple d’une classe dont plusieurs propriétés sont attachées à 
l’objet prototype. Les méthodes toString() et valueOf() de la classe Object sont en fait des 
fonctions affectées à des propriétés de l’objet prototype de la classe Object. Voici un exemple 
de l’aspect théorique de la déclaration de ces méthodes (l’implémentation réelle est légèrement 
différente en raison des détails pratiques d’implémentation) :
public dynamic class Object
{
prototype.toString = function()
{
//instructions
};
prototype.valueOf = function()
{
//instructions
};
}
Comme nous l’avons déjà mentionné, il est possible d’attacher une propriété à l’objet 
prototype d’une classe en-dehors de la définition de cette classe. Par exemple, la méthode 
toString() peut également être définie hors de la définition de la classe Object, comme suit :
Object.prototype.toString = function()
{
//instructions
};
190
Programmation orientée objet en ActionScript

Toutefois, contrairement à l’héritage des propriétés fixes, l’héritage du prototype ne nécessite 
pas le mot-clé override pour redéfinir une méthode d’une sous-classe. Par exemple, pour 
redéfinir la méthode valueOf() dans une sous-classe de la classe Object, trois options sont 
possibles. Premièrement, vous pouvez définir une méthode valueOf() dans l’objet prototype 
de la sous-classe, à l’intérieur de la définition de classe. Le code suivant crée une sous-classe 
d’Object nommée Foo, et redéfinit la méthode valueOf() dans la définition de classe de 
l’objet prototype de Foo. Chaque classe héritant de la classe Object, il n’est pas nécessaire 
d’utiliser le mot-clé extends.
dynamic class Foo
{
prototype.valueOf = function()
{
return "Instance of Foo";
};
}
Deuxièmement, vous pouvez définir une méthode valueOf() dans l’objet prototype de Foo 
en-dehors de la définition de classe, comme le montre le code ci-dessous :
Foo.prototype.valueOf = function()
{
return "Instance of Foo";
};
Troisièmement, vous pouvez définir une propriété fixe nommée valueOf() dans la classe Foo. 
Cette technique diffère des précédentes dans la mesure où elle mêle l’héritage des propriétés 
fixes et l’héritage du prototype. Pour redéfinir valueOf() à partir d’une sous-classe de Foo, il 
est nécessaire d’utiliser le mot-clé override. Le code ci-dessous montre valueOf() définie 
comme propriété fixe dans Foo :
class Foo
{
function valueOf():String
{
return "Instance of Foo";
}
}
Rubriques avancées
191

L’espace de nom d’ActionScript 3
L’existence de deux mécanismes d’héritage séparés, l’héritage des propriétés fixes et l’héritage 
du prototype, provoque un intéressant problème de compatibilité par rapport aux propriétés 
et méthodes des classe de base. La compatibilité avec les spécifications préliminaires du 
langage ECMAScript, édition 4, nécessite d’utiliser l’héritage de prototype, si bien que les 
propriétés et méthodes d’une classe de base sont définies dans l’objet prototype de cette classe. 
Mais par ailleurs, la compatibilité avec l’API de Flash Player nécessite d’utiliser l’héritage des 
propriétés fixes, si bien que les propriétés et méthodes d’une classe de base sont définies dans 
la définition de classe, à l’aide des mots-clés const, var et function. De plus, l’utilisation des 
propriétés fixes au lieu des versions du prototype est susceptible de permettre une nette 
amélioration des performances à l’exécution.
Pour résoudre ce problème, ActionScript 3.0 utilise les deux mécanismes d’héritage 
(propriétés fixes et prototype) pour les classes de base. Chaque classe de base contient deux 
jeux de propriétés et de méthodes. Un jeu est défini dans l’objet prototype pour assurer la 
compatibilité avec les spécifications d’ECMAScript, et l’autre jeu est défini avec les propriétés 
fixes et l’espace de nom d’AS3, pour assurer la compatibilité avec l’API de Flash Player. 
L’espace de nom d’AS3 représente un mécanisme fort pratique pour choisir entre les deux jeux 
de propriétés et de méthodes. Si vous n’utilisez pas l’espace de nom d’AS3, une instance d’une 
classe de base hérite des propriétés et des méthodes définies dans l’objet prototype de cette 
classe de base. Si par contre vous utilisez l’espace de nom d’AS3, une instance d’une classe de 
base hérite des versions d’AS3, car les propriétés fixes sont toujours préférées aux propriétés du 
prototype. En d’autres termes, lorsqu’une propriété fixe est disponible, elle est toujours utilisée 
à la place d’une propriété du prototype ayant le même nom.
Il est possible d’utiliser sélectivement la version de l’espace de nom d’AS3 d’une propriété ou 
d’une méthode, en la qualifiant à l’aide de l’espace de nom d’AS3. Par exemple, le code ci-
dessous utilise la version AS3 de la méthode () :
var nums:Array = new Array(1, 2, 3);
nums.AS3::pop();
trace(nums); // résultat : 1,2
Vous pouvez aussi faire appel à la directive use namespace pour ouvrir l’espace de nom d’AS3 
pour toutes les définitions figurant dans un bloc de code. Par exemple, le code ci-dessous 
utilise la directive use namespace pour ouvrir l’espace de nom d’AS3 pour les méthodes 
pop() et push(): 
use namespace AS3;
var nums:Array = new Array(1, 2, 3);
();
(5);
trace(nums) // résultat : 1,2,5
192
Programmation orientée objet en ActionScript

ActionScript 3.0 comporte aussi des options de compilation pour chaque jeu de propriétés, ce 
qui permet d’appliquer l’espace de nom d’AS3 au programme entier. L’option de compilation 
-as3 représente l’espace de nom d’AS3, et l’option de compilation -es représente l’option 
d’héritage du prototype (es signifie ECMAScript). Pour ouvrir l’espace de nom d’AS3 pour 
tout le programme, mettez l’option de compilation -as3 sur true et l’option de compilation 
-es sur false. Pour utiliser les versions du prototype, mettez les options de compilation sur 
les valeurs opposées. Les options de compilation par défaut pour Adobe Flex Builder 2 et 
Adobe Flash CS3 Professional sont -as3 = true et -es = false.
Si vous prévoyez d’étendre l’une des classes de base et de redéfinir des méthodes, vous devez 
comprendre comment l’espace de nom d’AS3 affecte la façon de déclarer une méthode 
redéfinie. Si vous utilisez l’espace de nom d’AS3, toute redéfinition d’une méthode d’une 
classe de base doit également utiliser l’espace de nom d’AS3, ainsi que l’attribut override. 
Si vous n’utilisez pas l’espace de nom d’AS3 et voulez redéfinir une méthode d’une classe de 
base dans une sous-classe, vous ne devez utiliser ni l’espace de nom d’AS3 dans cette 
redéfinition, ni l’attribut override.
Exemple : GeometricShapes
L’exemple d’application GeometricShapes montre comment il est possible d’appliquer un 
certain nombre de concepts et fonctionnalités orientés objet à l’aide d’ActionScript 3.0, en 
particulier :
?
Définition des classes 
?
l’extension des classes
?
le polymorphisme et le mot-clé override
?
la définition, l’extension et l’implémentation des interfaces.
Cet exemple comprend aussi une « méthode de factorisation » qui crée des instances de classes, 
montrant ainsi comment déclarer une valeur de retour comme instance d’une interface et 
utiliser l’objet ainsi renvoyé de manière générique.
Exemple : GeometricShapes
193

Pour obtenir les fichiers de cet exemple d’application, learn_programmingAS3samples_flash_fr. Les fichiers de l’application GeometricShapes se 
trouvent dans le dossier Samples/GeometricShapes. Cette application se compose des fichiers 
suivants :
Fichier
Description

Le fichier d’application principal pour Flash 
ou
(FLA) ou Flex (MXML)

com/example/programmingas3/
Interface de base définissant les méthodes qui 

doivent être implémentées par toutes les 
classes de l’application GeometricShapes.
com/example/programmingas3/
Interface définissant les méthodes qui doivent 

être implémentées par les classes de 
l’application GeometricShapes qui comportent 
plusieurs côtés.
com/example/programmingas3/
Type de forme géométrique dont les côtés sont 

de longueur égale et positionnés 
symétriquement autour du centre de la forme.
com/example/programmingas3/
Type de forme géométrique qui définit un 

cercle.
com/example/programmingas3/
Sous-classe de RegularPolygon, définissant un 

triangle équilatéral.
com/example/programmingas3/
Sous-classe de RegularPolygon, définissant un 

rectangle dont les quatre côtés sont égaux.
com/example/programmingas3/
Classe contenant une « méthode de 
geometricshapes/
factorisation » pour créer des formes à partir 

d’un type et d’une taille de forme.
194
Programmation orientée objet en ActionScript

Définition des classes de GeometricShapes
L’application GeometricShapes permet de spécifier un type de forme géométrique et la taille 
de cette dernière. Elle renvoie alors la description de la forme, sa surface et son périmètre.
L’interface utilisateur de l’application est triviale : elle se compose de quelques contrôles 
permettant de sélectionner le type de forme, de définir la taille et d’afficher la description. 
De fait, la partie intéressante de cette application est la face cachée de l’iceberg : la structure 
des classes et des interfaces elles-mêmes.
Cette application traite des formes géométriques, mais elle ne les affiche pas graphiquement. 
Elle représente une petite bibliothèque de classes et d’interfaces qui seront réutilisées dans un 
autre chapitre, dans la section « Exemple : SpriteArranger », à la page 451. L’exemple 
SpriteArranger affiche les formes graphiquement et permet à l’utilisateur de les manipuler, à 
partir de la structure de classes fournie ici, dans l’application GeometricShapes.
Les classes et interfaces qui définissent les formes géométriques de cet exemple sont 
représentées dans le diagramme ci-dessous, en notation UML (Unified Modeling Language) :
GeometricShapes Example Classes
<< interface >>
<< interface >>
IGeometricShape
IPolygon
+getArea (): Number
+getPerimeter (): Number
+describe (): Strin
+getSumOfAngles (): Number
Circle
RegularPolygon
+diameter:Number
+numSides : int
+Circle () : Circle
+sideLength : Number
+getArea () : Number
+RegularPolygon (): RegularPolygon
+describe () : String
+getSumOfAngles (): Number
+getCircumference () : Number
+getPerimeter (): Number
+getArea (): Number
+describe (): String

EquilateralTriangle
Square
+EquilateralTriangle (): EquilateralTriangle
+Square (): Square
+getArea (): Number
+getArea (): Number
+describe (): String
+describe (): String
Exemple : GeometricShapes
195

Définition d’un comportement commun à l’aide 
d’interfaces
Cette application GeometricShapes gère trois types de formes : cercles, carrés et triangles 
équilatéraux. La structure des classes de GeometricShapes commence par une interface très 
simple, IGeometricShape, qui liste des méthodes communes aux trois types de formes :
package com.example.programmingas3.geometricshapes
{
public interface IGeometricShape
{
function getArea():Number;
function describe():String;
}
}
L’interface définit deux méthodes : la méthode getArea(), qui calcule et renvoie la surface de 
la forme, et la méthode describe(), qui assemble une description textuelle des propriétés de 
la forme.
Nous voulons aussi connaître le périmètre de chaque forme. Toutefois, le périmètre d’un 
cercle est appelé circonférence et il est calculé de façon particulière, si bien que le 
comportement diverge de ceux d’un triangle ou d’un carré. Il existe cependant assez de 
similitudes entre les triangles, les carrés et les autres polygones pour qu’il soit logique de 
définir une nouvelle classe d’interface pour eux : IPolygon. L’interface IPolygon est également 
plutôt simple, comme on le voit :
package com.example.programmingas3.geometricshapes
{
public interface IPolygon extends IGeometricShape
{
function getPerimeter():Number;
function getSumOfAngles():Number;
}
}
Cette interface définit deux méthodes communes à tous les polygones : la méthode 
getPerimeter(), qui mesure la longueur combinée de tous les côtés, et la méthode 
getSumOfAngles() qui additionne tous les angles intérieurs.
L’interface IPolygon étend l’interface IGeometricShape, si bien que toute classe qui 
implémente l’interface IPolygon doit déclarer les quatre méthodes — les deux de l’interface 
IGeometricShape, et les deux de l’interface IPolygon.
196
Programmation orientée objet en ActionScript

Définition des classes de formes
Dès que vous avez une vue claire des méthodes communes à chaque type de forme, vous 
pouvez définir les classes de formes elles-mêmes. En ce qui concerne le nombre de méthodes à 
implémenter, la forme la plus simple est la classe Circle :
package com.example.programmingas3.geometricshapes
{
public class Circle implements IGeometricShape
{
public var diameter:Number;
public function Circle(diam:Number = 100):void
{
this.diameter = diam;
}
public function getArea():Number
{
// The formula is Pi * radius * radius.
var radius:Number = diameter / 2;
return * radius * radius;
}
public function getCircumference():Number
{
// The formula is Pi * diameter.
return * diameter;
}
public function describe():String
{
var desc:String = "This shape is a Circle.\n";
desc += "Its diameter is " + diameter + " pixels.\n";
desc += "Its area is " + getArea() + ".\n";
desc += "Its circumference is " + getCircumference() + ".\n";
return desc;
}
}
}
La classe Circle implémente l’interface IGeometricShape, elle doit donc comporter du code 
pour les méthodes getArea() et describe(). De plus, elle définit la méthode 
getCircumference(), qui est unique à la classe Circle. La classe Circle déclare aussi une 
propriété, diameter, qui n’apparaîtra pas dans les autres classes, dédiées aux polygones.
Exemple : GeometricShapes
197

Les deux autres types de formes, les carrés et les triangles équilatéraux, ont d’autres points 
communs : ils ont tous deux des côtés de longueurs égales, et il existe des formules communes 
pour calculer leurs périmètre et la somme de leurs angles intérieurs. En fait, ces formules 
communes s’appliquent à tout autre polygone régulier que vous êtes susceptible de définir par 
la suite. 
La classe RegularPolygon sera la super-classe de la classe Square et de la classe 
EquilateralTriangle. Une super-classe permet de définir en un seul point des méthodes 
communes, il n’est donc pas nécessaire de les définir séparément dans chaque sous-classe. 
Voici le code de la classe RegularPolygon :
package com.example.programmingas3.geometricshapes
{
public class RegularPolygon implements IPolygon
{
public var numSides:int;
public var sideLength:Number;
public function RegularPolygon(len:Number = 100, sides:int = 3):void
{
this.sideLength = len;
this.numSides = sides;
}
public function getArea():Number
{
// This method should be overridden in subclasses.
return 0;
}
public function getPerimeter():Number
{
return sideLength * numSides;
}
public function getSumOfAngles():Number
{
if (numSides >= 3)
{
return ((numSides - 2) * 180);
}
else
{
return 0;
}
}
198
Programmation orientée objet en ActionScript

public function describe():String
{
var desc:String = "Each side is " + sideLength + " pixels long.\n";
desc += "Its area is " + getArea() + " pixels square.\n";
desc += "Its perimeter is " + getPerimeter() + " pixels long.\n"; 
desc += "The sum of all interior angles in this shape is " + 
getSumOfAngles() + " degrees.\n"; 
return desc;  
}
}
}
La classe RegularPolygon déclare d’abord deux propriétés qui sont communes à tous les 
polygones réguliers : la longueur de chaque côté (la propriété sideLength) et le nombre de 
faces (la propriété numSides).
La classe RegularPolygon implémente l’interface IPolygon et déclare les quatre méthodes de 
l’interface IPolygon. Elle implémente deux d’entre elles, les méthodes getPerimeter() et 
getSumOfAngles() à l’aide de formules communes.
La formule de la méthode getArea() étant différente d’une forme à l’autre, la version de la 
méthode dans la classe de base ne peut pas comporter une logique commune dont hériteraient 
les méthodes des sous-classes. Elle renvoie donc simplement une valeur par défaut de 0 pour 
indiquer que la surface n’a pas été calculée. Pour calculer correctement la surface de chaque 
forme, les sous-classes de la classe RegularPolygon devront redéfinir elles-mêmes la méthode 
getArea().
Le code de la classe EquilateralTriangle, ci-dessous, montre comment la méthode getArea() 
est redéfinie :
package com.example.programmingas3.geometricshapes 
{
public class EquilateralTriangle extends RegularPolygon
{
public function EquilateralTriangle(len:Number = 100):void
{
super(len, 3);
}
public override function getArea():Number
{
    // The formula is ((sideLength squared) * (square root of 3)) / 4.
    return ( (this.sideLength * this.sideLength) * (3) ) / 4;
}
Exemple : GeometricShapes
199

public override function describe():String
{
 
/* starts with the name of the shape, then delegates the rest
 
of the description work to the RegularPolygon superclass */
    var desc:String = "This shape is an equilateral Triangle.\n";
    desc += super.describe();
    return desc;
}
}
}
Le mot-clé override indique que la méthode EquilateralTriangle.getArea() redéfinit 
volontairement la méthode getArea() de la super-classe RegularPolygon. Lorsque la méthode 
EquilateralTriangle.getArea() est appelée, elle calcule la surface à l’aide de la formule 
du code précédent, et le code de la méthode RegularPolygon.getArea() n’est jamais 
exécuté.
Par contre, la classe EquilateralTriangle ne définit pas sa propre version de la méthode 
getPerimeter(). Lorsque la méthode EquilateralTriangle.getPerimeter() est appelée, 
l’appel remonte la chaîne d’héritage et exécute le code de la méthode getPerimeter() de la 
super-classe RegularPolygon.
Le constructeur EquilateralTriangle() utilise l’instruction super() pour invoquer 
explicitement le constructeur RegularPolygon() de sa super-classe. Si les deux constructeurs 
avaient le même ensemble de paramètres, il serait possible d’omettre complètement le 
constructeur EquilateralTriangle, et il suffirait d’exécuter le constructeur 
RegularPolygon(). Toutefois, le constructeur RegularPolygon() nécessite un paramètre 
supplémentaire, numSides. Le constructeur EquilateralTriangle() appelle donc 
super(len, 3) qui passe le paramètre en entrée len et la valeur 3 pour indiquer que le 
nombre de côtés du triangle est 3.
La méthode describe() utilise également l’instruction super(), mais de façon différente, 
afin d’invoquer la version de la méthode describe() dans la super-classe RegularPolygon. 
La méthode EquilateralTriangle.describe() définit d’abord la variable de chaîne desc 
qui affiche le type de forme. Elle obtient ensuite les résultats de la méthode 
RegularPolygon.describe() en appelant super.describe(), et ajoute ces résultats à la fin 
de la chaîne desc.
La classe Square ne sera pas décrite en détail ici, mais elle est similaire à la classe 
EquilateralTriangle, avec un constructeur et ses propres implémentations des méthodes 
getArea() et describe().
200
Programmation orientée objet en ActionScript

Le polymorphisme et la « méthode de factorisation »
Il est possible d’utiliser de diverses façons intéressantes un ensemble de classes utilisant à bon 
escient les interfaces et l’héritage. Par exemple, toutes les classes de formes décrites jusqu’ici 
implémentent l’interface IGeometricShape ou étendent une super-classe qui se charge de cette 
implémentation. Si l’on définit une variable comme étant une instance de IGeometricShape, 
il n’est donc pas nécessaire, pour appeler sa méthode describe(), de savoir si c’est une 
instance de la classe Circle ou de la classe Square.
Le code suivant illustre cette situation :
var myShape:IGeometricShape = new Circle(100);
trace(myShape.describe());
Lorsque myShape.describe() est appelée, elle exécute la méthode Circle.describe(), car 
bien que la variable soit définie comme une instance de l’interface IGeometricShape, Circle 
est sa classe sous-jacente.
Cet exemple illustre le principe du polymorphisme : le même appel à une méthode 
provoquera l’exécution d’un code différent, selon la classe de l’objet dont la méthode est 
appelée.
L’application GeometricShapes applique ce type de polymorphisme basé sur l’interface à l’aide 
d’une version simplifiée d’un modèle de conception appelé « méthode de factorisation ». 
L’expression méthode de factorisation fait référence à une fonction qui renvoie un objet dont le 
type de données sous-jacent ou le contenu diffèrent selon le contexte.
La classe GeometricShapeFactory représentée ici définit une méthode de factorisation 
nommée createShape():
package com.example.programmingas3.geometricshapes 
{
public class GeometricShapeFactory 
{
public static var currentShape:IGeometricShape;
public static function createShape(shapeName:String, 
len:Number):IGeometricShape
{
switch (shapeName)
{
case "Triangle":
return new EquilateralTriangle(len);
case "Square":
return new Square(len);
Exemple : GeometricShapes
201

case "Circle":
return new Circle(len);
}
return null;
}
public static function describeShape(shapeType:String, 
shapeSize:Number):String
{
GeometricShapeFactory.currentShape =
GeometricShapeFactory.createShape(shapeType, shapeSize);
return GeometricShapeFactory.currentShape.describe();
}
}
}
La méthode de factorisation createShape() laisse aux constructeurs de la sous-classe de la 
forme le soin de définir les détails des instances qu’ils créent, tout en renvoyant les nouveaux 
objets comme instances de IgeometricShape, ce qui permet à l’application de les traiter de 
façon plus générale.
La méthode describeShape() de l’exemple précédent montre comment une application 
peut utiliser la méthode de factorisation pour obtenir une référence générique à un objet 
spécifique. L’application peut obtenir la description d’un objet Circle nouvellement créé en 
procédant comme suit :
GeometricShapeFactory.describeShape(“Circle”, 100);
La méthode describeShape() appelle alors la méthode de factorisation createShape() avec 
les mêmes paramètres, en mettant le nouvel objet Circle dans une variable statique nommée 
currentShape, dont le type a été défini comme objet de IGeometricShape. La méthode 
describe() est ensuite appelée pour l’objet currentShape, et cet appel est automatiquement 
résolu pour exécuter la méthode Circle.describe(), qui renvoie une description détaillée 
du cercle.
202
Programmation orientée objet en ActionScript

Amélioration de l’application d’exemple
La puissance des interfaces et de l’héritage devient évidente dès qu’il s’agit de modifier 
l’application.
Supposons que nous voulions ajouter une nouvelle forme, un pentagone, à cette application. 
Il suffit de créer une nouvelle classe, Pentagon, qui étend la classe RegularPolygon et définit 
ses propres versions des méthodes getArea() et describe(). Une nouvelle option Pentagon 
est ensuite ajoutée dans l’interface utilisateur de l’application. C’est tout. La classe Pentagon 
obtiendra automatiquement, par héritage, les fonctionnalités des méthode getPerimeter() 
et getSumOfAngles() de la classe RegularPolygon. Et puisqu’elle hérite d’une classe qui 
implémente l’interface IGeometricShape, une instance de Pentagon sera également traitée 
comme une instance de IGeometricShape. Autrement dit, il n’est pas nécessaire de modifier 
l’une des méthodes de la classe GeometricShapeFactory, ce qui rend beaucoup plus facile 
l’ajout ultérieur de nouveaux types de forme.
À titre d’exercice, il est conseillé d’ajouter une classe Pentagon à l’exemple Geometric Shapes, 
afin de constater à quel point les interfaces et l’héritage facilitent le processus d’ajout de 
nouvelles fonctionnalités à une application.
Exemple : GeometricShapes
203

204
Programmation orientée objet en ActionScript

CHAPITRE 5
Utilisation des dates 
5
et heures
Si la ponctualité ne fait pas tout, elle n’en est pas moins un facteur clé des applications 
logicielles. ActionScript 3.0 propose différentes méthodes de gestion des dates calendaires, des 
heures et des intervalles temporels. Deux classes principales assurent l’essentiel de la 
fonctionnalité temporelle : la classe Date et la nouvelle classe Timer du package flash.utils.
Contenu
Principes de base des dates et des heures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  205
Gestion des dates calendaires et des heures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  206
Contrôle des intervalles temporels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
Exemple : une horloge analogique simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Principes de base des dates et des heures
Introduction à l’utilisation des dates et des heures
Les dates et les heures constituent un type d’informations courant utilisé dans les programmes 
ActionScript. Par exemple, vous pouvez, entre autres, connaître la date du jour ou calculer 
combien de temps un utilisateur passe sur un écran particulier. Dans ActionScript, vous 
pouvez utiliser la classe Date pour représenter un moment unique dans le temps, y compris 
des informations de date et d’heure. Une instance Date contient des valeurs pour les unités de 
date et d’heure individuelles (année, mois, date, jour de la semaine, heure, minutes, secondes, 
millisecondes et fuseau horaire, par exemple). Pour des utilisations plus avancées, ActionScript 
comprend également la classe Timer que vous pouvez utiliser pour effectuer des actions après 
un certain délai ou à des intervalles répétés.
205

Tâches de date et d’heure courantes
Ce chapitre décrit les tâches courantes suivantes qui utilisent des informations de date et 
d’heure :
?
Utilisation des objets Date
?
Obtention de la date et de l’heure actuelles
?
Accès à des unités de date et d’heure individuelles (jours, années, heures, minutes, etc.)
?
Exécution d’opérations arithmétiques sur les dates et les heures
?
Conversion entre plusieurs fuseaux horaires
?
Exécutions d’actions répétées
?
Exécution d’actions après un délai défini
Concepts et termes importants
La liste de référence suivante contient les termes importants que vous rencontrerez dans ce 
chapitre :
?
Heure UTC : heure universelle—le fuseau horaire de référence d’« heure zéro ». Tous les 
autres fuseaux horaires sont définis sous la forme de nombre d’heures par rapport (avant 
ou après) à l’heure universelle.
Utilisation des exemples fournis dans le chapitre
Au fur et à mesure que vous avancez dans le chapitre, vous pouvez tester des exemples de code. 
Etant donné que le code de ce chapitre traite essentiellement des objets Date, le test des 
exemples implique l’affichage des valeurs des variables utilisées dans les exemples, soit en les 
écrivant dans une occurrence de champ texte sur la scène, soit en utilisant la fonction trace() 
pour imprimer des valeurs dans le panneau Sortie. Ces techniques sont décrites en détail dans 
« Test des exemples de code contenus dans un chapitre », à la page 67.
Gestion des dates calendaires et des heures
Dans ActionScript 3.0, toutes les fonctions de gestion des dates calendaires et des heures se 
concentrent autour de la classe de niveau supérieur Date. Cette classe contient des méthodes 
et des propriétés qui vous permettent de manier les dates et les heures soit selon le modèle 
universel coordonné (UTC, Universal Time Coordinated), soit selon le fuseau horaire 
considéré. L’UTC est une définition normalisée du temps qui correspond essentiellement à 
l’heure du méridien de Greenwich (GMT, Greenwich Mean Time).
206
Utilisation des dates et heures

Création d’objets Date
La classe Date compte l’une des méthodes constructeur les plus polyvalentes de toutes les 
classes de base. Vous pouvez l’invoquer de quatre manières différentes.
Primo, si aucun paramètre n’est fourni, le constructeur Date() renvoie un objet Date 
contenant la date et l’heure locale actuelle de votre fuseau horaire. Voici un exemple :
var now:Date = new Date();
Secundo, si un paramètre numérique unique est fourni, le constructeur Date() le considère 
comme le nombre de millisecondes écoulées depuis le 1er janvier 1970 et renvoie l’objet Date 
correspondant. Notez que la valeur en millisecondes que vous transmettez est considérée 
comme le nombre de millisecondes depuis le 1er janvier 1970 en temps UTC. Toutefois, 
l’objet Date affiche des valeurs dans votre fuseau horaire local, sauf si vous utilisez des 
méthodes UTC uniquement pour les extraire et les afficher. Si vous créez un nouvel objet 
Date à l’aide du paramètre en millisecondes, veillez à tenir compte du décalage horaire entre 
votre fuseau local et le temps UTC. Les instructions ci-après créent un objet Date défini à 
minuit le 1er janvier 1970 en temps UTC :
var millisecondsPerDay:int = 1000 * 60 * 60 * 24;
// établit un objet Date un jour après la date de départ du 1/1/1970
var startTime:Date = new Date(millisecondsPerDay);
Tertio, vous pouvez transmettre plusieurs paramètres numériques au constructeur Date(). 
Celui-ci les traite respectivement comme la date, le mois, le jour, les heures, les minutes, les 
secondes et les millisecondes, et renvoie un objet Date correspondant. Les paramètres entrés 
sont considérés comme correspondant à l’heure locale plutôt qu’au temps UTC. 
Les instructions suivantes établissent un objet Date défini à minuit le 1er janvier 2000, dans le 
fuseau horaire local :
var millenium:Date = new Date(2000, 0, 1, 0, 0, 0, 0);
Quarto, vous pouvez transmettre un paramètre numérique unique au constructeur Date(). 
Celui-ci essaiera d’analyser cette chaîne en composants de date et heure, et de renvoyer un 
objet Date correspondant. Si vous choisissez cette approche, il est recommandé d’inclure le 
constructeur Date() dans un bloc try..catch afin d’intercepter toute erreur d’analyse. 
Le constructeur Date() accepte plusieurs formats de chaînes, comme indiqué dans le 
Référence du langage et des composants ActionScript 3.0. L’instruction suivante initialise un 
nouvel objet Date à l’aide d’une valeur chaîne :
var nextDay:Date = new Date(“Mon May 1 2006 11:30:00 AM”);
Si le constructeur Date() ne peut analyser le paramètre chaîne, il ne déclenche pas 
d’exception. Cependant, l’objet Date résultant contiendra une valeur date incorrecte.
Gestion des dates calendaires et des heures
207

Obtention des valeurs d’unités temporelles
Vous pouvez extraire les valeurs de plusieurs unités temporelles au sein de l’objet Date grâce à 
des propriétés ou des méthodes de la classe Date. Chacune des propriétés suivantes fournit la 
valeur d’une unité temporelle de l’objet Date :
?
La propriété fullYear 
?
La propriété month au format numérique : de 0 pour janvier à 11 pour décembre
?
La propriété date, qui correspond au numéro calendaire du jour du mois, de 1 à 31
?
La propriété day, qui correspond au jour de la semaine au format numérique, 0 
représentant dimanche
?
La propriété hours, de 0 à 23
?
La propriété minutes 
?
La propriété seconds 
?
La propriété milliseconds 
La classe Date offre en fait plusieurs manières d’obtenir ces valeurs. Vous pouvez par exemple 
obtenir la valeur month de l’objet Date de quatre manières :
?
La propriété month
?
La méthode getMonth()
?
La propriété monthUTC
?
La méthode getMonthUTC()
Ces quatre solutions sont d’une efficacité équivalente, vous pouvez donc adopter celle qui 
convient le mieux à votre application.
Les propriétés répertoriées ci-dessus représentent toutes des composants de la valeur date 
totale. Par exemple, la propriété milliseconds ne sera jamais supérieure à 999, puisque si elle 
atteint 1000, la valeur seconds augmente de 1, la propriété milliseconds se remet à zéro. 
Si vous voulez obtenir la valeur de l’objet Date en millisecondes depuis le 1er janvier 1970 
(UTC), vous pouvez utiliser la méthode getTime(). La méthode setTime(), quant à elle, 
vous permet de modifier la valeur d’un objet Date existant en millisecondes depuis le 1er 
janvier 1970 (UTC). 
Opérations arithmétiques sur la date et l’heure
La classe Date permet d’additionner et de soustraire des dates et heures. Les valeurs Date sont 
conservées en interne sous forme de millisecondes. Il est donc nécessaire de convertir les autres 
valeurs en millisecondes avant de les ajouter ou de les soustraire aux objets Date.
208
Utilisation des dates et heures

Si votre application doit effectuer de nombreuses opérations arithmétiques sur les dates et 
heures, il peut s’avérer utile de créer des constantes qui conservent les valeurs d’unités 
temporelles courantes en millisecondes, comme illustré ci-après :
public static const millisecondsPerMinute:int = 1000 * 60;
public static const millisecondsPerHour:int = 1000 * 60 * 60;
public static const millisecondsPerDay:int = 1000 * 60 * 60 * 24;
Il devient alors simple d’effectuer des opérations arithmétiques à l’aide des unités temporelles 
standard. Le code ci-après décale la valeur date d’une heure par rapport à l’heure actuelle à 
l’aide des méthodes getTime() et setTime() :
var oneHourFromNow:Date = new Date();
oneHourFromNow.setTime(oneHourFromNow.getTime() + millisecondsPerHour);
Une autre manière de définir une valeur date consiste à créer un nouvel objet Date à l’aide 
d’un seul paramètre en millisecondes. Par exemple, le code suivant ajoute 30 jours à une date 
pour en calculer une autre : 
// Définit la date de facturation par rapport à la date courante.
var invoiceDate:Date = new Date();
// ajoute 30 jours pour obtenir la date d’échéance
var dueDate:Date = new Date(invoiceDate.getTime() + (30 * 
millisecondsPerDay));
Ensuite, la constante millisecondsPerDay est multipliée par 30 pour représenter la période 
de 30 jours et le résultat est ajouté à la valeur invoiceDate afin de définir la valeur dueDate. 
Conversion entre plusieurs fuseaux horaires
Les opérations arithmétiques sur les dates et heures sont particulièrement pratiques lorsque 
vous devez convertir des dates d’un fuseau horaire à un autre. Tel est le rôle de la méthode 
getTimezoneOffset(), qui renvoie la valeur (en minutes) de décalage entre le fuseau horaire 
de l’objet Date et le temps UTC. La valeur renvoyée s’exprime en minutes parce que tous les 
fuseaux horaires ne correspondent pas à une heure ; certains sont décalés d’une demi-heure 
par rapport aux fuseaux voisins.
L’exemple suivant utilise le décalage de fuseau horaire pour convertir une date à partir de 
l’heure locale en temps UTC. La conversion s’effectue tout d’abord par calcul de la valeur du 
fuseau horaire en millisecondes, puis par ajustement de la valeur Date selon ce montant :
// Crée une date selon l’heure locale.
var nextDay:Date = new Date("Mon May 1 2006 11:30:00 AM");
// Convertit la date en temps UTC par ajout ou soustraction du décalage 
// de fuseau horaire.
var offsetMilliseconds:Number = nextDay.getTimezoneOffset() * 60 * 1000;
nextDay.setTime(nextDay.getTime() + offsetMilliseconds);
Gestion des dates calendaires et des heures
209

Contrôle des intervalles temporels
Lorsque vous développez des applications à l’aide de Adobe Flash CS3 Professional, vous avez 
accès au scénario, qui fournit une progression constante, image par image, au sein de votre 
application. Toutefois, dans un projet purement ActionScript, vous devez compter sur 
d’autres mécanismes temporels.
Boucles ou minuteurs ?
Dans certains langages de programmation, vous devez mettre au point des motifs temporels à 
l’aide d’instructions en boucle telles que for ou do..while. 
Les instructions en boucle s’exécutent en général aussi vite que la machine locale le permet, ce 
qui signifie que l’application sera plus rapide sur certaines machines que sur d’autres. Si votre 
application doit bénéficier d’un intervalle temporel cohérent, vous devez l’associer à un 
calendrier ou une horloge réels. Bien des applications, telles que les jeux, les animations, les 
contrôleurs en temps réel, nécessitent des mécanismes de décompte temporel qui soient 
cohérents d’une machine à l’autre.
La classe Timer d’ActionScript 3.0 offre une solution performante dans ce domaine. Grâce au 
modèle d’événements ActionScript 3.0, la classe Timer distribue des événements Timer dès 
qu’un intervalle spécifié est atteint.
La classe Timer
Pour la gestion des fonctions temporelles dans ActionScript 3.0, il est recommandé d’utiliser 
la classe Timer (flash.utils.Timer), qui permet de distribuer des événements dès qu’un 
intervalle est atteint.
Pour lancer une horloge, vous devez d’abord créer une instance de la classe Timer et lui 
indiquer à quelle fréquence elle doit générer un événement Timer et combien de fois elle doit 
le faire avant de s’arrêter.
Par exemple, le code suivant crée une instance Timer qui distribue un événement toutes les 
secondes pendant 60 secondes :
var oneMinuteTimer:Timer = new Timer(1000, 60);
L’objet Timer distribue un objet TimerEvent chaque fois que l’intervalle donné est atteint. 
Le type d’événement de l’objet TimerEvent est timer (défini par la constante 
TimerEvent.TIMER). Un objet TimerEvent contient les mêmes propriétés que l’objet 
standard Event.
210
Utilisation des dates et heures

Si l’instance Timer prévoit un nombre fixe d’intervalles, elle distribue également un 
événement timerComplete (défini par la constante TimerEvent.TIMER_COMPLETE) 
lorsqu’elle atteint l’intervalle final.
Voici un court exemple d’application illustrant la classe Timer en action :
package 
{
import flash.display.Sprite;
import flash.events.TimerEvent;
import flash.utils.Timer;
public class ShortTimer extends Sprite
{
public function ShortTimer() 
{
// Crée un nouvel objet Timer de cinq secondes.
var minuteTimer:Timer = new Timer(1000, 5);
// Désigne les écouteurs destinés aux événements d’intervalle 
// et de fin.
minuteTimer.addEventListener(TimerEvent.TIMER, onTick);
minuteTimer.addEventListener(TimerEvent.TIMER_COMPLETE, 
onTimerComplete);
// Lance le décompte du minuteur.
minuteTimer.start();
}
public function onTick(event:TimerEvent):void 
{
// Affiche le nombre décompté jusqu’ici.
// La cible de cet événement est l’instance Timer elle-même
trace("tick " + event.target.currentCount);
}
public function onTimerComplete(event:TimerEvent):void
{
trace("Time's Up!");
}
}
}
Lorsque la classe ShortTimer est créée, elle génère une instance Timer qui marque chaque 
seconde pendant cinq secondes. Elle ajoute ensuite deux écouteurs au minuteur : l’un écoute 
chaque tic de l’horloge et l’autre attends l’événement timerComplete. 
Elle lance ensuite le décompte du minuteur et à partir de là, la méthode onTick() s’exécute 
toutes les secondes. 
Contrôle des intervalles temporels
211

La méthode onTick() affiche simplement le nombre actuel de tics. Après cinq secondes, la 
méthode onTimerComplete() s’exécute et vous avertit que le temps est écoulé.
Si vous exécutez cet exemple, vous devriez voir les lignes suivantes s’afficher dans votre console 
ou fenêtre de suivi à raison d’une ligne par seconde :
tick 1
tick 2
tick 3
tick 4
tick 5
Time's Up!
Fonctions temporelles du package flash.utils
ActionScript 3.0 contient plusieurs fonctions temporelles semblables à celles qui étaient 
disponibles dans ActionScript 2.0. Fournies au niveau package dans flash.utils, ces fonctions 
fonctionnent de la même manière que dans ActionScript 2.0.
Fonction
Description
clearInterval(id:uint):void
Annule un appel setInterval() spécifié.
clearTimeout(id:uint):void
Annule un appel setTimeout() spécifié.
getTimer():int
Renvoie le nombre de millisecondes qui se sont 
écoulées depuis l’initialisation d’Adobe Flash 
Player.
setInterval(closure:Function, 
Exécute une fonction à fréquence régulière 
delay:Number, arguments):uint 
(intervalle exprimé en millisecondes).
setTimeout(closure:Function, 
Exécute une fonction spécifiée après un délai 
delay:Number, arguments):uint 
donné (exprimé en millisecondes).
Ces fonctions demeurent dans ActionScript 3.0 afin d’assurer la compatibilité avec les versions 
antérieures. Adobe ne recommande pas leur utilisation dans les nouvelles applications 
ActionScript 3.0. Il est en général plus simple et plus efficace d’utiliser la classe Timer.
212
Utilisation des dates et heures

Exemple : une horloge analogique simple
Cet exemple d’horloge analogique simple illustre deux des concepts de date et heure étudiés 
dans ce chapitre :
?
Obtention de la date et de l’heure actuelle et extraction des valeurs heures, minutes et 
secondes
?
Utilisation d’une horloge pour fixer le rythme d’une application
Pour obtenir les fichiers d’application pour cet exemple, voir 
;Les fichiers d’application 
SimpleClock se trouvent dans le dossier Samples/SimpleClock. L’application se compose des 
fichiers suivants :
Fichier
Description

Le fichier d’application principal dans Flash 
ou
(FLA) ou Flex (MXML).

com/example/programmingas3/
Fichier d’application principal.

com/example/programmingas3/
Dessine un cadran d’horloge rond et les 

aiguilles des heures, des minutes et des 
secondes en fonction de l’heure.
Définition de la classe SimpleClock
Si l’exemple d’horloge est simple, il est toujours judicieux de bien organiser les applications de 
manière à faciliter leur extension future. Dans ce but, l’application SimpleClock utilise la 
classe SimpleClock pour gérer les tâches de démarrage et de mesure temporelle. Elle se sert 
ensuite d’une autre classe, AnalogClockFace, pour l’affichage réel de l’heure.
Voici le code qui définit et initialise la classe SimpleClock (vous remarquerez que dans la 
version Flash, SimpleClock étend la classe Sprite à la place) :
public class SimpleClock extends UIComponent
{
/**
 * Le composant d’affichage de l’heure.
 */
private var face:AnalogClockFace;
/**
 * L’horloge qui marque le rythme de l’application.
 */
private var ticker:Timer;
Exemple : une horloge analogique simple
213

La classe possède deux propriétés importantes :
?
La propriété face, qui correspond à une instance de la classe AnalogClockFace
?
La propriété ticker, qui est une instance de la classe Timer
La classe SimpleClock utilise un constructeur par défaut. La méthode initClock() se 
charge de la véritable configuration, en créant le cadran et en lançant le décompte de 
l’instance Timer.
Création du cadran
Les lignes suivantes du code SimpleClock créent le cadran utilisé pour afficher l’heure :
/**
 * Définit une instance SimpleClock.
 */
public function initClock(faceSize:Number = 200) 
{
// Crée le cadran et l’ajoute à la liste d’affichage
face = new AnalogClockFace((20, faceSize));
();
addChild(face);
// Dessine l’affichage initial de l’horloge
();
La taille de l’horloge peut être transmise à la méthode initClock(). Si aucune valeur 
faceSize n’est transmise, la taille par défaut de 200 pixels est utilisée.
Ensuite, l’application initialise le cadran et l’ajoute à la liste d’affichage à l’aide de la méthode 
addChild() héritée de la classe DisplayObject. Elle appelle enfin la méthode 
() pour afficher une fois le cadran, qui indique l’heure actuelle. 
Lancement du minuteur
Une fois le cadran créé, la méthode initClock() définit le minuteur : 
// Crée un minuteur qui déclenche un événement toutes les secondes.
ticker = new Timer(1000); 
// Désigne la méthode onTick() pour la gestion des événements Timer.
ticker.addEventListener(TimerEvent.TIMER, onTick);
// Lance le décompte de l’horloge.
ticker.start();
214
Utilisation des dates et heures

Cette méthode commence par instancier une instance Timer qui va distribuer un événement 
par seconde (toutes les 1000 millisecondes). Comme le constructeur Timer() ne reçoit pas de 
second paramètre repeatCount, l’horloge se reproduit indéfiniment. 
La méthode SimpleClock.onTick() s’exécute une fois par seconde après réception de 
l’événement timer :
public function onTick(event:TimerEvent):void 
{
// Met à jour l’affichage de l’horloge
();
}
La méthode () dessine simplement le cadran de l’horloge et des 
aiguilles. 
Affichage de l’heure actuelle
La plupart du code de la classe AnalogClockFace implique la définition des éléments 
d’affichage du cadran. Lors de son initialisation, AnalogClockFace dessine un contour 
circulaire, place des libellés numériques pour chaque heure, puis crée trois objets Shape, un 
pour l’aiguille des heures, un pour celle des minutes et un pour l’aiguille des secondes de 
l’horloge.
Lorsque l’application SimpleClock s’exécute, elle appelle la méthode 
() toutes les secondes, comme suit :
/**
 * Appel effectué par le conteneur parent lors du dessin de l’affichage.
 */
public override function draw():void
{
// Stocke la date et l’heure actuelle dans une variable d’instance
currentTime = new Date();
showTime(currentTime);
}
Exemple : une horloge analogique simple
215

Cette méthode enregistre l’heure actuelle dans une variable, pour que l’heure ne puisse 
changer pendant le dessin des aiguilles de l’horloge. Elle appelle ensuite la méthode 
showTime() pour afficher les aiguilles, comme illustré ci-après :
/**
 * Affiche la date et l’heure indiquée sur une horloge analogique des plus 
classiques.
 */
public function showTime(time:Date):void 
{
// Obtient les valeurs temporelles
var seconds:uint = time.getSeconds();
var minutes:uint = time.getMinutes();
var hours:uint = time.getHours();
// Multiplie par 6 pour obtenir les degrés
this.secondHand.rotation = 180 + (seconds * 6);
this.minuteHand.rotation = 180 + (minutes * 6);
// Multiplie par 30 pour obtenir les degrés de base, puis
// ajoute à 29,5 degrés (59 * 0.5)
// pour tenir compte des minutes.
this.hourHand.rotation = 180 + (hours * 30) + (minutes * 0.5);
}
Tout d’abord, cette méthode extrait les valeurs des heures, des minutes et des secondes pour 
l’heure actuelle. Elle utilise ensuite ces valeurs pour calculer l’angle de chaque aiguille. Comme 
l’aiguille des secondes effectue une rotation complète en 60 secondes, elle tourne de 6 degrés 
par seconde (360/60). L’aiguille des minutes pivote selon le même angle chaque minute.
L’aiguille des heures se met à jour toutes les minutes également et doit donc progresser à 
chaque minute. Elle tourne de 30 degrés toutes les heures (360/12), mais pivote également 
d’un demi-degré toutes les minutes (30 degrés divisés par 60 minutes). 
216
Utilisation des dates et heures

CHAPITRE 6
Utilisation des chaînes
6
La classe String contient des méthodes qui permettent de manipuler des chaînes de texte. 
Les chaînes s’utilisent avec de nombreux objets. Les méthodes décrites dans le présent chapitre 
sont utiles pour manipuler des chaînes dans des objets tels que TextField, StaticText, XML, 
ContextMenu, et FileReference.
Les chaînes sont des séquences de caractères. ActionScript 3.0 prend en charge les caractères 
ASCII et Unicode. 
Sommaire
Principes de base des chaînes  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Création de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  220
La propriété length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Utilisation de caractères dans des chaînes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .222
Comparaison de chaînes  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .223
Récupération des représentations de chaîne d’autres objets. . . . . . . . . . . . . . . . . .223
Concaténation de chaînes  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .224
Recherche de sous-chaînes et de motifs dans des chaînes . . . . . . . . . . . . . . . . . . .225
Conversion de la casse dans des chaînes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  230
Exemple : ASCII art  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
217

Principes de base des chaînes
Introduction à l’utilisation des chaînes
Pour les programmeurs, une « chaîne » est un texte, une suite de lettres, chiffres ou autres 
caractères qui se suivent et forment une unité représentée par une valeur. Par exemple, la ligne 
de code suivante crée une variable ayant le type de données String (chaîne) et affecte une 
valeur de chaîne littérale à cette variable :
var albumName:String = "Three for the money";
Comme le montre cet exemple, ActionScript permet de délimiter une valeur chaîne en 
enfermant du texte entre des guillemets droits doubles ou simples. Voici d’autres exemples de 
chaînes :
"Hello"
"555-7649"
";
Lorsque vous manipulez un fragment de texte en ActionScript, vous utilisez une valeur 
chaîne. La classe String d’ActionScript est le type de données qui permet de travailler avec du 
texte. Des instances de chaînes sont fréquemment utilisées pour des propriétés, des paramètres 
de méthodes, etc., dans de nombreuses autres classes en ActionScript.
Tâches courantes de manipulation des chaînes 
de texte
Voici quelques tâches courantes relatives aux chaînes de texte qui sont présentées dans ce 
chapitre :
?
Création d’objets String
?
Utilisation de caractères spéciaux (sauts de ligne, tabulations et caractères absents du 
clavier)
?
Mesure de la longueur des chaînes
?
Séparation de caractères individuels au sein d’une chaîne
?
Concaténation de chaînes
?
Comparaison de chaînes
?
Recherche, extraction et remplacement de parties d’une chaîne
?
Mise en majuscule ou minuscule de chaînes entières
218
Utilisation des chaînes

Concepts importants et terminologie
La liste de référence suivante énumère les termes importants que vous rencontrerez dans ce 
chapitre :
?
ASCII : système de codage permettant de représenter du texte sous forme de caractères et 
symboles dans les programmes informatiques. Le système ASCII gère les 26 lettres de 
l’alphabet latin, plus un nombre limité de caractères supplémentaires.
?
Caractère : unité de base d’un texte (lettre ou symbole).
?
Concaténation : ajout bout à bout de plusieurs valeurs de chaîne pour en créer une 
nouvelle.
?
Chaîne vide : chaîne qui ne contient rien : ni texte, ni espace, ni autre caractère, 
représentée par "". Une chaîne vide n’est pas la même chose qu’une variable ayant une 
valeur nulle (null) : celle-ci est une variable à laquelle aucune instance de l’objet String 
n’est affectée, alors qu’une chaîne vide est une instance dont la valeur ne contient aucun 
caractère.
?
Chaîne : valeur textuelle (séquence de caractères).
?
Littéral chaîne : valeur chaîne écrite explicitement en code, sous forme d’une valeur texte 
encadrée par des guillemets droits simples ou doubles.
?
Sous-chaîne : définit une chaîne qui est une partie d’une autre chaîne.
?
Unicode : système standardisé de codage permettant de représenter du texte sous forme de 
caractères et symboles dans les programmes informatiques. Le système Unicode permet 
d’utiliser la totalité des caractères de toutes les langues écrites existantes.
Utilisation des exemples des chapitres
Au fur et à mesure que vous avancez dans le chapitre, vous pouvez tester des exemples de code. 
Les exemples de code de ce chapitre portant essentiellement sur la manipulation de texte, il est 
nécessaire de voir les valeurs des variables utilisées dans ces exemples pour tester ces derniers, 
en transmettant ces valeurs soit à une instance de champ texte sur la scène, soit au panneau de 
sortie en utilisant la fonction trace(). Ces techniques sont décrites dans la section exemples de code contenus dans un chapitre », à la page 67.
Principes de base des chaînes
219

Création de chaînes
La classe String sert à représenter des données de chaîne (textuelles) en ActionScript 3.0. 
Les chaînes ActionScript 3.0 prennent en charge les caractères ASCII et Unicode. La meilleure 
façon de créer une chaîne est d’utiliser un littéral de chaîne. Pour déclarer un littéral de chaîne, 
utilisez les guillemets droits doubles (") ou les guillemets droits simples (’). Par exemple, les 
deux chaînes suivantes sont équivalentes :
var str1:String = "hello";
var str2:String = 'hello';
Vous pouvez également déclarer une chaîne àl’aide de l’opérateur new, comme suit :
var str1:String = new String("hello");
var str2:String = new String(str1);
var str3:String = new String();
// str3 == ""
Les deux chaînes suivantes sont équivalentes :
var str1:String = "hello"; 
var str2:String = new String("hello");
Pour utiliser des guillemets droits simples (’) dans un littéral chaîne délimité par des 
guillemets droits simples (’), utilisez le caractère d’échappement (\). De même, pour utiliser 
des guillemets droits doubles (’’) dans un littéral chaîne délimité par des guillemets droits 
doubles (’’), utilisez le caractère d’échappement (\). Les deux chaînes suivantes sont 
équivalentes : 
var str1:String = "That's \"A-OK\"";
var str2:String = 'That\'s "A-OK"';
Vous pouvez utiliser des guillemets simples ou des guillemets doubles en fonction de ceux qui 
existent dans un littéral chaîne, comme dans l’exemple suivant :
var str1:String = "ActionScript <span class='heavy'>3.0</span>";
var str2:String = '<item id="155">banana</item>';
Nous vous rappelons qu’ActionScript fait la distinction entre les guillemets simples droits (’) 
et les guillemets simples gauches ou droits (‘ ou ’). Il en est de même pour les guillemets 
doubles. Utilisez des guillemets droits pour délimiter des littéraux de chaîne. Lorsque vous 
collez du texte dans ActionScript depuis une autre source, utilisez les caractères corrects.
220
Utilisation des chaînes

Comme indiqué dans le tableau suivant, vous pouvez utiliser le caractère d’échappement (\) 
pour définir d’autres caractères dans des littéraux chaîne : 
Séquence 
Caractère
d’échappement
\b
Retour arrière
\f
Changement de page
\n
Nouvelle ligne
\r
Retour chariot
\t
Tabulation
\unnnn
Le caractère Unicode ayant le code de caractère spécifié par le 
nombre hexadécimal nnnn ; par exemple, \u263a est le caractère 
smiley.
\xnn
Le caractère ASCII dont le code est spécifié par le nombre 
hexadécimal nn. 
\’
Guillemet droit simple
\"
Guillemet droit double
\\
Barre oblique inversée
La propriété length
Chaque chaîne possède une propriété length correspondant au nombre de caractères qu’elle 
contient :
var str:String = "Adobe";
trace(str.length);
// résultat : 5
Une chaîne vide et une chaîne null ont toutes deux une longueur de 0, comme l’indique 
l’exemple suivant :
var str1:String = new String();
trace(str1.length);
// résultat : 0
str2:String = '';
trace(str2.length);
// résultat : 0
La propriété length
221

Utilisation de caractères dans des 
chaînes
Chaque caractère d’une chaîne possède une position d’index dans la chaîne (un entier). 
La position d’index du premier caractère est 0. Par exemple, dans la chaîne suivante, le 
caractère y occupe la position 0 et le caractère w occupe la position 5 :
"yellow"
Vous pouvez examiner des caractères individuels à différentes positions d’une chaîne à l’aide 
de la méthode charAt() et de la méthode charCodeAt(), comme dans l’exemple suivant :
var str:String = "hello world!";
for (var:i = 0; i < str.length; i++)
{
trace(str.charAt(i), "-", str.charCodeAt(i));
}
Lorsque vous exécutez ce code, vous obtenez le résultat suivant :
h - 104
e - 101
l - 108
l - 108
o - 111
  - 32
w - 119
o - 111
r - 114
l - 108
d - 100
! - 33 
Vous pouvez également utiliser les codes de caractère pour définir une chaîne à l’aide de la 
méthode fromCharCode(), comme l’indique l’exemple suivant :
var myStr:String = 
String.fromCharCode(104,101,108,108,111,32,119,111,114,108,100,33);
// Définition de myStr comme "hello world!"
222
Utilisation des chaînes

Comparaison de chaînes
Vous pouvez utiliser les opérateurs suivants pour comparer des chaînes : <, <=, !=, ==, =>, et >. 
Vous pouvez utiliser ces opérateurs avec des instructions conditionnelles (if et while, par 
exemple) comme l’indique l’exemple suivant : 
var str1:String = "Apple";
var str2:String = "apple";
if (str1 < str2)
{
trace("A < a, B < b, C < c, ");
}
Lorsque vous utilisez ces opérateurs avec des chaînes, ActionScript considère la valeur du code 
de chaque caractère dans la chaîne, en comparant les caractères de gauche à droite, comme 
indiqué ci-dessous :
trace("A" < "B"); // true
trace("A" < "a"); // true 
trace("Ab" < "az"); // true 
trace("abc" < "abza"); // true
Utilisez les opérateurs == et != pour comparer des chaînes entre elles et pour comparer des 
chaînes avec d’autres types d’objets, comme l’indique l’exemple suivant :
var str1:String = "1";
var str1b:String = "1";
var str2:String = "2";
trace(str1 == str1b); // true
trace(str1 == str2); // false
var total:uint = 1;
trace(str1 == total); // true
Récupération des représentations de 
chaîne d’autres objets
Vous pouvez obtenir une représentation de chaîne de n’importe quel type d’objet. Tous les 
objets disposent en effet d’une méthode toString() :
var n:Number = 99.47;
var str:String = n.toString();
// str == "99.47"
Lorsque vous utilisez l’opérateur de concaténation + avec une combinaison d’objet String et 
d’objets qui ne sont pas des chaînes, vous n’avez pas besoin d’utiliser la méthode toString(). 
Pour plus d’informations sur la concaténation, consultez la section suivante.
La fonction globale String() renvoie la même valeur pour un objet donné que la valeur 
renvoyée par l’objet appelant la méthode toString().
Récupération des représentations de chaîne d’autres objets
223

Concaténation de chaînes
La concaténation de chaînes consiste àprendre deux chaînes et à les combiner en une seule 
chaîne de façon séquentielle. Par exemple, vous pouvez utiliser l’opérateur + pour 
concaténer deux chaînes :
var str1:String = "green";
var str2:String = "ish";
var str3:String = str1 + str2; // str3 == "greenish"
Vous pouvez également utiliser l’opérateur += pour obtenir le même résultat, comme dans 
l’exemple suivant :
var str:String = "green";
str += "ish"; // str == "greenish"
En outre, la classe String comprend une méthode concat(), utilisable comme suit :
var str1:String = "Bonjour";
var str2:String = "from";
var str3:String = "Paris";
var str4:String = str1.concat(" ", str2, " ", str3);
// str4 == "Bonjour from Paris"
Si vous utilisez l’opérateur + (ou l’opérateur +=) avec un objet String et un objet qui n’est pas 
une chaîne, ActionScript convertit automatiquement ce dernier en un objet String afin 
d’évaluer l’expression, comme indiqué dans l’exemple :
var str:String = "Area = ";
var area:Number = * (3, 2);
str = str + area; // str == "Area = 28.274333882308138"
Néanmoins, vous pouvez utiliser des parenthèses pour le regroupement afin de fournir un 
contexte à l’opérateur +, comme indiqué dans l’exemple suivant :
trace("Total: $" + 4.55 + 1.45); // résultat : Total : $4.551.45
trace("Total: $" + (4.55 + 1.45)); // résultat : Total : $6
224
Utilisation des chaînes

Recherche de sous-chaînes et de motifs 
dans des chaînes
Les sous-chaînes sont des caractères consécutifs à l’intérieur d’une chaîne. Par exemple, la 
chaîne "abc" possède les sous-chaînes suivantes : "", "a", "ab", "abc", "b", "bc", "c". 
Vous pouvez utiliser des méthodes ActionScript pour localiser les sous-chaînes d’une chaîne.
Les modèles sont définis en ActionScript par des chaînes ou par des expressions régulières. 
Par exemple, l’expression régulière suivante définit un modèle spécifique—les lettres A, B, et 
C suivies d’un chiffre (les barres de fraction sont des délimiteurs d’expression régulière) :
/ABC\d/
ActionScript comporte des méthodes servant à rechercher des motifs dans des chaînes et à 
remplacer les correspondances trouvées par des sous-chaînes de substitution. Ces méthodes 
sont décrites dans les sections suivantes.
Les expressions régulières peuvent définir des modèles compliqués. Pour plus d’informations, 
consultez la section Chapitre 9, « Utilisation d’expressions régulières », à la page 305.
Recherche d’une sous-chaîne par la position d’un 
caractère
Les méthodes substr() et substring() sont identiques. Elles renvoient toutes les deux une 
sous-chaîne d’une chaîne. Elles prennent deux paramètres. Dans les deux méthodes, le 
premier paramètre est la position du caractère initial dans la chaîne concernée. Toutefois, dans 
la méthode substr(), le deuxième paramètre est la longueur de la sous-chaîne à renvoyer, 
alors que dans la méthode substring(), le deuxième paramètre est la position du caractère 
final de la sous-chaîne (qui ne figure pas dans la chaîne renvoyée). Cet exemple illustre la 
différence entre ces deux méthodes : 
var str:String = "Hello from Paris, Texas!!!";
trace(str.substr(11,15)); // résultat : Paris, Texas!!!
trace(str.substring(11,15)); // résultat : Pari
Recherche de sous-chaînes et de motifs dans des chaînes
225

La méthode slice() fonctionne de la même façon que la méthode substring(). Lorsque 
deux nombres entiers non négatifs sont passés en paramètres, son fonctionnement est 
identique. Néanmoins, la méthode slice() peut recevoir des entiers négatifs comme 
paramètres. Dans ce cas, la position des caractères est comptée à partir de la fin de la chaîne, 
comme dans l’exemple suivant :
var str:String = "Hello from Paris, Texas!!!";
trace(str.slice(11,15)); // résultat : Pari
trace(str.slice(-3,-1)); // résultat : !!
trace(str.slice(-3,26)); // résultat : !!!
trace(str.slice(-3,str.length)); // résultat : !!!
trace(str.slice(-8,-3)); // résultat : Texas
Vous pouvez associer des entiers positifs et négatifs comme paramètres de la méthode 
slice().
Recherche de la position des caractères d’une sous-
chaîne correspondante
Vous pouvez utiliser les méthodes indexOf() et lastIndexOf() pour localiser des sous-
chaînes correspondantes au sein d’une chaîne, comme dans l’exemple suivant :
var str:String = "The moon, the stars, the sea, the land";
trace(str.indexOf("the")); // résultat : 10
La méthode indexOf() est sensible à la casse.
Vous pouvez spécifier un deuxième paramètre pour indiquer la position de l’index dans la 
chaîne à partir de laquelle commencer la recherche, comme suit :
var str:String = "The moon, the stars, the sea, the land"
trace(str.indexOf("the", 11)); // résultat : 21
La méthode lastIndexOf() trouve la dernière occurrence d’une sous-chaîne dans la chaîne :
var str:String = "The moon, the stars, the sea, the land"
trace(str.lastIndexOf("the")); // résultat : 30
Si vous incluez un deuxième paramètre avec la méthode lastIndexOf(), la recherche est 
effectuée à l’envers à partir de cette position d’index dans la chaîne (de droite à gauche) :
var str:String = "The moon, the stars, the sea, the land"
trace(str.lastIndexOf("the", 29)); // résultat : 21
226
Utilisation des chaînes

Création d’un tableau de sous-chaînes segmenté par 
un délimiteur
Vous pouvez utiliser la méthode split() pour créer un tableau de sous-chaînes divisé en 
fonction d’un caractère délimiteur. Par exemple, vous pouvez segmenter une chaîne séparée 
par des virgules ou des tabulations en plusieurs chaînes.
L’exemple suivant indique comment diviser un tableau en sous-chaînes avec le caractère 
esperluette (&) comme délimiteur :
var queryStr:String = "first=joe&last=cheng&title=manager&StartDate=3/6/
65";
var params:Array = queryStr.split("&", 2); 
// params == ["first=joe","last=cheng"]
Le deuxième paramètre de la méthode split() (qui est facultatif ) définit la taille maximale 
du tableau renvoyé.
Vous pouvez également utiliser une expression régulière comme caractère délimiteur : 
var str:String = "Give me\t5."
var a:Array = str.split(/\s+/); // a == ["Give","me","5."]
Pour plus d’informations, voir page 305 et Référence du langage et des composants ActionScript 3.0.
Recherche de modèles dans des chaînes et 
remplacement de sous-chaînes
La classe String comprend les méthodes suivantes pour utiliser des modèles dans des chaînes :
?
Utilisez les méthodes match() et search() pour localiser des sous-chaînes qui 
correspondent à un modèle.
?
Utilisez la méthode replace() pour rechercher des sous-chaînes qui correspondent à un 
modèle et les remplacer par une sous-chaîne spécifiée.
Ces méthodes sont décrites dans les sections suivantes.
Vous pouvez utiliser des chaînes ou des expressions régulières pour définir des modèles utilisés 
dans ces méthodes. Pour plus d’informations sur les expressions régulières, voir « Utilisation d’expressions régulières », à la page 305.
Recherche de sous-chaînes et de motifs dans des chaînes
227

Recherche de sous-chaînes correspondantes
La méthode search() renvoie la position de l’index de la première sous-chaîne qui 
correspond Ã un modèle donné, comme illustré dans cet exemple :
var str:String = "The more the merrier.";
// (Cette recherche est sensible Ã la casse.)
trace(str.search("the")); // résultat : 9 
Vous pouvez également utiliser des expressions régulières pour définir le modèle pour lequel 
établir une correspondance, comme illustré dans cet exemple :
var pattern:RegExp = /the/i;
var str:String = "The more the merrier.";
trace(str.search(pattern)); // 0
Le résultat de la méthode trace() est 0, car le premier caractère dans la chaîne est la position 
de l’index 0. L’indicateur i est défini dans l’expression régulière. Par conséquent, la recherche 
n’est pas sensible à la casse.
La méthode search() trouve une seule correspondance et renvoie sa position d’index de 
début, même si l’indicateur g (global) est défini dans l’expression régulière.
L’exemple suivant présente une expression régulière plus compliquée qui correspond à une 
chaîne dans des guillemets doubles :
var pattern:RegExp = /"[^"]*"/;
var str:String = "The \"more\" the merrier.";
trace(str.search(pattern)); // résultat : 4
str = "The \"more the merrier.";
trace(str.search(pattern)); // résultat : -1 
// (Indique aucune correspondance, car il n’existe aucun guillemet 
// double de fermeture.)
La méthode match() fonctionne de façon identique. Elle recherche une sous-chaîne 
correspondante. Néanmoins, lorsque vous utilisez l’indicateur global dans un modèle 
d’expression régulière (comme dans l’exemple suivant), match() renvoie un tableau de sous-
chaînes correspondantes :
var str:String = ", ";
var pattern:RegExp = /\w*@\w*\.[org|com]+/g;
var results:Array = str.match(pattern);
Le tableau results est défini comme suit :
["",""]
Pour plus d’informations sur les expressions régulières, vd’expressions régulières », à la page 305.
228
Utilisation des chaînes

Remplacement de sous-chaînes mises en correspondance
Vous pouvez utiliser la méthode replace() pour rechercher un modèle spécifié dans une 
chaîne et remplacer les correspondances par la chaîne de remplacement spécifiée, comme 
illustré dans l’exemple suivant : 
var str:String = "She sells seashells by the seashore.";
var pattern:RegExp = /sh/gi;
trace(str.replace(pattern, "sch"));
//sche sells seaschells by the seaschore. 
Dans cet exemple, les chaînes mises en correspondance ne sont pas sensibles àla casse car 
l’indicateur i (ignoreCase) est défini dans l’expression régulière, et plusieurs correspondances 
sont remplacées car l’indicateur g (global) est défini. Pour plus d’informations, consultez la 
section Chapitre 9, « Utilisation d’expressions régulières », à la page 305.
Vous pouvez inclure les codes de remplacement $ suivants dans la chaîne de remplacement. 
Le texte de remplacement indiqué dans le tableau suivant est inséré à la place du code de 
remplacement $ :
Code $
Texte de remplacement
$$
$
$&
La sous-chaîne correspondante.
$`
La partie de la chaîne qui précède la sous-chaîne correspondante. 
Ce code utilise les guillemets simples droits gauches (`) et non les 
guillemets simples droits (’) ni les guillemets simples anglais gauches 
(‘).
$’
La partie de la chaîne qui suit la sous-chaîne correspondante. Ce code 
utilise les guillemets simples droits (’).
$n
Le nième groupe entre parenthèses correspondant capturé, où est un 
chiffre compris entre 1 et 9 et $n’est pas suivi d’une décimale. 
$nn
Le nnième groupe entre parenthèses correspondant capturé, où nn 
est un nombre décimal à deux chiffres compris entre 01 et 99. Si la 
nnième capture n’est pas définie, le texte de remplacement est une 
chaîne vide. 
L’exemple suivant illustre l’utilisation des codes de remplacement $2 et $1, qui représentent le 
premier et le deuxième groupes capturés correspondants :
var str:String = "flip-flop";
var pattern:RegExp = /(\w+)-(\w+)/g;
trace(str.replace(pattern, "$2-$1")); // flop-flip
Recherche de sous-chaînes et de motifs dans des chaînes
229

Vous pouvez également utiliser une fonction comme deuxième paramètre de la méthode 
replace(). Le texte correspondant est remplacé par la valeur renvoyée de la fonction.
var str:String = "Now only $9.95!";
var price:RegExp = /\$([\d,]+.\d+)+/i;
trace(str.replace(price, usdToEuro));
function usdToEuro(matchedSubstring:String, 
 capturedMatch1:String, 
 index:int, 
 str:String):String
{
var usd:String = capturedMatch1;
usd = usd.replace(",", "");
var exchangeRate:Number = 0.853690;
var euro:Number = usd * exchangeRate;
const euroSymbol:String = String.fromCharCode(8364);
return euro.toFixed(2) + " " + euroSymbol;
}
Lorsque vous utilisez une fonction comme deuxième paramètre de la méthode replace(), les 
arguments suivants sont transmis à la fonction :
?
La partie correspondante de la chaîne.
?
Tout groupe entre parenthèses capturé correspondant. Le nombre d’arguments transmis 
de cette façon varie selon le nombre de correspondances entre parenthèses. Pour 
déterminer ce dernier, vérifiez arguments.length - 3 dans le code de la fonction.
?
La position d’index dans la chaîne où débute la correspondance.
?
La chaîne complète.
Conversion de la casse dans des chaînes
Comme illustré dans l’exemple suivant, la méthode toLowerCase() et la méthode 
toUpperCase() convertissent les caractères alphabétiques dans la chaîne en minuscules et en 
majuscules, respectivement :
var str:String = "Dr. Bob Roberts, #9."
trace(str.toLowerCase()); // dr. bob roberts, #9.
trace(str.toUpperCase()); // DR. BOB ROBERTS, #9.
Une fois que ces méthodes sont exécutées, la chaîne source reste inchangée. Pour transformer 
la chaîne source, utilisez le code suivant :
str = str.toUpperCase();
Ces méthodes fonctionnent avec des caractères étendus, pas simplement a–z et A–Z :
var str:String = "José Barça";
trace(str.toUpperCase(), str.toLowerCase()); // JOSÉ BARÇA josé barça
230
Utilisation des chaînes

Exemple : ASCII art
Cet exemple ASCII Art représente différentes façons d’utiliser la classe String dans 
ActionScript 3.0, notamment : 
?
La méthode split() de la classe String est utilisée pour extraire des valeurs d’une chaîne 
séparée par des caractères (informations d’image dans un fichier texte séparé par des 
tabulations).
?
Plusieurs techniques de manipulation de chaînes, y compris split(), la concaténation et 
l’extraction d’une partie de la chaîne à l’aide de substring() et de substr(), sont 
utilisées pour mettre la première lettre de chaque mot dans les titres d’image en majuscule.
?
La méthode getCharAt() est utilisée pour obtenir un seul caractère à partir d’une chaîne 
(pour déterminer le caractère ASCII correspondant à une valeur bitmap d’échelle de gris).
?
La concaténation de chaîne est utilisée pour construire la représentation ASCII art d’une 
image, un caractère à la fois.
Le terme ASCII art fait référence à des représentations textuelles d’une image dans lesquelles 
une grille de polices de caractères à espacement constant (caractères Courier New, par 
exemple) trace l’image. L’image suivante est un exemple d’ASCII art produit par l’application : 
La version ASCII art du graphique est illustrée à droite.
Exemple : ASCII art
231

Pour obtenir les fichiers de cet exemple d’application, learn_programmingAS3samples_flash_fr. Les fichiers d’application ASCIIArt se trouvent 
dans le dossier Samples/AsciiArt. L’application se compose des fichiers suivants :
Fichier
Description

Fichier d’application principal en FLA pour 
ou
Flash ou en MXML pour Flex

com/example/programmingas3/asciiArt/
La classe qui fournit la fonctionnalité principale 

de l’application, notamment l’extraction de 
métadonnées d’image d’un fichier de texte, le 
chargement des images et la gestion du 
processus de conversion d’image en texte.
com/example/programmingas3/asciiArt/
Une classe qui fournit la méthode 

parseBitmapData() pour convertir des données 
d’image dans une version String.
com/example/programmingas3/asciiArt/
Une classe qui représente une image bitmap 

chargée.
com/example/programmingas3/asciiArt/
Une classe représentant des métadonnées pour 

une image ASCII art (titre, URL de fichier image, 
etc.).
image/
Un dossier contenant des images utilisées par 
l’application.

Un fichier de texte séparé par des tabulations et 
contenant des informations sur les images à 
charger par l’application.
Extraction de valeurs séparées par des tabulations
Cet exemple utilise le stockage séparé de données d’application par rapport à l’application ; de 
cette façon, si les données changent (par exemple, si une autre image est ajoutée ou que le titre 
d’une image change), il est inutile de recréer le fichier SWF. Dans ce cas, les métadonnées 
d’image, y compris le titre de l’image, l’URL du fichier d’image réel et certaines valeurs 
utilisées pour manipuler l’image, sont stockés dans un fichier de texte (le fichier txt/
dans le projet). Le contenu du fichier de texte est le suivant :
FILENAMETITLEWHITE_THRESHHOLDBLACK_THRESHHOLD
FruitBasket.jpgPear, apple, orange, and bananad810
picture of a bananaC820
Orange.jpgorangeFF20
Apple.jpgpicture of an apple6E10
232
Utilisation des chaînes

Le fichier utilise un format séparé par des tabulations spécifique. La première ligne est une 
ligne d’en-tête. Les lignes restantes contiennent les données suivantes pour chaque bitmap à 
charger :
?
Le nom de fichier du bitmap.
?
Le nom d’affichage du bitmap.
?
Les valeurs de seuil du blanc et les valeurs de seuil du noir pour les bitmaps. Il s’agit de 
valeurs hexadécimales en dessous desquelles un pixel doit être considéré comme 
totalement blanc ou totalement noir.
Dès que l’application démarre, la classe AsciiArtBuilder se charge et analyse le contenu du 
fichier de texte afin de créer la « pile » d’images qu’elle chargera. Pour cela, elle utilise le code 
suivant de la méthode parseImageInfo() de la classe AsciiArtBuilder :
var lines:Array = .split("\n");
var numLines:uint = lines.length;
for (var i:uint = 1; i < numLines; i++)
{
var imageInfoRaw:String = lines[i];

if (imageInfoRaw.length > 0)
{
// Création d’un enregistrement d’informations d’image et ajout 
// au tableau des informations d’image.
var imageInfo:ImageInfo = new ImageInfo();
// Division de la ligne actuelle en valeurs (séparée par des 
// tabulations (\t)) et extraction des propriétés individuelles :
var imageProperties:Array = imageInfoRaw.split("\t");
imageInfo.fileName = imageProperties[0];
imageInfo.title = normalizeTitle(imageProperties[1]);
imageInfo.whiteThreshold = parseInt(imageProperties[2], 16);
imageInfo.blackThreshold = parseInt(imageProperties[3], 16);
(imageInfo);
}
}
Le contenu entier du fichier de texte se trouve dans une seule instance String, la propriété 
. Vous pouvez utiliser la méthode split() avec le caractère de 
nouvelle ligne ("\n") comme paramètre pour diviser l’instance String en un tableau (lines) 
dont les éléments sont les lignes individuelles du fichier de texte. Le code utilise ensuite une 
boucle pour travailler avec chacune des lignes (excepté la première car elle contient 
uniquement des en-têtes). A l’intérieur de la boucle, la méthode split() est de nouveau 
utilisée pour diviser le contenu de la ligne en un ensemble de valeurs (l’objet Array appelé 
imageProperties). Le paramètre utilisé avec la méthode split() dans ce cas est le caractère 
de tabulation ("\t") car les valeurs dans chaque ligne sont délimitées par des tabulations.
Exemple : ASCII art
233

Utilisation de méthodes String pour normaliser des 
titres d’image
Dans cette application, tous les titres d’image sont affichés à l’aide d’un format standard, avec 
la première lettre de chaque mot en majuscule (excepté quelques mots qui ne sont 
généralement pas en majuscule dans des titres anglais). Au lieu de considérer que le fichier de 
texte contient des titres formatés correctement, l’application formate les titres lors de leur 
extraction du fichier de texte.
Dans la liste de code précédente, lors de l’extraction de valeurs de métadonnées d’image 
individuelles, la ligne de code suivante est utilisée :
imageInfo.title = normalizeTitle(imageProperties[1]);
Dans ce code, le titre de l’image issu du fichier de texte est transféré au moyen de la méthode 
normalizeTitle() avant d’être stocké dans l’objet ImageInfo :
private function normalizeTitle(title:String):String
{
var words:Array = title.split(" ");
var len:uint = words.length;
for (var i:uint; i < len; i++)
{
words[i] = capitalizeFirstLetter(words[i]);
}
return (" ");
}
Cette méthode utilise la méthode split() pour diviser le titre en deux mots (séparés par le 
caractère d’espacement), transfère chaque mot au moyen de la méthode 
capitalizeFirstLetter() puis utilise join() de la classe Array pour combiner de nouveau 
les mots en une chaîne unique.
234
Utilisation des chaînes

Comme son nom l’indique, la méthode capitalizeFirstLetter() met la première lettre de 
chaque mot en majuscule :
/**
 * Met la première lettre d’un mot en majuscule, à moins qu’il s’agisse d’
 * ensemble de mots qui ne sont normalement pas en majuscules en anglais.
 */
private function capitalizeFirstLetter(word:String):String
{
switch (word)
{
case "and":
case "the":
case "in":
case "an":
case "or":
case "at":
case "of":
case "a":
// Ne pas modifier ces mots.
break;
default:
// Pour tous les autres mots, mettre le premier caractère 
// en majuscule.
var firstLetter:String = word.substr(0, 1);
firstLetter = firstLetter.toUpperCase();
var otherLetters:String = word.substring(1);
word = firstLetter + otherLetters;
}
return word;
}
En anglais, le premier caractère de chaque mot d’un titre n’est pas en majuscule s’il s’agit d’un 
des  mots  suivants :  « and, »  « the, »  « in, »  « an, »  « or, »  « at, »  « of, »  ou  « a »  (il  s’agit  d’une 
version simplifiée des règles). Pour exécuter cette logique, le code utilise d’abord une 
instruction switch pour vérifier si le mot est l’un des mots ne devant pas être en majuscule. 
Si c’est le cas, le code sort de l’instruction switch. Si le mot doit être en majuscule, la 
procédure comprend plusieurs étapes :
1.
La première lettre du mot est extraite à l’aide de substr(0, 1), qui extraie une sous-chaîne 
commençant par le caractère au niveau de l’index 0 (la première lettre dans la chaîne, 
comme indiqué par le premier paramètre 0). La sous-chaîne contiendra un caractère 
(indiqué par le deuxième paramètre 1).
2. Ce caractère est mis en majuscule à l’aide de la méthode toUpperCase().
Exemple : ASCII art
235

3. Les caractères restants du mot d’origine sont extraits à l’aide de substring(1), qui extraie 
une sous-chaîne commençant à l’index 1 (la deuxième lettre) jusqu’à la fin de la chaîne 
(indiqué en laissant le deuxième paramètre de la méthode substring()).
4. Le dernier mot est créé en combinant la première lettre mise en majuscule et les lettres 
restantes en utilisant la concaténation de chaîne : firstLetter + otherLetters.
Génération du texte ASCII art
La classe BitmapToAsciiConverter permet de convertir une image bitmap en sa représentation 
de texte ASCII. Cette procédure est effectuée par la méthode parseBitmapData(), 
partiellement représentée ici :
var result:String = "";
// Boucle sur les lignes de pixels de haut en bas :
for (var y:uint = 0; y < _data.height; y += verticalResolution)
{
// Dans chaque ligne, boucle sur les pixels de gauche à droite :
for (var x:uint = 0; x < _data.width; x += horizontalResolution)
{

// Conversion des valeurs de gris dans la plage 0-255 en une valeur
// comprise entre 0 et 64 (car il s’agit du nombre de nuances de
// gris dans le jeu de caractères disponibles) :
index = Math.floor(grayVal / 4);
result += palette.charAt(index);
}
result += "\n";
}
return result;
236
Utilisation des chaînes

Ce code définit d’abord une instance String nommée result qui sera utilisée pour créer la 
version ASCII art de l’image bitmap. Il effectue ensuite une boucle sur les pixels de l’image 
bitmap source. Il utilise plusieurs techniques de manipulation des couleurs (non décrites ici) 
pour convertir le rouge, le vert et le bleu d’un pixel en une valeur d’échelle de gris (un nombre 
entre 0 et 255). Le code divise ensuite cette valeur par 4 (comme indiqué) pour la convertir en 
une valeur dans l’échelle 0-63, qui est stockée dans la variable index. (L’échelle 0-63 est 
utilisée car la palette des caractères ASCII disponibles utilisée par cette application contient 
64 valeurs.) La palette des caractères est définie en tant qu’instance String dans la classe 
BitmapToAsciiConverter :
// Les caractères sont ordonnés du plus foncé au plus clair, de façon à 
// ce que leur position (index) dans la chaîne corresponde à une valeur 
// de couleur relative (0 = noir).
private static const palette:String = 
"@#$%&8BMW*mwqpdbkhaoQ0OZXYUJCLtfjzxnuvcr[]{}1()|/?Il!i><+_~-;,. ";
Etant donné que la variable index définit le caractère ASCII dans la palette qui correspond au 
pixel actuel dans l’image bitmap, ce caractère est récupéré de la palette String à l’aide de la 
méthode charAt(). Il est ensuite ajouté à l’instance String result au moyen de l’opérateur 
d’affectation de concaténation (+=). En outre, à la fin de chaque ligne de pixels, un caractère 
de nouvelle ligne est concaténé à la fin de l’instance String result afin que la ligne à renvoyer 
crée une ligne de pixels de caractères.
Exemple : ASCII art
237

238
Utilisation des chaînes

CHAPITRE 7
Utilisation de tableaux
7
Les tableaux vous permettent de stocker plusieurs valeurs dans une seule structure de données. 
Vous pouvez utiliser des tableaux indexés simples qui stockent des valeurs à l’aide d’index 
d’entiers ordinaux fixes ou des tableaux associatifs complexes qui stockent des valeurs à l’aide 
de clés arbitraires. Les tableaux peuvent également être multidimensionnels et contenir des 
éléments étant eux-mêmes des tableaux. Ce chapitre décrit comment créer et manipuler 
différents types de tableaux.
Contenu
Principes de base des tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .239
Tableaux indexés  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .242
Tableaux associatifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Tableaux multidimensionnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .256
Clonage de tableaux  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258
Rubriques avancées :. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  259
Exemple : PlayList  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265
Principes de base des tableaux
Introduction à l’utilisation de tableaux
Vous aurez souvent besoin en programmation d’utiliser un ensemble d’éléments plutôt qu’un 
seul objet ; par exemple, dans une application de lecteur de musique, vous pouvez avoir une 
liste de morceaux en attente de lecture. Vous ne souhaitez pas créer une variable séparée pour 
chaque morceau de cette liste. Il serait préférable de rassembler tous les objets Song et de les 
utiliser sous forme de groupe.
239

Un tableau est un élément de programmation qui agit comme conteneur pour un ensemble 
d’éléments (une liste de morceaux, par exemple). La plupart du temps, tous les éléments d’un 
tableau sont des instances de la même classe, mais ceci n’est pas obligatoire dans ActionScript. 
Les éléments individuels d’un tableau sont les éléments du tableau. Un tableau peut être 
comparé à un tiroir classeur pour des variables. Les variables peuvent être ajoutées en tant 
qu’éléments au tableau, comme vous placez un dossier dans le tiroir classeur. Une fois que le 
tiroir contient plusieurs fichiers, vous pouvez utiliser le tableau comme une variable unique 
(comme si vous transportiez le tiroir entier à un autre endroit) ; vous pouvez utiliser les 
variables en tant que groupe (comme si vous recherchiez des informations dans les dossiers en 
les parcourant un à un) ; ou vous pouvez y accéder individuellement (comme si vous ouvriez 
le tiroir et sélectionniez un seul dossier).
Par exemple, imaginez que vous créez une application de lecteur de musique dans laquelle un 
utilisateur peut sélectionner plusieurs morceaux et les ajouter à une liste de lecture. Dans votre 
code ActionScript, vous pouvez avoir une méthode addSongsToPlaylist() qui accepte un 
seul tableau comme paramètre. Peu importe le nombre de morceaux à ajouter à la liste 
(quelques-unes, un grand nombre, ou même une seule), vous devez appeler la méthode 
addSongsToPlaylist() une seule fois, en lui transmettant le tableau contenant les objets 
Song. Dans la méthode addSongsToPlaylist(), vous pouvez utiliser une boucle pour 
parcourir les éléments (morceaux) du tableau un par un et les ajouter à la liste de lecture.
Le type de tableau ActionScript le plus courant est le tableau indexé dans lequel chaque 
élément est stocké dans un emplacement numéroté (appelé index) auquel vous accédez à l’aide 
du numéro (adresse). La classe Array est utilisée pour représenter un tableau indexé. 
Les tableaux indexés répondent à la plupart des besoins en programmation. Un tableau 
multidimensionnel est un tableau indexé dont les éléments sont des tableaux indexés (qui 
contiennent à leur tour d’autres éléments). Son utilisation est spéciale. Le tableau associatif est 
un autre type de tableau. Il utilise une chaîne key au lieu d’un index numérique pour identifier 
des éléments individuels. Pour finir, pour les utilisateurs avancés, ActionScript 3.0 inclut 
également la classe Dictionary, qui représente un dictionnaire—un tableau qui vous permet 
d’utiliser n’importe quel type d’objet comme clé pour faire une distinction entre des éléments.
240
Utilisation de tableaux

Tâches de tableau courantes
Les activités courantes suivantes d’utilisation de tableaux sont décrites dans ce chapitre :
?
Création de tableaux indexés
?
Ajout et suppression d’éléments de tableau
?
Tri d’éléments de tableau
?
Extraction de portions d’un tableau
?
Utilisation de tableaux associatifs et de dictionnaires
?
Utilisation de tableaux multidimensionnels
?
Copie d’éléments de tableau
?
Création d’une sous-classe de tableau
Concepts et termes importants
La liste de référence suivante contient les termes importants que vous rencontrerez dans ce 
chapitre :
?
Tableau : un objet qui sert de conteneur pour regrouper plusieurs objets.
?
Tableau associatif : un tableau qui utilise des clés de chaîne pour identifier des éléments 
individuels.
?
Dictionnaire : un tableau dont les éléments sont constitués de paires d’objets appelées clé 
et valeur. La clé est utilisée à la place d’un index numérique pour identifier un seul 
élément.
?
Elément : un élément unique dans un tableau.
?
Index : l’« adresse » numérique utilisée pour identifier un élément unique dans un tableau 
indexé.
?
Tableau indexé : le type de tableau standard qui stocke chaque élément dans un élément 
numéroté et utilise le numéro (index) pour identifier des éléments individuels.
?
Clé : la chaîne ou objet utilisé pour identifier un seul élément dans un tableau associatif ou 
un dictionnaire.
?
Tableau multidimensionnel : un tableau contenant des éléments qui sont des tableaux 
plutôt que des valeurs uniques.
Principes de base des tableaux
241

Utilisation des exemples fournis dans le chapitre
Au fur et à mesure que vous avancez dans le chapitre, vous pouvez tester des exemples de code. 
Tous les codes de ce chapitre comprennent l’appel de la fonction trace(). Pour tester les 
codes de ce chapitre :
1.
Créez un document Flash vide.
2. Sélectionnez une image-clé dans le scénario.
3. Ouvrez le panneau Actions et copiez le code dans le panneau Script.
4. Exécutez le programme en sélectionnant Contrôle > Tester l’animation.
Les résultats de la fonction trace() s’affichent dans le panneau Sortie.
Ceci ainsi que d’autres techniques de test des codes sont décrits en détail dans exemples de code contenus dans un chapitre », à la page 67.
Tableaux indexés
Les tableaux indexés stockent une série d’une ou de plusieurs valeurs organisées de façon à ce 
que vous puissiez accéder à chaque valeur à l’aide d’une valeur d’entier non signé. 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. Comme l’indique le code suivant, 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 :
// Utilisation du constructeur Array.
var myArray:Array = new Array();
("one");
("two");
("three");
trace(myArray); // résultat : un,deux,trois
// Utilisation du littéral Array.
var myArray:Array = ["one", "two", "three"];
trace(myArray); // résultat : un,deux,trois
La classe Array contient également des propriétés et des méthodes qui permettent de modifier 
des tableaux indexés. Ces propriétés et méthodes s’appliquent de façon quasi exclusive aux 
tableaux indexés plutôt qu’aux tableaux associatifs.
Les tableaux indexés utilisent un entier 32 bits non signé pour le numéro d’index. La taille 
maximale d’un tableau indexé est 232 - 1 ou 4,294,967,295. Si vous tentez de créer un 
tableau plus grand que la taille maximale, une erreur d’exécution se produit.
242
Utilisation de tableaux

Un élément de tableau peut comporter une valeur de n’importe quel type de données. 
ActionScript 3.0 ne prend pas en charge le concept de tableaux typés, ce qui signifie que vous 
ne pouvez pas indiquer que tous les éléments d’un tableau appartiennent à un type de données 
particulier. 
Cette section explique d’abord comment créer puis comment modifier des tableaux indexés en 
utilisant la classe Array. Les méthodes qui permettent de modifier des tableaux sont regroupées 
en trois catégories : comment insérer des élément, comment supprimer des éléments et 
comment trier des tableaux. Un dernier groupe de méthodes considère un tableau existant 
comme en lecture seule ; ces méthodes interrogent simplement des tableaux. Au lieu de 
modifier un tableau existant, les méthodes de requête renvoient toutes un nouveau tableau. 
La section se termine par une discussion sur l’extension de la classe Array.
Création de tableaux
Vous pouvez utiliser la fonction de constructeur Array de trois façons différentes. 
Premièrement, si vous appelez le constructeur sans arguments, vous obtenez un tableau vide. 
Vous pouvez utiliser la propriété length de la classe Array pour vérifier que le tableau ne 
contient aucun élément. Par exemple, le code suivant appelle le constructeur Array sans 
arguments :
var names:Array = new Array();
trace(names.length); // résultat : 0
Deuxièmement, si vous utilisez un nombre comme unique paramètre pour le constructeur 
Array, un tableau de cette longueur est créé, avec chaque valeur d’élément définie sur 
undefined. L’argument doit être un entier non signé compris entre les valeurs 0 et 
4,294,967,295. Par exemple, le code suivant appelle le constructeur Array avec un seul 
argument numérique :
var names:Array = new Array(3);
trace(names.length); // résultat : 3
trace(names[0]); // résultat : undefined
trace(names[1]); // résultat : undefined
trace(names[2]); // résultat : undefined
Troisièmement, si vous appelez le constructeur et transmettez une liste d’éléments comme 
paramètres, un tableau est créé avec des éléments correspondant à chacun des paramètres. 
Le code suivant transmet trois arguments au constructeur Array :
var names:Array = new Array("John", "Jane", "David");
trace(names.length); // résultat : 3
trace(names[0]); // résultat : John
trace(names[1]); // résultat : Jane
trace(names[2]); // résultat : David
Tableaux indexés
243

Vous pouvez également créer des tableaux avec des littéraux de tableau ou des littéraux d’objet. 
Un littéral de tableau peut être affecté directement à une variable de tableau, comme illustré 
dans l’exemple suivant :
var names:Array = ["John", "Jane", "David"];
Insertion d’éléments de tableau
Trois méthodes de la classe Array —push(), unshift(), et splice()—vous permettent 
d’insérer des éléments dans un tableau. La méthode push() ajoute un ou plusieurs éléments à 
la fin d’un tableau. Ainsi, le dernier élément inséré dans le tableau à l’aide de la méthode 
push() aura le numéro d’index le plus élevé. La méthode unshift() insère un ou plusieurs 
éléments au début d’un tableau, qui est toujours au numéro d’index 0. La méthode splice() 
insère des éléments au niveau d’un index spécifié dans le tableau.
L’exemple suivant illustre les trois méthodes. Un tableau appelé planets est créé pour trier les 
noms des planètes par ordre de proximité par rapport au soleil. Premièrement, la méthode 
push() est appelée pour ajouter l’élément initial, Mars. Deuxièmement, la méthode 
unshift() est appelée pour insérer l’élément Mercury. Pour finir, la méthode splice() est 
appelée pour insérer les éléments Venus et Earth après Mercury, mais avant Mars. Le premier 
élément envoyé à splice(), l’entier 1, indique à l’insertion de débuter à l’index 1. 
Le deuxième argument envoyé à splice(), l’entier 0, indique qu’aucun élément ne doit être 
supprimé. Pour finir, les troisième et quatrième arguments envoyés à splice(), Venus et 
Earth, sont les éléments à insérer. 
var planets:Array = new Array();
("Mars");       // contenu du tableau : Mars
planets.unshift("Mercury"); // contenu du tableau : Mercury,Mars
planets.splice(1, 0, "Venus", "Earth");
trace(planets);             // contenu du tableau : Mercury,Venus,Earth,Mars
Les méthodes push() et unshift() renvoient toutes les deux un entier non signé qui 
représente la longueur du tableau modifié. La méthode splice() renvoie un tableau vide 
lorsqu’elle est utilisée pour insérer des éléments, ce qui semble étrange mais compréhensible 
en raison de sa versatilité. Vous pouvez utiliser la méthode splice() non seulement pour 
insérer des éléments dans un tableau, mais également pour en supprimer. Lorsque vous 
l’utilisez pour supprimer des éléments, la méthode splice() renvoie un tableau contenant les 
éléments supprimés.
244
Utilisation de tableaux

Suppression des éléments d’un tableau
Trois des méthodes de la classe Array —pop(), shift(), et splice()—vous permettent de 
supprimer des éléments d’un tableau. La méthode pop() supprime un élément de la fin du 
tableau. En d’autres termes, elle supprime l’élément au niveau du numéro d’index le plus 
élevé. La méthode shift() supprime un élément du début du tableau, ce qui signifie qu’elle 
supprime toujours l’élément au numéro d’index 0. La méthode splice(), qui peut également 
être utilisée pour insérer des éléments, supprime un nombre arbitraire d’éléments en 
commençant au numéro d’index indiqué par le premier argument envoyé à la méthode.
L’exemple suivant utilise les trois méthodes pour supprimer des éléments d’un tableau. 
Un tableau nommé oceans est créé pour stocker les noms des océans. Certains noms dans le 
tableau sont des noms de lacs plutôt que des noms d’océans. Ils doivent donc être supprimés. 
Premièrement, la méthode splice() est utilisée pour supprimer les éléments Aral et 
Superior, et insérer les éléments Atlantic et Indian. Le premier argument envoyé à 
splice(), l’entier 2, indique que l’opération doit commencer par le troisième élément dans la 
liste, qui est à l’index 2. Le deuxième argument, 2, indique que deux éléments doivent être 
supprimés. Les arguments restants, Atlantic et Indian, sont des valeurs à insérer à l’index 2. 
Deuxièmement, la méthode pop() est utilisée pour supprimer le dernier élément dans le 
tableau, Huron. Et troisièmement, la méthode shift() est utilisée pour supprimer le premier 
élément dans le tableau, Victoria.
var oceans:Array = ["Victoria", "Pacific", "Aral", "Superior", "Indian", 
"Huron"];
oceans.splice(2, 2, "Arctic", "Atlantic"); // remplace Aral et Superior
();   // supprime Huron
oceans.shift(); // supprime Victoria
trace(oceans);  // résultat : Pacific,Arctic,Atlantic,Indian
Les méthodes pop() et shift() renvoient toutes les deux l’élément qui a été supprimé. 
Le type de données de la valeur renvoyée est Object car les tableaux peuvent contenir des 
valeurs de n’importe quel type de données. La méthode splice() renvoie un tableau 
contenant les valeurs supprimées. Vous pouvez modifier l’exemple du tableau oceans de façon 
à ce que l’appel à splice() affecte le tableau à une nouvelle variable de tableau, comme 
illustré dans l’exemple suivant :
var lakes:Array = oceans.splice(2, 2, "Arctic", "Atlantic");
trace(lakes); // résultat : Aral,Superior
Tableaux indexés
245

Il se peut que vous rencontriez un code qui utilise l’opérateur delete sur un élément de 
tableau. L’opérateur delete définit la valeur d’un élément de tableau sur undefined, mais il 
ne supprime pas l’élément du tableau. Par exemple, le code suivant utilise l’opérateur delete 
sur le troisième élément dans le tableau oceans, mais la longueur du tableau demeure 5 :
var oceans:Array = ["Arctic", "Pacific", "Victoria", "Indian", "Atlantic"];
delete oceans[2];
trace(oceans);        // résultat : Arctic,Pacific,,Indian,Atlantic
trace(oceans[2]);     // résultat : undefined
trace(oceans.length); // résultat : 5
Vous pouvez tronquer un tableau à l’aide d’une propriété de tableau length Si vous définissez 
la propriété length d’un tableau sur une longueur inférieure à la longueur actuelle du tableau, 
ce dernier est tronqué : tous les éléments stockés aux numéros d’index supérieurs à la nouvelle 
valeur de length moins 1 sont supprimés. Par exemple, si le tableau oceans a été trié de 
façon à ce que toutes les entrées valides se trouvent au début du tableau, vous pouvez utiliser la 
propriété length pour supprimer les entrées à la fin du tableau, comme illustré dans le code 
suivant :
var oceans:Array = ["Arctic", "Pacific", "Victoria", "Aral", "Superior"];
oceans.length = 2;
trace(oceans); // résultat : Arctic,Pacific
Tri d’un tableau
Il existe trois méthodes—reverse(), sort(), et sortOn()—qui vous permettent de 
modifier l’ordre d’un tableau, soit en triant, soit en inversant l’ordre. Toutes ces méthodes 
modifient le tableau existant. La méthode reverse() modifie l’ordre du tableau de telle sorte 
que le dernier élément devient le premier élément, le pénultième le second, etc. La méthode 
sort() vous permet de trier un tableau de différentes façons, et même de créer des 
algorithmes de tri personnalisés. La méthode sortOn() vous permet de trier un tableau 
d’objets indexé ayant une ou plusieurs propriétés en commun qui peuvent être utilisées 
comme clés de tri.
La méthode reverse() ne prend aucun paramètre et ne renvoie aucune valeur mais vous 
permet de faire basculer l’ordre de votre tableau de son état actuel à l’ordre inverse. L’exemple 
suivant inverse l’ordre des océans répertoriés dans le tableau oceans :
var oceans:Array = ["Arctic", "Atlantic", "Indian", "Pacific"];
oceans.reverse();
trace(oceans); // résultat : Pacific,Indian,Atlantic,Arctic
246
Utilisation de tableaux

La méthode sort() réorganise les éléments dans un tableau à l’aide de l’ordre de tri par défaut
L’ordre de tri par défaut a les caractéristiques suivantes :
?
Le tri est sensible à la casse, ce qui signifie que les majuscules précèdent les minuscules. 
Par exemple, la lettre D précède la lettre b. 
?
Le tri est croissant, ce qui signifie que les codes de caractère bas (A, par exemple) précèdent 
les codes de caractère élevés (B, par exemple).
?
Le tri place les valeurs identiques les unes à côté des autres mais sans ordre particulier.
?
Le tri est basé sur des chaînes, ce qui signifie que les éléments sont convertis en chaînes 
avant d’être comparés (par exemple, 10 précède 3 car la chaîne "1" a un code de caractère 
inférieur à celui de la chaîne "3"). 
Vous pouvez trier votre tableau en ignorant la casse, ou par ordre décroissant. Vous pouvez 
également trier les nombres de votre tableau par ordre numérique plutôt que par ordre 
alphabétique. La méthode sort() a un paramètre options qui vous permet de modifier 
chaque caractéristique de l’ordre de tri par défaut. Les options sont définies par un ensemble 
de constantes statiques dans la classe Array, comme indiqué dans la liste suivante :
?
Array.CASEINSENSITIVE : Cette option permet d’ignorer la casse lors du tri. 
Par exemple, la lettre minuscule b précède la lettre majuscule D.
?
Array.DESCENDING : Cette option inverse le tri croissant par défaut. Par exemple, la 
lettre B précède la lettre A. 
?
Array.UNIQUESORT : Cette option permet d’arrêter le tri si deux valeurs identiques sont 
repérées.
?
Array.NUMERIC : Cette option permet d’effectuer un tri numérique, de façon à ce que 3 
précède 10.
L’exemple suivant met en évidence certaines de ces options. Un tableau nommé poets est 
créé. Il est trié à l’aide de plusieurs options différentes.
var poets:Array = ["Blake", "cummings", "Angelou", "Dante"];
(); // tri par défaut
trace(poets); // résultat : Angelou,Blake,Dante,cummings
(Array.CASEINSENSITIVE);
trace(poets); // résultat : Angelou,Blake,cummings,Dante
(Array.DESCENDING);
trace(poets); // résultat : cummings,Dante,Blake,Angelou
(Array.DESCENDING | Array.CASEINSENSITIVE); 
// utilisation de deux options
trace(poets); // résultat : Dante,cummings,Blake,Angelou
Tableaux indexés
247

Vous pouvez également écrire votre fonction de tri personnalisée et la transmettre comme 
paramètre à la méthode sort(). Par exemple, si vous avez une liste de noms dans laquelle 
chaque élément de liste contient le nom entier d’une personne mais que vous souhaitez trier la 
liste par nom de famille, vous devez utiliser une fonction de tri personnalisé pour analyser 
chaque élément et utiliser le nom de famille dans la fonction de tri. Le code suivant indique 
comment procéder avec une fonction personnalisée utilisée comme paramètre pour la 
méthode () :
var names:Array = new Array("John Q. Smith", "Jane Doe", "Mike Jones");
function orderLastName(a, b):int
{
var lastName:RegExp = /\b\S+$/;
var name1 = a.match(lastName);
var name2 = b.match(lastName);
if (name1 < name2)
{
return -1;
}
else if (name1 > name2)
{
return 1;
}
else
{
return 0;
}
}
trace(names); // résultat : John Q. Smith,Jane Doe,Mike Jones
(orderLastName);
trace(names); // résultat : Jane Doe,Mike Jones,John Q. Smith
La fonction de tri personnalisé orderLastName() utilise une expression régulière pour 
extraire le nom de famille de chaque élément à utiliser pour l’opération de comparaison. 
L’identifiant de fonction orderLastName est utilisé comme paramètre lors de l’appel à la 
méthode sort() sur le tableau names. La fonction de tri accepte deux paramètres, a et b, car 
elle fonctionne sur deux éléments de tableau à la fois. La valeur renvoyée de la fonction de tri 
indique comment les éléments doivent être triés :
?
Une valeur renvoyée de -1 indique que le premier paramètre, a, précède le second 
paramètre, b. 
?
Une valeur renvoyée de 1 indique que le second paramètre, ab, précède le premier, a. 
?
Une valeur renvoyée de 0 indique que les éléments ont une précédence de tri équivalente. 
248
Utilisation de tableaux

La méthode sortOn() est conçue pour des tableaux indexés avec des éléments contenant des 
objets. Ces objets doivent avoir au moins une propriété en commun pouvant être utilisée 
comme clé de tri. L’utilisation de la méthode sortOn() pour des tableaux d’autres types 
provoque des résultats inattendus. 
L’exemple suivant modifie le tableau poets de façon à ce que chaque élément soit un objet au 
lieu d’une chaîne. Chaque objet contient à la fois le nom de famille du poète et sa date de 
naissance.
var poets:Array = new Array();
({name:"Angelou", born:"1928"});
({name:"Blake", born:"1757"});
({name:"cummings", born:"1894"});
({name:"Dante", born:"1265"});
({name:"Wang", born:"701"});
Vous pouvez utiliser la méthode sortOn() pour trier le tableau par la propriété born. 
La méthode sortOn() définit deux paramètres, fieldName et options. L’argument 
fieldName doit être spécifié en tant que chaîne. Dans l’exemple suivant, la méthode 
sortOn() est appelée avec deux arguments, "born" et Array.NUMERIC. L’argument 
Array.NUMERIC est utilisé pour vérifier que le tri est effectué par ordre numérique plutôt que 
par ordre alphabétique. Ceci est utile même lorsque tous les nombres ont le même nombre de 
chiffres car vous êtes certain que le tri se fera comme prévu si un nombre comportant un 
nombre inférieur ou supérieur de chiffres est ensuite ajouté au tableau.
poets.sortOn("born", Array.NUMERIC);
for (var i:int = 0; i < poets.length; ++i)
{
trace(poets[i].name, poets[i].born);
}
/* résultat :
Wang 701
Dante 1265
Blake 1757
cummings 1894
Angelou 1928
*/
Généralement, les méthodes sort() et sortOn() modifient un tableau. Si vous souhaitez 
trier un tableau sans modifier le tableau existant, transmettez la constante 
Array.RETURNINDEXEDARRAY avec le paramètre options. Cette option indique aux méthodes 
de renvoyer un nouveau tableau qui reflète le tri et laisse le tableau d’origine inchangé. 
Le tableau renvoyé par les méthodes est un tableau simple de numéros d’index qui reflète le 
nouvel ordre de tri et ne contient aucun élément du tableau d’origine. Par exemple, pour trier 
le tableau poets par année de naissance sans le modifier, incluez la constante 
Array.RETURNINDEXEDARRAY dans l’argument transmis pour le paramètre options. 
Tableaux indexés
249

L’exemple suivant stocke les informations d’index renvoyées dans un tableau nommé indices 
et utilise le tableau indices avec le tableau poets inchangé pour trier les poètes par ordre 
d’année de naissance :
var indices:Array;
indices = poets.sortOn("born", Array.NUMERIC | Array.RETURNINDEXEDARRAY);
for (var i:int = 0; i < indices.length; ++i)
{
var index:int = indices[i];
trace(poets[index].name, poets[index].born);
}
/* résultat :
Wang 701
Dante 1265
Blake 1757
cummings 1894
Angelou 1928
*/
Interrogation d’un tableau
Les quatre méthodes restantes de la classe Array class—concat(), join(), slice(), 
toString()—interrogent le tableau mais ne le modifient pas. Les méthodes concat() et 
slice() renvoient toutes les deux de nouveaux tableaux, alors que les méthodes join() et 
toString() renvoient des chaînes. La méthode concat() prend un nouveau tableau ou une 
liste d’éléments comme arguments et le/la combine avec le tableau existant pour créer un 
tableau. La méthode slice() a deux paramètres nommés startIndex et endIndex, et 
renvoie un nouveau tableau contenant une copie des éléments « découpés » du tableau 
existant. La découpe commence avec l’élément à startIndex et se termine avec l’élément 
juste avant endIndex. L’élément à endIndex n’est pas compris dans la valeur renvoyée.
L’exemple suivant utilise concat() et slice() pour créer des tableaux à l’aide d’éléments 
d’autres tableaux :
var array1:Array = ["alpha", "beta"];
var array2:Array = array1.concat("gamma", "delta");
trace(array2); // résultat : alpha,beta,gamma,delta
var array3:Array = array1.concat(array2);
trace(array3); // résultat : alpha,beta,alpha,beta,gamma,delta
var array4:Array = array3.slice(2,5);
trace(array4); // résultat : alpha,beta,gamma
250
Utilisation de tableaux

Vous pouvez utiliser les méthodes join() et toString() pour interroger le tableau et 
renvoyer son contenu sous la forme d’une chaîne. Si aucun paramètre n’est utilisé pour la 
méthode join(), les deux méthodes se comportent de façon identique : elles renvoient une 
chaîne contenant une liste de tous les éléments du tableau séparée par des virgules. 
La méthode join(), contrairement à la méthode toString(), accepte un paramètre nommé 
delimiter, qui permet de choisir le symbole à utiliser comme séparateur entre chaque 
élément de la chaîne renvoyée.
L’exemple suivant crée un tableau nommé rivers et appelle à la fois join() et toString() 
pour renvoyer les valeurs dans le tableau sous la forme d’une chaîne. La méthode toString() 
est utilisée pour renvoyer des valeurs séparées par une virgule (riverCSV), alors que la 
méthode join() est utilisée pour renvoyer des valeurs séparées par le caractère +.
var rivers:Array = ["Nile", "Amazon", "Yangtze", "Mississippi"];
var riverCSV:String = rivers.toString();
trace(riverCSV); // résultat : Nile,Amazon,Yangtze,Mississippi
var riverPSV:String = ("+");
trace(riverPSV); // résultat : Nile+Amazon+Yangtze+Mississippi
Il existe un problème avec la méthode join() : tous les tableaux imbriqués sont toujours 
renvoyés avec des valeurs séparées par des virgules, quel que soit le séparateur que vous 
spécifiez pour les éléments de tableau principaux, comme illustré dans l’exemple suivant :
var nested:Array = ["b","c","d"];      
var letters:Array = ["a",nested,"e"]; 
var joined:String = ("+");
trace(joined); // résultat : a+b,c,d+e
Tableaux associatifs
Les tableaux associatifs, parfois appelés hachages ou mappages, utilisent des clés au lieu d’un index 
numérique pour organiser des valeurs stockées. Chaque clé dans un tableau associatif est une 
chaîne unique qui est utilisée pour accéder à une valeur stockée. Un tableau associatif est une 
instance de la classe Object, ce qui signifie que chaque clé correspond à un nom de propriété. 
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. 
ActionScript 3.0 présente un type avancé de tableau associatif appelé dictionnaire
Les dictionnaires, qui sont des instances de la classe Dictionary dans le package flash.utils, 
utilisent des clés de n’importe quel type de données mais qui sont généralement des instances 
de la classe Object. En d’autres termes, les clés de dictionnaire ne sont pas limitées à des 
valeurs de type String. 
Cette section décrit comment créer des tableaux associatifs qui utilisent des chaînes pour les 
clés et comment utiliser la classe Dictionary.
Tableaux associatifs
251

Tableaux associatifs avec clés de chaîne
Deux méthodes permettent de créer des tableaux associatifs dans ActionScript 3.0. 
La première méthode consiste à utiliser le constructeur Object, qui vous permet d’initialiser 
votre tableau avec un littéral d’objet. Une instance de la classe Object, également appelée objet 
générique
, présente le même fonctionnement qu’un tableau associatif. Chaque nom de 
propriété de l’objet générique devient la clé qui permet d’accéder à une valeur stockée. 
L’exemple suivant crée un tableau associatif appelé monitorInfo, à l’aide d’un littéral d’objet 
pour initialiser le tableau avec deux paires de clés et de valeurs :
var monitorInfo:Object = {type:"Flat Panel", resolution:"1600 x 1200"};
trace(monitorInfo["type"], monitorInfo["resolution"]); 
// résultat : Ecran plat 1600 x 1200
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, comme suit :
var monitorInfo:Object = new Object();
Une fois que le tableau est créé à l’aide d’un littéral d’objet ou du constructeur de la classe 
Object, vous pouvez ajouter de nouvelles valeurs à l’aide de l’opérateur crochets ([]) ou de 
l’opérateur point (.). L’exemple suivant ajoute deux nouvelles valeurs à monitorArray :
monitorInfo["aspect ratio"] = "16:10"; // forme incorrecte, ne pas utiliser 
// d’espaces
monitorInfo.colors = "16.7 million";
trace(monitorInfo["aspect ratio"], monitorInfo.colors);
// résultat : 16:10 16.7 million
La clé appelée aspect ratio contient un caractère d’espace. Cela est possible dans le cas de 
l’opérateur crochets, mais avec l’opérateur point, une erreur se produit. L’utilisation d’espace 
dans le nom de vos clés n’est donc pas conseillée.
Le second moyen pour créer un tableau associatif consiste à utiliser le constructeur Array, puis 
l’opérateur crochets ([]) ou point (.) pour ajouter des paires de clés et de valeurs au 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. 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 :
var monitorInfo:Array = new Array();
monitorInfo["type"] = "Flat Panel";
monitorInfo["resolution"] = "1600 x 1200";
trace(monitorInfo["type"], monitorInfo["resolution"]); 
// résultat : Flat Panel 1600 x 1200
L’utilisation du constructeur Array pour créer un tableau associatif ne présente aucun 
avantage. Vous ne pouvez pas utiliser la propriété Array.length ou une méthode de la classe 
Array avec des tableaux associatifs, même si vous utilisez le constructeur Array ou le type de 
données Array. Il est préférable d’utiliser le constructeur Array pour créer des tableaux indexés.
252
Utilisation de tableaux

Tableaux associatifs avec clés d’objet
Vous pouvez utiliser la classe Dictionary pour créer un tableau associatif qui utilise des objets 
pour les clés au lieu de chaînes. Ces tableaux sont parfois appelés dictionnaires, hachages ou 
mappages. Par exemple, supposez que vous avez une application qui détermine l’emplacement 
d’un objet Sprite selon son association avec un conteneur spécifique. Vous pouvez utiliser un 
objet Dictionary pour mapper chaque objet Sprite à un conteneur.
Le code suivant crée trois instances de la classe Sprite qui servent de clés pour l’objet 
Dictionary. Une valeur de GroupA ou GroupB est affectée à chaque clé. Les valeurs peuvent 
être de n’importe quel type de données, mais dans cet exemple, GroupA et GroupB sont des 
instances de la classe Object. Vous pouvez ensuite accéder à la valeur associée à chaque clé avec 
l’opérateur d’accès à la propriété ([]), comme illustré dans le code suivant :
import flash.display.Sprite;
import flash.utils.Dictionary;
var groupMap:Dictionary = new Dictionary();
// objets à utiliser comme clés
var spr1:Sprite = new Sprite();
var spr2:Sprite = new Sprite();
var spr3:Sprite = new Sprite();
// objets à utiliser comme valeurs
var groupA:Object = new Object();
var groupB:Object = new Object();
// Création de paires clé/valeur dans le dictionnaire.
groupMap[spr1] = groupA;
groupMap[spr2] = groupB;
groupMap[spr3] = groupB;
if (groupMap[spr1] == groupA)
{
trace("spr1 is in groupA"); 
}
if (groupMap[spr2] == groupB)
{
trace("spr2 is in groupB"); 
}
if (groupMap[spr3] == groupB)
{
trace("spr3 is in groupB"); 
}
Tableaux associatifs
253

Itération avec des clés d’objet
Vous pouvez parcourir en boucle le contenu d’un objet Dictionary avec une boucle  
ou for . Une boucle  vous permet d’effectuer une itération basée sur les 
clés, tandis qu’une boucle for  vous permet d’effectuer une itération basée sur les 
valeurs associées à chaque clé.
Utilisez la boucle  pour accéder directement aux clés d’un objet Dictionary. 
Vous pouvez également accéder aux valeurs de l’objet Dictionary avec l’opérateur d’accès à la 
propriété ([]). Le code suivant utilise l’exemple précédent du dictionnaire groupMap pour 
indiquer comment parcourir en boucle un objet Dictionary avec la boucle  :
for (var key:Object in groupMap)
{
trace(key, groupMap[key]);
}
/* résultat :
[object Sprite] [object Object]
[object Sprite] [object Object]
[object Sprite] [object Object]
*/
Utilisez la boucle for  pour accéder directement aux valeurs d’un objet Dictionary. 
Le code suivant utilise également le dictionnaire groupMap pour indiquer comment parcourir 
en boucle un objet Dictionary avec la boucle for  :
for each (var item:Object in groupMap)
{
trace(item);
}
/* résultat :
[object Object]
[object Object]
[object Object]
*/
254
Utilisation de tableaux

Clés d’objet et gestion de la mémoire
Adobe Flash Player utilise un système de nettoyage permettant de récupérer la mémoire qui 
n’est plus utilisée. Lorsque aucune référence ne pointe vers un objet, ce dernier peut être 
nettoyé et la mémoire récupérée au prochain nettoyage. Par exemple, le code suivant crée un 
objet et lui affecte une référence à la variable myObject :
var myObject:Object = new Object();
Tant que des références à l’objet existent, le système de nettoyage ne récupère pas la mémoire 
que l’objet occupe. Si la valeur de myObject est modifiée et qu’elle pointe vers un autre objet 
ou qu’elle est définie sur null, la mémoire occupée par l’objet d’origine peut être nettoyée. 
Néanmoins, aucune autre référence à l’objet d’origine ne doit exister. 
Si vous utilisez myObject comme clé dans un objet Dictionary, vous créez une autre référence 
à l’objet d’origine. Par exemple, le code suivant crée deux références à un objet—la variable 
myObject et la clé dans l’objet myMap :
import flash.utils.Dictionary;
var myObject:Object = new Object();
var myMap:Dictionary = new Dictionary();
myMap[myObject] = "foo";
Pour que l’objet référencé par myObject puisse être nettoyé, vous devez supprimer toutes ses 
références. Dans ce cas, vous devez modifier la valeur de myObject et supprimer la clé 
myObject de myMap, comme indiqué dans le code suivant :
myObject = null;
delete myMap[myObject];
Vous pouvez également utiliser le paramètre useWeakReference du constructeur Dictionary 
pour que toutes les clés de dictionnaire deviennent des références faibles. Le système de 
nettoyage ignore les références faibles. Par conséquent, un objet n’ayant que des références 
faibles peut être nettoyé. Par exemple, dans le code suivant, vous n’avez pas besoin de 
supprimer la clé myObject de myMap pour que l’objet puisse être nettoyé :
import flash.utils.Dictionary;
var myObject:Object = new Object();
var myMap:Dictionary = new Dictionary(true);
myMap[myObject] = "foo";
myObject = null; // Faire en sorte que l’objet puisse être nettoyé.
Tableaux associatifs
255

Tableaux multidimensionnels
Les tableaux multidimensionnels contiennent d’autres tableaux comme é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é (semblable au tableau tasks) qui stocke la liste des tâches. Vous 
pouvez utiliser n’importe quelle combinaison de tableaux indexés ou associatifs dans des 
tableaux multidimensionnels. Les exemples des sections suivantes utilisent soit deux tableaux 
indexés soit un tableau associatif de tableaux indexés. Vous pouvez essayer les autres 
combinaisons pour vous exercer. 
Deux tableaux indexés
Lorsque vous utilisez deux tableaux indexés, vous pouvez visualiser le résultat sous forme de 
tableau ou de feuille de calcul. Les éléments du premier tableau représentent les lignes alors 
que les éléments du second tableau représentent les colonnes. 
Par exemple, le tableau multidimensionnel suivant utilise deux tableaux indexés pour suivre 
des listes de tâches pour chaque jour de la semaine. Le premier tableau, masterTaskList, est 
créé à l’aide du constructeur de classe Array. Chaque élément du tableau représente un jour de 
la semaine, avec l’index 0 représentant lundi et l’index 6 dimanche. Ces éléments peuvent être 
considérés comme les lignes du tableau. Vous pouvez créer la liste de tâches de chaque jour en 
affectant un littéral de tableau à chacun des sept éléments que vous créez dans le tableau 
masterTaskList. Les littéraux de tableau représentent les colonnes du tableau.
var masterTaskList:Array = new Array();
masterTaskList[0] = ["wash dishes", "take out trash"];
masterTaskList[1] = ["wash dishes", "pay bills"];
masterTaskList[2] = ["wash dishes", "dentist", "wash dog"];
masterTaskList[3] = ["wash dishes"];
masterTaskList[4] = ["wash dishes", "clean house"];
masterTaskList[5] = ["wash dishes", "wash car", "pay rent"];
masterTaskList[6] = ["mow lawn", "fix chair"];
Vous pouvez accéder à des éléments individuels sur les listes de tâches à l’aide de la notation 
crochets. Le premier groupe de crochets représente le jour de la semaine et le second la liste de 
tâches pour ce jour. Par exemple, pour récupérer la seconde tâche de la liste du mercredi, utilisez 
d’abord l’index 2 pour mercredi puis utilisez l’index 1 pour la seconde tâche dans la liste.
trace(masterTaskList[2][1]); // résultat : dentiste
256
Utilisation de tableaux

Pour récupérer la première tâche de la liste du dimanche, utilisez l’index 6 pour dimanche et 
l’index 0 pour la première tâche sur la liste.
trace(masterTaskList[6][0]); // résultat : tondre le gazon
Tableau associatif avec un tableau indexé
Pour faciliter l’accès aux tableaux, vous pouvez utiliser un tableau associatif pour les jours de la 
semaine et un tableau indexé pour les listes de tâche. Les tableaux associatifs vous permettent 
d’utiliser une syntaxe à point lorsque vous vous référez à un jour particulier de la semaine, 
mais nécessitent un traitement d’exécution supplémentaire pour accéder à chaque élément du 
tableau associatif. L’exemple suivant utilise un tableau associatif comme base d’une liste de 
tâches, avec une paire de clés et de valeurs pour chaque jour de la semaine : 
var masterTaskList:Object = new Object();
masterTaskList["Monday"] = ["wash dishes", "take out trash"];
masterTaskList["Tuesday"] = ["wash dishes", "pay bills"];
masterTaskList["Wednesday"] = ["wash dishes", "dentist", "wash dog"];
masterTaskList["Thursday"] = ["wash dishes"];
masterTaskList["Friday"] = ["wash dishes", "clean house"];
masterTaskList["Saturday"] = ["wash dishes", "wash car", "pay rent"];
masterTaskList["Sunday"] = ["mow lawn", "fix chair"];
La syntaxe à point rend le code plus lisible car elle évite d’utiliser plusieurs groupes de 
crochets.
trace(masterTaskList.Wednesday[1]); // résultat : dentiste
trace(masterTaskList.Sunday[0]);    // résultat : tondre le gazon
Vous pouvez parcourir en boucle la liste des tâches en utilisant une boucle , mais vous 
devez utiliser la notation crochets au lieu de la syntaxe à point pour accéder à la valeur associée 
à chaque clé. Etant donné que masterTaskList est un tableau associatif, les éléments ne sont 
pas nécessairement récupérés dans l’ordre que vous attendez, comme l’indique l’exemple 
suivant :
for (var day:String in masterTaskList)
{
trace(day + ": " + masterTaskList[day])
}
/* output:
Sunday: mow lawn,fix chair
Wednesday: wash dishes,dentist,wash dog
Friday: wash dishes,clean house
Thursday: wash dishes
Monday: wash dishes,take out trash
Saturday: wash dishes,wash car,pay rent
Tuesday: wash dishes,pay bills
*/
Tableaux multidimensionnels
257

Clonage de tableaux
La classe Array ne possède aucune méthode intégrée pour effectuer des copies de tableaux. 
Vous pouvez créer une copie simple d’un tableau en appelant la méthode concat() ou 
slice() sans arguments. Dans une copie simple, si le tableau d’origine a des éléments qui 
sont des objets, seules les références aux objets sont copiées (et non les objets). La copie pointe 
vers les mêmes objets que l’original. Tout changement effectué sur les objets apparaît dans les 
deux tableaux.
Dans une copie en profondeur, les objets se trouvant dans le tableau d’origine sont copiés 
également de façon à ce que le nouveau tableau ne pointe pas vers les mêmes objets que le 
tableau d’origine. La copie en profondeur exige plus d’une ligne de code, ce qui requiert 
généralement la création d’une fonction. Une telle fonction peut être créée comme fonction 
d’utilitaire globale ou comme méthode d’une sous-classe Array.
L’exemple suivant définit une fonction appelée clone() qui effectue une copie en profondeur. 
L’algorithme est issu d’une technique de programmation Java courante. La fonction crée une 
copie en profondeur en sérialisant le tableau en une instance de la classe ByteArray puis en 
relisant le tableau dans un nouveau tableau. Cette fonction accepte un objet de façon à ce qu’il 
puisse être utilisé à la fois avec des tableaux indexés et des tableaux associatifs, comme indiqué 
dans le code suivant :
import flash.utils.ByteArray;
function clone(source:Object):*
{
var myBA:ByteArray = new ByteArray();
myBA.writeObject(source);
myBA.position = 0;
return(myBA.readObject());
}
258
Utilisation de tableaux

Rubriques avancées :
Extension de la classe Array
La classe Array est l’une des classes de base non finale, c’est-à-dire que vous pouvez créer votre 
sous-classe d’Array. Cette section décrit comment créer une sous-classe d’Array et décrit les 
problèmes pouvant se poser pendant le processus. 
Comme mentionné précédemment, les tableaux dans ActionScript ne sont pas typés, mais 
vous pouvez créer une sous-classe d’Array qui accepte des éléments d’un seul type de données. 
L’exemple fourni dans les sections suivantes définit une sous-classe Array nommée TypedArray 
qui limite ses éléments à des valeurs du type de données indiqué dans le premier paramètre. 
La classe TypedArray est présentée comme un exemple de la façon dont la classe Array est 
étendue et risque de ne pas être adaptée à des fins de production pour différentes raisons. 
Premièrement, la vérification du type a lieu lors de l’exécution plutôt que de la compilation. 
Deuxièmement, lorsqu’une méthode TypedArray rencontre une incompatibilité, elle est 
ignorée et aucune exception n’est renvoyée, même si vous pouvez facilement modifier les 
méthodes pour renvoyer des exceptions. Troisièmement, la classe ne peut pas empêcher 
l’utilisation de l’opérateur d’accès au tableau pour insérer des valeurs de n’importe quel type 
dans le tableau. Quatrièmement, le style de codage privilégie la simplicité par rapport à 
l’optimisation des performances.
Déclaration de la sous-classe
Utilisez le mot-clé extends pour indiquer qu’une classe est une sous-classe d’Array. Une sous-
classe d’Array doit utiliser l’attribut dynamic, comme la classe Array. Autrement, votre sous-
classe ne fonctionne pas correctement. 
Rubriques avancées :
259

Le code suivant représente la définition de la classe TypedArray, qui comporte une constante 
contenant le type de données, une méthode de constructeur et les quatre méthodes 
permettant d’ajouter des éléments au tableau. Le code pour chaque méthode est omis dans cet 
exemple, mais il est décrit de façon détaillée dans les sections qui suivent :
public dynamic class TypedArray extends Array
{
private const dataType:Class;
public function TypedArray( args) {}
AS3 override function concat( args):Array {}
AS3 override function push( args):uint {}
AS3 override function splice( args) {}
AS3 override function unshift( args):uint {}
}
Les quatre méthodes de remplacement utilisent l’espace de nom AS3 au lieu de l’attribut 
public car cet exemple suppose que l’option -as3 du compilateur est définie sur true et 
l’option -es du compilateur sur false. Il s’agit des paramètres par défaut pour Adobe Flex 
Builder 2 et Adobe Flash CS3 Professional. Pour plus d’informations, voir d’ActionScript 3 », à la page 192.
CO
Si vous êtes un développeur expérimenté et que vous préférez utiliser l’héritage de 
NS
prototype, vous pouvez apporter deux changements mineurs à la classe TypedArray afin 
EI
qu’elle compile avec l’option -es du compilateur définie sur true. Commencez par 
L
supprimer toutes les occurrences de l’attribut override et remplacez l’espace de nom 
AS3 par l’attribut public. Remplacez ensuite Array.prototype pour les quatre 
occurrences de super.
Constructeur TypedArray
Le constructeur de sous-classe pose un défi intéressant car il doit accepter une liste 
d’arguments de longueur arbitraire. Il s’agit de savoir comment transférer les arguments au 
superconstructeur pour créer le tableau. Si vous transmettez la liste des arguments sous forme 
d’un tableau, le superconstructeur le considère comme un seul argument de type Array et le 
tableau résultant a toujours une longueur d’1 élément. Le transfert de listes d’arguments se fait 
généralement au moyen de la méthode Function.apply(), qui prend un tableau 
d’arguments comme second paramètre mais le convertit en une liste d’arguments lors de 
l’exécution de la fonction. Malheureusement, vous ne pouvez pas utiliser la méthode 
Function.apply() avec des constructeurs.
260
Utilisation de tableaux

La seule solution est de recréer la logique du constructeur Array dans le constructeur 
TypedArray. Le code suivant indique l’algorithme utilisé dans le constructeur de classe Array, 
que vous pouvez réutiliser dans votre constructeur de sous-classe Array :
public dynamic class Array
{
public function Array( args)
{
var n:uint = args.length
if (n == 1 && (args[0] is Number))
{
var dlen:Number = args[0];
var ulen:uint = dlen;
if (ulen != dlen)
{
throw new RangeError("Array index is not a 32-bit unsigned integer 
("+dlen+")");
}
length = ulen;
}
else
{
length = n;
for (var i:int=0; i < n; i++)
{
this[i] = args[i] 
}
}
}
}
Rubriques avancées :
261

Le constructeur TypedArray partage une grande partie du code du constructeur Array, avec 
seulement quatre changements apportés au code. Premièrement, la liste des paramètres 
comprend un nouveau paramètre obligatoire de type Class qui permet d’indiquer le type de 
données du tableau. Deuxièmement, le type de données transmis au constructeur est affecté à 
la variable dataType. Troisièmement, dans l’instruction else, la valeur de la propriété length 
est affectée après la boucle for de façon à ce que length comprenne uniquement des 
arguments du type correct. Quatrièmement, le corps de la boucle for utilise la version de 
remplacement de la méthode push() de façon à ce que seuls des arguments du type de 
données correct soient ajoutés au tableau. L’exemple suivant présente la fonction constructeur 
TypedArray :
public dynamic class TypedArray extends Array
{
private var dataType:Class;
public function TypedArray(typeParam:Class, args)
{
dataType = typeParam;
var n:uint = args.length
if (n == 1 && (args[0] is Number))
{
var dlen:Number = args[0];
var ulen:uint = dlen
if (ulen != dlen)
{
throw new RangeError("Array index is not a 32-bit unsigned integer 
("+dlen+")")
}
length = ulen;
}
else
{
for (var i:int=0; i < n; i++)
{
// vérification du type effectuée dans push() 
(args[i])
}
length = this.length;
}
}
}
262
Utilisation de tableaux

Méthodes de remplacement TypedArray
La classe TypedArray remplace les quatre méthodes de la classe Array qui permettent d’ajouter 
des éléments à un tableau. Dans chaque cas, la méthode de remplacement ajoute une 
vérification du type qui empêche d’ajouter des éléments qui ne sont pas du type de données 
correct. Chaque méthode appelle ensuite sa version de superclasse.
La méthode push() parcourt en boucle la liste des arguments avec une boucle  et 
effectue une vérification du type sur chaque argument. Les arguments qui ne sont pas de type 
correct sont supprimés du tableau args avec la méthode splice(). Une fois que la boucle 
 se termine, le tableau args contient des valeurs de type dataType uniquement. 
La version de superclasse de push() est ensuite appelée avec le tableau args mis à jour, 
comme indiqué dans le code suivant :
AS3 override function push( args):uint
{
for (var i:* in args)
{
if (!(args[i] is dataType))
{
args.splice(i,1);
}
}
return (.apply(this, args));
}
La méthode concat() crée un TypedArray temporaire appelé passArgs pour stocker les 
arguments soumis à la vérification de type. Ceci permet de réutiliser le code de vérification de 
type qui existe dans la méthode push(). Une boucle  effectue une itération sur le 
tableau args et appelle push() sur chaque argument. Etant donné que passArgs est typé 
sous la forme TypedArray, la version TypedArray de push() est exécutée. La méthode 
concat() appelle ensuite sa version de superclasse, comme indiqué dans le code suivant :
AS3 override function concat( args):Array
{
var passArgs:TypedArray = new TypedArray(dataType);
for (var i:* in args)
{
// vérification du type effectuée dans push()
(args[i]);
}
return (super.concat.apply(this, passArgs));
}
Rubriques avancées :
263

La méthode splice() prend une liste d’arguments arbitraire, mais les deux premiers 
arguments se réfèrent toujours à un numéro d’index et au nombre d’éléments à supprimer. 
C’est pourquoi la méthode de remplacement splice() effectue la vérification de type 
uniquement pour les éléments du tableau args dans les positions d’index 2 ou supérieures. 
Il est intéressant de noter que dans le code, il semble y avoir un appel récursif à splice() à 
l’intérieur de la boucle for, mais en réalité, ce n’est pas le cas car args est de type Array et non 
de type TypedArray, ce qui signifie que l’appel à args.splice() est un appel à la version de 
superclasse de la méthode. Une fois que la boucle  se termine, le tableau args 
contient des valeurs du type correct uniquement dans les positions d’index 2 ou supérieures, 
et splice() appelle sa version de superclasse, comme indiqué dans le code suivant :
AS3 override function splice( args):*
{
if (args.length > 2)
{
for (var i:int=2; i< args.length; i++)
{
if (!(args[i] is dataType))
{
args.splice(i,1);
}
}
}
return (super.splice.apply(this, args));
}
La méthode unshift(), qui ajoute des éléments au début d’un tableau, accepte une liste 
d’arguments arbitraire également. La méthode de remplacement unshift() utilise un 
algorithme très semblable à celui utilisé par la méthode push(), comme indiqué dans le code 
suivant :
AS3 override function unshift( args):uint
{
for (var i:* in args) 
{
if (!(args[i] is dataType))
{
args.splice(i,1);
}
}
return (super.unshift.apply(this, args));
}
}
264
Utilisation de tableaux

Exemple : PlayList
L’exemple PlayList présente les techniques d’utilisation des tableaux, dans le contexte d’une 
application de lecture musicale qui gère une liste de chansons. Ces techniques sont les 
suivantes :
?
Création d’un tableau indexé
?
Ajout d’éléments à un tableau indexé
?
Tri d’un tableau d’objets en fonction de différentes propriétés, à l’aide d’options de tri 
différentes
?
Conversion d’un tableau en une chaîne séparée par des caractères
Pour obtenir les fichiers d’application pour cet exemple, voir 
;Les fichiers d’application 
PlayList se trouvent dans le dossier Samples/PlayList. L’application se compose des fichiers 
suivants :
Fichier
Description

Le fichier d’application principal dans Flash 
ou
(FLA) ou Flex (MXML).

com/example/programmingas3/playlist/
Objet de valeur représentant des informations 

sur une seule chanson. Les éléments gérés par 
la classe PlayList sont des instances Song.
com/example/programmingas3/playlist/
Pseudo-énumération dont les valeurs 

disponibles représentent les propriétés de la 
classe Song en fonction desquelles une liste 
d’objets Song peut être triée.
Exemple : PlayList
265

Présentation de la classe PlayList
La classe PlayList gère un ensemble d’objets Song. Elle a des méthodes publiques qui 
permettent d’ajouter une chanson à la liste de lecture (la méthode addSong()) et de trier les 
chansons dans la liste (la méthode sortList()). En outre, la classe comprend une propriété 
d’accesseur en lecture seule, songList, qui permet d’accéder au groupe de chansons dans la 
liste de lecture. En interne, la classe PlayList conserve une trace de ses chansons à l’aide d’une 
variable Array privée :
public class PlayList
{
private var _songs:Array;
private var _currentSort:SortProperty = null;
private var _needToSort:Boolean = false;

}
En plus de la variable Array _songs utilisée par la classe PlayList pour conserver une trace de 
sa liste de chansons, deux autres variables privées vérifient si la liste doit être triée 
(_needToSort) et contrôlent la propriété sur laquelle est basé le tri de la liste de chansons à un 
moment donné (_currentSort).
Comme avec tous les objets, lorsque vous avez déclaré une instance Array, vous n’avez effectué 
que la moitié du travail consistant à créer un tableau. Avant d’accéder à des méthodes ou à des 
propriétés d’une instance Array, cette dernière doit être instanciée dans le constructeur de la 
classe PlayList.
public function PlayList()
{
this._songs = new Array();
// Définition du tri initial.
this.sortList(SortProperty.TITLE);
}
La première ligne du constructeur instancie la variable _songs pour qu’elle puisse être utilisée. 
En outre, la méthode sortList() est appelée pour définir la propriété de tri initiale.
266
Utilisation de tableaux

Ajout d’une chanson à la liste
Lorsqu’un utilisateur ajoute une nouvelle chanson dans l’application, le code dans le 
formulaire de saisie des données appelle la méthode addSong() de la classe PlayList.
/**
 * Ajout d’une chanson à la liste de lecture.
 */
public function addSong(song:Song):void
{
(song);
this._needToSort = true;
}
A l’intérieur de addSong(), la méthode push() du tableau _songs est appelée. Ceci permet 
d’ajouter l’objet Song transmis à addSong() en tant que nouvel élément dans ce tableau. 
Avec la méthode push(), le nouvel élément est ajouté à la fin du tableau, indépendamment 
du tri appliqué précédemment. Ceci signifie qu’une fois que la méthode push() a été appelée, 
la liste des chansons risque de ne plus être triée correctement. Par conséquent, la variable 
_needToSort est définie sur true. Théoriquement, la méthode sortList() pourrait être 
appelée immédiatement afin d’éviter de vérifier si la liste est triée ou non à un moment donné. 
En pratique, cependant, la liste des chansons n’a pas besoin d’être triée jusqu’au moment 
précédant immédiatement sa récupération. En retardant l’opération de tri, l’application 
n’effectue pas de tri inutile si, par exemple, plusieurs chansons sont ajoutées à la liste avant sa 
récupération.
Tri de la liste de chansons
Etant donné que les instances Song gérées par la liste de lecture sont des objets complexes, les 
utilisateurs de l’application peuvent trier la liste de lecture en fonction de différentes 
propriétés (titre de la chanson ou année de publication, par exemple). Dans l’application 
PlayList, le tri de la liste des chansons s’effectue en trois étapes : identification de la propriété 
sur laquelle est basé le tri de la liste, indication des options de tri à utiliser lors du tri en 
fonction de cette propriété et exécution du tri.
Exemple : PlayList
267

Propriétés de tri
Un objet Song conserve la trace de plusieurs propriétés, notamment le titre de la chanson, 
l’artiste, l’année de publication, le nom du fichier et un ensemble de genres sélectionné par 
l’utilisateur auquel la chanson appartient. Seules les trois premières propriétés sont pratiques 
pour le tri. Dans un souci de commodité pour les développeurs, l’exemple inclut la classe 
SortProperty, qui agit comme une énumération avec des valeurs représentant les propriétés 
disponibles pour le tri.
public static const TITLE:SortProperty = new SortProperty("title");
public static const ARTIST:SortProperty = new SortProperty("artist");
public static const YEAR:SortProperty = new SortProperty("year");
La classe SortProperty contient trois classes, TITLE, ARTIST et YEAR. Chacune d’elles stocke 
une chaîne comportant le nom de la propriété de la classe Song pouvant être utilisée pour le 
tri. Chaque fois qu’une propriété de tri est indiquée dans le reste du code, le membre de 
l’énumération est utilisé. Par exemple, dans le constructeur PlayList, la liste est triée 
initialement en appelant la méthode sortList(), comme suit :
// Définition du tri initial.
this.sortList(SortProperty.TITLE);
Etant donné que la propriété de tri est spécifiée sous la forme SortProperty.TITLE, les 
chansons sont triées par titre.
Tri par propriété et définition d’options de tri
La classe PlayList trie la liste de chansons dans la méthode sortList(), comme suit :
/**
 * Tri de la liste de chansons en fonction de la propriété spécifiée.
 */
public function sortList(sortProperty:SortProperty):void
{

var sortOptions:uint;
switch (sortProperty)
{
case SortProperty.TITLE:
sortOptions = Array.CASEINSENSITIVE;
break;
case SortProperty.ARTIST:
sortOptions = Array.CASEINSENSITIVE;
break;
case :
sortOptions = Array.NUMERIC;
break;
}
268
Utilisation de tableaux

// Tri des données.
this._songs.sortOn(sortProperty.propertyName, sortOptions);
// Enregistrement de la propriété de tri actuelle.
this._currentSort = sortProperty;
// Enregistrement du fait que la liste est triée.
this._needToSort = false;
}
Lors du tri par titre ou par artiste, il est préférable d’effectuer un tri par ordre alphabétique. 
En revanche, lors du tri par année, il est plus logique d’effectuer un tri numérique. 
L’instruction switch sert à définir l’option de tri appropriée, stockée dans la variable 
sortOptions, en fonction de la valeur indiquée dans le paramètre sortProperty. Ici encore, 
les membres de l’énumération nommés sont utilisés pour faire la différence entre les 
propriétés, plutôt que les valeurs absolues.
Une fois que vous avez déterminé la propriété et les options de tri, le tableau _songs est trié en 
appelant sa méthode sortOn(), en transmettant ces deux valeurs comme paramètres. 
La propriété de tri est enregistrée et la liste des chansons est triée.
Combinaison d’éléments de tableau en une chaîne 
séparée par des caractères
Cet exemple utilise non seulement un tableau pour conserver la liste des chansons dans la 
classe PlayList mais également des tableaux dans la classe Song pour gérer la liste des genres 
auxquels une chanson appartient. Prenez en compte ce fragment de code issu de la définition 
de la classe Song :
private var _genres:String;
public function Song(title:String, artist:String, year:uint, 
filename:String, genres:Array)
{

// Les genres sont transmis sous la forme d’un tableau
// mais ils sont stockés sous la forme d’une chaîne séparée 
// par des points-virgules.
this._genres = (";");
}
Exemple : PlayList
269

Lors de la création d’une instance Song, le paramètre genres utilisé pour spécifier le genre 
(ou les genres) auquel la chanson appartient est défini comme instance Array. Ainsi, vous 
pouvez regrouper plusieurs genres en une seule variable qui peut être transmise au 
constructeur. Néanmoins, la classe Song conserve, en interne, les genres dans la variable privée 
_genres sous la forme d’une instance String séparée par des points-virgules. Le paramètre 
Array est converti en une chaîne séparée par des points-virgules en appelant sa méthode 
join() avec la valeur de chaîne littérale ";" comme séparateur spécifié.
De la même façon, les accesseurs genres permettent de définir ou de récupérer des genres 
sous la forme d’un tableau :
public function get genres():Array
{
// Les genres sont stockés sous la forme d’une chaîne séparée par 
// des points-virgules, et doivent donc être transformés en un tableau 
// pour être de nouveau transférés.
return this._genres.split(";");
}
public function set genres(value:Array):void
{
// Les genres sont transmis sous la forme d’un tableau,
// mais ils sont stockés sous la forme d’une chaîne séparée 
// par des points-virgules.
this._genres = (";");
}
L’accesseur genres set se comporte exactement comme le constructeur ; il accepte un tableau 
et appelle la méthode join() pour la convertir en une chaîne séparée par des points-virgules. 
L’accesseur get effectue l’opération inverse : la méthode split() de la variable _genres est 
appelée. Elle divise la chaîne en un tableau de valeurs utilisant le séparateur spécifié (la valeur 
de chaîne littérale ";" comme précédemment).
270
Utilisation de tableaux

CHAPITRE 8
Gestion des erreurs
8
« Gérer » une erreur signifie insérer une logique dans votre application permettant de 
répondre à une erreur ou de la réparer lors de la compilation ou de l’exécution d’une 
application. Lorsque votre application gère des erreurs, quelque chose se produit en réponse à 
l’erreur. Dans certaines situations, il se peut en revanche qu’une erreur soit ignorée (échec 
silencieux) et qu’aucune réponse ne soit fournie. La gestion des erreurs, lorsqu’elle est utilisée 
correctement, protège votre application et ses utilisateurs contre un comportement inattendu.
Cependant, la gestion des erreurs est une catégorie large qui englobe la réponse à de nombreux 
types d’erreurs générées lors de la compilation ou de l’exécution. Ce chapitre se concentre sur 
la gestion des erreurs lors de l’exécution, les différents types d’erreurs pouvant être générés et 
les avantages que présente le nouveau système de gestion des erreurs dans ActionScript 3.0. 
Il explique également comment mettre en oeuvre vos stratégies de gestion des erreurs 
personnalisées pour vos applications.
Contenu
Principes de base de la gestion des erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Types d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Gestion des erreurs dans ActionScript 3.0  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
Utilisation de la version de débogage de Flash Player . . . . . . . . . . . . . . . . . . . . . . .  280
Gestion des erreurs synchrones dans une application . . . . . . . . . . . . . . . . . . . . . . . . 281
Création de classes d’erreur personnalisées  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .286
Réponse à des événements d’erreurs et au statut  . . . . . . . . . . . . . . . . . . . . . . . . . . .288
Comparaison des classes Error. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292
Exemple : Application CustomErrors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .298
271

Principes de base de la gestion des erreurs
Introduction à la gestion des erreurs
Une erreur d’exécution est une erreur qui se produit dans votre code ActionScript et qui 
empêche le contenu ActionScript de s’exécuter dans Flash Player. Pour vous assurer que votre 
code ActionScript s’exécute correctement, vous devez écrire le code dans l’application qui gère 
l’erreur, la répare, la contourne ou informe au moins l’utilisateur qu’elle a eu lieu. 
Ce processus est appelé gestion des erreurs.
La gestion des erreurs est une catégorie large qui englobe la réponse à de nombreux types 
d’erreurs générées lors de la compilation ou de l’exécution. Les erreurs qui se produisent lors 
de la compilation sont souvent plus faciles à identifier - vous devez les corriger pour terminer 
la création d’un fichier SWF. Ce chapitre ne traite pas des erreurs de compilation ; pour plus 
d’informations sur l’écriture de code dépourvu d’erreurs de compilation, v« Syntaxe et langage ActionScript », à la page 71 et objet en ActionScript », à la page 147. Ce chapitre se concentre sur les erreurs d’exécution.
Les erreurs d’exécution peuvent être difficiles à détecter car elles se produisent lorsque le code 
erroné est exécuté. Si un segment de votre programme possède plusieurs branches de code, 
comme une instruction , vous devez tester chaque condition possible, avec 
toutes les valeurs d’entrée possibles que les utilisateurs réels peuvent utiliser, de façon à 
confirmer que votre code ne contient aucune erreur.
Les erreurs d’exécution peuvent être classées en deux catégories : les erreurs de programme sont 
des erreurs dans votre code ActionScript (spécification du type de données incorrect pour un 
paramètre de méthode, par exemple) ; les erreurs logiques sont des erreurs dans la logique 
(le contrôle des données et la manipulation des valeurs) de votre programme (utilisation de la 
formule incorrecte pour calculer les taux d’intérêt dans une application bancaire, par 
exemple). Encore une fois, ces deux types d’erreurs peuvent souvent être détectées et corrigées 
à l’avance en testant votre application.
Il serait idéal d’identifier et de supprimer toutes les erreurs de votre application avant de la 
mettre à la disposition des utilisateurs finaux. Cependant, toutes les erreurs ne peuvent pas 
être prévues ni évitées. Par exemple, supposez que votre application ActionScript charge des 
informations depuis un site Web particulier qui se trouve hors de votre contrôle. Si ce site 
Web n’est pas disponible, la partie de votre application qui dépend de ces données externes ne 
se comportera pas correctement. L’aspect le plus important de la gestion des erreurs implique 
une préparation pour ces cas inconnus ainsi que leur gestion afin de permettre aux utilisateurs 
de continuer à utiliser votre application, ou au moins de recevoir un message d’erreur amical 
expliquant la raison du problème.
272
Gestion des erreurs

Les erreurs d’exécution sont représentées de deux façons dans ActionScript :
?
Classes Error : de nombreuses erreurs ont une classe Erreur qui leur est associée. 
Lorsqu’une erreur se produit, Flash Player crée une instance de la classe Error spécifique 
associée à cette erreur. Votre code peut utiliser les informations contenues dans cet objet 
erreur pour donner une réponse appropriée à l’erreur.
?
Evénements d’erreur : parfois, une erreur se produit lorsque Flash Player devrait 
normalement déclencher un événement. Dans ces cas, Flash Player déclenche un 
événement d’erreur à la place. A l’instar d’autres événements, chaque événement d’erreur 
possède une classe qui lui est associé, et Flash Player transmet une instance de cette classe 
aux méthodes qui sont enregistrées auprès de l’événement d’erreur.
Pour déterminer si une méthode particulière peut déclencher une erreur ou un événement d’erreur, 
voir l’entrée de la méthode dans la Référence du langage et des composants ActionScript 3.0.
Tâches de gestion des erreurs courantes
Voici des tâches liées à des erreurs courantes que vous effectuez avec votre code :
?
Ecriture de code pour gérer des erreurs
?
Test, capture et renvoi d’erreurs
?
Définition de votre classe d’erreur
?
Réponse à des événements d’erreurs et de statut
Concepts et termes importants
La liste de référence suivante contient les termes importants que vous rencontrerez dans ce 
chapitre :
?
Asynchrone : une commande de programme telle qu’un appel de méthode qui ne fournit 
pas un résultat immédiat mais qui donne un résultat (ou erreur) sous la forme d’un 
événement.
?
Capturer : lorsqu’une exception (une erreur d’exécution) se produit et que votre code la 
découvre, ce dernier la capture. Une fois qu’une exception est capturée, Flash Player arrête 
d’indiquer à d’autre code ActionScript que l’exception s’est produite.
?
Version de débogage : une version spéciale de Flash Player qui contient du code 
permettant d’informer les utilisateurs lorsque des erreurs d’exécution se produisent. Dans 
la version standard de Flash Player (celle que la plupart des utilisateurs possèdent), les 
erreurs qui ne sont pas gérées par votre code ActionScript sont ignorées par Flash Player. 
Dans la version de débogage (qui est incluse avec Adobe Flash CS3 Professional et Adobe 
Flex), un message d’avertissement apparaît lorsqu’une erreur non gérée se produit.
Principes de base de la gestion des erreurs
273

?
Exception : une erreur qui se produit lorsqu’un programme est exécuté et que 
l’environnement d’exécution (Flash Player) ne peut pas résoudre.
?
Renvoyer : lorsque votre code capture une exception, Flash Player ne signale plus 
l’exception à aucun autre objet. S’il est important pour d’autres objets que l’exception leur 
soit signalée, votre code doit renvoyer l’exception pour recommencer le processus de 
notification.
?
Synchrone : une commande de programme (un appel de méthode, par exemple) qui 
fournit un résultat immédiat (ou qui renvoie immédiatement une erreur), ce qui signifie 
que la réponse peut être utilisée dans le même bloc de code.
?
Envoyer : le fait de signaler à Flash Player (et par conséquent, à d’autre objets et au code 
ActionScript) qu’une erreur s’est produite s’appelle envoyer une erreur.
Utilisation des exemples fournis dans le chapitre
Au fur et à mesure que vous avancez dans le chapitre, vous pouvez tester des exemples de code. 
Tous les codes de ce chapitre comprennent l’appel de la fonction trace(). Pour tester les 
codes de ce chapitre :
1.
Créez un document Flash vide.
2. Sélectionnez une image-clé dans le scénario.
3. Ouvrez le panneau Actions et copiez le code dans le panneau Script.
4. Exécutez le programme en sélectionnant Contrôle > Tester l’animation.
Les résultats des fonctions trace() des codes s’affichent dans le panneau Sortie.
Certains des prochains codes sont plus complexes et sont écrits sous la forme d’une classe. 
Pour tester ces exemples :
1.
Créez un document Flash vide et enregistrez-le sur votre ordinateur.
2. Créez un nouveau fichier ActionScript et enregistrez-le dans le même répertoire que le 
document Flash. Le nom du fichier doit correspondre au nom de la classe du code. 
Par exemple, si le code définit une classe ErrorTest, enregistrez le fichier ActionScript sous 
le nom . 
3. Copiez le code dans le fichier ActionScript et enregistrez le fichier.
4. Dans le document Flash, cliquez sur une partie vide de la scène ou de l’espace de travail 
pour activer l’inspecteur des propriétés du document.
5. Dans l’inspecteur des propriétés, dans le champ Classe du document, saisissez le nom de la 
classe ActionScript que vous avez copiée du texte.
274
Gestion des erreurs

6. Exécutez le programme en sélectionnant Contrôle > Tester l’animation
Les résultats de l’exemple s’affichent dans le panneau Sortie (si l’exemple utilise la fonction 
trace()) ou dans un champ texte créé par l’exemple de code.
Ces techniques de test des exemples de code sont décrites de façon plus détaillée dans des exemples de code contenus dans un chapitre », à la page 67.
Types d’erreurs
Lorsque vous développez et exécutez des applications, vous rencontrez différents types 
d’erreurs et de termes. La liste suivante présente les principaux termes et types d’erreurs :
?
Erreurs de compilation : générées par le compilateur ActionScript lors de la compilation du 
code. Les erreurs de compilation ont lieu lorsque des problèmes de syntaxe dans votre code 
empêchent de créer votre application. 
?
Erreurs d’exécution : générées lorsque vous exécutez votre application après l’avoir 
compilée. Les erreurs d’exécution sont générées lorsqu’un fichier SWF est lu dans Adobe 
Flash Player 9. Dans la plupart des cas, vous pouvez gérer ces erreurs lorsqu’elles se 
produisent, en les signalant à l’utilisateur et en faisant en sorte que l’exécution de votre 
application continue. S’il s’agit d’une erreur grave (impossibilité de se connecter à un site 
Web distant ou de charger des données), vous pouvez utiliser la gestion des erreurs pour 
mettre fin à votre application en douceur. 
?
Erreurs synchrones : générées lorsqu’une fonction est appelée—par exemple, lorsque vous 
tentez d’utiliser une méthode spécifique et que l’argument que vous lui transmettez n’est 
pas valide, par conséquent, Flash Player renvoie une exception. La plupart des erreurs ont 
lieu de façon synchrone (au moment de l’exécution d’une instruction) et le flux de 
contrôle passe immédiatement à l’instruction catch la plus applicable. 
Par exemple, l’extrait de code suivant renvoie une erreur d’exécution car la méthode 
browse() n’est pas appelée avant que le programme tente de charger un fichier :
var fileRef:FileReference = new FileReference();
try
{
fileRef.upload("");
}
catch (error:IllegalOperationError)
{
trace(error);
// Error #2037: Fonctions appelées dans un ordre incorrect, ou appel
// précédent impossible.
}
Types d’erreurs
275

Dans ce cas, une erreur d’exécution est renvoyée de façon synchrone car Flash Player a 
déterminé que la méthode browse() n’a pas été appelée avant la tentative de chargement 
du fichier. 
Pour de plus amples informations sur la gestions des erreurs synchrones, voir erreurs synchrones dans une application », à la page 281.
?
Erreurs asynchrones : générées à différents moments lors de l’exécution. Elles provoquent 
des événements et sont interceptées par des écouteurs d’événements. Une opération 
asynchrone est une opération dans laquelle une fonction lance une opération mais 
n’attend pas qu’elle se termine. Vous pouvez créer un écouteur d’événement d’erreur pour 
attendre que l’application ou l’utilisateur tente une opération, et si cette dernière échoue, 
vous interceptez l’erreur avec un écouteur d’événement et répondez à l’événement d’erreur. 
Ensuite, l’écouteur d’événement appelle une fonction de gestionnaire d’événements pour 
répondre à l’événement d’erreur de façon utile. Par exemple, le gestionnaire d’événements 
peut lancer une boîte de dialogue qui invite l’utilisateur à résoudre l’erreur.
Reprenez l’exemple d’erreur synchrone lors du chargement d’un fichier présenté 
précédemment. Si vous réussissez à appeler la méthode browse() avant de lancer le 
chargement d’un fichier, Flash Player distribue plusieurs événements. Par exemple, au 
démarrage d’un chargement, l’événement open est distribué. A la fin du chargement, 
l’événement complete est distribué. Etant donné que la gestion d’événements est 
asynchrone (c’est-à-dire qu’elle n’a pas lieu à des moments prédéfinis, connus et 
spécifiques), vous devez utiliser la méthode addEventListener() pour détecter ces 
événements spécifiques, comme l’indique le code suivant :
var fileRef:FileReference = new FileReference();
fileRef.addEventListener(Event.SELECT, selectHandler);
fileRef.addEventListener(, openHandler);
fileRef.addEventListener(Event.COMPLETE, completeHandler);
fileRef.browse();
function selectHandler(event:Event):void
{
trace(" select ");
var request:URLRequest = new URLRequest("
");
request.method = ;
event.target.upload();
}
function openHandler(event:Event):void
{
trace(" open ");
}
function completeHandler(event:Event):void
{
trace(" complete ");
}
276
Gestion des erreurs

Pour de plus amples informations sur la gestions des erreurs asynchrones, vdes événements d’erreurs et au statut », à la page 288.
?
Exceptions non interceptées : renvoyées sans logique correspondante (comme une 
instructioncatch) pour y répondre. Si votre application renvoie une erreur, et qu’aucune 
instruction catch ni gestionnaire d’événements approprié n’est trouvé au niveau actuel ou 
supérieur pour gérer l’erreur, cette dernière est considérée comme une exception non 
interceptée. 
Lors de l’exécution, Flash Player ignore les erreurs non interceptées et tente de poursuivre 
la lecture si l’erreur n’arrête pas le fichier SWF actuel, car les utilisateurs ne peuvent pas 
nécessairement résoudre une erreur eux-même. Le fait d’ignorer une erreur non 
interceptée est appelé « échec silencieux » et peut compliquer le débogage des applications. 
La version de débogage de Flash Player répond à une erreur non interceptée en terminant 
le script courant et en affichant l’erreur non interceptée dans le résultat de l’instruction 
trace ou en enregistrant le message d’erreur dans un fichier journal. Si l’objet d’exception 
est une instance de la classe Error ou l’une de ses sous-classes, la méthode 
getStackTrace() est appelée, et les informations de trace de pile sont également affichées 
dans le résultat de l’instruction trace ou dans un fichier journal. Pour de plus amples 
informations sur l’utilisation de la version de débogage de Flash Player, voir de la version de débogage de Flash Player », à la page 280.
Gestion des erreurs dans ActionScript 3.0
Etant donné que de nombreuses applications peuvent être exécutées sans créer de logique pour 
gérer les erreurs, les développeurs sont tentés de retarder la création de la gestion des erreurs 
dans leurs applications. Néanmoins, sans gestion des erreurs, une application risque de 
s’interrompre facilement ou de poser des problèmes à l’utilisateur si quelque chose ne 
fonctionne pas comme prévu. ActionScript 2.0 possède une classe Error qui vous permet de 
créer une logique dans des fonctions personnalisées afin de renvoyer une exception avec un 
message spécifique. Etant donné que la gestion des erreurs est cruciale pour rendre une 
application conviviale, ActionScript 3.0 inclut une architecture étendue pour intercepter les 
erreurs.
REMA
La Référence du langage et des composants ActionScript 3.0 documente les exceptions 
renvoyées par de nombreuses méthodes mais risque de ne pas inclure toutes les 
R
exceptions possibles pour chaque méthode. Une méthode peut renvoyer une exception 
Q
UE
pour des erreurs de syntaxe ou d’autres problèmes qui ne sont pas signalés 
explicitement dans la description de la méthode, même lorsque cette dernière répertorie 
les exceptions qu’une méthode renvoie.
Gestion des erreurs dans ActionScript 3.0
277

Eléments de gestion des erreurs ActionScript 3.0
ActionScript 3.0 comprend de nombreux outils permettant de gérer les erreurs, notamment :
?
Classes Error. Conformément à la spécification de langage ECMAScript (ECMA-262), 
version 4, ActionScript 3.0 comprend une large gamme de classes Error afin d’élargir le 
domaine des situations pouvant produire des objets d’erreur. Chaque classe Error permet 
aux applications de gérer et de répondre à des conditions d’erreur spécifiques, qu’elles 
soient liées à des erreurs système (comme une condition MemoryError), à des erreurs de 
codage (comme une condition ArgumentError), à des erreurs de réseau et de 
communication (comme une condition URIError), ou d’autres situations. Pour plus 
d’informations sur chaque classe, voir « Comparaison des classes Error », à la page 292.
?
Moins d’échecs silencieux. Dans les versions précédentes de Flash Player, les erreurs étaient 
générées et signalées uniquement si vous utilisiez explicitement l’instruction throw. Pour 
Flash Player 9, les propriétés et les méthodes ActionScript natives renvoient des erreurs qui 
vous permettent de gérer ces exceptions de façon plus efficace lorsqu’elles se produisent, 
puis de réagir individuellement à chaque exception. 
?
Messages d’erreur clairs affichés lors du débogage. Lorsque vous utilisez la version de 
débogage de Flash Player, les situations ou le code problématiques génèrent des messages 
d’erreur détaillés qui vous aident à identifier les raisons de l’échec d’un bloc de code 
particulier. Ceci permet de réparer les erreurs de façon plus efficace. Pour plus 
d’informations, voir la page 280.
?
Les erreurs précises permettent d’afficher des messages d’erreur clairs pour les utilisateurs 
lors de l’exécution. Dans les versions précédentes de Flash Player, la méthode 
FileReference.upload() renvoyait une valeur booléenne de false en cas d’échec de 
l’appel upload(), indiquant l’une des cinq erreurs possibles. Si une erreur se produit 
lorsque vous appelez la méthode upload() dans ActionScript 3.0, vous pouvez renvoyer 
l’une des quatre erreurs spécifiques afin d’afficher des messages d’erreur plus précis pour 
les utilisateurs finaux.
?
Gestion des erreurs affinée. Des erreurs distinctes sont renvoyées pour de nombreuses 
situations courantes. Par exemple, dans ActionScript 2.0, avant qu’un objet FileReference 
soit renseigné, la propriété name a la valeur null (par conséquent, avant d’utiliser ou 
d’afficher la propriété name, vous devez vérifier que la valeur est définie et qu’elle n’est pas 
null). Dans ActionScript 3.0, si vous tentez d’accéder à la propriété name avant qu’elle 
soit renseignée, Flash Player renvoie une erreur IllegalOperationError qui vous indique 
que la valeur n’a pas été définie. Vous pouvez utiliser des blocs try..catch..finally 
pour gérer l’erreur. Pour plus d’informations, vtry..catch..finally », à la page 281.
278
Gestion des erreurs

?
Aucun problème sérieux de performance. L’utilisation des blocs try..catch..finally 
pour gérer des erreurs ne nécessite pas de ressources supplémentaires comparé aux versions 
précédentes d’ActionScript.
?
Une classe ErrorEvent qui vous permet de créer des écouteurs pour des événements 
d’erreurs asynchrones spécifiques. Pour plus d’informations, voir événements d’erreurs et au statut », à la page 288.
Stratégies de gestion des erreurs
Tant que votre application ne rencontre pas de condition problématique, vous pouvez 
continuer à l’exécuter sans créer de logique de gestion des erreurs dans votre code. 
En revanche, si vous ne gérez pas d’erreurs de façon active et que votre application rencontre 
un problème, vos utilisateurs ignoreront toujours la raison de son échec.
Vous disposez de différentes façons pour aborder la gestion des erreurs dans votre application. 
La liste suivante résume les trois principales options permettant de gérer des erreurs :
?
Utilisez des instructions try..catch..finally. Elles interceptent les erreurs synchrones 
lorsqu’elles se produisent. Vous pouvez imbriquer vos instructions dans une hiérarchie 
pour intercepter des exceptions à différents niveaux d’exécution du code. Pour plus 
d’informations, voir « Utilisation d’instructions try..catch..finally », à la page 281.
?
Créez vos objets d’erreur personnalisés. Vous pouvez utiliser la classe Error pour créer vos 
objets d’erreur personnalisés afin de suivre des opérations spécifiques dans votre 
application qui ne sont pas couvertes par des types d’erreur intégrés. Vous pouvez ensuite 
utiliser des instructions try..catch..finally sur vos objets d’erreur personnalisés. Pour 
plus d’informations, voir « Création de classes d’erreur personnalisées », à la page 286.
?
Ecrivez des gestionnaires et des écouteurs d’événements pour répondre à des événements 
d’erreur. Cette stratégie vous permet de créer des gestionnaires d’erreurs globaux pour 
gérer des événements identiques sans dupliquer beaucoup de code dans des blocs 
try..catch..finally. Il est également plus probable que vous interceptiez des erreurs 
asynchrones à l’aide de cette approche. Pour plus d’informations, événements d’erreurs et au statut », à la page 288.
Gestion des erreurs dans ActionScript 3.0
279

Utilisation de la version de débogage 
de Flash Player
Adobe offre une édition spéciale de Flash Player aux développeurs pour les aider dans leurs 
tâches de débogage. Vous obtenez une copie de la version de débogage de Flash Player lorsque 
vous installez Adobe Flash CS3 ou Adobe Flex Builder 2.
Il existe une grande différence dans la façon dont la version de débogage et la version de Flash 
Player mise sur le marché signalent les erreurs. La version de débogage indique le type d’erreur 
(Error, IOError, ou EOFError générique), le numéro de l’erreur et un message d’erreur sous 
une forme lisible par une personne. La version mise sur le marché indique uniquement le type 
d’erreur et son numéro. Par exemple, considérez le code suivant :
try
{
= myByteArray.readBoolean();
}
catch (error:EOFError)
{
= error.toString();
}
Si la méthode readBoolean() a renvoyé une erreur EOFError dans la version de débogage de 
Flash Player, le message suivant s’affiche dans le champ texte tf : « EOFError: Error #2030: 
End of file was encountered. »
Le même code dans une version de Flash Player mise sur le marché afficherait le texte suivant : 
« EOFError: Error #2030. »
Il n’existe pas de chaînes de message d’erreur afin de réduire au minimum les ressources et la 
taille de Flash Player dans la version mise sur le marché. Vous pouvez consulter le numéro 
d’erreur dans la documentation (les annexes de Référence du langage et des composants 
ActionScript 3.0
) pour l’associer à un message d’erreur. Vous pouvez également reproduire 
l’erreur à l’aide de la version de débogage de Flash Player pour visualiser le message entier. 
280
Gestion des erreurs

Gestion des erreurs synchrones dans une 
application
La gestion des erreurs la plus courante est la logique de gestion des erreurs synchrones, où vous 
insérez des instructions dans votre code pour intercepter des erreurs synchrones lors de 
l’exécution. Ce type de gestion des erreurs permet à votre application de repérer des erreurs 
d’exécution et de les résoudre lorsque des fonctions échouent. La logique permettant 
d’intercepter une erreur synchrone comprend des instructions try..catch..finally qui 
tentent une opération au sens littéral, interceptent les réponses aux erreurs de Flash Player, et 
exécutent d’autres opérations pour gérer celle qui a échoué. 
Utilisation d’instructions try..catch..finally
Lorsque vous gérez des erreurs d’exécution synchrones, utilisez les instructions 
try..catch..finally pour intercepter des erreurs. Lorsqu’une erreur d’exécution se produit, 
Flash Player renvoie une exception, ce qui signifie qu’il suspend l’exécution normale et crée un 
objet spécial de type Error. L’objet Error est ensuite renvoyé au premier bloc catch disponible.
L’instruction try regroupe les instructions pouvant créer des erreurs. Vous utilisez toujours 
l’instruction catch avec une instruction try. Si une erreur est détectée dans l’une des 
instructions du bloc try, les instructions catch associées à cette instruction try sont exécutées. 
L’instruction finally regroupe les instructions exécutées, qu’une erreur se produise ou non 
dans le bloc try. S’il n’y a aucune erreur, les instructions du bloc finally sont exécutées une 
fois que les instructions du bloc try l’ont été. S’il y a une erreur, l’instruction catch 
appropriée est exécutée en premier lieu, suivi des instructions du bloc finally. 
Le code suivant démontre la syntaxe permettant d’utiliser les instructions 
try..catch..finally :
try
{
   // code qui pourrait renvoyer une erreur
}
catch (err:Error)
{
   // code réagissant à l’erreur
}
finally
{
// Code exécuté, qu’une erreur soit renvoyée ou non. Ce code peut 
// nettoyer après l’erreur, ou faire en sorte que l’exécution 
// de l’application continue.
}
Gestion des erreurs synchrones dans une application
281

Chaque instruction catch identifie un type d’exception spécifique qu’elle gère. L’instruction 
catch peut spécifier uniquement des classes d’erreur qui sont des sous-classes de la classe 
Error. Chaque instruction catch est vérifiée dans l’ordre. Seule la première instruction catch 
qui correspond au type d’erreur renvoyé est exécutée. En d’autres termes, si vous vérifiez 
d’abord la classe Error de niveau supérieur, seule la classe Error de niveau supérieur 
correspond. Le code suivant illustre ce point :
try
{
throw new ArgumentError("I am an ArgumentError");
}
catch (error:Error)
{
trace("<Error> " + error.message);
}
catch (error:ArgumentError)
{
trace("<ArgumentError> " + error.message);
}
Le code précédent affiche le résultat suivant :
<Error> I am an ArgumentError
Si vous souhaitez intercepter correctement l’erreur ArgumentError, vous devez vérifier que les 
types d’erreur les plus spécifiques sont répertoriés en premier, et les types d’erreur les plus 
génériques ensuite, comme l’indique le code suivant :
try
{
throw new ArgumentError("I am an ArgumentError");
}
catch (error:ArgumentError)
{
trace("<ArgumentError> " + error.message);
}
catch (error:Error)
{
trace("<Error> " + error.message);
}
282
Gestion des erreurs

Plusieurs méthodes et propriétés dans l’API de Flash Player renvoient des erreurs d’exécution 
si elles en rencontrent lors de leur exécution. Par exemple, la méthode close() dans la classe 
Sound renvoie une erreur IOError si la méthode ne parvient pas à fermer le flux audio, 
comme indiqué dans le code suivant :
var mySound:Sound = new Sound();
try
{
mySound.close();
}
catch (error:IOError)
{
// Error #2029: This URLStream object does not have an open stream.
}
Au fur et à mesure que vous vous familiariserez avec la Référence du langage et des composants 
ActionScript 3.0
, vous identifierez les méthodes qui renvoient des exceptions, comme détaillé 
dans la description de chaque méthode.
L’instruction throw
Flash Player renvoie des exceptions lorsqu’il rencontre des erreurs dans votre application lors 
de l’exécution. En outre, vous pouvez renvoyer des exceptions de façon explicite à l’aide de 
l’instruction throw. Lorsque vous le faites, Adobe vous conseille de renvoyer des instances de 
la classe Error ou de ses sous-classes. Le code suivant démontre une instruction throw qui 
renvoie une instance de la classe Error, MyErr, et appelle une fonction, myFunction() en 
réponse au renvoi de l’erreur :
var MyError:Error = new Error("Encountered an error with the numUsers 
value", 99);
var numUsers:uint = 0;
try
{
if (numUsers == 0)
{
trace("numUsers equals 0");
}
}
catch (error:uint)
{
throw MyError; // Interception d’erreurs d’entiers non signés.
}
catch (error:int)
{
throw MyError; // Interception d’erreurs d’entiers.
}
Gestion des erreurs synchrones dans une application
283

catch (error:Number)
{
throw MyError; // Interception d’erreurs de nombres.
}
catch (error:*)
{
throw MyError; // Interception d’autres erreurs.
}
finally 
{
myFunction(); // Exécution du nettoyage nécessaire ici.
}
Les instructions catch sont classées de façon à ce que les types de données les plus spécifiques 
apparaissent en premier. Si l’instruction catch pour le type de données Number est 
répertoriée en premier, ni l’instruction catch pour le type de données uint ni l’instruction 
catch pour le type de données int n’est exécutée.
REMARQUE
Dans le langage de programmation Java, chaque fonction qui peut renvoyer une 
exception doit déclarer ce fait en répertoriant les classes d’exception qu’elle peut 
renvoyer dans une clause throws associée à la déclaration de la fonction. ActionScript 
n’exige pas que vous déclariez les exceptions pouvant être renvoyées par une fonction.
Affichage d’un message d’erreur simple
L’un des avantages majeurs du nouveau modèle d’événement d’erreur et d’exception est qu’il 
vous permet d’informer les utilisateurs du moment où une action échoue et de la raison de cet 
échec. Votre rôle consiste à écrire le code pour afficher le message et à offrir des options en 
réponse.
Le code suivant représente une instruction try..catch simple pour afficher l’erreur dans un 
champ texte :
package
{
import flash.display.Sprite;
import .TextField;
public class SimpleError extends Sprite
{
public var employee:XML = 
<EmpCode>
<costCenter>1234</costCenter>
<costCenter>1-234</costCenter>
</EmpCode>;
284
Gestion des erreurs

public function SimpleError()
{
try
{
if (employee.costCenter.length() != 1)
{
throw new Error("Error, employee must have exactly one cost 
center assigned.");
}

catch (error:Error)
{
var errorMessage:TextField = new TextField();
errorMessage.autoSize = ;
errorMessage.textColor = 0xFF0000;
= error.message;
addChild(errorMessage);
}
}
}
}
En utilisant un plus grand nombre de classes d’erreur et d’erreurs de compilateur intégrées, 
ActionScript 3.0 fournit de plus amples informations sur les raisons de l’échec d’une action 
que les versions précédentes. Ceci vous permet de créer des applications plus stables avec une 
meilleure gestion des erreurs. 
Renvoi des erreurs
Lorsque vous créez des applications, il peut souvent arriver que vous deviez renvoyer une 
erreur si vous ne parvenez pas à la gérer correctement. Par exemple, le code suivant représente 
un bloc try..catch imbriqué, qui renvoie une erreur ApplicationError personnalisée si le 
bloc catch ne parvient pas à gérer l’erreur :
try
{
try
{
trace("<< try >>");
throw new ArgumentError("some error which will be rethrown");
}
catch (error:ApplicationError)
{
trace("<< catch >> " + error);
trace("<< throw >>");
throw error;
}
Gestion des erreurs synchrones dans une application
285

catch (error:Error)
{
trace("<< Error >> " + error);
}
}
catch (error:ApplicationError)
{
trace("<< catch >> " + error);
}
Le résultat issu du fragment de code précédent serait le suivant :
<< try >>
<< catch >> ApplicationError: some error which will be rethrown
<< throw >>
<< catch >> ApplicationError: some error which will be rethrown
Le bloc try imbriqué renvoie une erreur ApplicationError personnalisée qui est interceptée 
par le bloc catch suivant. Ce bloc catch imbriqué peut tenter de gérer l’erreur, et si la 
tentative échoue, renvoyer l’objet ApplicationError au bloc try..catch.
Création de classes d’erreur 
personnalisées
Vous pouvez étendre l’une des classes Error standard pour créer vos classes d’erreur spécialisées 
dans ActionScript. Vous pouvez créer vos classes d’erreur pour les motifs suivants :
?
Identifier des erreurs ou des groupes d’erreurs spécifiques uniques pour votre application. 
Par exemple, vous pouvez gérer différemment les erreurs renvoyées par votre code, en plus 
de celles interceptées par Flash Player. Vous pouvez créer une sous-classe de la classe Error 
pour suivre le nouveau type de données d’erreur dans les blocs try..catch.
?
Fournir des fonctionnalités d’affichage d’erreurs exceptionnelles pour les erreurs générées 
par votre application. 
Par exemple, vous pouvez créer une méthode toString() qui formate vos messages 
d’erreur d’une certaine façon. Vous pouvez également définir une méthode 
lookupErrorString() qui prend un code d’erreur et récupère le message adéquat en 
fonction du langage que l’utilisateur préfère.
286
Gestion des erreurs

Une classe d’erreur spécialisée doit étendre la classe Error d’ActionScript de base. Voici un 
exemple d’une classe AppError spécialisée qui étend la classe Error :
public class AppError extends Error
{
public function AppError(message:String, errorID:int)
{
super(message, errorID);
}
}
L’exemple suivant illustre l’utilisation d’une classe AppError dans votre projet :
try
{
throw new AppError("Encountered Custom AppError", 29);
}
catch (error:AppError)
{
trace(error.errorID + ": " + error.message)
}
REMARQUE
Si vous souhaitez remplacer la méthode Error.toString() dans votre sous-classe, vous 
devez lui fournir un paramètre  (reste). La spécification de langage ECMAScript 
(ECMA-262), version 3 définit la méthode Error.toString() de cette façon, et 
ActionScript 3.0 la définit de la même manière pour la compatibilité ascendante avec 
cette spécification. Par conséquent, lorsque vous remplacez la méthode 
Error.toString() vous devez faire correspondre les paramètres exactement. Vous ne 
pouvez pas transmettre de paramètres à votre méthode toString() lors de l’exécution 
car ils sont ignorés.
Création de classes d’erreur personnalisées
287

Réponse à des événements d’erreurs et 
au statut
L’une des améliorations majeures apportées à la gestion des erreurs dans ActionScript 3.0 est la 
prise en charge de la gestion des événements d’erreur pour répondre à des erreurs d’exécution 
asynchrones. (Voir « Types d’erreurs », à la page 275 pour consulter la définition des erreurs 
asynchrones.) 
Vous pouvez créer des écouteurs d’événements et des gestionnaires d’événements pour 
répondre aux événements d’erreurs. De nombreuses classes distribuent des événements 
d’erreurs de la même façon que d’autres événements. Par exemple, une instance de la classe 
XMLSocket distribue normalement trois types d’événements : Event.CLOSE, 
Event.CONNECT, et . Néanmoins, lorsqu’un problème a lieu, la classe 
XMLSocket peut distribuer IOErrorEvent.IOError ou 
SecurityErrorEvent.SECURITY_ERROR. Pour de plus amples informations sur les écouteurs 
d’événements et les gestionnaires d’événements, voir la page 335.
Les événements d’erreurs peuvent être classés en deux catégories : 
?
Evénements d’erreurs qui étendent la classe ErrorEvent 
La classe flash.events.ErrorEvent contient les propriétés et les méthodes permettant de 
gérer les erreurs d’exécution de Flash Player liées à des opérations de réseau et de 
communication. Les classes AsyncErrorEvent, IOErrorEvent et SecurityErrorEvent 
étendent la classe ErrorEvent. Si vous utilisez la version de débogage de Flash Player, 
une boîte de dialogue vous informe, lors de l’exécution, de la présence d’événements 
d’erreurs sans fonctions d’écouteur rencontrés par le lecteur.
?
Evénements d’erreurs basés sur le statut
Les événements basés sur le statut sont liés aux propriétés netStatus et status des 
classes de communication et de réseau. Si Flash Player rencontre un problème lors de 
la lecture ou de l’écriture des données, la valeur des propriétés 
.level ou status.level (selon l’objet de classe que vous utilisez) 
est définie sur la valeur "error". Vous répondez à cette erreur en vérifiant que la 
propriété level contient la valeur "error" dans votre fonction de gestionnaire 
d’événements.
288
Gestion des erreurs

Utilisation d’événements d’erreurs
La classe ErrorEvent et ses sous-classes contiennent des types d’erreurs pour gérer les erreurs 
distribuées par Flash Player lors de la lecture ou de l’écriture des données.
L’exemple suivant utilise une instruction try..catch et des gestionnaires d’événements pour 
afficher les erreurs détectées lors de la tentative de lecture d’un fichier local. Vous pouvez 
ajouter un code de gestion plus élaboré pour permettre à l’utilisateur de gérer l’erreur 
automatiquement aux endroits indiqués par le commentaire « entrez votre code ici » :
package
{
import flash.display.Sprite;
import flash.errors.IOError;
import flash.events.IOErrorEvent;
import flash.events.TextEvent;
import flash.media.Sound;
import flash.media.SoundChannel;
import .URLRequest;
import .TextField;
public class LinkEventExample extends Sprite
{
private var myMP3:Sound;
public function LinkEventExample()
{
myMP3 = new Sound();
var list:TextField = new TextField();
list.autoSize = ;
list.multiline = true;
list.htmlText = "<a href=\"event:track1.mp3\">Track 1</a><br>";
list.htmlText += "<a href=\"event:track2.mp3\">Track 2</a><br>";
addEventListener(, linkHandler);
addChild(list);
}
private function playMP3(mp3:String):void
{
try
{
(new URLRequest(mp3));
();
}
catch (err:Error)
{
trace(err.message);
// entrez votre code ici
}
myMP3.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);
}
Réponse à des événements d’erreurs et au statut
289

private function linkHandler(linkEvent:TextEvent):void
{
playMP3();
// entrez votre code ici
}
private function errorHandler(errorEvent:IOErrorEvent):void
{
trace();
// entrez votre code ici
}
}
}
Utilisation d’événements de changement de statut
Flash Player change dynamiquement la valeur des propriétés .level ou 
status.level pour les classes qui prennent en charge la propriété level. Les classes qui ont 
la propriété .level sont NetConnection, NetStream et SharedObject. 
Les classes qui ont la propriété status.level sont HTTPStatusEvent, Camera, Microphone 
et LocalConnection. Vous pouvez écrire une fonction de gestionnaire pour répondre au 
changement de valeur level et suivre les erreurs de communication.
L’exemple suivant utilise une fonction netStatusHandler() pour tester la valeur de la 
propriété level. Si la propriété level indique qu’une erreur a été rencontrée, le code suit le 
message « Video stream failed ».
package
{
import flash.display.Sprite;
import flash.events.NetStatusEvent;
import flash.events.SecurityErrorEvent;
import flash.media.Video;
import .NetConnection;
import .NetStream;
public class VideoExample extends Sprite
{
private var videoUrl:String = "";
private var connection:NetConnection;
private var stream:NetStream;
290
Gestion des erreurs

public function VideoExample()
{
connection = new NetConnection();
connection.addEventListener(NetStatusEvent.NET_STATUS, 
netStatusHandler);
connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, 
securityErrorHandler);
connection.connect(null);
}
private function netStatusHandler(event:NetStatusEvent):void
{
if (.level = "error")
{
trace("Video stream failed")
}
else 
{
connectStream();
}
}
private function securityErrorHandler(event:SecurityErrorEvent):void
{
trace("securityErrorHandler: " + event);
}
private function connectStream():void
{
var stream:NetStream = new NetStream(connection);
var video:Video = new Video();
video.attachNetStream(stream);
(videoUrl);
addChild(video);
}
}
}
Réponse à des événements d’erreurs et au statut
291

Comparaison des classes Error 
ActionScript fournit de nombreuses classes Error prédéfinies. Flash Player utilise un grand 
nombre de ces classes mais vous pouvez également utiliser les mêmes classes Error dans votre 
code. Il existe deux principaux types de classes Error dans ActionScript 3.0 : les classes Error 
de base d’ActionScript et les classes Error du package flash.error. Les classes Error de base sont 
définies par la spécification de langage ECMAScript (ECMA-262), version 4. Le package 
flash.error contient des classes supplémentaires permettant le débogage et le développement 
de l’application ActionScript 3.0.
Classes Error de base ECMAScript
Les classes Error de base ECMAScript comprennent les classes Error, EvalError, RangeError, 
ReferenceError, SyntaxError, TypeError et URIError. Chacune de ces classes se trouve dans 
l’espace de nom de niveau supérieur.
Nom de 
Description
Remarques
classe
Error
Vous pouvez utiliser la classe 
La classe Error sert de classe de base 
Error pour renvoyer des 
pour toutes les erreurs d’exécution 
exceptions. Il s’agit de la classe 
renvoyées par Flash Player. Elle est 
de base pour les autres classes 
recommandée pour toutes les classes 
d’exception définies dans 
d’erreur personnalisées.
ECMAScript : EvalError, 
RangeError, ReferenceError, 
SyntaxError, TypeError et 
URIError.
EvalError
Une exception EvalError est 
Dans ActionScript 3.0, la prise en 
renvoyée si des paramètres sont  charge de la fonction eval() a été 
transmis au constructeur de la 
supprimée et les tentatives d’utilisation 
classe Function ou si le code 
de la fonction provoquent le renvoi d’une 
utilisateur appelle la fonction 
erreur.
eval().
Les versions précédentes de Flash 
Player utilisaient la fonction eval() pour 
accéder à des variables, des propriétés, 
des objets ou des clips par nom.
292
Gestion des erreurs

Nom de 
Description
Remarques
classe
RangeError
Une exception RangeError est 
Par exemple, une exception RangeError 
renvoyée si une valeur numérique  est renvoyée par la classe Timer si un 
excède la plage acceptable.
retard est négatif ou non fini. Elle peut 
également être renvoyée si vous tentez 
d’ajouter un objet d’affichage à une 
profondeur non valide.
ReferenceError
Une exception ReferenceError 
Les exceptions pour des variables non 
est renvoyée lorsque vous tentez  définies pointent vers des bogues 
d’utiliser une référence à une 
éventuels afin d’améliorer la qualité du 
propriété non définie pour un 
logiciel. Cependant, si vous n’avez pas 
objet scellé (non dynamique). 
l’habitude d’initialiser vos variables, ce 
Les versions du compilateur 
nouveau comportement d’ActionScript 
ActionScript antérieures à 
risque d’exiger des changements dans 
ActionScript 3.0 ne renvoyaient  vos habitudes de codage.
pas d’erreur lorsque vous tentiez 
d’accéder à une propriété 
undefined. Néanmoins, étant 
donné que la nouvelle 
spécification ECMAScript 
indique qu’une erreur doit être 
renvoyée dans cette condition, 
ActionScript 3.0 renvoie 
l’exception ReferenceError. 
SyntaxError
Une exception SyntaxError est 
Une exception SyntaxError peut être 
renvoyée lorsqu’il se produit une  renvoyée dans les cas suivants :
erreur d’analyse dans votre code  • ActionScript renvoie des exceptions 
ActionScript.
SyntaxError lorsqu’une expression 
Pour plus d’informations, voir 
régulière non valide est analysée par la 
Section 15.11.6.4 du langage de 
classe RegExp.
spécification ECMAScript 
• ActionScript renvoie des exceptions 
SyntaxError lorsqu’un fichier XML non 
(ECMA-262), version 3 
valide est analysé par la classe 
(disponible jusqu’à la version 4) 
XMLDocument.
sur le  ainsi 
que la Section 10.3.1 de la 
spécification ECMAScript pour 
XML (E4X) (ECMA-357, version 
2) sur le site .
Comparaison des classes Error
293

Nom de 
Description
Remarques
classe
TypeError
L’exception TypeError est 
Une exception TypeError peut être 
renvoyée lorsque le type réel d’un  renvoyée dans les cas suivants :
opérande ne correspond pas au  • Un paramètre réel de fonction ou de 
type prévu.
méthode ne peut pas être forcé à 
Pour plus d’informations, voir 
correspondre au type de paramètre 
Section 15.11.6.5 de la 
formel.
spécification ECMAScript sur le  • Une valeur est affectée à une variable 
et ne peut pas être forcée à 
site -
correspondre au type de la variable.

• Le côté droit de l’opérateur is ou 
 ainsi 
instanceof n’est pas un type valide.
que la Section 10.3 de la 
• L’utilisation du mot clé super n’est pas 
spécification E4X sur le site 
valide.

• Une recherche de propriété donne lieu 
publications/standards/Ecma-
à plusieurs liaisons, soit un résultat 
.
ambigu.
• Une méthode est appelée pour un 
objet incompatible. Par exemple, une 
exception TypeError est renvoyée si 
une méthode dans la classe RegExp 
est « greffée » sur un objet générique, 
puis appelée.
URIError
L’exception URIError est 
Une exception URIError peut être 
renvoyée lorsque l’une des 
renvoyée dans les cas suivants :
fonctions de gestion URI 
Un URI non valide est défini par une 
globales est utilisée d’une 
fonction API de Flash qui s’attend à un 
manière qui n’est pas compatible  URI valide, comme Socket.connect().
avec sa définition.
Pour plus d’informations, voir 
Section 15.11.6.6 de la 
spécification ECMAScript sur le 
site .
294
Gestion des erreurs

Classes Error de base d’ActionScript
Outre les classes Error ECMAScript de base, ActionScript ajoute plusieurs classes pour des 
conditions d’erreurs propres à ActionScript et la fonctionnalité de gestion des erreurs.
Etant donné que ces classes sont des extensions de langage ActionScript de la spécification de 
langage ECMAScript, version 4 qui pourraient être intéressantes pour la spécification 
préliminaire, elles sont conservées au niveau supérieur au lieu d’être placées dans un package 
comme flash.error.
Nom de classe
Description
Remarques
ArgumentError
La classe ArgumentError 
Voici des exemples d’erreurs 
représente une erreur qui se 
d’argument :
produit lorsque les valeurs de 
• Trop ou trop peu d’arguments 
paramètre fournies lors d’un 
sont fournis à une méthode.
appel de fonction ne 
• Un argument devait être membre 
correspondent pas aux 
d’une énumération, et cela n’a pas 
paramètres définis pour celle-ci.
été le cas.
SecurityError
L’exception SecurityError est 
Voici des exemples d’erreurs de 
renvoyée lorsqu’une violation de  sécurité :
sécurité se produit et que l’accès  • Un accès à une propriété ou un 
est refusé.
appel de méthode non autorisé 
est effectué en franchissant les 
limites du sandbox de sécurité.
• Il s’est produit une tentative 
d’accès à une URL non autorisée 
par le sandbox de sécurité.
• Il s’est produit une tentative de 
connexion socket à un numéro de 
port non autorisé (port inférieur à 
1024, par exemple) sans fichier de 
régulation défini.
• Il s’est produit une tentative 
d’accès à l’appareil photo ou au 
microphone de l’utilisateur et 
celui-ci a refusé la demande 
d’accès au périphérique.
VerifyError
Une erreur VerifyError est 
Lorsqu’un fichier SWF charge un 
renvoyée lorsqu’un fichier SWF 
autre fichier SWF, le SWF parent 
incorrect ou altéré est détecté.
peut intercepter une exception 
VerifyError générée par le SWF 
chargé.
Comparaison des classes Error
295

Classes Error du package flash.error
Le package flash.error regroupe des classes Error qui font partie de l’API de Flash Player. A la 
différence des classes Error décrites précédemment, le package flash.error communique des 
événements d’erreurs propres à Flash Player.
Nom de classe
Description
Remarques
EOFError
Une exception EOFError est 
Par exemple, une exception 
renvoyée lors d’une tentative de  EOFError est renvoyée lorsque 
lecture au-delà de la fin des 
l’une des méthodes de lecture dans 
données disponibles.
l’interface IDataInput est appelée et 
qu’il n’existe pas assez de données 
pour satisfaire la requête de lecture.
IllegalOperationError Une exception 
Voici quelques exemples 
IllegalOperationError est 
d’exceptions d’erreurs non valides :
renvoyée lorsqu’une méthode 
• Une classe de base, telle que 
n’est pas mise en oeuvre ou si la 
DisplayObjectContainer, propose 
mise en oeuvre ne couvre pas 
plus de fonctionnalités qu’une 
l’utilisation actuelle.
scène peut prendre en charge. 
Par exemple, si vous tentez 
d’obtenir ou de définir un masque 
sur la scène (à l’aide de 
), Flash Player renvoie 
une exception 
IllegalOperationError 
accompagnée du message « The 
Stage class does not implement 
this property or method ».
• Une sous-classe hérite d’une 
méthode dont elle n’a pas besoin 
et qu’elle ne souhaite pas prendre 
en charge.
• Certaines méthodes 
d’accessibilité sont appelées 
lorsque Flash Player est compilé 
sans les fonctions d’accessibilité.
• Les fonctions liées à la 
programmation uniquement sont 
appelées à partir d’une version 
d’exécution de Flash Player.
• Vous tentez de définir le nom d’un 
objet placé sur le scénario.
296
Gestion des erreurs

Nom de classe
Description
Remarques
IOError
Une exception IOError est 
Vous obtenez cette erreur, par 
renvoyée lorsqu’un type 
exemple, lorsque vous tentez une 
d’exception E/S se produit.
opération de lecture-écriture sur un 
socket qui n’est pas connecté ou qui 
est déconnecté.
MemoryError
Une exception MemoryError est  Par défaut, ActionScript Virtual 
renvoyée lors de l’échec d’une 
Machine 2 n’impose pas de limite à 
requête d’allocation de mémoire. la quantité de mémoire qu’un 
programme ActionScript peut 
allouer. Sur un PC de bureau, les 
échecs d’allocation de mémoire ne 
sont pas fréquents. Une erreur est 
renvoyée lorsque le système ne 
parvient pas à allouer la mémoire 
requise pour une opération. Par 
conséquent, sur un PC de bureau, 
cette exception est rare, à moins 
qu’une requête d’allocation soit 
vraiment importante (par exemple, 
une requête de 3 milliards d’octets 
est impossible car un programme 
Microsoft® Windows® de 32 bits 
peut accéder à 2 Go d’espace 
d’adressage uniquement).
ScriptTimeoutError
Une exception 
Pour éviter qu’un développeur 
ScriptTimeoutError est renvoyée  intercepte l’exception et reste dans 
lorsqu’un intervalle de délai 
une boucle sans fin, seule la 
d’expiration du script de 
première exception 
15 secondes est atteint. 
ScriptTimeoutError renvoyée au 
En interceptant une exception 
cours d’un script donné peut être 
ScriptTimeoutError, vous pouvez  interceptée. Votre code ne peut pas 
gérer le délai d’expiration du 
intercepter une exception 
script plus en douceur. S’il 
ScriptTimeoutError ultérieure. 
n’existe aucun gestionnaire 
Elle passe immédiatement au 
d’exceptions, le gestionnaire de 
gestionnaire de l’exception non 
l’exception non interceptée 
interceptée.
affiche une boîte de dialogue 
accompagnée d’un message 
d’erreur.
StackOverflowError
L’exception StackOverflowError  Une exception StackOverflowError 
est renvoyée lorsque la pile 
peut indiquer qu’un problème de 
disponible pour le script a été 
récursivité à l’infini s’est produit. 
épuisée.
Comparaison des classes Error
297

Exemple : Application CustomErrors
L’application CustomErrors décrit les techniques d’utilisation des erreurs personnalisées lors 
de la création d’une application. Ces techniques sont les suivantes :
?
Validation d’un paquet XML
?
Ecriture d’une erreur personnalisée
?
Renvoi d’erreurs personnalisées
?
Notification des utilisateurs lors du renvoi d’une erreur
Pour obtenir les fichiers d’application pour cet exemple, voir 
;Les fichiers d’application 
CustomErrors se trouvent dans le dossier Samples/CustomError. Cette application se 
compose des fichiers suivants :
Fichier
Description

Le fichier d’application principal dans Flash 
ou
(FLA) ou Flex (MXML)

com/example/programmingas3/errors/
Une classe servant de classe d’erreur de base 

pour les classes FatalError et WarningError.
com/example/programmingas3/errors/
Une classe qui définit une erreur FatalError qui 

peut être renvoyée par l’application. 
Cette classe étend la classe ApplicationError 
personnalisée.
com/example/programmingas3/errors/
Une classe qui définit une seule méthode qui 

valide un paquet XML employee fourni par 
l’utilisateur.
com/example/programmingas3/errors/
Une classe qui définit une erreur WarningError 

qui peut être renvoyée par l’application. 
Cette classe étend la classe ApplicationError 
personnalisée.
298
Gestion des erreurs

Présentation de l’application CustomErrors
Le fichier contient l’interface utilisateur et une logique pour 
l’application d’erreur personnalisée. Une fois que l’événement creationComplete de 
l’application est distribué, la méthode initApp() est appelée. Cette méthode définit un 
exemple de paquet XML que la classe Validator vérifiera. Le code suivant présente la méthode 
initApp() :
private function initApp():void
{
employeeXML = 
<employee id="12345">
<firstName>John</firstName>
<lastName>Doe</lastName>
<costCenter>12345</costCenter>
<costCenter>67890</costCenter>
</employee>;
}
Le paquet XML est ensuite affiché dans une occurrence de composant TextArea sur la scène. 
Ceci vous permet de modifier le paquet XML avant de tenter de le revalider. 
Lorsque l’utilisateur clique sur le bouton de validation, la méthode validateData() est 
appelée. Cette méthode valide le paquet XML employee à l’aide de la méthode 
validateEmployeeXML() dans la classe Validator. Le code suivant présente la méthode 
validateData() :
public function validateData():void
{
try
{
var tempXML:XML = XML();
Validator.validateEmployeeXML(tempXML);
= "The XML was successfully validated.";
}
catch (error:FatalError)
{
showFatalError(error);
}
catch (error:WarningError)
{
showWarningError(error);
}
catch (error:Error)
{
showGenericError(error);
}
}
Exemple : Application CustomErrors
299

Un objet XML temporaire est d’abord créé à l’aide du contenu de l’occurrence de composant 
TextArea xmlText. Ensuite, la méthode validateEmployeeXML() dans la classe Validator 
personnalisée () est appelée et transmet 
l’objet XML temporaire comme paramètre. Si le paquet XML est valide, l’occurrence de 
composant Label status affiche un message de réussite et l’application se ferme. Si la 
méthode validateEmployeeXML() a renvoyé une erreur personnalisée (c’est-à-dire qu’une 
erreur FatalError, WarningError ou une erreur générique s’est produite), l’instruction catch 
appropriée est exécutée et appelle les méthodes showFatalError(), showWarningError() 
ou showGenericError(). Chacune de ces méthodes affiche un message approprié dans une 
composant Alert afin d’informer l’utilisateur de l’erreur spécifique qui s’est produite. Chaque 
méthode met également à jour l’occurrence de composant Label status avec un message 
spécifique.
Si une erreur grave se produit pendant une tentative de validation du paquet XML employee, 
le message d’erreur s’affiche dans un composant Alert, et l’occurrence de composant TextArea 
xmlText et l’occurrence de composant Button validateBtn sont désactivées, comme 
l’indique le code suivant :
public function showFatalError(error:FatalError):void
{
var message:String = error.message + "\n\n" + "Click OK to end.";
var title:String = error.getTitle();
(message, title);
= "This application has ended.";
this.xmlText.enabled = false;
this.validateBtn.enabled = false;
}
Si une erreur d’avertissement au lieu d’une erreur grave se produit, le message d’erreur est 
désactivé dans une occurrence de composant Alert, mais les occurrences de composant 
TextField et Button ne sont pas désactivées. La méthode showWarningError() affiche le 
message d’erreur personnalisée dans l’occurrence de composant Alert. Le message invite 
également l’utilisateur à indiquer s’il souhaite poursuivre la validation du XML ou 
abandonner le script. Le fragment de code suivant présente la méthode 
showWarningError() :
public function showWarningError(error:WarningError):void
{
var message:String = error.message + "\n\n" + "Do you want to exit this 
application?";
var title:String = error.getTitle();
(message, title, | , null, closeHandler);
= message;
}
300
Gestion des erreurs

Lorsque l’utilisateur ferme l’occurrence de composant Alert au moyen du bouton Oui ou 
Non, la méthode closeHandler() est appelée. Le fragment de code suivant présente la 
méthode closeHandler() :
private function closeHandler(event:CloseEvent):void
{
switch (event.detail)
{
case :
showFatalError(new FatalError(9999));
break;
case :
break;
}
}
Si l’utilisateur souhaite abandonner le script en cliquant sur Oui dans la boîte de dialogue 
Alert d’erreur d’avertissement, une exception FatalError est renvoyée, provoquant l’arrêt de 
l’application.
Création d’une validation personnalisée
La classe de validation personnalisée contient une seule méthode, validateEmployeeXML(). 
La méthode validateEmployeeXML() prend un seul argument, employee, qui correspond au 
paquet XML que vous souhaitez valider. La méthode validateEmployeeXML() est la 
suivante :
public static function validateEmployeeXML(employee:XML):void
{
// checks for the integrity of items in the XML
if (employee.costCenter.length() < 1)
{
throw new FatalError(9000);
}
if (employee.costCenter.length() > 1)
{
throw new WarningError(9001);
}
if (.length() != 1)
{
throw new FatalError(9002);
}
}
Exemple : Application CustomErrors
301

Un employé doit appartenir à un (et un seul) centre de coût pour être validé. S’il n’appartient 
à aucun centre de coût, la méthode renvoie une FatalError, qui se propage jusqu’à la méthode 
validateData() dans le fichier d’application principale. Si l’employé appartient à plusieurs 
centres de coût, une WarningError est renvoyée. La dernière vérification dans la validation 
XML contrôle que l’utilisateur a exactement un numéro de sécurité sociale défini (le noeud 
ssn dans le paquet XML). S’il n’y a pas exactement un nœud ssn, une erreur FatalError est 
renvoyée.
Vous pouvez ajouter des vérifications supplémentaires à la méthode validateEmployeeXML(). 
Par exemple, pour vérifier que le noeud ssn contient un numéro valide, ou que l’employé a au 
moins un numéro de téléphone et une adresse électronique définis, et que ces deux valeurs sont 
valides. Vous pouvez également modifier le XML de façon à ce que chaque employé ait un ID 
unique et spécifie l’ID de son responsable.
Définition de la classe ApplicationError
La classe ApplicationError sert de classe de base pour les classes FatalError et WarningError. 
Elle étend la classe Error et définit ses propres propriétés et méthodes personnalisées, y 
compris un ID d’erreur, la gravité et un objet XML contenant les codes d’erreur personnalisés 
et les messages. Cette classe définit également deux constantes statiques utilisées pour définir 
la gravité de chaque type d’erreur.
La méthode du constructeur de la classe ApplicationError est la suivante :
public function ApplicationError()
{
messages = 
<errors>
<error code="9000">
<![CDATA[Employee must be assigned to a cost center.]]>
</error>
<error code="9001">
<![CDATA[Employee must be assigned to only one cost center.]]>
</error>
<error code="9002">
<![CDATA[Employee must have one and only one SSN.]]>
</error>
<error code="9999">
<![CDATA[The application has been stopped.]]>
</error>
</errors>;
}
302
Gestion des erreurs

Chaque noeud d’erreur dans l’objet XML contient un code numérique unique et un message 
d’erreur. Vous pouvez consulter facilement les messages d’erreur par code d’erreur à l’aide 
d’E4X, comme indiqué dans la méthode getMessageText() suivante :
public function getMessageText(id:int):String
{
var message:XMLList = messages.error.(@code == id);
return message[0].text();
}
La méthode getMessageText() prend un seul argument entier, id, et renvoie une chaîne. 
L’argument id est le code d’erreur pour l’erreur à rechercher. Par exemple, lorsque vous 
transmettez un id de 9001, l’erreur indiquant que les employés doivent être affectés à un seul 
centre de coût est renvoyée. Si plusieurs erreurs ont le même code, ActionScript renvoie le 
message d’erreur uniquement pour le premier résultat trouvé (message[0] dans l’objet 
XMLList renvoyé).
La méthode suivante dans cette classe, getTitle(), ne prend aucun paramètre et renvoie une 
valeur de chaîne qui contient l’ID d’erreur pour cette erreur spécifique. Cette valeur est 
utilisée dans le titre du composant Alert pour identifier l’erreur exacte s’étant produite lors de 
la validation du paquet XML. Le fragment de code suivant présente la méthode getTitle() :
public function getTitle():String
{
return "Error #" + id;
}
La méthode finale dans la classe ApplicationError est toString(). Cette méthode remplace 
la fonction définie dans la classe Error pour que vous puissiez personnaliser la présentation du 
message d’erreur. La méthode renvoie une chaîne qui identifie le numéro d’erreur spécifique et 
le message qui s’est affiché.
public override function toString():String
{
return "[APPLICATION ERROR #" + id + "] " + message;
}
Exemple : Application CustomErrors
303

Définition de la classe FatalError
La classe FatalError étend la classe ApplicationError personnalisée et définit trois méthodes : le 
constructeur FatalError, getTitle(), et toString(). La première méthode, le constructeur 
FatalError, prend un seul argument entier, errorID, et définit la gravité de l’erreur à l’aide des 
valeurs de constante statiques définies dans la classe ApplicationError. Elle obtient le message 
de l’erreur spécifique en appelant la méthode getMessageText() dans la classe 
ApplicationError. Le constructeur FatalError se présente comme suit :
public function FatalError(errorID:int)
{
id = errorID;
severity = ApplicationError.FATAL;
message = getMessageText(errorID);
}
La méthode suivante dans la classe FatalError, getTitle(), remplace la méthode getTitle() 
définie précédemment dans la classe ApplicationError et ajoute le texte « -- FATAL » dans le 
titre pour informer l’utilisateur qu’une erreur grave s’est produite. La méthode getTitle() se 
présente comme suit :
public override function getTitle():String
{
return "Error #" + id + " -- FATAL";
}
La méthode finale dans cette classe, toString(), remplace la méthode toString() définie 
dans la classe ApplicationError. La méthode toString() est 
public override function toString():String
{
return "[FATAL ERROR #" + id + "] " + message;
}
Définition de la classe WarningError
La classe WarningError étend la classe ApplicationError et est presque identique à la classe 
FatalError, excepté quelques changements de chaîne mineurs. Elle définit la gravité de l’erreur 
sur ApplicationError.WARNING au lieu de ApplicationError.FATAL, comme indiqué dans 
le code suivant :
public function WarningError(errorID:int)
{
id = errorID;
severity = ApplicationError.WARNING;
message = super.getMessageText(errorID);
}
304
Gestion des erreurs

CHAPITRE 9
Utilisation d’expressions 
9
régulières
Une expression régulière décrit un modèle servant à rechercher et à manipuler du texte de 
correspondance dans des chaînes. Les expressions régulières ressemblent à des chaînes, mais 
elles comprennent des codes spéciaux pour décrire des modèles et des répétitions. Par exemple, 
l’expression régulière suivante correspond à une chaîne qui commence par le caractère A suivi 
d’un ou de plusieurs chiffres séquentiels :
/A\d+/
Ce chapitre décrit la syntaxe de base permettant de construire des expressions régulières. 
Néanmoins, les expressions régulières peuvent être très complexes et comporter de nombreuses 
nuances. Vous pouvez vous documenter sur les expressions régulières sur le Web et dans les 
librairies. Différents environnements de programmation mettent en oeuvre des expressions 
régulières de différentes façons. ActionScript 3.0 met en oeuvre des expressions régulières 
comme défini dans la version 3 de la spécification de langage ECMAScript (ECMA-262).
Contenu
Principes de base des expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  306
Syntaxe d’expression régulière . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  309
Méthodes d’utilisation d’expressions régulières avec des chaînes . . . . . . . . . . . . . 327
Exemple : Un analyseur Wiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328
305

Principes de base des expressions 
régulières
Introduction à l’utilisation d’expressions régulières
Une expression régulière décrit un modèle de caractères. Les expressions régulières servent 
généralement à vérifier qu’une valeur de texte est conforme à un modèle particulier 
(par exemple, vérifier qu’un numéro de téléphone saisi par l’utilisateur comporte le nombre de 
chiffres correct) ou à remplacer des portions d’une valeur de texte qui correspondent à un 
modèle donné.
Les expressions régulières peuvent être simples. Par exemple, supposons que vous souhaitiez 
confirmer qu’une chaîne particulière corresponde à « ABC » ou que vous souhaitiez remplacer 
chaque occurrence d’« ABC » dans une chaîne par un autre texte. Dans ce cas, vous pouvez 
utiliser l’expression régulière suivante qui définit le modèle comportant les lettres A, B et C, 
dans l’ordre :
/ABC/
Le littéral de l’expression régulière est délimité avec la barre oblique (/).
Les modèles d’expression régulière peuvent également être complexes, et peuvent parfois 
sembler obscures, comme l’expression suivante pour établir une correspondance avec une 
adresse électronique valide :
/([0-9a-zA-Z]+[-._+&])*[0-9a-zA-Z]+@([-0-9a-zA-Z]+[.])+[a-zA-Z]{2,6}/
Vous utiliserez le plus souvent des expressions régulières pour rechercher des modèles dans des 
chaînes et pour remplacer des caractères. Dans ces cas, vous créerez un objet d’expression 
régulière et l’utiliserez comme paramètre pour une ou plusieurs méthodes de classe String. 
Les méthodes suivantes de la classe String prennent des expressions régulières comme 
paramètres : match(), replace(), search(), et split(). Pour plus d’informations sur ces 
méthodes, voirla page 227.
La classe RegExp comprend les méthodes suivantes : test() et exec(). Pour plus 
d’informations, voir la page 327.
306
Utilisation d’expressions régulières

Tâches d’expression régulière courantes
Les différentes utilisations courantes d’expressions régulières sont décrites en détail dans ce 
chapitre :
?
Création d’un modèle d’expression régulière
?
Utilisation de caractères spéciaux dans des modèles
?
Identification de séquences de plusieurs caractères (« un nombre à deux chiffres » ou 
« entre sept et dix lettres », par exemple)
?
Identification d’un caractère dans une série de lettres ou de nombres (« toute lettre de 
a à »)
?
Identification d’un caractère dans un jeu de caractères possibles
?
Identification de sous-séquences (segments dans un modèle)
?
Mise en correspondance et substitution de texte selon des modèles
Concepts et termes importants
La liste de référence suivante contient les termes importants utilisés dans ce chapitre :
?
Caractère d’échappement : un caractère indiquant que le caractère qui suit doit être traité 
comme un caractère de remplacement plutôt que comme un caractère littéral. Dans une 
syntaxe d’expression régulière, la barre oblique inverse (\) est le caractère d’échappement. 
Par conséquent, une barre oblique inverse suivie d’un autre caractère est un code spécial 
plutôt que simplement le caractère lui-même.
?
Indicateur : un caractère qui spécifie une option concernant la façon dont le modèle 
d’expression régulière doit être utilisé (s’il faut respecter la casse, par exemple).
?
Caractère de remplacement : un caractère qui a une signification spéciale dans un modèle 
d’expression régulière et qui ne représente pas littéralement ce caractère dans le modèle.
?
Quantificateur : un caractère (ou plusieurs caractères) indiquant combien de fois une 
partie du modèle doit se répéter. Par exemple, un quantificateur peut être utilisé pour 
indiquer qu’un code postal américain doit contenir cinq ou neuf chiffres.
?
Expressions régulières : une instruction de programme définissant un modèle de caractères 
pouvant être utilisé pour confirmer si d’autres chaînes correspondent à ce modèle ou pour 
remplacer des portions d’une chaîne.
Principes de base des expressions régulières
307

Utilisation des exemples fournis dans le chapitre
Au fur et à mesure que vous avancez dans le chapitre, vous pouvez tester des exemples de code. 
Etant donné que les codes de ce chapitre sont constitués principalement de modèles 
d’expressions régulières, le test des exemples implique que vous suiviez les étapes suivantes :
1.
Créez un nouveau document Flash.
2. Sélectionnez une image-clé et ouvrez le panneau Actions.
3. Créez une variable RegExp (expression régulière) comme la suivante :
var pattern:RegExp = /ABC/;
4. Copiez le modèle de l’exemple et affectez-le comme valeur de votre variable RegExp. 
Par exemple, dans la ligne de code précédente, le modèle fait partie du code situé à droite 
du signe d’égalité, point-virgule exclu (/ABC/).
5. Créez une ou plusieurs variables contenant des chaînes appropriées au test de votre 
expression régulière. Par exemple, si vous créez une expression régulière pour tester des 
adresses électroniques valides, créez quelques variables String contenant des adresses 
électroniques valides et non valides :
var goodEmail:String = "";
var badEmail:String = "5@$2.99";
6. Ajoutez des lignes de code pour tester les variables String afin de déterminer si elles 
correspondent au modèle d’expression régulière. Celles-ci seront les valeurs que vous 
afficherez à l’écran à l’aide de la fonction trace() ou en les écrivant dans un champ texte 
sur la scène.
trace(goodEmail, " is valid:", (goodEmail));
trace(badEmail, " is valid:", (badEmail));
Par exemple, supposons que pattern définisse le modèle d’expression régulière pour une 
adresse électronique valide. Les lignes de code précédentes écrivent ce texte dans le 
panneau Sortie :
is valid: true
5@$2.99 is valid: false
Pour plus d’informations sur le test des valeurs en les écrivant dans une instance de champ 
texte sur la scène ou en utilisant la fonction trace() pour imprimer les valeurs dans le 
panneau Sortie, voir « Test des exemples de code contenus dans un chapitre », à la page 67.
308
Utilisation d’expressions régulières

Syntaxe d’expression régulière
Cette section décrit tous les éléments de la syntaxe d’expression régulière d’ActionScript. 
Comme vous pourrez le constater, les expressions régulières peuvent être très complexes et 
comporter de nombreuses nuances. Vous pouvez vous documenter sur les expressions 
régulières sur le Web et dans les librairies. Différents environnements de programmation 
mettent en oeuvre des expressions régulières de différentes façons. ActionScript 3.0 met en 
œuvre des expressions régulières comme défini dans la version 3 de la spécification de langage 
ECMAScript (ECMA-262).
Généralement, vous utilisez des expressions régulières qui correspondent à des modèles plus 
compliqués qu’une simple chaîne de caractères. Par exemple, l’expression régulière suivante 
définit le modèle comportant les lettres A, B et C, dans l’ordre, suivies par un chiffre :
/ABC\d/
Le code \d représente « un chiffre ». La barre oblique inverse (\) est appelée caractère 
d’échappement. Lorsqu’elle est combinée au caractère qui la suit (dans ce cas, la lettre d), elle a 
une signification spéciale dans l’expression régulière. Ce chapitre décrit ces séquences de 
caractères d’échappement et d’autres fonctions de syntaxe d’expression régulière. 
L’expression régulière suivante définit le modèle des lettres ABC suivies par des chiffres 
(remarquez l’astérisque) :
/ABC\d*/
L’astérisque (*) est un caractère de remplacement. Un caractère de remplacement est un 
caractère ayant une signification spéciale dans les expressions régulières. L’astérisque est un 
type de caractère de remplacement spécifique appelé quantificateur, utilisé pour quantifier le 
nombre de répétitions d’un caractère ou groupe de caractères. Pour plus d’informations, voir 
« Quantificateurs », à la page 316.
Outre son modèle, une expression régulière peut contenir des indicateurs qui spécifient 
comment l’expression régulière doit être mise en correspondance. Par exemple, l’expression 
régulière suivante utilise l’indicateur i qui spécifie qu’elle ignore le respect de la casse dans les 
chaînes de correspondance :
/ABC\d*/i
Pour plus d’informations, voir « Indicateurs et propriétés », à la page 322.
Vous pouvez utiliser des expressions régulières à l’aide des méthodes suivantes de la classe 
String : match(), replace(), et search(). Pour plus d’informations sur ces méthodes, voir 
« Recherche de modèles dans des chaînes et remplacement de sous-chaînes », à la page 227.
Syntaxe d’expression régulière
309

Création d’une instance d’une expression régulière
Il existe deux façons de créer une instance d’expression régulière. L’une des méthodes consiste 
à utiliser des barres obliques (/) pour délimiter l’expression régulière, et l’autre consiste à 
utiliser le constructeur new. Par exemple, les expressions régulières suivantes sont équivalentes :
var pattern1:RegExp = /bob/i;
var pattern2:RegExp = new RegExp("bob", "i");
Des barres obliques délimitent un littéral d’expression régulière de la même façon que des 
guillemets délimitent un littéral de chaîne. La partie de l’expression régulière contenue entre 
les barres obliques définit le modèle. L’expression régulière peut également inclure des 
indicateurs après la barre de délimitation finale. Ces indicateurs sont considérés comme faisant 
partie de l’expression régulière, mais ils sont séparés de son modèle. 
Lorsque vous utilisez le constructeur new, vous utilisez deux chaînes pour définir l’expression 
régulière. La première chaîne définit le modèle, et la seconde les indicateurs, comme dans 
l’exemple suivant :
var pattern2:RegExp = new RegExp("bob", "i");
Lorsque vous incluez une barre oblique dans une expression régulière qui est définie à l’aide de 
délimiteurs de barre oblique, vous devez faire précéder la barre oblique du caractère 
d’échappement (\). Par exemple, l’expression régulière suivante correspond au modèle 1/2 :
var pattern:RegExp = /1\/2/;
Pour inclure des guillemets dans une expression régulière définie avec le constructeur new, 
vous devez ajouter un caractère d’échappement (\) avant les guillemets (comme lorsque vous 
définissez un littéral String). Par exemple, les expressions régulières suivantes correspondent au 
modèle eat at "joe’s" :
var pattern1:RegExp = new RegExp("eat at \"joe's\"", "");
var pattern2:RegExp = new RegExp('eat at "joe\'s"', "");
N’utilisez pas le caractère d’échappement avec des guillemets dans des expressions régulières 
définies à l’aide des délimiteurs de barre oblique. De même, n’utilisez pas le caractère 
d’échappement avec des barres obliques dans des expressions régulières définies avec le 
constructeur new. Les expressions régulières suivantes sont équivalentes. Elles définissent le 
modèle 1/2 "joe’s":
var pattern1:RegExp = /1\/2 "joe's"/;
var pattern2:RegExp = new RegExp("1/2 \"joe's\"", "");
var pattern3:RegExp = new RegExp('1/2 "joe\'s"', '');
310
Utilisation d’expressions régulières

De même, dans une expression régulière définie à l’aide du constructeur new, tapez deux fois le 
caractère barre oblique inversée pour utiliser une métaséquence débutant par le caractère barre 
oblique inversée(\), telle que \d (qui correspond à n’importe quel chiffre).
var pattern:RegExp = new RegExp("\\d+", ""); // correspondance avec un 
// ou plusieurs chiffres
Vous devez taper deux fois le caractère barre oblique inversée, car le premier paramètre de la 
méthode constructeur RegExp() est une chaîne. Dans un littéral de chaîne, ce caractère doit 
être entré deux fois pour être interprété comme une barre oblique inversée unique.
La section qui suit décrit la syntaxe servant à définir des modèles d’expression régulière.
Pour plus d’informations sur les indicateurs, voir « Indicateurs et propriétés », à la page 322.
Caractères, caractères de remplacement et 
métaséquences
L’expression régulière la plus simple est celle qui correspond à une séquence de caractères, 
comme dans l’exemple suivant :
var pattern:RegExp = /hello/;
Néanmoins, les caractères suivants, appelés caractères de remplacement, ont des significations 
spéciales dans des expressions régulières :
^ $ \ . * + ? ( ) [ ] { } |
Par exemple, l’expression régulière suivante correspond à la lettre A suivie par zéro ou plusieurs 
instances de la lettre B (le caractère de remplacement astérisque indique cette répétition), 
suivie par la lettre C :
/AB*C/
Pour inclure un caractère de remplacement sans sa signification spéciale dans un modèle 
d’expression régulière, vous devez utiliser le caractère d’échappement (\). Par exemple, 
l’expression régulière suivante correspond à la lettre A suivie par la lettre B, suivie par un 
astérisque, suivie par la lettre C :
var pattern:RegExp = /AB\*C/;
Une métaséquence, comme un caractère de remplacement, a une signification spéciale dans 
une expression régulière. Une métaséquence est constituée de plusieurs caractères. Les sections 
suivantes fournissent des détails sur l’utilisation des caractères de remplacement et des 
métaséquences.
Syntaxe d’expression régulière
311

A propos des caractères de remplacement 
Le tableau suivant répertorie les caractères de remplacement que vous pouvez utiliser dans des 
expressions régulières : 
Caractère de 
Description
remplacement
^ (caret) 
Etablit une correspondance au début d’une chaîne. Lorsque l’indicateur 
m (multiline) est défini, le caret correspond au début d’une ligne 
également (voir « L’indicateur m (multiline) », à la page 324). Lorsqu’il 
est utilisé au début d’une classe de caractère, le caret indique la négation 
et non le début d’une chaîne. Pour plus d’informations, voircaractère », à la page 314.
$ (signe dollar)
Etablit une correspondance à la fin d’une chaîne. Lorsque l’indicateur m 
(multiline) est défini, $ correspond à la position avant une nouvelle ligne 
(\n) également. Pour plus d’informations, (multiline) », à la page 324.
\ (caractère 
Echappe la signification spéciale du caractère de remplacement des 
d’échappement)
caractères spéciaux.
Vous pouvez également utiliser le caractère d’échappement si vous 
souhaitez utiliser une barre oblique dans un littéral d’expression 
régulière, comme dans /1\/2/ (pour correspondre au caractère 1, suivi 
par la barre oblique, suivi par le caractère 2).
. (point)
Correspond à un seul caractère. 
Un point correspond à un caractère de nouvelle ligne (\n) uniquement si 
l’indicateur s (dotall) est défini. Pour plus d’informations, voir 
« L’indicateur s (dotall) », à la page 325. 
* (étoile)
Correspond à l’élément précédent répété zéro ou plusieurs fois. 
Pour plus d’informations, voir « Quantificateurs », à la page 316.
+ (plus)
Correspond à l’élément précédent répété une ou plusieurs fois. 
Pour plus d’informations, voir « Quantificateurs », à la page 316.
? (point 
Correspond à l’élément précédent répété zéro ou une fois. 
d’interrogation)
Pour plus d’informations, voir « Quantificateurs », à la page 316.
( et ) 
Définit des groupes dans l’expression régulière. Utilisez des groupes 
pour :
• confiner le domaine de l’altérateur | : /(a|b|c)d/
• définir le domaine d’un quantificateur : /(walla.){1,2}/
• dans des backreferences. Par exemple, le \1 dans l’expression 
régulière suivante correspond à toute correspondance au premier 
groupe entre parenthèses du modèle : 
/(\w*) est répété : \1/
Pour plus d’informations, voir « Groupes », à la page 319.
312
Utilisation d’expressions régulières

Caractère de 
Description
remplacement
[ et ] 
Spécifie une classe de caractère qui définit des correspondances 
possibles pour un seul caractère :
/[aeiou]/ correspond à l’un des caractères spécifiés.
Dans les classes de caractère, utilisez le trait d’union (-) pour désigner 
une plage de caractères :
/[A-Z0-9]/ correspond aux lettres majuscules A à Z ou aux 
chiffres 0 à 9.
Dans les classes de caractère, insérez un caractère d’échappement 
pour échapper les caractères ] et 
- :
/[+\-]\d+/ correspond à + ou à - avant un ou plusieurs chiffres.
Dans les classes de caractère, d’autres caractères (qui sont 
normalement des caractères de remplacement) sont considérés comme 
des caractères normaux (et non comme des caractères de 
remplacement), sans qu’un caractère d’échappement soit nécessaire :
/[$£]/ correspond à $ ou à £.
Pour plus d’informations, voir « Classes de caractère », à la page 314.
| (opérateur de 
Utilisé pour la permutation, pour correspondre à la partie de gauche ou à 
transfert de 
celle de droite :
données)
/abc|xyz/ correspond à abc ou à xyz.
A propos des métaséquences
Les métaséquences sont des séquences de caractères ayant une signification spéciale dans un 
modèle d’expression régulière. Le tableau suivant décrit ces métaséquences :
Métaséquence
Description
{n}
Indique un quantificateur numérique ou une plage de quantificateurs 
{n,}
pour l’élément précédent : 
et
/A{27}/ correspond au caractère A répété 27 fois.
{n,n}
/A{3}/ correspond au caractère A répété 3 fois ou plus.
/A{3,5}/ correspond au caractère A répété 3 à 5 fois.
Pour plus d’informations, voir « Quantificateurs », à la page 316.
\b
Etablit une correspondance à la position entre un caractère mot et un 
caractère non-mot. Si le premier ou Ie dernier caractère dans la chaîne 
est un caractère mot, correspond également au début ou à la fin de la 
chaîne.
\B
Etablit une correspondance à la position entre deux caractères mot. 
Correspond également à la position entre deux caractères non-mot.
\d
Correspond à une décimale.
Syntaxe d’expression régulière
313

Métaséquence
Description
\D
Correspond à tout caractère autre qu’un chiffre.
\f
Correspond à un caractère de changement de page.
\n
Correspond au caractère de nouvelle ligne.
\r
Correspond au caractère de retour de chariot.
\s
Correspond à tout caractère d’espace blanc (un espace, une tabulation, 
une nouvelle ligne ou un caractère de retour de chariot).
\S
Correspond à tout caractère autre qu’un caractère d’espace blanc.
\t
Correspond au caractère de tabulation.
\unnnn
Correspond au caractère Unicode avec le code de caractère spécifié par 
le nombre hexadécimal nnnn. Par exemple, \u263a est le caractère 
smiley.
\v
Correspond à un caractère d’avancement vertical.
\w
Correspond à un caractère mot (A–Z, a–z, 0-9, ou _). \w ne correspond 
pas aux caractères qui ne sont pas anglais tels que é, ñ, ou ç.
\W
Correspond à tout caractère autre qu’un caractère mot.
\xnn
Correspond au caractère avec la valeur ASCII spécifiée, comme défini 
par le nombre hexadécimal nn.
Classes de caractère
Vous utilisez des classes de caractère pour spécifier une liste de caractères devant correspondre 
à une position dans l’expression régulière. Vous définissez des classes de caractère avec des 
crochets ( [ et ] ). Par exemple, l’expression régulière suivante définit une classe de caractère 
qui correspond à bag, beg, big, bog, ou bug :
/b[aeiou]g/
Séquences d’échappement dans des classes de caractère
La plupart des caractères de remplacement et des métaséquences ayant normalement des 
significations spéciales dans une expression régulière n’ont pas ces mêmes significations dans 
une classe de caractère. Par exemple, dans une expression régulière, l’astérisque est utilisé pour 
la répétition, mais ce n’est pas le cas lorsqu’il apparaît dans une classe de caractère. La classe de 
caractère suivante correspond à l’astérisque de façon littérale, avec tout autre caractère 
répertorié :
/[abc*123]/
314
Utilisation d’expressions régulières

Cependant, les trois caractères répertoriés dans le tableau suivant fonctionnent comme des 
caractères de remplacement, avec une signification spéciale, dans des classes de caractère :
Caractère de 
Signification dans des classes de caractère
remplacement
]
Définit la fin de la classe de caractère.
-
Définit une plage de caractdes classes de caractère », à la page 316).
\
Définit des métaséquences et annule la signification spéciale des 
caractères de remplacement. 
Pour que ces caractères soient reconnus comme caractères littéraux (dans la signification du 
caractère de remplacement spéciale), vous devez faire précéder le caractère du caractère 
d’échappement. Par exemple, l’expression régulière suivante inclut une classe de caractère qui 
correspond à l’un des quatre symboles ($, \, ], ou -) :
/[$\\\]\-]/
Outre les caractères de remplacement qui conservent leurs significations spéciales, les 
métaséquences suivantes fonctionnent comme des métaséquences dans des classes de 
caractère :
Métaséquence
Signification dans des classes de caractère
\n
Correspond à un caractère de nouvelle ligne.
\r
Correspond à un caractère de retour de chariot.
\t
Correspond à un caractère de tabulation.
\unnnn
Correspond au caractère avec la valeur de point de code Unicode 
spécifiée (comme défini par le nombre hexadécimal nnnn).
\xnn
Correspond au caractère avec la valeur ASCII spécifiée (comme 
défini par le nombre hexadécimal nn).
D’autres caractères de remplacement et métaséquences d’expression régulière sont considérés 
comme des caractères normaux dans une classe de caractère. 
Syntaxe d’expression régulière
315

Plages de caractères dans des classes de caractère
Utilisez le trait d’union pour spécifier une plage de caractères telle que A-Z, a-z, ou 0-9. 
Ces caractères doivent constituer une plage valide dans le jeu de caractères. Par exemple, la 
classe de caractère suivante correspond à un caractère compris dans la plage a-z ou un chiffre :
/[a-z0-9]/
Vous pouvez également utiliser le code de caractère ASCII \xnn pour spécifier une plage par 
valeur ASCII. Par exemple, la classe de caractère suivante correspond à un caractère d’un jeu 
de caractères ASCII étendus (é et ê, par exemple) :
/[\x80-\x9A]/
Classes de caractère niées
Lorsque vous utilisez un caret (^) au début d’une classe de caractère, il la nie (tout caractère 
non répertorié est considéré comme une correspondance). La classe de caractère suivante 
correspond à tout caractère sauf une lettre minuscule (a–z) ou un chiffre :
/[^a-z0-9]/
Vous devez taper le caret (^) au début d’une classe de caractère pour indiquer la négation. 
Autrement, vous ajoutez simplement le caret aux caractères dans la classe de caractère. 
Par exemple, la classe de caractère suivante correspond à un symbole (le caret, par exemple) :
/[!.,#+*%$&^]/
Quantificateurs
Vous utilisez des quantificateurs pour spécifier des répétitions de caractères ou de séquences 
dans des modèles, comme suit :
Caractère de 
Description
remplacement 
de 
quantificateur
* (étoile)
Correspond à l’élément précédent répété zéro ou plusieurs fois. 
+ (plus)
Correspond à l’élément précédent répété une ou plusieurs fois. 
? (point 
Correspond à l’élément précédent répété zéro ou une fois. 
d’interrogation)
{n}
Indique un quantificateur numérique ou une plage de quantificateurs 
{n,}
pour l’élément précédent : 
et
/A{27}/ correspond au caractère A répété 27 fois.
{n,n}
/A{3}/ correspond au caractère A répété 3 fois ou plus.
/A{3,5}/ correspond au caractère A répété de 3 à 5 fois.
316
Utilisation d’expressions régulières

Vous pouvez appliquer un quantificateur à un seul caractère, à une classe de caractère ou à un 
groupe :
?
/a+/ correspond au caractère a répété une ou plusieurs fois.
?
/\d+/ correspond à un ou plusieurs chiffres.
?
/[abc]+/ correspond à une répétition d’un ou de plusieurs caractères, a, b, ou c.
?
/(very, )*/ correspond au mot very suivi par une virgule et un espace répété zéro ou 
plusieurs fois.
Vous pouvez utiliser des quantificateurs dans des groupes de parenthèses auxquels sont 
appliqués des quantificateurs. Par exemple, le quantificateur suivant correspond à des chaînes 
du type word et word-word-word :
/\w+(-\w+)*/
Par défaut, les expressions régulières effectuent un greedy matching. Tout sous-modèle dans 
l’expression régulière (.*, par exemple) tente de mettre en correspondance autant de caractères 
que possible dans la chaîne avant de passer à la partie suivante de l’expression régulière. 
Par exemple, considérez l’expression régulière et la chaîne suivantes :
var pattern:RegExp = /<p>.*<\/p>/;
str:String = "<p>Paragraph 1</p> <p>Paragraph 2</p>";
L’expression régulière correspond à la chaîne entière : 
<p>Paragraph 1</p> <p>Paragraph 2</p>
Supposez, néanmoins, que vous souhaitez établir une correspondance avec un seul groupe 
<p> </p>. Vous pouvez procéder comme suit :
<p>Paragraph 1</p>
Ajoutez un point d’interrogation (?) après les quantificateurs pour qu’ils deviennent des 
quantificateurs paresseux. Par exemple, l’expression régulière suivante, qui utilise le 
quantificateur paresseux *?, correspond à <p> suivi du nombre minimum de caractères 
possible (paresseux), suivi de </p>:
/<p>.*?<\/p>/
Syntaxe d’expression régulière
317

Lisez attentivement les points suivants concernant les quantificateurs :
?
Les quantificateurs {0} et {0,0} n’excluent pas un élément d’une correspondance.
?
Ne combinez pas plusieurs quantificateurs, comme dans /abc+*/.
?
Le point (.) ne couvre pas des lignes à moins que l’indicateur s (dotall) soit défini, même 
s’il est suivi par un quantificateur *. Par exemple, considérez le code suivant :
var str:String = "<p>Test\n";
str += "Multiline</p>";
var re:RegExp = /<p>.*<\/p>/;
trace(str.match(re)); // null;
re = /<p>.*<\/p>/s;
trace(str.match(re)); 
// résultat : <p>Test
//
Multiligne</p>
Pour plus d’informations, voir « L’indicateur s (dotall) », à la page 325.
Permutation
Utilisez le caractère | (barre) dans une expression régulière pour que son moteur tienne 
compte des autres possibilités pour une correspondance. Par exemple, l’expression régulière 
suivante correspond à l’un des mots cat, dog, pig, rat :
var pattern:RegExp = /cat|dog|pig|rat/;
Vous pouvez utiliser des parenthèses pour définir des groupes et limiter le domaine du 
permutateur |. L’expression régulière suivante correspond à cat suivi de nap ou nip :
var pattern:RegExp = /cat(nap|nip)/;
Pour plus d’informations, voir « Groupes », à la page 319.
Les deux expressions régulières suivantes (l’une utilisant le permutateur |, l’autre une classe de 
caractère (définie avec [ et ] )) sont équivalentes :
/1|3|5|7|9/
/[13579]/
Pour plus d’informations, voir « Classes de caractère », à la page 314.
318
Utilisation d’expressions régulières

Groupes
Vous pouvez spécifier un groupe dans une expression régulière en utilisant des parenthèses, 
comme suit :
/class-(\d*)/
Un groupe est une sous-section d’un modèle. Vous pouvez utiliser des groupes pour effectuer 
les opérations suivantes :
?
Appliquer un quantificateur à plusieurs caractères
?
Délimiter des sous-modèles à appliquer avec la permutation (à l’aide du caractère |)
?
Capturer des correspondances de sous-chaîne (par exemple, en utilisant \1 dans une 
expression régulière pour établir une correspondance avec un groupe mis en 
correspondance précédemment, ou en utilisant $1 de la même façon dans la méthode 
replace() de la classe String)
Les sections suivantes fournissent des détails sur ces utilisations de groupes.
Utilisation de groupes avec des quantificateurs
Si vous n’utilisez pas de groupe, un quantificateur s’applique au caractère ou à la classe de 
caractère qui le précède, comme indiqué ci-dessous :
var pattern:RegExp = /ab*/ ;
// correspond au caractère a suivi de
// zéro ou plusieurs occurrences du caractère b
pattern = /a\d+/; 
// correspond au caractère a suivi de 
// un ou plusieurs chiffres
pattern = /a[123]{1,3}/;
// correspond au caractère a suivi de 
// l’une des trois occurrences de 1, 2 ou 3
Néanmoins, vous pouvez utiliser un groupe pour appliquer un quantificateur à plusieurs 
caractères ou classes de caractère :
var pattern:RegExp = /(ab)*/;
// correspond à zéro ou à plusieurs occurrences du caractère a 
// suivi du caractère b, comme ababab
pattern = /(a\d)+/;
// correspond à une ou à plusieurs occurrences du caractère a suivi de 
// un chiffre, tel que a1a5a8a3
pattern = /(spam ){1,3}/; 
// correspond à 1 à 3 occurrences du mot spam suivi d’un espace
Pour plus d’informations sur les quantificateurs, voir « Quantificateurs », à la page 316.
Syntaxe d’expression régulière
319

Utilisation de groupes avec le permutateur (|)
Vous pouvez utiliser des groupes pour définir le groupe de caractères auquel vous souhaitez 
appliquer un permutateur (|), comme suit :
var pattern:RegExp = /cat|dog/;
// correspond à cat ou dog
pattern = /ca(t|d)og/;
// correspond à catog ou cadog
Utilisation de groupes pour capturer des correspondances de 
sous-chaîne
Lorsque vous définissez un groupe entre parenthèses standard dans un modèle, vous pouvez 
ensuite vous y référer dans l’expression régulière. Il s’agit d’une backreference. Ces types de 
groupes sont appelés groupes capturés. Par exemple, dans l’expression régulière suivante, la 
séquence \1 correspond à toute sous-chaîne mise en correspondance avec le groupe entre 
parenthèses capturé :
var pattern:RegExp = /(\d+)-by-\1/;
// correspond aux éléments suivants : 48-par-48
Vous pouvez spécifier jusqu’à 99 backreferences dans une expression régulière en tapant 
\1, \2,   , \99. 
De même, dans la méthode replace() de la classe String, vous pouvez utiliser $1–$99 pour 
insérer des correspondances de chaîne de groupe capturé dans la chaîne de remplacement :
var pattern:RegExp = /Hi, (\w+)\./;
var str:String = "Hi, Bob.";
trace(str.replace(pattern, "$1, hello."));
// résultat : Bob, bonjour.
Si vous utilisez des groupes capturés, la méthode exec() de la classe RegExp et la méthode 
match() de la classe String renvoient des sous-chaînes qui correspondent aux groupes 
capturés :
var pattern:RegExp = /(\w+)@(\w+).(\w+)/;
var str:String = "";
trace((str));
// ,bob,example,com
320
Utilisation d’expressions régulières

Utilisation de groupes non capturés et de groupes d’anticipation
Un groupe non capturé est utilisé pour le regroupement uniquement ; il n’est pas « collecté », 
et il ne correspond pas à des backreferences numérotées. Utilisez (?: et ) pour définir des 
groupes non capturés, comme suit :
var pattern = /(?:com|org|net);
Par exemple, notez la différence entre mettre (com|org) dans un groupe capturé et dans un 
groupe non capturé (la méthode exec() répertorie les groupes capturés après la 
correspondance complète) :
var pattern:RegExp = /(\w+)@(\w+).(com|org)/;
var str:String = "";
trace((str));
  // ,bob,example,com
  
//non capturé :
var pattern:RegExp = /(\w+)@(\w+).(?:com|org)/;
var str:String = "";
trace((str));
  // ,bob,example
Un type spécial de groupe non capturé est le groupe d’anticipation dont il existe deux types : le 
groupe d’anticipation positif et le groupe d’anticipation négatif. 
Utilisez (?= et ) pour définir un groupe d’anticipation positif, qui spécifie que le sous-modèle 
dans le groupe doit établir une correspondance à la position. Néanmoins, la portion de la 
chaîne qui correspond au groupe d’anticipation positif peut correspondre aux modèles 
restants dans l’expression régulière. Par exemple, étant donné que (?=e) est un groupe 
d’anticipation positif dans le code suivant, le caractère e auquel il correspond peut être mis en 
correspondance par une partie suivante de l’expression régulière (dans ce cas, le groupe 
capturé, \w*) :
var pattern:RegExp = /sh(?=e)(\w*)/i;
var str:String = "Shelly sells seashells by the seashore";
trace((str));
// Shelly,elly
Utilisez (?= et ) pour définir un groupe d’anticipation négatif, qui indique que le sous-
modèle dans le groupe ne doit pas établir une correspondance à la position. Voici un exemple :
var pattern:RegExp = /sh(?!e)(\w*)/i;
var str:String = "She sells seashells by the seashore";
trace((str));
// shore,ore
Syntaxe d’expression régulière
321

Utilisation de groupes nommés
Un groupe nommé est un type de groupe dans une expression régulière ayant un 
identificateur nommé. Utilisez (?P<nom> et ) pour définir le groupe nommé. Par exemple, 
l’expression régulière suivante inclut un groupe nommé avec l’identificateur nommé digits :
var pattern = /[a-z]+(?P<digits>\d+)[a-z]+/;
Lorsque vous utilisez la méthode exec(), un groupe nommé de correspondance est ajouté 
comme propriété du tableau result :
var myPattern:RegExp = /([a-z]+)(?P<digits>\d+)[a-z]+/; 
var str:String = "a123bcd";
var result:Array = (str);
trace(result.digits); // 123
Voici un autre exemple, qui utilise deux groupes nommés, avec les identificateurs name et 
dom :
var emailPattern:RegExp = 
/(?P<name>(\w|[_.\-])+)@(?P<dom>((\w|-)+))+\.\w{2,4}+/; 
var address:String = "";
var result:Array = (address);
trace(); // bob
trace(); // exemple
REMARQUE
Les groupes nommés ne font pas partie de la spécification de langage ECMAScript. 
Ils représentent une fonction ajoutée dans ActionScript 3.0.
Indicateurs et propriétés
Le tableau suivant répertorie les cinq indicateurs que vous pouvez définir pour des expressions 
régulières. Vous pouvez accéder à chaque indicateur en tant que propriété de l’objet 
d’expression régulière. 
Indicateur Propriété
Description
g
global
A plusieurs correspondances.
i
ignoreCase
Correspondance sensible à la casse. S’applique aux caractères 
A—Z et a—z mais pas à des caractères étendus tels que É et é.
m
multiline
Lorsque cet indicateur est défini, $ et ^ peuvent correspondre au 
début d’une ligne et à la fin d’une ligne, respectivement. 
322
Utilisation d’expressions régulières

Indicateur Propriété
Description
s
dotall
Lorsque cet indicateur est défini, . (point) peut correspondre au 
caractère de nouvelle ligne (\n).
x
extended
Autorise les expressions régulières étendues. Vous pouvez 
tapez des espaces dans l’expression régulière. Ils sont ignorés 
dans le cadre du modèle. Ceci vous permet de taper un code 
d’expression régulière de façon plus lisible.
Ces propriétés sont en lecture seule. Vous pouvez définir les indicateurs (g, i, m, s, x) lorsque 
vous définissez une variable d’expression régulière, comme suit :
var re:RegExp = /abc/gimsx;
Cependant, vous ne pouvez pas définir directement les propriétés nommées. Par exemple, le 
code suivant génère une erreur :
var re:RegExp = /abc/;
re.global = true; // Génération d’une erreur.
Par défaut, à moins de les spécifier dans la déclaration d’expression régulière, les indicateurs ne 
sont pas définis, et les propriétés correspondantes sont également définies sur false. 
De plus, il existe deux autres propriétés d’une expression régulière : 
?
La propriété lastIndex spécifie la position d’index dans la chaîne à utiliser pour l’appel 
suivant à la méthode exec() ou test() d’une expression régulière. 
?
La propriété source spécifie la chaîne qui définit la portion de modèle de l’expression 
régulière.
L’indicateur g (global)
Lorsque l’indicateur g (global) n’est pas inclus, une expression régulière n’a pas plus d’une 
correspondance. Par exemple, avec l’indicateur g exclu de l’expression régulière, la méthode 
String.match() renvoie une sous-chaîne de correspondance uniquement :
var str:String = "she sells seashells by the seashore.";
var pattern:RegExp = /sh\w*/;
trace(str.match(pattern)) // résultat : she
Lorsque l’indicateur g est défini, la méthode Sting.match() renvoie plusieurs 
correspondances, comme suit :
var str:String = "she sells seashells by the seashore.";
var pattern:RegExp = /sh\w*/g;
// Le même modèle, mais cette fois, l’indicateur g EST défini.
trace(str.match(pattern)); // résultat : she,shells,shore
Syntaxe d’expression régulière
323

L’indicateur i (ignoreCase)
Par défaut, les correspondances d’expression régulière sont sensibles à la casse. Lorsque vous 
définissez l’indicateur i (ignoreCase), le respect de la casse est ignoré. Par exemple, la lettre 
minuscule s dans l’expression régulière ne correspond pas à la lettre majuscule S, le premier 
caractère de la chaîne :
var str:String = "She sells seashells by the seashore.";
trace(str.search(/sh/)); // résultat : 13 -- Pas le premier caractère
Lorsque l’indicateur i est défini, cependant, l’expression régulière correspond à la lettre 
majuscule S :
var str:String = "She sells seashells by the seashore.";
trace(str.search(/sh/i)); // résultat : 0
L’indicateur i ignore le respect de la casse uniquement pour les caractères A–Z et a–z, mais par 
pour les caractères étendus tels que É et é.
L’indicateur m (multiline)
Si l’indicateur m (multiline) n’est pas défini, le ^ correspond au début de la chaîne et le $ à sa 
fin. Si l’indicateur m est défini, ces caractères correspondent au début d’une ligne et à la fin d’une 
ligne, respectivement. Considérez la chaîne suivante, qui inclut un caractère de nouvelle ligne :
var str:String = "Test\n";
str += "Multiline";
trace(str.match(/^\w*/g)); // Correspondance avec un mot au début 
// de la chaîne.
Même si l’indicateur g (global) est défini dans l’expression régulière, la méthode match() 
correspond à une seule sous-chaîne, car il n’existe qu’une seule correspondance pour le ^ 
(le début de la chaîne). Le résultat est le suivant :
Test
Voici le même code avec l’indicateur m défini :
var str:String = "Test\n";
str += "Multiline";
trace(str.match(/^\w*/gm)); // Correspondance avec un mot au début 
// des lignes. 
Cette fois, le résultat inclut les mots au début des deux lignes :
Test,Multiline
Seul le caractère \n signale la fin d’une ligne. Ce n’est pas le cas des caractères suivants :
?
Retour de chariot (\r)
?
Séparateur de ligne Unicode (\u2028)
?
Séparateur de paragraphe Unicode (\u2028)
324
Utilisation d’expressions régulières

L’indicateur s (dotall)
Si l’indicateur s (dotall ou « dot all ») n’est pas défini, un point (.) dans un modèle 
d’expression régulière ne correspond pas à un caractère de nouvelle ligne (\n). Par conséquent, 
il n’existe aucune correspondance pour l’exemple suivant :
var str:String = "<p>Test\n";
str += "Multiline</p>";
var re:RegExp = /<p>.*?<\/p>/;
trace(str.match(re)); 
Néanmoins, si l’indicateur the s est défini, le point correspond au caractère de nouvelle ligne :
var str:String = "<p>Test\n";
str += "Multiline</p>";
var re:RegExp = /<p>.*?<\/p>/s;
trace(str.match(re)); 
Dans ce cas, la correspondance est la sous-chaîne entière dans les balises <p>, y compris le 
caractère de nouvelle ligne :
<p>Test
Multiline</p>
L’indicateur x (extended)
Les expressions régulières peuvent être difficiles à lire, notamment lorsqu’elles comprennent 
de nombreux métasymboles et métaséquences. Voici un exemple :
/<p(>|(\s*[^>]*>)).*?<\/p>/gi
Lorsque vous utilisez l’indicateur x (extended) dans une expression régulière, les espaces vides 
que vous tapez dans le modèle sont ignorés. Par exemple, l’expression régulière suivante est 
identique à l’exemple précédent :
/
<p
(>
|
(\s*
[^>]*
>))
.*?
<\/p>
/gix
Si l’indicateur x est défini et que vous souhaitez établir une correspondance avec un espace 
vide, faites précéder l’espace vide d’une barre oblique. Par exemple, les deux expressions 
régulières suivantes sont équivalentes :
/foo bar/
/foo \ bar/x
Syntaxe d’expression régulière
325

La propriété lastIndex
La propriété lastIndex spécifie la position d’index dans la chaîne à laquelle la recherche 
suivante doit démarrer. Cette propriété affecte les méthodes exec() et test() appelées sur 
une expression régulière dont l’indicateur g est défini sur true. Par exemple, considérez le 
code suivant :
var pattern:RegExp = /p\w*/gi;
var str:String = "Pedro Piper picked a peck of pickled peppers.";
trace(pattern.lastIndex);
var result:Object = (str);
while (result != null)
{
trace(pattern.lastIndex);
result = (str);
}
La propriété lastIndex est défini sur 0 par défaut (pour commencer les recherches au début 
de la chaîne). Après chaque correspondance, elle est définie sur la position d’index suivant la 
correspondance. Par conséquent, le résultat pour le code précédent est le suivant :
0
5
11
18
25
36
44
Si l’indicateur global est défini sur false, les méthodes exec() et test() n’utilisent pas ni 
ne définissent la propriété lastIndex.
Les méthodes match(), replace() et search() de la classe String démarrent toutes les 
recherches du début de la chaîne, indépendamment du réglage de la propriété lastIndex de 
l’expression régulière utilisée dans l’appel à la méthode. (Néanmoins, la méthode match() 
définit lastIndex sur 0.)
Vous pouvez définir la propriété lastIndex de façon à ajuster la position de début dans la 
chaîne pour la mise en correspondance des expressions régulières.
La propriété source
La propriété source spécifie la chaîne qui définit la portion de modèle d’une expression 
régulière. Voici un exemple :
var pattern:RegExp = /foo/gi;
trace(pattern.source); // foo
326
Utilisation d’expressions régulières

Méthodes d’utilisation d’expressions 
régulières avec des chaînes
La classe RegExp comprend deux méthodes : exec() et test().
Outre les méthodes exec() et test() de la classe RegExp, la classe String comprend les 
méthodes suivantes qui vous permettent d’établir une correspondance avec des expressions 
régulières dans des chaînes : match(), replace(), search(), et splice().
La méthode test()
La méthode test() de la classe RegExp vérifie si la chaîne fournie contient une 
correspondance pour l’expression régulière, comme l’indique l’exemple suivant :
var pattern:RegExp = /Class-\w/;
var str = "Class-A";
trace((str)); // résultat : true
La méthode exec()
La méthode exec() de la classe RegExp vérifie si la chaîne fournie contient une 
correspondance pour l’expression régulière et renvoie un tableau avec les éléments suivants :
?
La sous-chaîne correspondante
?
Les correspondances de sous-chaîne pour les groupes entre parenthèses dans l’expression 
régulière
Le tableau inclut également une propriété index qui indique la position d’index du début de 
la correspondance de sous-chaîne.
Par exemple, considérez le code suivant :
var pattern:RegExp = /\d{3}\-\d{3}-\d{4}/; // numéro de téléphone 
// aux Etats-Unis
var str:String = "phone: 415-555-1212";
var result:Array = (str);
trace(result.index, " - ", result);
// 7  -  415-555-1212
Méthodes d’utilisation d’expressions régulières avec des chaînes
327

Utilisez la méthode exec() plusieurs fois pour établir une correspondance avec plusieurs sous-
chaînes lorsque l’indicateur g (global) est défini pour l’expression régulière :
var pattern:RegExp = /\w*sh\w*/gi;
var str:String = "She sells seashells by the seashore";
var result:Array = (str);
 
while (result != null)
{
trace(result.index, "\t", pattern.lastIndex, "\t", result);
result = (str);
}
//résultat : 
// 0  3  She
// 10  19  seashells
// 27  35  seashore
Méthodes de chaîne utilisant des paramètres RegExp
Les méthodes suivantes de la classe String prennent des expressions régulières comme 
paramètres : match(), replace(), search(), et split(). Pour plus d’informations sur ces 
méthodes, voirla page 227. 
Exemple : Un analyseur Wiki
Cet exemple simple de conversion de texte Wiki illustre des utilisations d’expressions 
régulières :
?
Conversion de lignes de texte qui mettent en correspondance un modèle Wiki source et 
les chaînes de sortie HTML appropriées.
?
Utilisation d’une expression régulière pour convertir des modèles URL en balises de lien 
hypertexte HTML <a>.
?
Utilisation d’une expression régulière pour convertir les chaînes dollar américain 
("$9.95", par exemple) en chaînes euro ("8.24 €", par exemple).
328
Utilisation d’expressions régulières

Pour obtenir les fichiers d’application pour cet exemple, voir learn_programmingAS3samples_flash_fr. Les fichiers d’application WikiEditor se trouvent 
dans le dossier Samples/WikiEditor. Cette application se compose des fichiers suivants :
Fichier
Description

Le fichier d’application principal dans Flash 
ou
(FLA) ou Flex (MXML).

com/example/programmingas3/
Une classe qui comprend des méthodes 

utilisant des expressions régulières pour 
convertir des modèles de texte d’entrée Wiki en 
sortie HTML équivalente.
com/example/programmingas3/
Une classe qui comprend des méthodes 

utilisant des expressions régulières pour 
convertir des chaînes URL en balises de lien 
hypertexte HTML <a>.
com/example/programmingas3/
Une classe qui comprend des méthodes 

utilisant des expressions régulières pour 
convertir des chaînes dollar américain en 
chaînes euro.
Définition de la classe WikiParser
La classe WikiParser inclut des méthodes qui convertissent le texte d’entrée Wiki en sortie 
HTML équivalente. Il ne s’agit pas d’une application de conversion Wiki très puissante, mais 
elle illustre des utilisations d’expressions régulières pour la mise en correspondance de modèle 
et la conversion de chaîne.
La fonction constructeur et la méthode setWikiData() initialisent un exemple de chaîne de 
texte d’entrée Wiki, comme suit :
public function WikiParser()
{
wikiData = setWikiData();
}
Exemple : Un analyseur Wiki
329

Lorsque l’utilisateur clique sur le bouton de test dans l’application exemple, cette dernière 
appelle la méthode parseWikiString() de l’objet WikiParser. Cette méthode appelle 
plusieurs autres méthodes, qui assemblent à leur tour la chaîne HTML résultante.
public function parseWikiString(wikiString:String):String
{
var result:String = parseBold(wikiString);
result = parseItalic(result);
result = linesToParagraphs(result);
result = parseBullets(result);
return result;
}
Chaque méthode appelée—parseBold(), parseItalic(), linesToParagraphs(), et 
parseBullets()—utilise la méthode replace() de la chaîne pour remplacer les modèles de 
correspondance, définis par une expression régulière, de façon à transformer le texte Wiki en 
texte formaté HTML.
Conversion des modèles de texte en gras et en italique
La méthode parseBold() recherche un modèle de texte Wiki en gras (’’’foo’’’, par 
exemple) et le transforme en son équivalent HTML (<b>foo</b>, par exemple), comme suit :
private function parseBold(input:String):String
{
var pattern:RegExp = /'''(.*?)'''/g;
return input.replace(pattern, "<b>$1</b>");
}
La portion (.?*) de l’expression régulière correspond à des caractères (*) entre les deux 
modèles de définition ’’’. Le quantificateur ? rend la correspondance nongreedy, de façon à 
ce que pour une chaîne telle que ’’’aaa’’’ bbb ’’’ccc’’’, la première chaîne mise en 
correspondance soit ’’’aaa’’’ et non la chaîne entière (qui commence et se termine par le 
modèle ’’’). 
Les parenthèses dans l’expression régulière définissent un groupe capturé, et la méthode 
replace() se réfère à ce groupe en utilisant le code $1 dans la chaîne de remplacement. 
L’indicateur g (global) dans l’expression régulière vérifie que la méthode replace() 
remplace toutes les correspondances dans la chaîne (pas simplement la première).
La méthode parseItalic() fonctionne comme la méthode parseBold(), sauf qu’elle 
recherche deux apostrophes (’’) comme séparateur pour le texte en italique (au lieu de trois) :
private function parseItalic(input:String):String
{
var pattern:RegExp = /''(.*?)''/g;
return input.replace(pattern, "<i>$1</i>");
}
330
Utilisation d’expressions régulières

Conversion de modèles de puce
Comme dans l’exemple suivant, la méthode parseBullet() recherche le modèle de puce 
Wiki (* foo, par exemple) et le transforme en son équivalent HTML (<li>foo</li>, par 
exemple) :
private function parseBullets(input:String):String
{
var pattern:RegExp = /^\*(.*)/gm;
return input.replace(pattern, "<li>$1</li>");
}
Le symbole ^ au début de l’expression régulière correspond au début d’une ligne. L’indicateur 
m (multiline) dans l’expression régulière fait en sorte que cette dernière compare le symbole 
^ au début d’une ligne, et non simplement au début de la chaîne.
Le modèle \* correspond à un astérisque (la barre oblique est utilisée pour signaler un 
astérisque littéral au lieu d’un quantificateur *). 
Les parenthèses dans l’expression régulière définissent un groupe capturé, et la méthode 
replace() se réfère à ce groupe en utilisant le code $1 dans la chaîne de remplacement. 
L’indicateur g (global) dans l’expression régulière vérifie que la méthode replace() 
remplace toutes les correspondances dans la chaîne (pas simplement la première). 
Conversion de modèles Wiki de paragraphe
La méthode linesToParagraphs() convertit chaque ligne dans la chaîne Wiki d’entrée en 
une balise de paragraphe HTML <p>. Ces lignes dans la méthode extraient des lignes vides de 
la chaîne d’entrée Wiki :
var pattern:RegExp = /^$/gm;
var result:String = input.replace(pattern, "");
Les symboles ^ et $ dans l’expression régulière correspondent au début et à la fin d’une ligne. 
L’indicateur m (multiline) dans l’expression régulière fait en sorte que cette dernière compare 
le symbole ^ au début d’une ligne, et non simplement au début de la chaîne.
La méthode replace() remplace toutes les chaînes de correspondance (lignes vides) par une 
chaîne vide (""). L’indicateur g (global) dans l’expression régulière vérifie que la méthode 
replace() remplace toutes les correspondances dans la chaîne (pas simplement la première).
Exemple : Un analyseur Wiki
331

Conversion d’URL en balises HTML <a>
Lorsque l’utilisateur clique sur le bouton de test dans l’exemple d’application et qu’il a coché 
la case urlToATag, l’application appelle la méthode statique URLParser.urlToATag() pour 
convertir les chaînes URL de la chaîne Wiki d’entrée en balises HTML <a>. 
var protocol:String = "((?:http|ftp)://)";
var urlPart:String = "([a-z0-9_-]+\.[a-z0-9_-]+)";
var optionalUrlPart:String = "(\.[a-z0-9_-]*)";
var urlPattern:RegExp = new RegExp(protocol + urlPart + optionalUrlPart, 
"ig");
var result:String = input.replace(urlPattern, 
"<a href='$1$2$3'><u>$1$2$3</u></a>");
La fonction constructeur RegExp() sert à assembler une expression régulière (urlPattern) à 
partir de plusieurs parties constituantes. Ces parties constituantes sont représentées par 
chaque chaîne définissant une partie du modèle de l’expression régulière. 
La première partie du modèle de l’expression régulière, définie par la chaîne protocol, définit 
un protocole URL : soit http:// soit ftp://. Les parenthèses définissent un groupe non 
capturé, indiqué par le symbole ?. Ceci signifie que les parenthèses servent simplement à 
définir un groupe pour le modèle de permutation | ; le groupe ne correspondra pas à des codes 
de backreference ($1, $2, $3) dans la chaîne de remplacement de la méthode replace(). 
Les autres parties constituantes de l’expression régulière utilisent chacune des groupes capturés 
(indiqués par des parenthèses dans le modèle) qui sont ensuite utilisés dans les codes de 
backreference ($1, $2, $3) dans la chaîne de remplacement de la méthode replace().
La partie du modèle définie par la chaîne urlPart correspond au moins à l’un des caractères 
suivants : a-z, 0-9, _, ou -. La quantificateur + indique qu’au moins un caractère a une 
correspondance. Le \. indique un point obligatoire (.). Et le reste correspond à une autre 
chaîne d’au moins un de ces caractères : a-z, 0-9, _, ou -.
La partie du modèle définie par la chaîne optionalUrlPart correspond à zéro ou plus des 
caractères suivants : un point (.) suivi par n’importe quel nombre de caractères 
alphanumériques (y compris _ et -). Le quantificateur * indique que zéro ou plus de 
caractères ont une correspondance.
L’appel à la méthode replace() utilise l’expression régulière et assemble la chaîne HTML de 
remplacement, à l’aide de backreferences.
La méthode urlToATag() appelle ensuite la méthode emailToATag(), qui utilise des 
techniques semblables pour remplacer des modèles de courrier électronique avec des chaînes 
de lien hypertexte HTML <a>. Les expressions régulières utilisées pour correspondre à des 
URL HTTP, FTP et de courrier électronique dans le fichier sont assez simples car elles sont 
données à titre d’exemple. Elles sont beaucoup plus compliquées si l’on souhaite établir une 
correspondance plus correcte.
332
Utilisation d’expressions régulières

Conversion des chaînes dollar américain en 
chaînes euro
Lorsque l’utilisateur clique sur le bouton de test dans l’exemple d’application et qu’il a coché 
la case dollarToEuro, l’application appelle la méthode statique 
CurrencyConverter.usdToEuro() pour convertir des chaînes dollar américain ("$9.95", 
par exemple) en chaînes euro ("8.24 €", par exemple), comme suit :
var usdPrice:RegExp = /\$([\d,]+.\d+)+/g;
return input.replace(usdPrice, usdStrToEuroStr); 
La première ligne définit un modèle simple pour établir une correspondance avec des chaînes 
dollar américain. Le caractère $ est précédé du caractère d’échappement (\).
La méthode replace() utilise l’expression régulière pour établir une correspondance avec le 
modèle et appelle la fonction usdStrToEuroStr() pour déterminer la chaîne de 
remplacement (une valeur en euros).
Lorsqu’un nom de fonction est utilisé comme deuxième paramètre de la méthode replace(), 
les éléments suivants sont transmis comme paramètres à la fonction appelée :
?
La partie correspondante de la chaîne.
?
Tout groupe entre parenthèses capturé correspondant. Le nombre d’arguments transmis 
de cette façon varie selon le nombre de correspondances de groupes entre parenthèses 
capturées. Pour déterminer le nombre de correspondances de groupes entre parenthèses 
capturés, vérifiez arguments.length - 3 dans le code de la fonction.
?
La position d’index dans la chaîne où débute la correspondance.
?
La chaîne complète.
La méthode usdStrToEuroStr() convertit les modèles de chaîne dollar américain en chaînes 
euro, comme suit :
private function usdToEuro( args):String
{
var usd:String = args[1];
usd = usd.replace(",", "");
var exchangeRate:Number = 0.828017;
var euro:Number = Number(usd) * exchangeRate;
trace(usd, Number(usd), euro);
const euroSymbol:String = String.fromCharCode(8364); // €
return euro.toFixed(2) + " " + euroSymbol; 
}
args[1] représente le groupe entre parenthèses capturé mis en correspondance par 
l’expression régulière usdPrice. Il s’agit de la portion numérique de la chaîne dollar 
américain : c’est-à-dire la quantité en dollar, sans le signe $. La méthode applique une 
conversion de taux de change et renvoie la chaîne résultante (avec un symbole de fin de ligne € 
au lieu du symbole $ placé à gauche).
Exemple : Un analyseur Wiki
333

334
Utilisation d’expressions régulières

CHAPITRE 10
Gestion d’événements
1 0
Un système de gestion des événements permet au programmeur de répondre aux actions de 
l’utilisateur et aux événements système de manière pratique. Le modèle d’événements 
ActionScript 3.0 n’est pas uniquement pratique, il respecte les normes en vigueur et s’intègre 
parfaitement à la liste d’affichage d’Adobe Flash Player 9. Ce modèle repose sur la 
spécification d’événements Document Object Model (DOM) de niveau 3, une architecture 
de gestion d’événements normalisée. Il constitue donc pour les programmeurs ActionScript 
un outil puissant et parfaitement intuitif.
Ce chapitre s’organise en cinq sections. Les deux premières fournissent des informations 
générales sur la gestion d’événements dans ActionScript. Les trois dernières décrivent les 
principaux concepts qui sous-tendent le modèle d’événements : le flux d’événements, l’objet 
événement et les écouteurs d’événements. Dans ActionScript 3.0, le système de gestion des 
événements interagit étroitement avec la liste d’affichage ; ce chapitre suppose que vous 
connaissiez les principes de base de cette liste. Pour plus d’informations, voir 
« Programmation de l’affichage », à la page 395.
Contenu
Principes de base de la gestion des événements . . . . . . . . . . . . . . . . . . . . . . . . . . . .336
Variation de la gestion d’événements dans ActionScript 3.0 par rapport aux 
versions antérieures  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .339
Flux d’événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .343
Objets événements  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .345
Ecouteurs d’événements  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
Exemple : un réveil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  360
335

Principes de base de la gestion des 
événements
Introduction à la gestion des événements
Vous pouvez concevoir un événement comme tout type d’action qui se produit dans votre 
fichier SWF et qui présente un intérêt pour vous en tant que programmeur. Par exemple, la 
plupart des fichiers SWF prennent en charge une certaine forme d’interaction, qu’il s’agisse 
d’une action aussi simple qu’un clic avec la souris ou d’une opération plus complexe, telle que 
l’acceptation et le traitement des données saisies dans un formulaire. Toute interaction de ce 
type dans le fichier SWF est considérée comme un événement. Des événements peuvent 
également se produire sans aucune interaction directe de l’utilisateur, par exemple lorsque le 
chargement des données depuis un serveur se termine ou qu’une caméra connectée devient 
active.
Dans ActionScript 3.0, tout événement est représenté par un objet événement, qui correspond 
à une instance de la classe Event ou de l’une de ses sous-classes. Le rôle d’un objet événement 
est non seulement de stocker des informations relatives à un événement spécifique, mais aussi 
de contenir des méthodes qui favorisent la manipulation de cet objet. Par exemple, lorsque 
Flash Player détecte un clic de la souris, il crée un objet événement (une instance de la classe 
MouseEvent) qui représente cet événement particulier.
Après création d’un objet événement, Flash Player le distribue, ce qui signifie que l’objet 
événement est transmis à l’objet représentant la cible de l’événement. L’objet qui doit recevoir 
l’objet événement ainsi distribué est appelé cible d’événement. Par exemple, lorsqu’une caméra 
reliée devient active, Flash Player distribue un objet événement directement à la cible de 
l’événement, dans ce cas l’objet représentant la caméra. Toutefois, si la cible d’événement se 
trouve dans la liste d’affichage, l’objet événement est transmis tout au long de la hiérarchie de 
la liste d’affichage jusqu’à ce qu’il atteigne la cible en question. Dans certains cas, l’objet 
événement se « propage » ensuite vers le haut de la hiérarchie de la liste d’affichage, selon le 
même cheminement. Cette traversée de la hiérarchie de la liste d’affichage correspond au flux 
d’événements
.
Vous pouvez « écouter » les objets événement de votre code grâce aux écouteurs d’événements. 
Les écouteurs d’événements sont des fonctions ou des méthodes que vous écrivez pour répondre 
aux différents événements. Pour garantir que le programme réagisse aux événements, vous 
devez ajouter des écouteurs d’événements soit à la cible d’événement, soit à l’un des objets de 
la liste d’affichage qui font partie du flux d’événements de l’objet événement.
336
Gestion d’événements

Chaque fois que vous écrivez un code d’écouteur d’événement, il suit cette structure de base 
(les éléments en gras sont des espaces réservés que vous rempliriez pour votre cas particulier) :
function eventResponse(eventObject:EventType):void
{
// Les actions effectuées en réponse à l’événement apparaissent ici.
}
eventTarget.addEventListener(EventType.EVENT_NAMEeventResponse);
Ce code a deux rôles. Tout d’abord, il définit une fonction, qui est une manière de spécifier les 
actions à exécuter en réponse à l’événement. Ensuite, il appelle la méthode 
addEventListener() de l’objet source, « inscrivant » ainsi la fonction auprès de l’événement 
spécifié de façon à ce que lorsque l’événement survient, les actions de la fonction ont lieu. 
Lorsque l’événement se produit, la cible de l’événement vérifie sa liste de toutes les fonctions 
et méthodes enregistrées en tant qu’écouteurs d’événements. Elle appelle ensuite chacune 
d’entre elles, transmettant l’objet événement comme paramètre.
Vous devez apporter quatre modifications à ce code pour créer votre propre écouteur 
d’événement. Premièrement, vous devez remplacer le nom de la fonction par celui que vous 
souhaitez utiliser (ceci doit être modifié à deux endroits, là où le code indique 
eventResponse). Deuxièmement, vous devez spécifier le nom de la classe de l’objet 
événement qui est envoyé par l’événement que vous souhaitez écouter (EventType dans le 
code), et vous devez indiquer la constante pour l’événement en question (EVENT_NAME dans la 
liste). Troisièmement, vous devez appeler la méthode addEventListener() sur l’objet qui 
enverra l’événement (eventTarget dans ce code). Vous pouvez également modifier le nom de 
la variable utilisée comme paramètre de la fonction (eventObject dans ce code).
Tâches courantes de gestion des événements
Vous trouverez ci-dessous des tâches courantes de gestion des événements. Chacune d’entre 
elles est décrite dans ce chapitre :
?
Ecrire un code pour répondre à des événements
?
Empêcher qu’un code réponde à des événements
?
Utiliser des objets event
?
Utiliser un flux d’événements :
?
Identification des informations de flux d’événements
?
Arrêt du flux d’événements
?
Arrêt du comportement par défaut
?
Envoyer des événements à partir de vos classes
?
Créer un type d’événement personnalisé
Principes de base de la gestion des événements
337

Concepts et termes importants
La liste de référence suivante contient les termes importants que vous rencontrerez dans ce 
chapitre :
?
Comportement par défaut : certains événements sont liés à un comportement appelé 
comportement par défaut. Par exemple, lorsqu’un utilisateur tape du texte dans un champ, 
un événement de saisie de texte est déclenché. Le comportement par défaut de cet 
événement consiste à afficher le caractère tapé dans le champ texte—mais vous pouvez 
annuler ce comportement par défaut (si vous ne souhaitez pas afficher le caractère tapé, 
par exemple).
?
Envoyer : indiquer à des écouteurs d’événements qu’un événement a eu lieu.
?
Evénement : quelque chose qui s’est produit sur un objet et que ce dernier peut indiquer à 
d’autres objets.
?
Flux d’événements : lorsque des événements concernent un objet sur la liste d’affichage 
(un objet affiché à l’écran), tous les objets qui contiennent l’objet sont informés de 
l’événement et avertissent à leur tour leurs écouteurs d’événements. Ce processus 
commence avec la scène et se poursuit à travers la liste d’affichage jusqu’à l’objet réel où 
s’est produit l’événement. Il recommence ensuite avec la scène. Ce processus est appelé 
flux d’événements.
?
Objet événement : un objet contenant des informations sur l’occurrence d’un événement 
particulier qui est envoyé à tous les écouteurs lorsqu’un événement est envoyé.
?
Cible d’événement : l’objet qui envoie un événement. Par exemple, si l’utilisateur clique 
sur un bouton situé dans un Sprite se trouvant dans la scène, tous ces objets envoient des 
événements mais c’est au niveau de la cible d’événement que se produit l’événement 
(le bouton cliqué, dans ce cas).
?
Ecouteur : un objet ou une fonction qui s’est enregistré(e) avec un objet, pour indiquer 
qu’il doit être averti lorsqu’un événement spécifique se produit.
Utilisation des exemples fournis dans le chapitre
Au fur et à mesure que vous avancez dans le chapitre, vous pouvez tester des exemples de code. 
Tous les codes de ce chapitre comprennent un appel de la fonction trace() pour tester les 
résultats du code. Pour tester les codes de ce chapitre :
1.
Créez un document Flash vide.
2. Sélectionnez une image-clé dans le scénario.
3. Ouvrez le panneau Actions et copiez le code dans le panneau Script.
338
Gestion d’événements

4. Exécutez le programme en sélectionnant Contrôle > Tester l’animation.
Les résultats des fonctions trace() des codes s’affichent dans le panneau Sortie.
Certains codes sont plus complexes et sont écrits sous la forme d’une classe. Pour tester ces 
exemples :
1.
Créez un document Flash vide et enregistrez-le sur votre ordinateur.
2. Créez un nouveau fichier ActionScript et enregistrez-le dans le même répertoire que le 
document Flash. Le nom du fichier doit correspondre au nom de la classe du code. 
Par exemple, si le code définit une classe EventTest, enregistrez le fichier ActionScript sous 
le nom .
3. Copiez le code dans le fichier ActionScript et enregistrez le fichier.
4. Dans le document Flash, cliquez sur une partie vide de la scène ou de l’espace de travail 
pour activer l’inspecteur Propriétés du document.
5. Dans l’inspecteur Propriétés, dans le champ Classe du document, saisissez le nom de la 
classe ActionScript que vous avez copiée du texte.
6. Exécutez le programme en sélectionnant Contrôle > Tester l’animation
Les résultats de l’exemple s’affichent dans le panneau Sortie.
Ces techniques de test des exemples de code sont décrites de façon plus détaillée dans des exemples de code contenus dans un chapitre », à la page 67.
Variation de la gestion d’événements 
dans ActionScript 3.0 par rapport aux 
versions antérieures
En ce qui concerne la gestion des événements, la différence la plus évidente entre ActionScript 
3.0 et les versions antérieures est qu’ActionScript 3.0 comprend un seul système de gestion des 
événements alors que les anciennes versions d’ActionScript en comptent plusieurs. 
Cette section commence par une présentation générale du fonctionnement de la gestion des 
événements dans les versions précédentes, puis étudie les nouveautés apportées par 
ActionScript 3.0 dans ce domaine.
Variation de la gestion d’événements dans ActionScript 3.0 par rapport aux versions antérieures
339

Gestion des événements dans les versions 
précédentes d’ActionScript
Antérieurement à ActionScript 3.0, le langage ActionScript fournissait plusieurs méthodes de 
gestion des événements :
?
Les gestionnaires d’événement on(), qui peuvent se placer directement sur des 
occurrences Button et MovieClip
?
Les gestionnaires d’événement onClipEvent(), qui peuvent se placer directement sur des 
occurrences MovieClip
?
Des propriétés de fonction de rappel, telles que XML.onload et Camera.onActivity
?
Des écouteurs d’événements, que vous pouvez enregistrer à l’aide de la méthode 
addListener()
?
La classe UIEventDispatcher, qui mettait partiellement en œuvre le modèle 
d’événements DOM
Chacun de ces mécanismes présente des avantages et des inconvénients. Les gestionnaires 
on() et onClipEvent() sont simples d’utilisation, mais compliquent la maintenance des 
projets car il peut s’avérer difficile de localiser le code placé directement sur les boutons ou les 
clips. Les fonctions de rappel sont également faciles à mettre en œuvre, mais imposent une 
limite d’une seule fonction de rappel par événement. La mise en œuvre des écouteurs 
d’événements est plus complexe : ils nécessitent non seulement la création d’un objet et d’une 
fonction d’écouteur mais aussi l’enregistrement de l’écouteur auprès de l’objet qui génère 
l’événement. Bien qu’elle accroisse le temps système nécessaire, cette solution vous permet de 
créer plusieurs objets écouteur et de tous les enregistrer pour le même événement.
Dans ActionScript 2.0, le développement des composants engendrait un modèle 
d’événements encore différent. Ce nouveau modèle, caractérisé par la classe 
UIEventDispatcher, reposait sur un sous-ensemble de la spécification d’événements DOM. 
Ainsi, pour les développeurs accoutumés à la gestion des événements de composant, le passage 
au nouveau modèle d’événements d’ActionScript 3.0 se fera sans trop de difficultés.
Malheureusement, si l’on constate des recoupements entre les divers modèles d’événements, il 
existe aussi des différences. Par exemple, dans ActionScript 2.0, certaines propriétés, telles que 
TextField.onChanged, peuvent s’utiliser soit comme fonction de rappel, soit comme 
écouteur d’événements. Toutefois, la syntaxe qui permet d’enregistrer les objets écouteurs 
varie selon que vous utilisez l’une des six classes qui prennent en charge les écouteurs ou la 
classe UIEventDispatcher. Pour les classes Key, Mouse, MovieClipLoader, Selection, Stage et 
TextField, vous utilisez la méthode addListener(), mais pour la gestion des événements de 
composant, vous utilisez une méthode appelée addEventListener().
340
Gestion d’événements

La multiplicité des modèles de gestion d’événements a fait naître une autre complexité : 
l’étendue de la fonction de gestionnaire d’événements variait largement en fonction du 
mécanisme utilisé. En d’autres termes, la signification du mot-clé this n’était pas cohérente 
sur l’ensemble des systèmes de gestion d’événements.
Gestion d’événements dans ActionScript 3.0
ActionScript 3.0 utilise pour la première fois un modèle de gestion d’événements qui vient 
remplacer les nombreux mécanismes qui existaient dans les précédentes versions du langage. 
Ce nouveau modèle d’événements se fonde sur la spécification d’événements du modèle 
d’objet de document (DOM, Document Object Model) niveau 3. Bien que le format de 
fichier SWF ne suive pas spécifiquement la norme DOM, il existe suffisamment de 
similitudes entre la liste d’affichage et la structure du DOM pour permettre la mise en œuvre 
de ce modèle d’événements. Un objet de la liste d’affichage est semblable à un nœud de la 
structure hiérarchique du DOM ; dans ce chapitre, les termes objet de liste d’affichage et nœud 
sont d’ailleurs utilisés de façon interchangeable.
La mise en œuvre du modèle d’événements DOM dans Flash Player comprend un concept 
appelé comportements par défaut. Un comportement par défaut est une action que Flash Player 
effectue comme conséquence normale de certains événements.
Comportements par défaut
Les développeurs se chargent normalement d’écrire le code qui permet de répondre aux 
événements. Dans certains cas, cependant, un comportement est si couramment associé à un 
événement que Flash Player l’exécute automatiquement, sauf si le développeur ajoute du code 
pour annuler son exécution. Comme Flash Player se livre automatiquement à cette opération, 
on parle de comportements par défaut.
Par exemple, lorsqu’un utilisateur entre du texte dans un objet TextField, il est si courant de 
voir s’afficher la saisie dans l’objet TextField en question que ce comportement est prédéfini 
dans Flash Player. Si vous ne souhaitez pas conserver ce comportement par défaut, vous 
pouvez l’annuler à l’aide du système de gestion des événements. Lorsqu’un utilisateur entre du 
texte dans un objet TextField, Flash Player crée une instance de la classe TextEvent afin de 
représenter cette saisie. Pour éviter que Flash Player n’affiche le texte dans l’objet TextField, 
vous devez accéder à cette instance TextEvent spécifique et appeler sa méthode 
preventDefault().
Certains comportements par défaut ne peuvent être évités. Par exemple, Flash Player génère 
un objet MouseEvent lorsque l’utilisateur double-clique sur un mot dans un objet TextField. 
Le comportement par défaut, qui ne peut être évité, consiste à mettre en évidence le mot situé 
sous le curseur.
Variation de la gestion d’événements dans ActionScript 3.0 par rapport aux versions antérieures
341

De nombreux types d’objets événement ne sont associés à aucun comportement par défaut. 
Par exemple, l’objet événement Connect, que Flash Player distribue lorsqu’une connexion 
réseau est établie, n’est associée à aucun comportement par défaut. La documentation de l’API 
relative à la classe Event et ses sous-classes fait l’inventaire de chaque type d’événement, décrit 
le comportement par défaut qui lui est éventuellement associé et indique si ce dernier peut 
être évité.
Il est important de comprendre que les comportements par défaut sont uniquement associés à 
des objets événement distribués par Flash Player ; il n’en existe aucun pour les objets 
événement distribués via ActionScript par programmation. Par exemple, vous pouvez utiliser 
les méthodes de la classe EventDispatcher pour distribuer un objet événement du type 
textInput, mais cet objet ne sera associé à aucun comportement par défaut. En d’autres 
termes, Flash Player n’affiche aucun caractère dans un objet TextField en réponse à un 
événement textInput que vous avez distribué par programmation.
Nouveautés des écouteurs d’événements dans ActionScript 3.0
Pour les développeurs familiarisés avec la méthode ActionScript 2.0 addListener(), il peut 
être utile de souligner les différences entre le modèle d’écouteur d’événements d’ActionScript 
2.0 et le modèle d’événements d’ActionScript 3.0. La liste ci-après décrit les principales 
différences entre ces deux modèles d’événements :
?
Pour ajouter des écouteurs d’événements dans ActionScript 2.0, vous utilisez, selon le cas, 
addListener() ou addEventListener(). Dans ActionScript 3.0, il faut utiliser 
addEventListener() dans tous les cas.
?
ActionScript 2.0 ne propose aucun flux d’événements dans ActionScript 2.0, ce qui 
signifie que la méthode addListener() peut uniquement être appelée sur l’objet qui 
émet l’événement. Dans ActionScript 3.0, la méthode addEventListener() peut être 
appelée sur tout objet faisant partie du flux d’événements. 
?
Dans ActionScript 2.0, les écouteurs d’événements peuvent être des fonctions, des 
méthodes ou des objets, alors que dans ActionScript 3.0, seules les fonctions et les 
méthodes peuvent agir comme écouteurs d’événements.
342
Gestion d’événements

Flux d’événements
Flash Player distribue des objets événement dès que survient un événement. Si la cible 
d’événement ne se trouve pas dans la liste d’affichage, Flash Player distribue l’objet événement 
directement à la cible. Par exemple, Flash Player distribue l’objet événement Progress 
directement à un objet URLStream. Cependant, si la cible d’événement se trouve dans la liste 
d’affichage, Flash Player distribue l’objet événement à la liste d’affichage, dans laquelle l’objet 
chemine jusqu’à atteindre la cible d’événement. 
Le flux d’événements représente le parcours que suivra un objet événement dans la liste 
d’affichage. Cette liste s’organise de manière hiérarchique, pour constituer une arborescence. 
Au sommet de la liste d’affichage se trouve la scène, un conteneur d’objet d’affichage spécial 
qui lui sert de racine. La scène, représentée par la classe flash.display.Stage, est uniquement 
accessible via un objet d’affichage. Chaque objet d’affichage présente une propriété nommée 
stage, qui renvoie à la scène de cette application.
Lorsque Flash Player distribue un objet d’événement, celui-ci effectue un aller-retour entre la 
scène et le nœud cible. Selon la définition de la spécification d’événements DOM, le nœud 
cible est le nœud qui représente la cible d’événement. En d’autres termes, le nœud cible est 
l’objet de la liste d’affichage au niveau duquel est survenu l’événement. Par exemple, si 
l’utilisateur clique sur un objet de la liste d’affichage appelé child1, Flash Player distribue un 
objet événement dont le nœud cible est child1.
Le flux d’événements se décompose en trois phases. La première correspond à la phase de 
capture, qui comprend tous les nœuds de la scène jusqu’au parent du nœud cible. 
La deuxième partie est appelée la phase cible, qui comprend uniquement le nœud cible. 
La troisième partie s’appelle la phase de propagation vers le haut. Elle comprend les nœuds 
rencontrés lors du cheminement du parent du nœud cible jusqu’à la scène.
Le nom de ces phases prend tout son sens si vous envisagez la liste d’affichage comme une 
hiérarchie verticale dont le sommet est la scène, comme illustré par le schéma suivant :
Scène
Nœud parent
Nœud enfant1
Nœud enfant2
Flux d’événements
343

Si un utilisateur clique sur Child1 Node, Flash Player distribue un objet événement dans ce 
flux d’événements. Comme le montre l’illustration suivante, le parcours de l’objet commence 
à Stage. L’objet descend ensuite jusqu’à Parent Node, puis vers Child1 Node. Il se propage 
alors vers le haut jusqu’à Stage, en repassant par Parent Node. 
Scène
Phase de
Phase de
capture
propagation vers le haut
Nœud parent
Nœud enfant1
Nœud enfant2
Phase cible
Dans cet exemple, la phase de capture comprend Stage et Parent Node pendant le trajet 
descendant initial. La phase cible comprend le temps passé au nœud Child1 Node. La phase 
de propagation comprend les nœuds Parent Node et Stage, qui se trouvent sur le chemin du 
retour vers le nœud racine.
Le flux d’événements contribue au renforcement du système de gestion des événements par 
rapport aux versions précédentes d’ActionScript. Dans ces dernières, le flux d’événements est 
inexistant, ce qui signifie que les écouteurs d’événements s’ajoutent uniquement à l’objet qui 
génère l’événement. Dans ActionScript 3.0, vous pouvez ajouter des écouteurs d’événements 
aussi bien à un nœud cible qu’à tout autre nœud du flux d’événements. 
Cette possibilité d’ajouter des écouteurs d’événements tout au long du flux d’événements 
s’avère particulièrement utile lorsqu’un composant d’interface comprend plusieurs objets. 
Par exemple, un objet bouton contient souvent un objet texte qui sert de libellé au bouton. 
Sans la possibilité d’ajouter un écouteur au flux d’événements, il faudrait en ajouter un à 
l’objet bouton et un à l’objet texte pour être sûr d’être averti des événements de clic survenant 
à tout endroit du bouton. Le flux d’événements vous permet, au contraire, de placer un seul 
écouteur d’événements sur l’objet bouton afin de gérer les événements de clic, qu’ils se 
produisent sur l’objet texte ou sur des zones de l’objet bouton non couvertes par l’objet texte. 
344
Gestion d’événements

Cependant, certains objets événement ne participent pas aux trois phases du flux 
d’événements. Certains types d’événements, tels que enterFrame et init, sont distribués 
directement au nœud cible et ne participent ni à la phase de capture, ni à la phase de 
propagation vers le haut. D’autres événements peuvent cibler des objets qui ne font pas partie 
de la liste d’affichage, par exemple les événements distribués à une instance de la classe Socket. 
Ces objets événements aboutissent directement à l’objet cible, sans participer à la phase de 
capture et de propagation vers le haut.
Pour savoir comme se comporte un type d’événement particulier, vous pouvez consulter la 
documentation de l’API ou examiner les propriétés de l’objet événement. Cette dernière 
méthode est décrite à la section suivante.
Objets événements
Les objets événements jouent deux rôles essentiels dans le nouveau système de gestion des 
événements. Tout d’abord, ces objets représentent de véritables événements puisqu’ils stockent 
dans un ensemble de propriétés des informations relatives à des événements précis. Ils contient 
en outre un jeu de méthodes qui vous permet de manipuler les objets événements et d’agir sur 
le comportement du système de gestion des événements.
Pour faciliter l’accès à ces propriétés et ces méthodes, l’API Flash Player définit une classe 
Event qui constitue la classe de base de tous les objets événement. La classe Event définit un 
jeu fondamental de propriétés et de méthodes commun à tous les objets événements.
Cette section commence par étudier les propriétés de la classe Event avant de décrire les 
méthodes de cette même classe, puis explique l’existence de sous-classes dans la classe Event.
Présentation des propriétés de la classe Event
La classe Event définit plusieurs propriétés et constantes en lecture seule qui fournissent des 
informations essentielles sur l’objet événement. Les points suivants revêtent une importance 
particulière :
?
Les types d’objet événement sont représentés par des constantes et stockés dans la 
propriété .
?
La possibilité d’éviter le comportement par défaut d’un événement est représentée par une 
valeur booléenne, stockée dans la propriété Event.cancelable.
?
Les informations relatives au flux d’événements se trouvent dans les propriétés restantes.
Objets événements
345

Types d’objets événement
Chaque objet événement est associé à un type d’événement. Les types d’événement sont 
stockés dans la propriété  sous forme de chaîne. Il est utile de connaître le type 
d’un objet événement car votre code peut alors distinguer les objets de types différents. 
Par exemple, le code suivant spécifie que la fonction clickHandler() doit répondre à tous les 
objets événements clic de souris transmis à myDisplayObject :
myDisplayObject.addEventListener(MouseEvent.CLICK, clickHandler);
La classe Event est elle-même associée à deux douzaines de types d’événement, représentés par 
des constantes de la classe Event. Dans cet extrait de la définition de la classe Event, certaines 
de ces constantes sont illustrées :
package flash.events
{
public class Event
{
// Constantes de classe
public static const ACTIVATE:String = "activate";
public static const ADDED:String    = "added";
// Les autres constantes sont omises par souci de concision
}
}
Ces constantes permettent de faire facilement référence à des types d’événement précis. 
Vous devez utiliser ces constantes au lieu des chaînes qu’elles représentent. Si vous 
orthographiez de manière incorrecte un nom de constante dans votre code, le compilateur 
peut détecter l’erreur. Si vous utilisez les chaînes qu’elles représentent, une erreur de frappe ne 
sera pas forcément détectée lors de la compilation et pourrait provoquer un comportement 
inattendu, difficile à déboguer. Par exemple, utilisez le code suivant pour ajouter un écouteur 
d’événements :
myDisplayObject.addEventListener(MouseEvent.CLICK, clickHandler);
plutôt que :
myDisplayObject.addEventListener("click", clickHandler);
Informations de comportement par défaut
Le code que vous écrivez est en mesure de vérifier si le comportement par défaut d’un objet 
événement donné peut être évité. Pour ce faire, il doit accéder à la propriété cancelable. 
La propriété cancelable contient une valeur booléenne qui indique si le comportement par 
défaut peut être évité ou non. Vous pouvez éviter, ou annuler, le comportement par défaut de 
quelques événements à l’aide de la méthode preventDefault(). Pour plus d’informations, 
voir « Annulation du comportement d’événement par défaut », à la page 350.
346
Gestion d’événements

Informations de flux d’événements
Les propriétés restantes de la classe Event contiennent des informations importantes sur 
l’objet événement et ses relations au flux d’événements, comme l’explique la liste suivante : 
?
La propriété bubbles contient des informations sur les parties du flux d’événements 
auquel participe l’objet événement. 
?
La propriété eventPhase indique la phase actuelle du flux d’événements. 
?
La propriété target stocke une référence à la cible d’événement. 
?
La propriété currentTarget stocke une référence de l’objet de liste d’affichage qui traite 
actuellement l’objet événement.
La propriété bubbles
On dit d’un événement qu’il se propage vers le haut (en anglais, « to bubble ») lorsqu’il 
participe à la phase de propagation vers le haut du flux d’événements, c’est-à-dire quand 
l’objet événement est transmis du nœud cible via ses ascendants jusqu’à la scène. La propriété 
Event.bubbles stocke une valeur booléenne qui indique si l’objet événement participe à la 
phase de propagation vers le haut. Tous les événements qui se propagent vers le haut 
participent également aux phases de capture et cible ; de tels événements participent donc aux 
trois phases du flux d’événements. Si la valeur est true, l’objet événement participe aux trois 
phrases. Si la valeur est false, l’objet événement ne participe pas à la phase de propagation 
vers le haut.
Propriété eventPhase
Vous pouvez déterminer la phase d’événement de tout objet événement grâce à sa propriété 
eventPhase. La propriété eventPhase a pour valeur un entier non signé qui représente l’une 
des trois phases du flux d’événements. L’API de Flash Player définit une classe EventPhase 
distincte qui contient trois constantes correspondant aux trois valeurs entières non signées, 
comme illustré par l’extrait de code suivant :
package flash.events
{
public final class EventPhase
{
public static const CAPTURING_PHASE:uint = 1;
public static const AT_TARGET:uint       = 2;
public static const BUBBLING_PHASE:uint  = 3;
}
}
Objets événements
347

Ces constantes correspondent aux trois valeurs valables pour la propriété eventPhase. 
Vous pouvez utiliser ces constantes pour améliorer la lisibilité de votre code. Supposons par 
exemple que vous souhaitiez être sûr qu’une fonction nommée myFunc() soit uniquement 
appelée lorsque la cible d’événement se trouve dans la scène cible. Le code suivant vous permet 
de tester cette condition :
if (event.eventPhase == EventPhase.AT_TARGET)
{
myFunc();
}
Propriété target
La propriété target contient une référence à l’objet cible de l’événement. Dans certains cas, 
ce système est simple, par exemple, lorsqu’un micro devient actif, la cible de l’objet événement 
est l’objet Microphone. Toutefois, si la cible se trouve sur la liste d’affichage, la hiérarchie de 
cette dernière doit être prise en compte. Par exemple, si un utilisateur clique avec la souris sur 
un point correspondant à plusieurs objets de la liste d’affichage qui se chevauchent, Flash 
Player choisit toujours comme cible d’événement l’objet qui se trouve le plus loin de la scène. 
Dans des fichiers SWF complexes, et particulièrement ceux dont les boutons sont 
régulièrement ornés d’objets enfant plus petits, la propriété target ne doit pas être utilisée 
fréquemment car elle pointera souvent vers l’objet enfant du bouton plutôt que vers le bouton 
lui-même. Dans de telles situations, il est courant d’ajouter des écouteurs d’événements au 
bouton et d’utiliser la propriété currentTarget. En effet, cette dernière pointe vers le bouton 
alors que la propriété target peut pointer vers l’un des enfants du bouton. 
Propriété currentTarget
La propriété currentTarget contient une référence de l’objet de liste d’affichage qui traite 
actuellement l’objet événement. Même s’il peut paraître étrange de ne pas savoir quel nœud 
traite actuellement l’objet événement que vous étudiez, gardez à l’esprit que vous pouvez 
ajouter une fonction écouteur à n’importe quel objet d’affichage du flux d’événements de 
l’objet événement en question. En outre, cette fonction écouteur peut être placée à tout 
endroit. Par ailleurs, la même fonction écouteur peut être ajoutée à différents objets 
d’affichage. L’utilité de la propriété currentTarget augmente donc avec la taille et la 
complexité du projet.
348
Gestion d’événements

Présentation des méthodes de la classe Event
Il existe trois catégories de méthodes dans la classe Event :
?
Les méthodes d’utilitaire, qui peuvent créer des copies d’un objet événement ou le 
convertir en chaîne
?
Les méthodes de flux d’événements, qui suppriment les objets événement du flux 
d’événements
?
Les méthodes de comportement par défaut, qui évitent le comportement par défaut ou 
vérifient s’il peut être évité
Méthodes d’utilitaire de la classe Event
La classe Event compte deux méthodes d’utilitaire. La méthode clone() permet de créer des 
copies d’un objet événement. La méthode toString() permet de représenter sous forme de 
chaînes les propriétés d’un objet événement ainsi que leurs valeurs. Bien qu’utilisées en interne 
par le modèle d’événements, ces deux méthodes sont mises à la disposition des développeurs 
pour un usage générique.
Pour les développeurs expérimentés qui souhaitent créer des sous-classes de la classe Event, il 
est nécessaire de redéfinir et de mettre en œuvre des versions de ces deux méthodes d’utilitaires 
afin de garantir le bon fonctionnement de la sous-classe d’événement.
Arrêt du flux d’événements
La méthode Event.stopPropogation() ou Event.stopImmediatePropogation() vous 
permet d’arrêter le cheminement d’un objet événement dans le flux d’événements. 
Quasi identiques, ces deux méthodes diffèrent uniquement en ce que les autres écouteurs 
d’événements du nœud actuel sont autorisés ou non à s’exécuter :
?
La méthode Event.stopPropogation() empêche l’objet événement de passer au nœud 
suivant mais seulement après que tous les autres écouteurs du nœud actuel ont été 
autorisés à s’exécuter.
?
La méthode Event.stopImmediatePropogation() empêche l’objet événement de passer 
au nœud suivant sans autoriser les autres écouteurs du nœud actuel à s’exécuter.
Quelle que soit la méthode appelée, elle n’a aucun effet sur la réalisation du comportement 
par défaut de l’événement. Utilisez les méthodes de comportement par défaut de la classe 
Event pour éviter le comportement par défaut.
Objets événements
349

Annulation du comportement d’événement par défaut
Deux méthodes sont liées à l’annulation du comportement par défaut : preventDefault() et 
isDefaultPrevented(). Appelez la méthode preventDefault() pour annuler le 
comportement par défaut associé à un événement. Pour vérifier si preventDefault() a déjà 
été appelée sur un objet événement, appelez la méthode isDefaultPrevented(), qui renvoie 
la valeur true si la méthode a déjà été appelée, false dans le cas contraire.
La méthode preventDefault() fonctionne uniquement s’il est possible d’annuler le 
comportement par défaut de l’événement. Pour vérifier que c’est le cas, reportez-vous à la 
documentation de l’API de ce type d’événement ou examinez la propriété cancelable de 
l’objet événement à l’aide du code ActionScript.
L’annulation du comportement par défaut n’a aucun effet sur la progression d’un objet 
événement dans le flux d’événements. Utilisez les méthodes de flux d’événements de la classe 
Event pour supprimer un objet événement du flux d’événements.
Sous-classes de la classe Event
Pour de nombreux événements, le jeu de propriétés commun, défini dans la classe Event est 
suffisant. Néanmoins, d’autres événements présentent des caractéristiques exclusives qui ne 
peuvent être capturées par les propriétés disponibles dans la classe Event. Pour ceux-là, l’API 
de Flash Player définit plusieurs sous-classes de la classe Event. 
Chaque sous-classe fournit un complément de propriétés et de types d’événement spécifiques 
à la catégorie d’événement considérée. Par exemple, les événements liés aux actions de la souris 
présentent plusieurs caractéristiques uniques, que les propriétés définies dans la classe Event 
ne peuvent capturer. La classe MouseEvent constitue une extension de la classe Event 
puisqu’elle ajoute dix propriétés contenant des informations telles que l’emplacement de 
l’événement de souris et les éventuelles touches actionnées en même temps. 
Une sous-classe d’Event contient également des constantes qui représentent de types 
d’événement associés à la sous-classe. Par exemple, la classe MouseEvent définit des constantes 
pour plusieurs types d’événement de souris, notamment click, doubleClick, mouseDown et 
mouseUp.
Comme le décrit la section « Méthodes d’utilitaire de la classe Event », à la page 349, lors de la 
création d’une sous-classe d’Event, vous devez bloquer les méthodes clone() et toString() 
pour fournir la fonctionnalité propre à la sous-classe.
350
Gestion d’événements

Ecouteurs d’événements
Les écouteurs d’événements, également appelés gestionnaires d’événements, sont des fonctions 
que Flash Player exécute en réponse à des événements déterminés. La procédure d’ajout d’un 
écouteur d’événements se déroule en deux temps. En premier lieu, vous créez une fonction ou 
méthode de classe que Flash Player doit exécuter en réponse à l’événement. On parle parfois 
de fonction d’écouteur ou de fonction de gestionnaire d’événements. En second lieu, vous 
utilisez la méthode addEventListener() pour enregistrer la fonction d’écouteur auprès de la 
cible de l’événement ou tout autre objet de la liste d’affichage qui appartient au flux 
d’événements approprié. 
Création d’une fonction d’écouteur
La création d’une fonction d’écouteur est un domaine dans lequel le modèle d’événements 
ActionScript 3.0 diffère du modèle d’événements DOM. Le modèle d’événements DOM 
établit une distinction claire entre l’écouteur d’événements et la fonction d’écouteur : un 
écouteur d’événements est une instance de classe qui met en œuvre l’interface EventListener, 
tandis que la fonction d’écouteur est une méthode de la classe appelée handleEvent(). 
Dans le modèle d’événements DOM, vous enregistrez l’instance de classe qui contient la 
fonction d’écouteur, plutôt que la fonction d’écouteur elle-même. 
Le modèle d’événements ActionScript ne fait aucune distinction entre l’écouteur 
d’événements et la fonction d’écouteur. L’interface EventListener est inexistante dans 
ActionScript 3.0 et les fonctions d’écouteur peuvent être définies en dehors de toute classe ou 
au sein d’une classe. Par ailleurs, il n’est pas nécessaire de nommer les fonctions d’écouteur 
handleEvent() ; vous pouvez utiliser tout identifiant valable. Dans ActionScript 3.0, vous 
enregistrez le nom de la fonction d’écouteur elle-même.
Ecouteurs d’événements
351

Fonction d’écouteur défini en dehors de toute classe
Le code suivant crée un fichier SWF simple qui affiche une forme carrée de couleur rouge. 
Une fonction d’écouteur nommée clickHandler(), qui n’appartient à aucune classe, écoute 
les événements de clic de souris dans le carré rouge.
package
{
import flash.display.Sprite;
public class ClickExample extends Sprite
{
public function ClickExample()
{
var child:ChildSprite = new ChildSprite();
addChild(child);
}
}
}
import flash.display.Sprite;
import flash.events.MouseEvent;
class ChildSprite extends Sprite
{
public function ChildSprite()
{
graphics.beginFill(0xFF0000);
graphics.drawRect(0,0,100,100);
graphics.endFill();
addEventListener(MouseEvent.CLICK, clickHandler);
}
}
function clickHandler(event:MouseEvent):void
{
trace("clickHandler detected an event of type: " + );
trace("the this keyword refers to: " + this);
}
Lorsqu’un utilisateur interagit avec le fichier SWF résultant, en cliquant sur le carré, Flash 
Player génère la sortie de trace ci-après :
clickHandler detected an event of type: click
the this keyword refers to: [object global]
Notez que l’objet événement est transmis sous forme d’instruction à clickHandler(). 
Cela permet à votre fonction d’écouteur d’examiner l’objet événement. Dans cet exemple, 
vous utilisez la propriété type de l’objet événement pour vérifier que cet événement 
correspond à un clic.
L’exemple vérifie aussi la valeur du mot-clé this. Dans ce cas, this représente l’objet global, 
ce qui est logique puisque la fonction est définie en dehors de toute classe ou objet 
personnalisé.
352
Gestion d’événements

Fonction d’écouteur définie comme méthode de classe
L’exemple ci-dessous est identique au précédent, qui définit la classe ClickExample, sauf que la 
fonction clickHandler() est définie comme méthode de la classe ChildSprite : 
package
{
import flash.display.Sprite;
public class ClickExample extends Sprite
{
public function ClickExample()
{
var child:ChildSprite = new ChildSprite();
addChild(child);
}
}
}
import flash.display.Sprite;
import flash.events.MouseEvent;
class ChildSprite extends Sprite
{
public function ChildSprite()
{
graphics.beginFill(0xFF0000);
graphics.drawRect(0,0,100,100);
graphics.endFill();
addEventListener(MouseEvent.CLICK, clickHandler);
}
private function clickHandler(event:MouseEvent):void
{
trace("clickHandler detected an event of type: " + );
trace("the this keyword refers to: " + this);
}
}
Lorsqu’un utilisateur interagit avec le fichier SWF résultant, en cliquant sur le carré rouge, 
Flash Player génère la sortie de trace ci-après :
clickHandler detected an event of type: click
the this keyword refers to: [object ChildSprite]
Ecouteurs d’événements
353

Notez que le mot-clé this renvoie à l’instance ChildSprite nommée child. Cela constitue un 
changement de comportement par rapport à ActionScript 2.0. Si vous utilisiez des composants 
dans ActionScript 2.0, vous vous rappelez sans doute que lorsqu’une méthode de classe était 
transmise à UIEventDispatcher.addEventListener(), l’étendue de la méthode était liée au 
composant qui émettait l’événement, et non à la classe dans laquelle la méthode d’écouteur 
était définie. En d’autres termes, si vous utilisiez cette technique dans ActionScript 2.0, le mot-
clé this renvoyait au composant émettant l’événement et non à l’instance ChildSprite. 
Pour certains développeurs, il s’agissait d’un vrai problème car cela signifiait qu’ils ne 
pouvaient accéder à aucune autre méthode et propriété de la classe qui contenait la méthode 
d’écouteur. Pour le contourner, les programmeurs d’ActionScript 2.0 pouvaient utiliser la 
classe .Delegate pour modifier l’étendue de la méthode d’écouteur. Cette 
manipulation n’est plus nécessaire puisque ActionScript 3.0 crée une méthode liée lorsque 
addEventListener() est appelée. Par conséquent, le mot-clé this fait référence à l’instance 
ChildSprite nommée child et le programmeur peut accéder aux autres méthodes et 
propriétés de la classe ChildSprite.
Ecouteur d’événement à ne pas utiliser
Une troisième technique permet de créer un objet générique dont l’une des propriétés pointe 
vers une fonction d’écouteur affectée dynamiquement. Elle est cependant déconseillée. 
Nous l’évoquons ici en raison de son utilisation courante dans ActionScript 2.0 ; il n’est 
toutefois pas recommandé de l’utiliser dans ActionScript 3.0. Cette mise en garde tient au fait 
que le mot-clé this fera référence à l’objet global et non à l’objet écouteur. 
L’exemple ci-après est identique à l’exemple précédent de la classe ClickExample, sauf que la 
fonction d’écouteur est définie comme faisant partie d’un objet générique appelé 
myListenerObj :
package
{
import flash.display.Sprite;
public class ClickExample extends Sprite
{
public function ClickExample()
{
var child:ChildSprite = new ChildSprite();
addChild(child);
}
}
}
354
Gestion d’événements

import flash.display.Sprite;
import flash.events.MouseEvent;
class ChildSprite extends Sprite
{
public function ChildSprite()
{
graphics.beginFill(0xFF0000);
graphics.drawRect(0,0,100,100);
graphics.endFill();
addEventListener(MouseEvent.CLICK, myListenerObj.clickHandler);
}
}
var myListenerObj:Object = new Object();
myListenerObj.clickHandler = function (event:MouseEvent):void
{
trace("clickHandler detected an event of type: " + );
trace("the this keyword refers to: " + this);
}
Les résultats de trace seront les suivants :
clickHandler detected an event of type: click
the this keyword refers to: [object global]
On s’attendrait à ce que this fasse référence à myListenerObj et que la sortie de trace soit 
[object Object], mais le mot-clé renvoie en fait à l’objet global. Lorsque vous transmettez 
un nom de propriété dynamique comme instruction à addEventListener(), Flash Player est 
incapable de créer une méthode liée. En effet, ce que vous transmettez comme paramètre 
listener n’est rien de plus que l’adresse mémoire de votre fonction d’écouteur ; Flash Player 
n’a aucun moyen de lier cette adresse à l’instance myListenerObj.
Ecouteurs d’événements
355

Gestion des écouteurs d’événements
Vous pouvez gérer vos fonctions d’écouteur à l’aide des méthodes de l’interface 
IEventDispatcher. Cette interface est la version ActionScript 3.0 de l’interface EventTarget du 
modèle d’événements DOM. Bien que le nom IEventDispatcher semble impliquer que l’objet 
principal de la classe est l’envoi (ou la distribution) des objets événements, les méthodes qui 
lui correspondent servent en fait plus souvent à l’enregistrement, la vérification et la 
suppression des écouteurs d’événements. L’interface IEventDispatcher définit cinq méthodes, 
comme illustré dans le code suivant :
package flash.events
{
public interface IEventDispatcher
{
function addEventListener(eventName:String, 
listener:Object,
useCapture:Boolean=false,
priority:Integer=0,
useWeakReference:Boolean=false):Boolean;
function removeEventListener(eventName:String, 
listener:Object,
useCapture:Boolean=false):Boolean;
function dispatchEvent(eventObject:Event):Boolean;
function hasEventListener(eventName:String):Boolean;
function willTrigger(eventName:String):Boolean;
}
}
L’API de Flash Player met en œuvre l’interface IEventDispatcher à l’aide de la classe Event 
Dispatcher. Cette dernière constitue la classe de base de toutes les classes pouvant servir de 
cibles d’événement ou faire partie d’un flux d’événements. Par exemple, la classe 
DisplayObject hérite de la classe EventDispatcher, par conséquent, tout objet de la liste 
d’affichage peut accéder aux méthode de l’interface IEventDispatcher.
356
Gestion d’événements

Ajout des écouteurs d’événements
La méthode addEventListener() est la clé de voûte de l’interface IEventDispatcher. 
Elle permet d’enregistrer les fonctions d’écouteurs. Les deux paramètres requis sont type et 
listener. Le paramètre type spécifie le type d’événement. Avec le paramètre listener, vous 
pouvez spécifier la fonction d’écouteur qui doit s’exécuter lorsque l’événement survient. 
Le paramètre listener peut être une référence à une fonction ou une méthode de classe.
REMARQUE
N’utilisez pas de parenthèses lors de la spécification du paramètre listener. 
Par exemple, la fonction clickHandler() est spécifiée sans parenthèses dans l’appel 
suivant à la méthode addEventListener() : 
addEventListener(MouseEvent.CLICK, clickHandler). 
Le paramètre useCapture de la méthode addEventListener() vous permet de contrôler la 
phase du flux d’événements pendant laquelle votre écouteur sera actif. Si useCapture a la 
valeur true, votre écouteur sera actif pendant la phase de capture du flux d’événements. 
Si useCapture a la valeur false, votre écouteur sera actif pendant la phase cible et la phase de 
propagation du flux d’événements. Pour écouter un événement pendant toutes les phases du 
flux d’événements, vous devez appeler deux fois addEventListener() ; la première fois 
useCapture prend la valeur true, la seconde, useCapture prend la valeur false.
Le paramètre priority de la méthode addEventListener() ne fait pas officiellement partie 
du modèle d’événements DOM de niveau 3. Il est inclus dans ActionScript 3.0 pour vous 
offrir une plus grande souplesse dans l’organisation de vos écouteurs d’événements. Lorsque 
vous appelez addEventListener(), vous pouvez définir la priorité de cet écouteur 
d’événements en transmettant une valeur entière comme paramètre priority. La valeur par 
défaut est 0. Vous pouvez toutefois utiliser une valeur entière négative ou positive. Plus le 
nombre est élevé, plus l’exécution de l’écouteur d’événements est rapide. Les écouteurs 
d’événements de priorité équivalente sont exécutés suivant l’ordre dans lequel ils ont été 
ajoutés : plus l’écouteur est ajouté tôt, plus il est exécuté rapidement. 
Le paramètre useWeakReference vous permet de spécifier si la référence à la fonction 
d’écouteur est faible ou normale. En lui attribuant la valeur true, vous évitez les situations 
dans lesquelles les fonctions d’écouteurs demeurent dans la mémoire alors qu’elles sont 
inutiles. Flash Player utilise une technique appelée nettoyage pour effacer de la mémoire les 
objets qui ne servent plus. Un objet est considéré comme inutilisé lorsqu’il n’apparaît dans 
aucune référence. Le nettoyeur de mémoire ignore les références faibles, c’est-à-dire qu’une 
fonction d’écouteur vers laquelle pointe uniquement une référence faible est incluse dans le 
nettoyage.
Ecouteurs d’événements
357

Ce paramètre présente une conséquence importante concernant l’utilisation des événements 
d’objets d’affichage. On s’attendrait normalement à ce qu’un objet d’affichage soit supprimé 
de la mémoire dès sa suppression de la liste d’affichage. Cependant, si d’autres objets se sont 
enregistrés comme écouteurs auprès de l’objet d’affichage, avec le paramètre 
useWeakReference ayant la valeur par défaut false, l’objet d’affichage persiste dans la 
mémoire Flash Player bien qu’il ne s’affiche plus à l’écran. Pour pallier ce problème, soit vous 
enregistrez tous les écouteurs auprès de l’objet d’affich