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. (www.nellymoser.com).
Technologie de compression et décompression vidéo Sorenson™ Spark™ utilisée sous licence de
Sorenson Media, Inc.
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.
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.
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 :
ChapitresDescription
Chapitres 1 à 4, présentation de la
programmation avec ActionScript
Chapitres 5 à 10, classes et types de
données ActionScript 3.0 de base
Chapitres 11 à 26, API de Flash PlayerDécrit les fonctions importantes mises en
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 ».
Décrit les concepts ActionScript 3.0 de base, y
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
Décrit les types de données de niveau supérieur
dans ActionScript 3.0 qui font également partie
de la spécification ECMAScript.
œ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.
® Flash® Player 9.
16A 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 « Accès à la documentation
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 :
ManuelDescription
Utilisation de FlashDécrit comment développer vos applications
Web dynamiques dans l’environnement de
programmation de Flash
Programmation avec ActionScript 3.0Décrit l’utilisation spécifique du langage
ActionScript 3.0 et de l’API de base de
Flash Player
Accès à la documentation ActionScript17
ManuelDescription
Référence du langage et des composants
ActionScript 3.0
Utilisation des composants ActionScript 3.0 Explique comment utiliser les composants pour
Formation à ActionScript 2.0 dans
Adobe Flash
Guide de référence du langage
ActionScript 2.0
Utilisation des composants ActionScript 2.0 Explique de façon détaillée comment utiliser les
Référence du langage des composants
ActionScript 2.0
Extension de FlashDécrit les objets, les méthodes et les propriétés
Prise en main de Flash Lite 2.xExplique comment utiliser Adobe® Flash® Lite™
Développement d’applications Flash Lite 2.0 Explique comment développer des applications
Introduction à ActionScript Flash Lite 2.xExplique comment développer des applications
Référence du langage ActionScript Flash
Lite 2.x
Prise en main de Flash Lite 1.xPrésente Flash Lite 1.x et décrit comment tester
Fournit des exemples de code, d’utilisation et
de syntaxe pour les composants de Flash et
l’API d’ActionScript 3.0
développer des applications Flash
Passe en revue les principes généraux de la
syntaxe ActionScript 2.0 et explique comment
utiliser ce langage pour intervenir sur différents
types d’objet
Fournit des exemples de code, d’utilisation et
de syntaxe pour les composants de Flash et
l’API d’ActionScript 2.0
composants ActionScript 2.0 pour développer
des applications Flash
Décrit chaque composant disponible dans
l’architecture des composants Adobe, version
2, avec son API
disponibles dans l’API de JavaScript
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
Flash Lite 2.x
avec Flash Lite 2.x et décrit toutes les fonctions
ActionScript disponibles pour les développeurs
de Flash Lite 2.x
Fournit des exemples de code, d’utilisation et
de syntaxe pour l’API d’ActionScript 2.0
disponible dans Flash Lite 2.x
votre contenu à l’aide de l’émulateur CS3
d’Adobe® Device Central
18A propos de ce manuel
ManuelDescription
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.xExplique 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
Flash Lite 1.x
Fournit la syntaxe et l’utilisation d’éléments
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
www.adobe.com/go/developer_fr.
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
www.adobe.com/go/designcenter_fr.
Ressources ActionScript destinées à la formation19
20A propos de ce manuel
CHAPITRE 1
Introduction à ActionScript 3.0
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.
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.
1
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, voir « Compatibilité avec les
versions précédentes », à la page 27.
22Introduction à 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.023
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é
peuvent être déclarées dynamiques grâce au mot-clé
dynamic. Bien que scellées par défaut, toutes les classes d’ActionScript 3.0
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 www.ecma-international.org.
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).
24Introduction à 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 (
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.
public, private, protected). Ils fonctionnent
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.025
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
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.
offre un mécanisme distinct de
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é.
26Introduction à ActionScript 3.0
Utilisation du texte
ActionScript 3.0 contient un package flash.text 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,
getFirstCharInParagraph(), qui renvoie l’index du premier caractère d’un paragraphe.
Les méthodes de niveau de ligne incluent
caractères d’une ligne de texte donnée, et
getCharIndexAtPoint(), qui renvoie l’index d’un caractère à un point donné et
getLineLength(), qui renvoie le nombre de
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édentes27
■ 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 7Flash Player 8Flash Player 9
Peut charger les fichiers
SWF pour
Machine virtuelle incluse
Exécute les fichiers SWF
écrits en ActionScript
Fonctionnalité prise
version 7 et
antérieure
AVM1AVM1AVM1 et AVM2
1.0 et 2.01.0 et 2.01.0, 2.0 et 3.0
version 8 et
antérieure
version 9 et antérieure
Contenu créé dans
en charge*
ActionScript 1.0 et 2.0ActionScript 3.0
Peut charger du contenu
et exécuter le code de
contenus créé dans
Peut programmer le
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
ActionScript 1.0 et 2.0 uniquement
ActionScript 1.0 et 2.0 uniquement†
ActionScript 1.0 et 2.0 et
ActionScript 3.0
ActionScript 3.0‡
28Introduction à ActionScript 3.0
CHAPITRE 2
Prise en main d’ActionScript
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.
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
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
value1 et value2, chacune contenant un nombre, vous
30Prise 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 value1:Number;
var :
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 base31
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.
32Prise 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 objets33
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
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.x = 100;
square vers la coordonnée x 100 pixels :
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
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.
artist et title. La classe MovieClip
triangle :
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.play();
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) :
shortFilm.stop();
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);
34Prise en main d’ActionScript
shortFilm de commencer la lecture :
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
les parenthèses. D’autres méthodes, telles
gotoAndStop() doit savoir quel cadre atteindre ; un paramètre est donc requis dans
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
l’objet TextField nommé
calculatorDisplay.text = numericData.toString();
calculatorDisplay :
numericData en texte, puis la fait apparaître à l’écran dans
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 objets35
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.
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.
36Prise 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
aussi spécifier un paramètre (
eventObject dans cet exemple). La spécification d’un paramètre
eventResponse) mais
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
Le code écrit par le programmeur est le suivant :
function eventResponse(event:MouseEvent):void
{
// Actions performed in response to the event go here.
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.
38Prise 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
stocke la fonction
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).
eventResponse() dans sa liste d’écouteurs d’événements.
addEventListener() est appelée, myButton
A ce stade, les opérations suivantes ont lieu :
Utilisation des objets39
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.
40Prise 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
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...";
42Prise 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) :
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 « Utilisation
de tableaux », à la page 239, « Utilisation d’expressions régulières », à la page 305 et «Type de
donné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
Dans Flash, l’opérateur
new peut en outre servir à créer une instance d’un symbole de clip
new.
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 objets43
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
effectuer ou non.
Pour plus d’informations et d’exemples sur l’utilisation des opérateurs, voir «Opérateurs»,
à la page 118
if afin de déterminer si certaines actions sont à
44Prise 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 (
commentaire (
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.
/*), le contenu du commentaire, puis un marqueur de fin de
*/). L’ordinateur ignore tout ce qui apparaît entre les marqueurs de début
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 courants45
■ 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
dans ses parenthèses. Si le résultat est
if. Cette instruction if vérifie la valeur ou l’expression placée
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
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
}
true :
Pour plus d’informations sur les instructions conditionnelles, voir «Instructions
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).
46Prise 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’animation47
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
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
playButton.
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();
48Prise 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
{
this.play();
}
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 :
Cette ligne de code enregistre la fonction startMovie() comme écouteur pour
l’événement
bouton
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("http://example.com/");
navigateToURL(targetURL);
}
click de playButton. Ainsi, chaque fois que l’utilisateur clique sur le
playButton, la fonction startMovie() est appelée.
Ce code définit une fonction gotoAuthorPage(). Cette fonction crée d’abord une
instance URLRequest représentant l’URL http://example.com/, puis transmet cette URL
à la fonction
3. Sur la ligne qui suit le code ajouté à l’étape précédente, entrez cette ligne de code :
navigateToURL() afin que le navigateur de l’utilisateur l’ouvre.
Cette ligne de code enregistre la fonction gotoAuthorPage() comme écouteur pour
l’événement
bouton
click de homeButton. Ainsi, chaque fois que l’utilisateur clique sur le
homeButton, la fonction gotoAuthorPage() est appelée.
Exemple : Elément de portfolio d’animation49
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.
50Prise 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 ActionScript51
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é Box.as :
<mx:Script source=“Box.as” />
■ 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 flash.display.*;
import pour chaque classe du package :
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.
REMARQUE
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
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.
52Prise 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 ActionScript53
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.
54Prise 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 ActionScript55
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.
56Prise 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, voir «Héritage», à
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 classes57
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
paire d’accolages (qui entoureront l’élément structurel
package suivi du nom complet du package, puis d’une
class). Par exemple, nous pouvons
modifier le code précédent comme suit :
package mypackage
{
public class MyClass
{
}
}
Définissez chaque propriété de la classe à l’aide de l’instruction var ajoutée dans le corps
4.
de la classe. Utilisez la même syntaxe que pour la déclaration de variable (en y ajoutant le
qualificatif
définition de classe permettent de créer des propriétés nommées
numericVariable et dateVariable :
public var textVariable:String = "some default value";
public var numericVariable:Number = 17;
public var dateVariable:Date;
Définissez chaque méthode de la classe à l’aide de la syntaxe utilisée pour définir une
5.
public). Par exemple, les lignes suivantes ajoutées entre les accolages de la
textVariable,
fonction. Voici un exemple :
■Pour créer une méthode myMethod(), saisissez :
public function myMethod(param1:String, param2:Number):void
{
// utiliser les paramètres
}
58Prise 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 « Les méthodes accesseurs de lecture et de
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 classes59
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.
60Prise 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 Greeter.as, 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 base61
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 Greeter.as, nommez le document Flash HelloWorld.fla, 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();
mainText.text = myGreeter.sayHello("Bob");
Enregistrez le fichier.
8.
Passez à « Publication et test de votre application ActionScript », à la page 63.
62Prise 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 HelloWorld.fla ou HelloWorld.as, 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 Greeter.as :
1. Ouvrez le fichier Greeter.as.
Exemple : Création d’une application de base63
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 == "")
{
the Enter key.";
greeting = "Hello. Please type your user name, and then press
}
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;
}
}
}
}
64Prise 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
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
userName."
greeting renvoie la valeur "Sorry, userName, you are not on the list."
Enfin, si l’une de ces deux conditions n’est pas satisfaite, la variable
userName est
"Hello,
(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.indexOf(inputName) compare toutes les chaînes du tableau
validNames à la chaîne inputName. La méthode Array.indexOf() renvoie la
validNames, et la valeur false s’il ne s’y trouve pas. L’instruction
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 HelloWorld.fla.
2. Modifiez le script dans l’image 1 de façon à ce qu’une chaîne vide ("") soit transmise à la
méthode
var myGreeter:Greeter = new Greeter();
mainText.text = myGreeter.sayHello("");
Sélectionnez l’outil Texte dans la palette des outils, puis créez deux champs texte sur la
3.
scène, l’un à côté de l’autre, et directement sous le champ texte
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
6. Cliquez sur la première image du scénario principal.
sayHello() de la classe Greeter :
mainText existant.
textIn comme nom d’instance.
Exemple : Création d’une application de base65
7. Dans le panneau Actions, ajoutez les lignes suivantes à la fin du script existant :
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 ».
66Prise 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
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
sa méthode
5. Dans le menu principal, choisissez Contrôle > Tester l’animation pour créer un fichier
appendText().
trace() ou ajoutez une valeur au champ texte à l’aide de
SWF et afficher les résultats.
appendText()
Exécution des exemples suivants67
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
d’une variable dans un code qui ne la contient pas encore, ajoutez un appel
trace() pour tester la valeur
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
la valeur de la variable
var albumName:String = "Three for the money";
outputText.appendText("albumName = ");
outputText.appendText(albumName);
albumName :
outputText, le code suivant peut être utilisé pour vérifier
Ce code écrit le texte suivant dans le champ texte outputText :
albumName = Three for the money
68Prise 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
continue sur la ligne suivante, vous pouvez ajouter un caractère de nouvelle ligne (
outputText.appendText("\n"); // adds a line break to the text field
appendText(). Pour que le texte
"\n"):
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
var albumYear:int = 1999;
outputText.appendText("albumYear = ");
outputText.appendText(albumYear.toString());
toString() de l’objet :
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 suivants69
70Prise en main d’ActionScript
CHAPITRE 3
Syntaxe et langage
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.
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.
72Syntaxe 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 classes73
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 motclé
const, des variables avec le mot-clé var et des propriétés de lecture et de définition au
moyen des attributs
méthodes avec le mot-clé
Vous créez une instance d’une classe à l’aide de l’opérateur
instance de la classe Date appelée
var myBirthday:Date = new Date();
get et set dans une déclaration de méthode. Vous pouvez déclarer des
function.
new. L’exemple suivant crée une
myBirthday.
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.
74Syntaxe 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 nom75
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 flash.xml fourni par l’API de Flash Player illustre très bien ceci.
Le package flash.xml est imbriqué dans le package Flash.
Le package flash.xml contient le programme d’analyse XML hérité utilisé dans les versions
précédentes d’ActionScript. Il se trouve maintenant dans le package flash.xml 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 flash.xml, 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 (flash.xml.XML). Pour éviter cela, la classe XML héritée est
maintenant appelée XMLDocument, comme l’indique l’exemple suivant :
package flash.xml
{
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.
76Syntaxe 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
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
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
par fichier peut utiliser l’attribut
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.
package mais incluiez plutôt le nom du package dans le nom de classe
package pour déclarer un package, ce qui signifie
public et internal, et une seule déclaration au niveau du package
public, que cette déclaration soit une classe, une variable,
Packages et espaces de nom77
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.
78Syntaxe 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 SampleCode.as
package samples
{
public class SampleCode {}
}
// fichier CodeFormatter.as
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 nom79
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
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
class SampleCode
{
var sampleGreeting:String;
function sampleFunction () {
trace(sampleGreeting + " from sampleFunction()");
}
}
sampleGreeting et sampleFunction():
public, private,
80Syntaxe 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
l’exemple de code précédent,
de nom d’
internal.
sampleGreeting et sampleFunction() ont une valeur d’espace
public. Dans
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é
suivant définit l’espace de nom
namespace version1;
version1 :
namespace. Par exemple, le code
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
version1 function myFunction() {}
myFunction() dans l’espace de nom version1 :
Troisièmement, une fois que vous avez appliqué l’espace de nom, vous pouvez le référencer à
l’aide de la directive
L’exemple suivant fait référence à la fonction
use namespace version1;
myFunction();
use ou en qualifiant le nom d’un identifiant avec un espace de nom.
myFunction() à l’aide de la directive use :
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 :
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é).
82Syntaxe 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 (
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
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 nom83
public, private,
private sont
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 (
référencer un espace de nom avec la directive
use namespace « ouvre » l’espace de nom, ce
::). Le fait de
qui permet de l’appliquer à n’importe quel identifiant non qualifié. Par exemple, si vous avez
défini l’espace de nom
utilisant
use namespace example1;
myFunction();
use namespace example1 :
example1, vous pouvez accéder aux noms dans cet espace de nom en
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
example1::myFunction();
myFunction() avec l’espace de nom example1 :
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é
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
d’empêcher les conflits de noms.
Pour mieux comprendre comment l’espace de nom
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
classe Proxy.
Object.__resolve d’ActionScript 2.0, vous permet d’intercepter des
flash_proxy afin
flash_proxy est utilisé, vous devez savoir
callProperty() de la
84Syntaxe 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
uniquement appliquer l’espace de nom
L’e sp ac e d e n om
flash_proxy et l’applique dans la classe Proxy. Votre code doit
flash_proxy à des classes qui étendent la classe Proxy.
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
strict). Lorsque vous remplacez la méthode
nom
flash_proxy override function callProperty(name:*, ...rest):*
{
trace("method call intercepted: " + name);
}
}
}
Packages et espaces de nom85
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
car votre version de la méthode
dynamic class MyProxy extends Proxy
{
public function callProperty() {}
flash_proxy override function callProperty(name:*, ...rest):*
{
trace("method call intercepted: " + name);
}
}
callProperty() se trouve dans un espace de nom différent :
callProperty(). Le code suivant est acceptable
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 (
internal et protected). Par exemple, vous pouvez avoir des méthodes d’utilitaire éparpillées
public, private,
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.
86Syntaxe 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, myInternal.as, 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.
// myInternal.as dans le dossier example
package example
{
public namespace myInternal = "http://www.adobe.com/2006/actionscript/
examples";
}
Le deuxième et le troisième fichiers, Utility.as et Helper.as, 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 example.beta, 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 example.beta, doivent importer l’espace de nom avant de l’utiliser.
// Utility.as 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 nom87
// Helper.as dans le dossier example/beta
package example.beta
{
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, NamespaceUseCase.as, 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.
// NamespaceUseCase.as
package
{
import flash.display.MovieClip;
import example.myInternal; // importation de l’espace de nom
import example.alpha.Utility; // importation de la classe Utility
import example.beta.Helper; // importation de la classe Helper
Helper.someTask();
trace(Helper.lastCalled); // [heure de dernier appel de someTask()]
}
}
}
88Syntaxe 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
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
nécessaire. Par exemple, la ligne d’ActionScript suivante déclare une variable appelée
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; // 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
var i:int;
i de type 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
var i:int;
i = 20;
i et lui affecte la valeur 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
nouvellement créée sur la variable appelée
var customItem:CustomClass = new CustomClass();
CustomClass, et affecte une référence à l’instance de classe
customItem :
var avec le nom de variable. Dans
var est toujours
i :
i n’a pas été définie précédemment :
Variables89
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
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()
{
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
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
strGlobal en la déclarant en dehors de toute fonction. L’exemple
str2 dans une
90Syntaxe 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
fonction
scopeTest(). L’instruction trace placée dans la fonction génère la valeur locale de
str1, puis une variable locale du même nom dans la
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 ()
{
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"]);
Variables91
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
variable
trace(num); // NaN
var num:Number = 10;
trace(num); // 10
num :
trace() initiale pour la variable num se produit avant la déclaration de la
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éesValeur par défaut
Boolean
int0
Number
Object
String
uint0
Non déclaré (équivalent à l’annotation de type *)
Toutes les autres classes, y compris celles définies par
l’utilisateur.
92Syntaxe et langage ActionScript
false
NaN
null
null
undefined
null
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
uint. Si vous tentez d’affecter une valeur
null n’est pas une valeur valide pour des variables de type Boolean, Number, int, ou
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
Object, la valeur est convertie en
null. Si vous tentez d’affecter la valeur undefined à une variable de type
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 :
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 complexes, sont 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.
REMARQUE
Pour les lecteurs intéressés par les détails techniques, ActionScript stocke les valeurs
primitives en tant qu’objets inaltérables. Le fait qu’elles soient stockées en tant qu’objets
inaltérables signifie que le transfert par référence est identique au transfert par valeur.
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.
true et false. Outre le type de données Boolean,
Types de données93
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 java.lang.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à.
94Syntaxe 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 (
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
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
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)
{
}
else if (xParam is Number)
{
}
}
:) suivi par le type de données comme suffixe au nom de variable. Pour associer
xParam, et déclare une variable myParam avec un type de données explicite :
xParam,
var myStr:String = xParam; // erreur de compilateur en mode strict
trace("String: " + myStr);
var myNum:Number = xParam; // erreur de compilateur en mode strict
trace("Number: " + myNum);
Types de données95
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 (
le paramètre
xParam dans l’exemple précédent est modifié de façon à ne plus avoir
*). Par exemple, si
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
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
typeTest() qui attend une instruction
96Syntaxe 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
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
myNum (définie sur 3 en raison de l’instruction d’affectation), avec le type
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
class ClassBase
{
}
final ne peuvent pas être étendues) :
Vous pouvez ensuite créer une sous-classe de ClassBase appelée ClassExtender, qui possède
une propriété nommée
class ClassExtender extends ClassBase
{
var someString:String;
}
someString, comme suit :
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ées97
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 ne doit pas être utilisé pour tester l’appartenance à un type de données.
L’opérateur
types manuelle car l’expression
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
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
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
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
correctement que
instanceof offrait cette fonctionnalité, mais dans ActionScript 3.0, l’opérateur
is doit être utilisé à la place de l’opérateur instanceof pour la vérification des
x instanceof y vérifie simplement la chaîne de prototype de
is examine sa hiérarchie d’héritage et peut être utilisé pour vérifier non seulement
mySprite et utilise l’opérateur is pour tester si mySprite
is vérifie également si mySprite hérite d’une classe qui
is signale
mySprite met en oeuvre la même interface.
98Syntaxe 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
instance de Sprite ou de DisplayObject, mais il renvoie
mySprite met en oeuvre l’interface IEventDispatcher.
trace(mySprite instanceof Sprite); // true
is. L’opérateur instanceof identifie correctement que mySprite est une
false lorsqu’il est utilisé pour tester si
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
l’opérateur
de l’expression eu lieu de
résultats obtenus lors de l’utilisation de l’opérateur
as ne renvoie pas de valeur booléenne. A la place, l’opérateur as renvoie la valeur
true, et null au lieu de false. L’exemple suivant indique les
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.
is, cependant,
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
classe. Par exemple, le code suivant crée une classe dynamique nommée
dynamic class Protean
{
private var privateGreeting:String = "hi";
public var publicGreeting:String = "hello";
function Protean()
{
trace("Protean instance created");
}
}
dynamic lorsque vous déclarez une
Protean :
Types de données99
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
appelée
var myProtean:Protean = new Protean();
myProtean.aString = "testing";
myProtean.aNumber = 3;
trace(myProtean.aString, myProtean.aNumber); // test 3
aNumber à l’instance :
Protean et ajoute une propriété nommée aString et une autre
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
fonction et en l’associant à une propriété de l’instance
l’instruction trace dans une méthode nommée
var myProtean:Protean = new Protean();
myProtean.aString = "testing";
myProtean.aNumber = 3;
myProtean.traceProtean = function ()
{
trace(this.aString, this.aNumber);
};
myProtean.traceProtean(); // test 3
traceProtean():
myProtean en définissant une
myProtean. Le code suivant déplace
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
nom de classe. L’exemple suivant présente la méthode
variables privées et publiques de la classe
myProtean.traceProtean = function ()
{
trace(myProtean.privateGreeting); // non défini
trace(myProtean.publicGreeting); // bonjour
};
myProtean.traceProtean();
Protean doivent être qualifiées avec le mot-clé this ou le
traceProtean() tentant d’accéder aux
Protean.
100Syntaxe et langage ActionScript
Loading...
+ hidden pages
You need points to download manuals.
1 point = 1 manual.
You can buy points or you can get point for every manual you upload.