ADOBE Flash CS3 Programmation avec ActionScript 3.0 [fr]

Download

PROGRAMMATION AVEC

™

ACTIONSCRIPT

3.0

Programmation avec ActionScript™ 3.0

Si le présent guide est fourni avec un logiciel régi par un contrat d’utilisateur final, ce guide ainsi que le logiciel décrit, sont fournis sous licence et peuvent être utilisés ou copiés uniquement selon les clauses et conditions de la licence. Sauf indication expresse dans le contrat de licence, aucune partie de ce guide ne peut être reproduite, stockée dans un système d’extraction ni transmise de quelque manière que soit, électronique, mécanique, par enregistrement ou autre, sans l’accord écrit préalable d’Adobe Systems Incorporated. Veuillez noter que le contenu de ce guide est protégé par les lois de copyright même s’il n’est pas diffusé avec le logiciel comprenant l’accord de licence utilisateur final.

Le contenu de ce guide est fourni à titre d’information uniquement, peut faire l’objet de modifications sans préavis et ne saurait être considéré comme un engagement quelconque de la part d’Adobe Systems Incorporated. Adobe Systems Incorporated décline toute responsabilité quant aux erreurs ou imprécisions susceptibles d’apparaître dans les informations que présente ce guide.

Rappelez-vous que certaines illustrations ou images que vous souhaitez inclure dans votre projet peuvent être protégées par les lois de copyright. L’inclusion sans autorisation de tels éléments dans vos propres travaux peut porter atteinte aux droits du détenteur de ce copyright. Veillez à obtenir toutes les autorisations nécessaires auprès de ce dernier.

Toutes les références aux noms de sociétés dans les exemples de modèles sont fournies à titre d’illustration uniquement et ne visent aucune entreprise existante.

Adobe, le logo Adobe, Flex, Flex Builder et Flash Player sont des marques déposées ou des marques d’Adobe Systems Incorporated aux Etats-Unis et/ou dans d’autres pays.

ActiveX et Windows sont des marques ou des marques déposées de Microsoft Corporation aux Etats-Unis et dans d’autres pays. Macintosh est une marque d’Apple Inc., déposée aux Etats-Unis et dans d’autres pays. Toutes les autres marques sont la propriété de leurs détenteurs respectifs.

Technologie de compression et décompression audio discours utilisée sous licence de Nellymoser, Inc. (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.

Table des matières

A propos de ce manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

Utilisation de ce manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Accès à la documentation ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . 17

Ressources ActionScript destinées à la formation . . . . . . . . . . . . . . . . . 19

Chapitre 1: Introduction à ActionScript 3.0 . . . . . . . . . . . . . . . . . . 21

A propos d’ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Avantages d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

Nouveautés d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Fonctions du langage de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Fonctions API de Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

Compatibilité avec les versions précédentes . . . . . . . . . . . . . . . . . . . . . .27

Chapitre 2: Prise en main d’ActionScript . . . . . . . . . . . . . . . . . . . 29

Concepts de programmation de base . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Quel est le rôle d’un programme informatique. . . . . . . . . . . . . . . . . . 29

Variables et constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Utilisation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Evénements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

Gestion des événements de base . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Description du processus de gestion des événements. . . . . . . . .37

Exemples de gestion d’événements . . . . . . . . . . . . . . . . . . . . . . . . . 41

Création d’instances d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

Eléments de programme courants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

Exemple : Elément de portfolio d’animation. . . . . . . . . . . . . . . . . . . . . . 46

Création d’applications avec ActionScript . . . . . . . . . . . . . . . . . . . . . . . 50

Options d’organisation du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Choix de l’outil approprié . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Processus de développement ActionScript . . . . . . . . . . . . . . . . . . . 55

Création de vos propres classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Stratégies de conception d’une classe . . . . . . . . . . . . . . . . . . . . . . . . 56

Ecriture du code d’une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Suggestions d’organisation des classes . . . . . . . . . . . . . . . . . . . . . . . 59

Exemple : Création d’une application de base . . . . . . . . . . . . . . . . . . . .60

Exécution des exemples suivants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Chapitre 3: Syntaxe et langage ActionScript . . . . . . . . . . . . . . . . 71

Présentation du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

Objets et classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Packages et espaces de nom. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

Vérification des types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Classes dynamiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99

Descriptions des types de données . . . . . . . . . . . . . . . . . . . . . . . . . . .101

Conversions de type. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .118

Instructions conditionnelles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

Boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

Fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131

Concepts de fonction de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

Paramètres de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

Fonctions comme objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

Domaine de la fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

Chapitre 4: Programmation orientée objet en ActionScript. . . . 147

Principes de la programmation orientée objet . . . . . . . . . . . . . . . . . . . 148

Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

Définitions de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .151

Attributs de propriété de classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Les énumérations et les classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

Les classes des éléments incorporés. . . . . . . . . . . . . . . . . . . . . . . . . 169

Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

Rubriques avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

Exemple : GeometricShapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

Chapitre 5: Utilisation des dates et heures . . . . . . . . . . . . . . . . . 205

Principes de base des dates et des heures. . . . . . . . . . . . . . . . . . . . . . 205

Gestion des dates calendaires et des heures. . . . . . . . . . . . . . . . . . . . 206

Contrôle des intervalles temporels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .210

Exemple : une horloge analogique simple. . . . . . . . . . . . . . . . . . . . . . . .213

Chapitre 6: Utilisation des chaînes . . . . . . . . . . . . . . . . . . . . . . . . 217

Principes de base des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .218

Création de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220

La propriété length. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .221

Utilisation de caractères dans des chaînes. . . . . . . . . . . . . . . . . . . . . . 222

Comparaison de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

Récupération des représentations de chaîne d’autres objets. . . . . . 223

Concaténation de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

Recherche de sous-chaînes et de motifs dans des chaînes. . . . . . . 225

Conversion de la casse dans des chaînes. . . . . . . . . . . . . . . . . . . . . . . 230

Exemple : ASCII art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231

Chapitre 7: Utilisation de tableaux . . . . . . . . . . . . . . . . . . . . . . . . 239

Principes de base des tableaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

Tableaux indexés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

Tableaux associatifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .251

Tableaux multidimensionnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256

Clonage de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258

Rubriques avancées :. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

Exemple : PlayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

Chapitre 8: Gestion des erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

Principes de base de la gestion des erreurs . . . . . . . . . . . . . . . . . . . . . 272

Types d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

Gestion des erreurs dans ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . 277

Eléments de gestion des erreurs ActionScript 3.0. . . . . . . . . . . . . 278

Stratégies de gestion des erreurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

Utilisation de la version de débogage de Flash Player. . . . . . . . . . . . 280

Gestion des erreurs synchrones dans une application. . . . . . . . . . . . .281

Création de classes d’erreur personnalisées . . . . . . . . . . . . . . . . . . . . 286

Réponse à des événements d’erreurs et au statut . . . . . . . . . . . . . . . 288

Comparaison des classes Error . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292

Classes Error de base ECMAScript . . . . . . . . . . . . . . . . . . . . . . . . . .292

Classes Error de base d’ActionScript. . . . . . . . . . . . . . . . . . . . . . . . 295

Classes Error du package flash.error . . . . . . . . . . . . . . . . . . . . . . . . .296

Exemple : Application CustomErrors . . . . . . . . . . . . . . . . . . . . . . . . . . .298

Chapitre 9: Utilisation d’expressions régulières . . . . . . . . . . . . 305

Principes de base des expressions régulières. . . . . . . . . . . . . . . . . . . 306

Syntaxe d’expression régulière . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

Création d’une instance d’une expression régulière . . . . . . . . . . . . 310

Caractères, caractères de remplacement et métaséquences. . . . .311

Classes de caractère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314

Quantificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316

Permutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318

Groupes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319

Indicateurs et propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .322

Méthodes d’utilisation d’expressions régulières avec

des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .327

Exemple : Un analyseur Wiki. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328

Chapitre 10: Gestion d’événements. . . . . . . . . . . . . . . . . . . . . . . 335

Principes de base de la gestion des événements. . . . . . . . . . . . . . . . .336

Variation de la gestion d’événements dans ActionScript 3.0

par rapport aux versions antérieures . . . . . . . . . . . . . . . . . . . . . . . . . . . .339

Flux d’événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .343

Objets événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .345

Ecouteurs d’événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351

Exemple : un réveil. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360

Chapitre 11: Utilisation de XML . . . . . . . . . . . . . . . . . . . . . . . . . . .367

Principes de base de XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .368

L’approche E4X concernant le traitement XML. . . . . . . . . . . . . . . . . .372

Objets XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374

XMLList, objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

Initialisation de variables XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .378

Assemblage et transformation d’objets XML . . . . . . . . . . . . . . . . . . . 380

Parcours de structures XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381

Utilisation d’espaces de nom XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . .387

Conversion de type XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .388

Lecture de documents XML externes. . . . . . . . . . . . . . . . . . . . . . . . . . 390

Exemple : Chargement de données RSS depuis Internet . . . . . . . . 390

Chapitre 12: Programmation de l’affichage . . . . . . . . . . . . . . . . 395

Bases de la programmation de l’affichage . . . . . . . . . . . . . . . . . . . . . . 395

Classes d’affichage de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .401

Avantages de l’utilisation de la liste d’affichage. . . . . . . . . . . . . . . . . . 403

Utilisation des objets d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406

Propriétés et méthodes de la classe DisplayObject. . . . . . . . . . . . 406

Ajout d’objets d’affichage à la liste d’affichage . . . . . . . . . . . . . . . . 407

Utilisation des conteneurs d’objets d’affichage. . . . . . . . . . . . . . . . 407

Traversée de la liste d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411

Définition des propriétés de la scène . . . . . . . . . . . . . . . . . . . . . . . . .413

Gestion des événements des objets d’affichage . . . . . . . . . . . . . . .417

Choix d’une sous-classe de DisplayObject . . . . . . . . . . . . . . . . . . . .418

Manipulation des objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . . . . . 420

Modification de la position. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420

Défilement horizontal et vertical des objets d’affichage . . . . . . . . 426

Redimensionnement et mise à l’échelle des objets . . . . . . . . . . . . 428

Contrôle de la distorsion lors de la mise à l’échelle . . . . . . . . . . 429

Mise en cache des objets d’affichage . . . . . . . . . . . . . . . . . . . . . . . . 432

Pertinence de la mise en cache . . . . . . . . . . . . . . . . . . . . . . . . . . . 433

Activation de la mise en cache sous forme de bitmap . . . . . . . 435

Définition d’une couleur d’arrière-plan opaque . . . . . . . . . . . . . 435

Application de modes de fondu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436

Modification des couleurs des objets d’affichage. . . . . . . . . . . . . . 437

Modification par code des valeurs des couleurs. . . . . . . . . . . . . 438

Modification par code des effets de couleur et

de luminosité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438

Rotation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

Application d’effets de fondu à des objets . . . . . . . . . . . . . . . . . . . . 440

Masquage des objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

Animation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444

Chargement dynamique de contenu à afficher . . . . . . . . . . . . . . . . . . 446

Chargement d’objets d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446

Suivi de la progression du chargement. . . . . . . . . . . . . . . . . . . . . . . 447

Spécification du contexte de chargement . . . . . . . . . . . . . . . . . . . . 449

Exemple : SpriteArranger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .451

Chapitre 13: Utilisation de la géométrie. . . . . . . . . . . . . . . . . . . . 459

Principes de base de la géométrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459

Utilisation des objets Point. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462

Utilisation d’objets Rectangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465

Utilisation des objets Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469

Exemple : Application d’une transformation de matrice

à un objet d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470

Chapitre 14: Utilisation de l’API de dessin . . . . . . . . . . . . . . . . . 475

Les bases d’utilisation de l’API de dessin. . . . . . . . . . . . . . . . . . . . . . . .476

Présentation de la classe Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . .478

Dessin de lignes et de courbes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .479

Dessin de formes à l’aide des méthodes intégrées . . . . . . . . . . . . . . .482

Création de lignes et de remplissages en dégradé. . . . . . . . . . . . . . . .483

Utilisation de la classe Math avec les méthodes de dessin . . . . . . . 489

Animation avec l’API de dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490

Exemple : générateur algorithmique d’effets visuels . . . . . . . . . . . . . . 491

Chapitre 15: Filtrage des objets d’affichage . . . . . . . . . . . . . . . . 495

Bases du filtrage des objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . 495

Création et application de filtres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .497

Création d’un nouveau filtre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .497

Application d’un filtre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498

Le fonctionnement des filtres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500

Problèmes potentiels d’utilisation des filtres. . . . . . . . . . . . . . . . . . 500

Filtres d’affichage disponibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502

Filtre de biseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503

Filtre de flou . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504

Filtre d’ombre portée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504

Filtre de rayonnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505

Filtre de biseau dégradé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506

Filtre de rayonnement dégradé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .507

Exemple : combinaison de filtres de base . . . . . . . . . . . . . . . . . . . . 508

Filtre matrice de couleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510

Filtre de convolution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .511

Filtre mappage de déplacement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514

Exemple : Filter Workbench . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520

Chapitre 16: Utilisation des clips . . . . . . . . . . . . . . . . . . . . . . . . . . 521

Principes de base des clips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521

Utilisation des objets MovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524

Contrôle de la lecture d’un clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524

Utilisation des séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .527

Création d’objets MovieClip à l’aide d’ActionScript. . . . . . . . . . . . . . .528

Exportation des symboles de bibliothèque pour

ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .528

Chargement d’un fichier SWF externe . . . . . . . . . . . . . . . . . . . . . . . . . .532

Exemple : RuntimeAssetsExplorer . . . . . . . . . . . . . . . . . . . . . . . . . . . . .533

Chapitre 17: Utilisation de texte . . . . . . . . . . . . . . . . . . . . . . . . . . 539

Les bases de l’utilisation du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540

Affichage du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543

Types de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543

Modification du contenu d’un champ texte . . . . . . . . . . . . . . . . . . . 544

Affichage du texte HTML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545

Utilisation d’images dans des champs texte . . . . . . . . . . . . . . . . . . 545

Défilement du texte dans un champ texte . . . . . . . . . . . . . . . . . . . . 546

Sélection et manipulation de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547

Capture de la saisie de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549

Restriction de la saisie de texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550

Formatage du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .551

Attribution de formats texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .551

Application de feuilles de style en cascade . . . . . . . . . . . . . . . . . . . 552

Chargement de fichiers CSS externes . . . . . . . . . . . . . . . . . . . . . . . 553

Formatage de plages de texte au sein d’un champ texte . . . . . . . 555

Fonctions avancées d’affichage de texte . . . . . . . . . . . . . . . . . . . . . . . 556

Utilisation de texte statique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558

Exemple : formatage du texte dans le style « journal ». . . . . . . . . . . . 560

Lecture du fichier CSS externe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .561

Disposition des éléments de l’article sur la page . . . . . . . . . . . . . . 564

Modification de la taille de la police en fonction de

la taille du champ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564

Répartition du texte sur plusieurs colonnes . . . . . . . . . . . . . . . . . . . 567

Chapitre 18: Utilisation des graphismes bitmap . . . . . . . . . . . . . . 571

Les bases de l’utilisation des bitmaps . . . . . . . . . . . . . . . . . . . . . . . . . . .571

Les classes Bitmap et BitmapData . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575

Manipulation des pixels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577

Manipulation individuelle de pixels. . . . . . . . . . . . . . . . . . . . . . . . . . . 577

Détection de collision au niveau des pixels . . . . . . . . . . . . . . . . . . . 579

Copie de données bitmap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .581

Création de textures avec les fonctions de bruit aléatoire. . . . . . . . . 582

Défilement du contenu d’images bitmap. . . . . . . . . . . . . . . . . . . . . . . . 584

Exemple : animation d’objets Sprite à l’aide d’une image

bitmap hors écran. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585

Chapitre 19: Utilisation de la vidéo. . . . . . . . . . . . . . . . . . . . . . . . 587

Principes de base de la vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588

Présentation du format vidéo Flash (FLV) . . . . . . . . . . . . . . . . . . . . . . .591

Présentation de la classe Video . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592

Chargement de fichiers vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593

Contrôle de la lecture de la vidéo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594

Détection de la fin d’un flux vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . 595

Lecture de fichiers vidéo en flux continu . . . . . . . . . . . . . . . . . . . . . . . 596

Présentation des points de repère. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .597

Création de méthodes de rappel pour les gestionnaires

d’événements onCuePoint et onMetaData . . . . . . . . . . . . . . . . . . . . . .598

Définir la propriété « client » de l’objet NetStream

comme Object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599

Créer une classe et définir des méthodes pour gérer

les méthodes de rappel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600

Étendre la classe NetStream et lui ajouter des méthodes

pour gérer les méthodes de rappel. . . . . . . . . . . . . . . . . . . . . . . . . 601

Étendre la classe NetStream et la rendre dynamique. . . . . . . . . . 602

Définir la propriété « client » de l’objet NetStream

comme this. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604

Utilisation des points de repère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604

Utilisation des métadonnées de la vidéo . . . . . . . . . . . . . . . . . . . . . . . 605

Capture d’un signal vidéo provenant de la caméra

de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609

Présentation de la classe Camera. . . . . . . . . . . . . . . . . . . . . . . . . . . 609

Affichage du signal provenant de la caméra. . . . . . . . . . . . . . . . . . . 610

Conception d’une application gérant une caméra locale . . . . . . . . 610

Établissement d’une connexion avec la caméra de l’utilisateur . . .611

Vérification de la présence de caméras . . . . . . . . . . . . . . . . . . . . . . . .611

Détection de l’autorisation d’accéder à la caméra. . . . . . . . . . . . . . 612

Optimisation de la qualité d’image vidéo . . . . . . . . . . . . . . . . . . . . . . 614

Suivi des conditions de lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616

Envoi de vidéo à un serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617

Rubriques avancées : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617

Compatibilité de Flash Player avec les fichiers FLV codés . . . . . . 617

La configuration de fichier FLV pour l’hébergement sur

un serveur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618

Le ciblage des fichiers FLV locaux sur Macintosh . . . . . . . . . . . . . 619

Exemple : Video Jukebox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619

Chapitre 20: Utilisation du son . . . . . . . . . . . . . . . . . . . . . . . . . . .627

Principes de base de l’utilisation du son. . . . . . . . . . . . . . . . . . . . . . . . .628

Présentation de l’architecture audio . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631

Chargement de fichiers audio externes . . . . . . . . . . . . . . . . . . . . . . . . .633

Utilisation des sons incorporés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .636

Utilisation de fichiers audio de lecture en continu . . . . . . . . . . . . . . . .637

Lecture de sons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638

Pause et reprise d’un son. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639

Surveillance de la lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640

Arrêt de sons diffusés en continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642

Sécurité lors du chargement et de la lecture des sons. . . . . . . . . . . . 642

Contrôle du volume du son et de la balance. . . . . . . . . . . . . . . . . . . . . 643

Utilisation des métadonnées audio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646

Accès aux données audio brutes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647

Capture de l’entrée de son . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .651

Accès à un microphone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .651

Acheminement de l’audio du microphone vers des

haut-parleurs locaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652

Modification de l’audio du microphone. . . . . . . . . . . . . . . . . . . . . . . 653

Détection de l’activité du microphone. . . . . . . . . . . . . . . . . . . . . . . . 653

Envoi d’audio vers et depuis une passerelle multimédia . . . . . . . . 655

Exemple : Podcast Player. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655

Lecture de données RSS pour une chaîne de balado. . . . . . . . . . 657

Simplification de la lecture et du chargement du son

à l’aide de la classe SoundFacade . . . . . . . . . . . . . . . . . . . . . . . . 657

Affichage de la progression de la lecture . . . . . . . . . . . . . . . . . . . . . .661

Interruption et reprise de la lecture. . . . . . . . . . . . . . . . . . . . . . . . . . . 662

Extension de l’exemple Podcast Player . . . . . . . . . . . . . . . . . . . . . . 663

Chapitre 21: Capture des données saisies par l’utilisateur . . . . 665

Principes de base de la saisie utilisateur . . . . . . . . . . . . . . . . . . . . . . . . 665

Capture de la saisie au clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667

Capture des entrées de souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670

Exemple : WordSearch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675

Chapitre 22: Réseau et communication . . . . . . . . . . . . . . . . . . . 679

Principes de base de la mise en réseau et de

la communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679

Utilisation de données externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683

Connexion à d’autres instances Flash Player. . . . . . . . . . . . . . . . . . . . 690

Connexions socket. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697

Stockage des données locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702

Utilisation des chargements et téléchargements

de fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706

Exemple : création d’un client Telnet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 717

Exemple : chargement et téléchargement de fichiers . . . . . . . . . . . . .721

Chapitre 23: Environnement du système client. . . . . . . . . . . . . . 731

Principes de base de l’environnement du système client. . . . . . . . . . 731

Utilisation de la classe System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .734

Utilisation de la classe Capabilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . .735

Utilisation de la classe ApplicationDomain . . . . . . . . . . . . . . . . . . . . . .736

Utilisation de la classe IME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .740

Exemple : détection des capacités du système . . . . . . . . . . . . . . . . . .746

Chapitre 24: Impression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751

Principes de base de l’impression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .752

Impression d’une page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .753

Tâches Flash Player et impression système . . . . . . . . . . . . . . . . . . . . .755

Définition de la taille, de l’échelle et de l’orientation . . . . . . . . . . . . . .758

Exemple : Impression sur plusieurs pages . . . . . . . . . . . . . . . . . . . . . . . 761

Exemple : Redimensionnement, recadrage et ajustement. . . . . . . . .764

Chapitre 25: Utilisation de l’API externe . . . . . . . . . . . . . . . . . . .767

Principes de base de l’utilisation de l’API externe . . . . . . . . . . . . . . . .768

Avantages de l’API externe et conditions requises . . . . . . . . . . . . . . . 772

Utilisation de la classe ExternalInterface . . . . . . . . . . . . . . . . . . . . . . . .773

Obtention d’informations sur le conteneur externe . . . . . . . . . . . . . 774

Appel de code externe à partir d’ActionScript . . . . . . . . . . . . . . . . .774

Appel du code ActionScript à partir du conteneur . . . . . . . . . . . . .775

Format XML de l’API externe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777

Exemple : utilisation de l’API externe dans un conteneur

de page Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779

Exemple : utilisation de l’API externe avec un conteneur

ActiveX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787

Chapitre 26: La sécurité dans Flash Player . . . . . . . . . . . . . . . . .797

Présentation de la sécurité dans Flash Player . . . . . . . . . . . . . . . . . . .798

Présentation des contrôles d’autorisation . . . . . . . . . . . . . . . . . . . . . . . 801

Sandboxes de sécurité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 812

Restriction des API de réseau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 815

Sécurité du mode plein écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 817

Chargement de contenu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818

Programmation croisée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .822

Accès aux médias chargés comme s’il s’agissait de données. . . . . .826

Chargement des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .829

Chargement de contenu incorporé à partir de fichiers

SWF importés dans un domaine de sécurité . . . . . . . . . . . . . . . . . . . .832

Utilisation de contenus existants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833

Définition des autorisations LocalConnection . . . . . . . . . . . . . . . . . . . 833

Contrôle de l’accès aux scripts dans une page Web hôte. . . . . . . . . 834

Objets partagés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 836

Accès à la caméra, au microphone, au presse-papiers,

à la souris et au clavier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 839

A propos de ce manuel

Ce manuel peut servir de base au développement d’applications avec ActionScript™ 3.0. Il est préférable de maîtriser les concepts de programmation généraux (types de données, variables, boucles et fonctions) afin de mieux comprendre les idées et techniques décrites. Il est également conseillé de comprendre les concepts de programmation orientés objet (classes et héritage). La connaissance d’ActionScript 1.0 ou ActionScript 2.0 est utile mais pas nécessaire.

Contenu

Utilisation de ce manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Accès à la documentation ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17

Ressources ActionScript destinées à la formation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Utilisation de ce manuel

Les chapitres de ce manuel sont structurés en groupes logiques (indiqués ci-dessous) afin de faciliter la recherche de sections de documentation ActionScript connexes :

Chapitres Description

Chapitres 1 à 4, présentation de la programmation avec ActionScript

Chapitres 5 à 10, classes et types de données ActionScript 3.0 de base

Chapitres 11 à 26, API de Flash Player Dé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.

16 A propos de ce manuel

Pour comprendre les exemples de code fournis dans ce manuel, vous n’avez pas besoin de savoir utiliser les environnements de développement intégrés pour ActionScript (Flex Builder ou l’outil de création Flash, par exemple). En revanche, vous pouvez consulter la documentation relative à ces outils pour savoir comment les utiliser pour écrire et compiler du code ActionScript 3.0. Pour plus d’informations, voir « 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 :

Manuel Description

Utilisation de Flash Décrit comment développer vos applications

Web dynamiques dans l’environnement de programmation de Flash

Programmation avec ActionScript 3.0 Décrit l’utilisation spécifique du langage

ActionScript 3.0 et de l’API de base de Flash Player

Accès à la documentation ActionScript 17

Manuel Description

Référence du langage et des composants 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 Flash Décrit les objets, les méthodes et les propriétés

Prise en main de Flash Lite 2.x Explique comment utiliser Adobe® Flash® Lite™

Développement d’applications Flash Lite 2.0 Explique comment développer des applications

Introduction à ActionScript Flash Lite 2.x Explique comment développer des applications

Référence du langage ActionScript Flash Lite 2.x

Prise en main de Flash Lite 1.x Pré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

18 A propos de ce manuel

Manuel Description

Développement d’applications Flash Lite 1.x Décrit comment développer des applications

pour des périphériques mobiles à l’aide de Flash Lite 1.x

Formation à ActionScript Flash Lite 1.x Explique comment utiliser ActionScript dans

des applications Flash Lite 1.x et décrit toutes les fonctions ActionScript disponibles avec Flash Lite 1.x

Guide de référence du langage ActionScript 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 formation 19

20 A 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.

Contenu

A propos d’ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Avantages d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22

Nouveautés d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23

Compatibilité avec les versions précédentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

A propos d’ActionScript

ActionScript est un langage de programmation destiné à l’environnement d’exécution d’Adobe Flash Player. Il assure l’interactivité, le traitement des données et bien d’autres fonctions du contenu Flash et dans les applications associées.

ActionScript est exécuté par la machine virtuelle ActionScript, un composant de Flash Player. Le code ActionScript est généralement compilé en pseudo-code binaire (une sorte de langage de programmation écrit et compris par les ordinateurs) par un compilateur, par exemple celui intégré dans Adobe Flash CS3 Professional ou Adobe® Flex™ Builder™, ou celui fourni dans le kit de développement Adobe® Flex™ SDK et les services de données Flex™ Data Services. Le pseudo-code binaire est incorporé aux fichiers SWF, qui sont exécuté par Flash Player dans l’environnement d’exécution.

ActionScript 3.0 constitue un modèle de programmation solide, bien connu des développeurs dotés des connaissances élémentaires de la programmation orientée objet. Les fonctions principales d’ActionScript 3.0 sont les suivantes :

■ Une nouvelle machine virtuelle ActionScript, nommée AVM2, qui exploite un nouveau

jeu d’instructions de pseudo-code binaire et améliore grandement les performances.

■ 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.

22 Introduction à ActionScript 3.0

Nouveautés d’ActionScript 3.0

Bien que de nombreuses classes et fonctions d’ActionScript 3.0 seront familières aux programmeurs d’ActionScript, son architecture et sa conceptualisation diffèrent des versions précédentes. Parmi les améliorations d’ActionScript 3.0, on compte de nouvelles fonctions du langage de base et une API Flash Player avancée, qui accroît le contrôle des objets de bas niveau.

Fonctions du langage de base

Le langage de base définit les éléments de construction fondamentaux du langage de programmation, par exemple les arguments, expressions, conditions, boucles et types. ActionScript 3.0 contient de nombreuses fonctions qui accélèrent le processus de développement.

Exceptions d’exécution

ActionScript 3.0 peut signaler davantage de conditions d’erreur que les versions précédentes d’ActionScript. Utilisées pour les conditions d’erreur courantes, les exceptions d’exécution améliorent la procédure de débogage et vous permettent de développer des applications susceptibles de gérer les erreurs de manière fiable. Les erreurs d’exécution peuvent fournir des traces d’empilement qui identifient le fichier source et le numéro de ligne, pour un repérage plus rapide des erreurs.

Types d’exécution

Dans ActionScript 2.0, les annotations de type visaient avant tout à aider le développeur ; lors de l’exécution, toutes les valeurs étaient typées dynamiquement. Dans ActionScript 3.0, les informations de type sont préservées lors de l’exécution et utilisées à plusieurs fins. Flash Player 9 effectue une vérification du type d’exécution afin d’améliorer la sécurité du système quant aux types. Les informations de type servent également à représenter les variables dans les représentations machine natives, ce qui accroît les performances et réduit l’utilisation de la mémoire.

Nouveautés d’ActionScript 3.0 23

Classes scellées

ActionScript 3.0 introduit le concept de classe scellée. Une telle classe possède uniquement un jeu fixe de propriétés et de méthodes, définies lors de la compilation. Il est impossible d’ajouter d’autres propriétés et méthodes. Ainsi, la vérification effectuée au moment de la compilation est plus stricte et garantit une plus grande robustesse des programmes. L’utilisation de la mémoire est également optimisée puisque la table de hachage n’est pas requise pour chaque instance d’objet. Les classes dynamiques sont également disponibles, par le biais du mot-clé 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).

24 Introduction à ActionScript 3.0

Espaces de noms

Les espaces de noms sont semblables aux spécificateurs d’accès classiques qui assurent le contrôle de visibilité des déclarations ( 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.0 25

API de liste d’affichage

L’API d’accès à la liste d’affichage Flash Player, c’est-à-dire l’arborescence contenant tous les éléments visuels d’une application Flash, est constituée de classes permettant de manipuler les primitives visuelles dans Flash.

La nouvelle classe Sprite est un élément de construction léger, semblable à la classe MovieClip mais plus adaptée à la classe de base des composants d’interface. La nouvelle classe Shape représente des formes vectorielles brutes. Il est possible d’instancier ces classes naturellement à l’aide de l’opérateur

new, mais aussi de les redéfinir dynamiquement comme parent à tout

moment. Grâce à la gestion de profondeur désormais automatique et intégrée à Flash Player, le rendu

d’affectation de numéros de profondeur n’est plus nécessaire. De nouvelles méthodes permettent de spécifier et de gérer l’ordre z des objets.

Gestion des données et contenus dynamiques

ActionScript 3.0 comprend des mécanismes de chargement et de gestion des actifs et des données au sein de l’application Flash qui se caractérisent par leur intuitivité et leur cohérence dans l’ensemble de l’API. La nouvelle classe Loader propose un unique mécanisme de chargement des fichiers SWF et des actifs d’image, et permet d’accéder à des informations détaillées sur le contenu chargé. La classe URLLoader 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é.

26 Introduction à 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édentes 27

■ En général, les fichiers SWF écrits en ActionScript 1.0 ou 2.0 doivent faire l’objet d’une

migration s’ils sont destinés à fonctionner avec des fichiers SWF écrits en ActionScript

3.0. Imaginez par exemple que vous ayez créé un lecteur de média avec ActionScript 2.0. Ce lecteur peut charger de nombreux contenus également créés à l’aide d’ActionScript 2.0. Mais vous ne pouvez pas créer un contenu avec ActionScript 3.0 et le charger dans ce lecteur. Vous devez migrer le lecteur vers ActionScript 3.0.

Néanmoins, si vous avez créé un lecteur de média avec ActionScript 3.0, ce lecteur peut effectuer de simples chargements de votre contenu ActionScript 2.0.

Le tableau ci-après récapitule les limitations des versions précédentes de Flash Player relatives au chargement de nouveaux contenus et à l’exécution de code, ainsi que les restrictions liées à la programmation croisée entre les fichiers SWF écrits avec différentes versions d’ActionScript.

Fonctionnalité prise

Environnement d’exécution

en charge

Flash Player 7 Flash Player 8 Flash Player 9

Peut charger les fichiers SWF pour

Machine virtuelle incluse

Exécute les fichiers SWF écrits en ActionScript

Fonctionnalité prise

version 7 et

antérieure

AVM1 AVM1 AVM1 et AVM2

1.0 et 2.0 1.0 et 2.0 1.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.0 ActionScript 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‡

28 Introduction à 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.

Contenu

Concepts de programmation de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Utilisation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .33

Eléments de programme courants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44

Exemple : Elément de portfolio d’animation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .46

Création d’applications avec ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50

Création de vos propres classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Exemple : Création d’une application de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

Exécution des exemples suivants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Concepts de programmation de base

ActionScript étant un langage de programmation, il vous sera plus facile de l’apprendre si vous maîtrisez déjà quelques concepts généraux de programmation.

Quel est le rôle d’un programme informatique

Pour commencer, il est intéressant d’avoir une idée conceptuelle de la nature et du rôle d’un programme informatique. Un tel programme présente deux aspects principaux :

■ Il s’agit d’une série d’instructions ou d’étapes que l’ordinateur doit effectuer.

■ Chaque étape implique à terme la manipulation d’informations ou de données.

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

30 Prise en main d’ActionScript

Nous venons de voir comment l’ordinateur utilise le nom comme une balise d’emplacement destinée à la valeur. Le type de données a également une importance. Lorsque vous créez une variable ActionScript, vous spécifiez le type de données qu’elle contiendra. A partir de là, les instructions de votre programme peuvent uniquement stocker ce type de données dans la variable considérée et la valeur peut être manipulée selon les caractéristiques associées à ce type de données. Dans ActionScript, la création d’une variable (on parle également de déclaration de variable) s’effectue à l’aide de l’instruction

var 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 base 31

Les types de données simples représentent une seule information : par exemple, un seul nombre ou une seule séquence de texte. Cependant, la majorité des types de données définis dans ActionScript peuvent être considérés comme complexes puisqu’ils représentent un ensemble de valeurs regroupées. Par exemple, une variable du type Date représente une valeur unique, un point temporel. Néanmoins, la valeur de date est représentée par différentes valeurs : le jour, le mois, l’année, les heures, les minutes, les secondes, etc., et toutes correspondent à des nombres distincts. Ainsi, bien que nous percevions une date comme une valeur unique (et qu’il soit possible de la traiter comme telle en créant une variable Date), l’ordinateur, en interne, la considère comme un groupe de valeurs qui, ensemble, définissent une seule date.

La plupart des types de données intégrés et ceux créés par les programmeurs, sont des types de date complexes. Voici quelques exemples de types de données complexes que vous pourriez rencontrer :

■ MovieClip : un symbole de clip

■ TextField : un champ texte dynamique ou saisi

■ SimpleButton : un symbole de bouton

■ Date : une information relative à un point temporel (date et heure)

Deux termes sont souvent utilisés comme synonymes de type de données : classe et objet. Une classe est tout simplement la définition d’un type de données. Il s’agit d’un modèle applicable à tous les types d’objets du type de données, comme si l’on déclarait : « toutes les variables du type de données Exemple présentent les caractéristiques suivantes : A, B et C ». A l’inverse, un objet n’est qu’une instance de classe : une variable dont le type de données est MovieClip peut être décrite comme un objet MovieClip. Les exemples ci-après décrivent la même chose :

■ Le type de données de la variable myVariable est Number.

■ La variable myVariable est une instance de Number.

■ La variable myVariable est un objet Number.

■ La variable myVariable est une instance de la classe Number.

32 Prise en main d’ActionScript

Utilisation des objets

ActionScript constitue ce que l’on appelle un langage de programmation orienté objet. Ce terme désigne une simple approche de la programmation, rien d’autre qu’une manière d’organiser le code d’un programme à l’aide d’objets.

Nous avons défini plus haut un programme informatique comme une série de procédures ou d’instructions que l’ordinateur effectue. Nous pouvons alors considérer qu’un programme informatique n’est qu’une longue liste d’instructions. Dans le cas de la programmation orientée objet, les instructions du programme se divisent néanmoins en différents objets : le code étant rassemblé en groupes de fonctionnalités, un même conteneur réunit des types de fonctionnalités et des informations connexes.

En fait, si vous avez travaillé avec des symboles dans Flash, vous savez déjà manipuler les objets. Imaginons que vous ayez défini un symbole de clip, par exemple le dessin d’un rectangle, et que vous en ayez placé une copie sur la scène. Ce symbole de clip constitue aussi un objet (au sens littéral) dans ActionScript ; il s’agit d’une instance de la classe MovieClip.

Vous avez la possibilité de modifier plusieurs caractéristiques du clip. S’il est sélectionné, vous pouvez par exemple modifier certaines valeurs de l’inspecteur Propriétés, telles que la coordonnée x ou la largeur, ou encore différents réglages de couleur comme la transparence alpha ou l’application d’un filtre d’ombre portée. D’autres outils Flash vous permettent d’effectuer davantage de modifications, par exemple l’outil Transformer librement pour faire pivoter le rectangle. Toutes ces actions de transformation du symbole de clip disponibles dans l’environnement de programmation de Flash sont également disponibles dans ActionScript. Pour les utiliser, vous devez modifier les données réunies dans un ensemble appelé objet MovieClip.

Dans la programmation orientée objet que propose ActionScript, chaque classe comprend trois types de caractéristiques :

■ Propriétés

■ Méthodes

■ Evénements

Pris ensemble, ces éléments servent à gérer les données que le programme utilise, et à déterminer les actions à exécuter ainsi que l’ordre d’exécution.

Utilisation des objets 33

Propriétés

Une propriété représente l’une des données réunies dans un objet. Un objet song, par exemple, peut présenter des propriétés nommées 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);

34 Prise 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 objets 35

Par essence, des événements sont des faits qui surviennent et auxquels ActionScript peut répondre parce qu’il les connaît. De nombreux d’événements sont liés à l’interaction de l’utilisateur, par exemple un clic sur un bouton ou une pression sur une touche du clavier. Il existe néanmoins d’autres types d’événement. Par exemple, si vous utilisez ActionScript pour charger une image externe, un événement est capable de vous prévenir lorsque le chargement de l’image est terminé. Pendant l’exécution d’un programme ActionScript, Adobe Flash Player attend que des événements se produisent et lorsque c’est le cas, il exécute le code ActionScript que vous avez spécifié en réponse.

Gestion des événements de base

La gestion des événements est la technique qui permet de spécifier les actions à exécuter en réponse à des événements particuliers. Lors de l’écriture de code ActionScript en vue de la gestion des événements, trois éléments importants sont à identifier :

■ La source de l’événement : quel objet sera concerné par l’événement ? Par exemple, sur

quel bouton aura lieu le clic ou quel objet Loader charge-t-il l’image ? La source de

l’événement est également appelée cible de l’événement car elle représente l’objet où

l’événement est ciblé par Flash Player (là où l’événement a lieu).

■ L’événement : que doit-il se passer, à quel événement voulez-vous répondre ? Ce point est

très important, car de nombreux objets déclenchent plusieurs événements.

■ La réponse : quelles actions doivent faire suite à l’occurrence de l’événement ?

Tout code ActionScript de gestion des événements doit contenir ces trois éléments et respecte la structure de base suivante (les éléments en gras sont des espaces réservés à remplir selon le cas envisagé) :

function eventResponse(eventObject:EventType):void {

// Les actions exécutées en réponse à l’événement apparaissent ici.

}

eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);

Ce code a deux rôles. Tout d’abord, il définit une fonction, qui est une manière de spécifier les actions à exécuter en réponse à l’événement. Ensuite, il appelle la méthode

addEventListener() de l’objet source, « inscrivant » ainsi la fonction auprès de l’événement

spécifié de manière que lorsque l’événement survient, les actions de la fonction ont lieu. Nous allons étudier chacun de ces rôles en détail.

36 Prise en main d’ActionScript

Une fonction sert à regrouper des actions sous un nom unique, un raccourci qui vous permet de les exécuter. La fonction est identique à la méthode, à cette exception près qu’elle n’est pas nécessairement associée à une classe particulière (on pourrait d’ailleurs définir la méthode ainsi : une fonction associée à une classe donnée). Lorsque vous créez une fonction de gestion des événements, vous devez choisir le nom de la fonction (dans ce cas 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.

}

myButton.addEventListener(MouseEvent.CLICK, eventResponse);

myButton.

Utilisation des objets 37

Voici comment ce code devrait fonctionner lorsqu’il est exécuté dans Flash Player :

1. Lors du chargement du fichier SWF, Flash Player remarque qu’il existe une fonction

eventResponse().

2. Flash Player exécute ensuite le code (notamment les lignes de code qui ne sont pas dans une

fonction). Dans ce cas, il n’y a qu’une ligne de code : l’appel à la méthode

addEventListener() sur l’objet source (appelé myButton) et le transfert de la fonction

eventResponse en tant que paramètre.

38 Prise en main d’ActionScript

a. En interne, myButton a une liste de fonctions qui écoutent chaque événement.

Par conséquent, lorsque sa méthode 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 objets 39

a. Flash Player crée un objet, une instance de la classe associée à l’événement en question

(MouseEvent dans cet exemple). Pour de nombreux événements, il s’agira d’une instance de la classe Event ; pour des événements de souris, une instance MouseEvent et pour d’autres événements, une instance de la classe associée à cet événement. Cet objet créé est appelé l’objet événement. Il contient des informations spécifiques sur l’événement qui a eu lieu : le type d’événement, l’endroit où il s’est produit et d’autres informations propres à l’événement, le cas échéant.

b. Flash Player consulte ensuite la liste des écouteurs d’événements stockés par myButton.

Il parcourt ces fonctions l’une après l’autre en les appelant et en transmettant l’objet événement à la fonction en tant que paramètre. Etant donné que la fonction

eventResponse() est l’un des écouteurs de myButton, Flash Player appelle la fonction eventResponse() dans le cadre de ce processus.

40 Prise en main d’ActionScript

c. Lorsque la fonction eventResponse() est appelée, le code qu’elle contient est exécuté

et vos actions spécifiées sont effectuées.

Exemples de gestion d’événements

Voici quelques exemples plus concrets d’événements qui vous donneront une idée des éléments les plus courants et des variations que vous pourrez utiliser lors de l’écriture de votre propre code de gestion des événements :

■ Clic sur un bouton pour lancer la lecture du clip actif. Dans l’exemple suivant,

playButton est le nom d’occurrence du bouton et this est un nom spécial qui signifie

« l’objet actif » :

this.stop();

function playMovie(event:MouseEvent):void

{

this.play();

}

playButton.addEventListener(MouseEvent.CLICK, playMovie);

■ Détection de la saisie dans un champ texte. Dans cet exemple, entryText est un champ

de saisie de texte et

function updateOutput(event:TextEvent):void

{

var pressedKey:String = event.text; outputText.text = "You typed: " + pressedKey;

}

entryText.addEventListener(TextEvent.TEXT_INPUT, updateOutput);

outputText est un champ texte dynamique :

Utilisation des objets 41

■ Clic sur un bouton pour atteindre une URL. Dans ce cas, linkButton est le nom

d’occurrence du bouton :

function gotoAdobeSite(event:MouseEvent):void

{

var adobeURL:URLRequest = new URLRequest("http://www.adobe.com/"); navigateToURL(adobeURL);

}

linkButton.addEventListener(MouseEvent.CLICK, gotoAdobeSite);

Création d’instances d’objets

Bien entendu, pour utiliser un objet dans ActionScript, cet objet doit exister. La création d’un objet repose en partie sur la déclaration d’une variable. Néanmoins la variable crée uniquement un emplacement vide dans la mémoire de l’ordinateur. Vous devez lui attribuer une valeur réelle (c’est-à-dire créer un objet et le stocker dans une variable) avant de pouvoir l’utiliser ou le manipuler. Le processus de création d’un objet est appelé instanciation de l’objet, soit la création d’une instance d’une classe particulière.

La création d’une instance d’objet peut passer par une méthode simple, qui n’implique pas ActionScript. Dans Flash, lorsque vous placez un symbole de clip, un symbole de bouton ou un champ texte sur la scène, puis que vous lui attribuez un nom d’occurrence dans l’inspecteur Propriétés, l’application déclare une variable dotée de ce nom d’occurrence, crée une instance d’objet et stocke cet objet dans la variable. Il en va de même dans Adobe Flex Builder : si vous créez un composant dans Macromedia® MXML™ à partir d’Adobe (soit par codage d’une balise MXML, soit en plaçant le composant dans l’éditeur en mode Création) et lui attribuez un identifiant (dans la balise MXML ou dans la vue des propriétés Flex), cet identifiant devient le nom d’une variable ActionScript et une instance du composant est créée et stockée dans la variable.

Toutefois, vous ne pourrez pas toujours créer un objet visuellement. Plusieurs méthodes permettent donc de créer des instances d’objet à l’aide d’ActionScript uniquement. A partir de plusieurs types de données ActionScript, vous pouvez tout d’abord créer une instance en utilisant une expression littérale, une valeur écrite directement dans le code ActionScript. Voici quelques exemples :

■ Valeur numérique littérale (entrez le nombre directement) :

var someNumber:Number = 17.239;

var someNegativeInteger:int = -53;

var someUint:uint = 22;

■ Valeur de chaîne littérale (placez le texte entre guillemets doubles) :

var firstName:String = "George";

var soliloquy:String = "To be or not to be, that is the question...";

42 Prise en main d’ActionScript

■ Valeur booléenne littérale (utilisez la valeur littérale true ou false):

var niceWeather:Boolean = true;

var playingOutside:Boolean = false;

■ Valeur XML littérale (entrez le XML directement) :

var employee:XML = <employee>

<firstName>Harold</firstName> <lastName>Webster</lastName>

</employee>;

ActionScript définit également des expressions littérales pour les types de données Array, RegExp, Object et Function. Pour des informations détaillées sur ces classes, voir « 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 objets 43

Eléments de programme courants

Outre la déclaration des variables, la création d’instances d’objets et la manipulation des objets à l’aide des propriétés et des méthodes, d’autres éléments de construction peuvent servir à la création d’un programme ActionScript.

Opérateurs

Les opérateurs sont des symboles spéciaux (et parfois des mots) qui permettent d’effectuer des calculs. Ils sont surtout utilisés dans les opérations mathématiques et pour la comparaison de valeurs. En règle générale, un opérateur utilise une ou plusieurs valeurs et « établit » un résultat unique. Voici un exemple :

■ L’opérateur de somme (+) ajoute deux valeurs pour obtenir un nombre unique :

var sum:Number = 23 + 32;

■ L’opérateur de multiplication (*) multiplie une valeur par une autre pour obtenir un

nombre unique :

var energy:Number = mass * speedOfLight * speedOfLight;

■ L’opérateur d’égalité (==) compare deux valeurs pour vérifier si elles sont égales, afin

d’obtenir une valeur vrai/faux (booléenne) unique :

if (dayOfWeek == "Wednesday")

{

takeOutTrash();

}

Comme illustré ici, l’opérateur d’égalité et les autres opérateurs de comparaison sont le

plus souvent utilisés avec l’instruction

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 à

44 Prise en main d’ActionScript

Commentaires

Lors de la rédaction du code ActionScript, il peut s’avérer utile de conserver des notes personnelles, expliquant par exemple le fonctionnement de certaines lignes de code ou la raison pour laquelle vous avez fait tel ou tel choix. Les commentaires de code vous permettent d’insérer du texte dans votre code que l’ordinateur devra ignorer. ActionScript comprend deux types de commentaires :

■ Commentaire sur une ligne : un commentaire sur une ligne est indiqué par l’insertion de

deux barres obliques en tout point d’une ligne. Tout ce qui apparaît après les barres

obliques, jusqu’à la fin de la ligne, est ignoré par l’ordinateur :

// Ceci est un commentaire, que l’ordinateur ignore.

var age:Number = 10; // Définir l’âge sur 10 par défaut.

■ Commentaire sur plusieurs lignes : un commentaire sur plusieurs lignes inclut un

marqueur de début (

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 courants 45

■ Boucles : les structures en boucle vous permettent de désigner un jeu d’instructions que

l’ordinateur exécutera un nombre défini de fois ou jusqu’à ce qu’une condition change.

Souvent, les boucles sont utilisées pour manipuler plusieurs éléments connexes à l’aide

d’une variable dont la valeur change à chaque fois que l’ordinateur achève une boucle.

Pour plus d’informations sur les boucles, voir « Boucle », à la page 128.

■ Instructions conditionnelles : les instructions conditionnelles permettent de désigner

certaines actions à effectuer uniquement dans certaines circonstances ou de définir des

ensembles d’actions destinés à différentes conditions. L’instruction conditionnelle la plus

courante est l’instruction

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).

46 Prise en main d’ActionScript

Le processus de création de cet élément peut être divisé en deux sections principales :

1. Préparer le fichier FLA pour ajouter des éléments ActionScript interactifs.

2. Créer et ajouter les boutons.

3. Ecrire le code ActionScript.

4. Tester l’application.

Préparation à l’ajout de l’interactivité

Avant d’ajouter des éléments interactifs à notre animation, nous devons configurer le fichier FLA en créant des emplacements pour ajouter notre nouveau contenu. Ceci comprend la création d’un espace sur la scène où les boutons sont placés, et la création d’un « espace » dans le fichier FLA pour garder différents éléments séparés.

Pour configurer votre FLA et ajouter des éléments interactifs :

1. Si vous n’avez pas encore d’animation linéaire à laquelle vous ajouterez de l’interactivité,

créez un fichier FLA avec une animation simple (une interpolation de mouvement simple ou une interpolation de forme, par exemple). Autrement, ouvrez le fichier FLA contenant l’animation que vous présentez dans le projet, et enregistrez-le sous un nouveau nom pour créer un nouveau fichier de travail.

2. Choisissez l’endroit où vous souhaitez que les deux boutons apparaissent à l’écran (un pour

démarrer l’animation et l’autre pour effectuer un lien vers le portfolio de l’auteur ou la page d’accueil). Si nécessaire, effacez ou ajoutez de l’espace sur la scène pour ce nouveau contenu. Si l’animation n’en possède pas, vous pouvez créer une page de garde sur la première image (vous pouvez décaler l’animation dessus afin qu’elle démarre sur l’image 2 ou ultérieurement).

3. Ajoutez un nouveau calque, au-dessus des autres calques dans le scénario, et renommez-le

boutons. Il s’agira du calque auquel vous ajouterez les boutons.

4. Ajoutez un nouveau calque, au-dessus du calque boutons, et renommez-le actions. Il s’agira

du calque auquel vous ajouterez le code ActionScript à votre application.

Exemple : Elément de portfolio d’animation 47

Création et ajout de boutons

Nous allons ensuite créer et positionner les boutons qui constitueront le centre de notre application interactive.

Pour créer et ajouter des boutons au FLA :

1. A l’aide des outils de dessin, créez l’aspect visuel de votre premier bouton (le bouton de

lecture) sur le calque boutons. Par exemple, vous pouvez dessiner un ovale horizontal avec du texte au-dessus.

2. A l’aide de l’outil de sélection, sélectionnez toutes les parties graphiques du bouton.

3. Dans le menu principal, choisissez Modifier > Convertir en symbole.

4. Dans la boîte de dialogue, choisissez le type de symbole de bouton, donnez-lui un nom et

cliquez sur OK.

5. Lorsque le bouton est sélectionné, dans l’inspecteur Propriétés, affectez-lui le nom

d’occurrence

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();

48 Prise en main d’ActionScript

Pour écrire un code qui démarre l’animation lorsque l’utilisateur clique sur le bouton de lecture :

1. A la fin du code entré aux étapes précédentes, ajoutez deux lignes vides.

2. Entrez le code suivant en bas du script :

function startMovie(event:MouseEvent):void {

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 :

playButton.addEventListener(MouseEvent.CLICK, startMovie);

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 :

homeButton.addEventListener(MouseEvent.CLICK, gotoAuthorPage);

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’animation 49

Test de l’application

A ce stade, l’application devrait fonctionner complètement. Testons-la.

Pour tester l’application :

1. Dans le menu principal, sélectionnez Contrôle > Tester l’animation. Flash crée le fichier

SWF et l’ouvre dans une fenêtre Flash Player.

2. Testez les deux boutons pour vérifier qu’ils fonctionnent.

3. Si ce n’est pas le cas, vérifiez les points suivants :

■ Les deux boutons ont-ils des noms d’instance différents ?

■ Les appels à la méthode addEventListener() utilisent-ils les mêmes noms que les

noms d’instance des boutons ?

■ Les noms d’événement corrects sont-ils utilisés dans les appels à la méthode

addEventListener() ?

■ Le paramètre correct est-il spécifié pour chacune des fonctions ? (Elles doivent toutes

les deux avoir un seul paramètre avec le type de données MouseEvent.)

Tous ces points et la plupart des autres erreurs possibles devraient entraîner l’apparition d’un message lorsque vous choisissez la commande Tester l’animation ou lorsque vous cliquez sur le bouton. Recherchez les erreurs de compilation dans le panneau prévu à cet effet (celles qui ont lieu lorsque vous choisissez d’abord Tester l’animation), et recherchez les erreurs d’exécution dans le panneau Sortie (erreurs qui ont lieu pendant la lecture du fichier SWF - lorsque vous cliquez sur un bouton, par exemple).

Création d’applications avec ActionScript

La création d’une application avec ActionScript requiert d’autres connaissances que la syntaxe et les noms de classes à utiliser. Bien que le contenu de ce manuel soit essentiellement axé sur ces deux sujets (la syntaxe et l’utilisation des classes ActionScript), d’autres informations pourront vous être utiles, notamment quels programmes permettent d’écrire du code ActionScript, comment ce code s’organise et s’intègre dans une application et quelles étapes il faut respecter dans le développement d’une application ActionScript.

50 Prise en main d’ActionScript

Options d’organisation du code

Le code ActionScript 3.0 peut servir à générer de nombreuses applications, qu’il s’agisse d’une simple animation graphique ou d’un système complexe de traitement des transactions client/ serveur. Selon le type d’application envisagé, vous choisirez l’une ou plusieurs des méthodes suivantes pour intégrer ActionScript dans votre projet.

Stockage de code dans les images d’un scénario Flash

Dans l’environnement de programmation Flash, vous pouvez ajouter du code ActionScript à toute image placée dans un scénario. Ce code sera exécuté pendant la lecture du clip, au moment où la tête de lecture atteindra l’image.

L’insertion de code ActionScript dans des images est une manière simple d’ajouter des comportements à des applications créées dans l’outil de programmation Flash. Vous pouvez placer du code dans n’importe quelle image du scénario principal ou du scénario d’un symbole de clip. Cette souplesse a néanmoins un coût. Lorsque vous créez des applications assez volumineuses, vous risquez de ne plus savoir quelles images contiennent quels scripts. A terme, cela peut compliquer la maintenance de l’application.

Pour simplifier l’organisation de leur code ActionScript, les développeurs placent ce code uniquement dans la première image du scénario ou sur un calque spécifique du document Flash. Il est ainsi plus facile de localiser et de maintenir le code dans les fichiers FLA Flash. Toutefois, la réutilisation du même code dans un autre projet Flash oblige à copier et coller le code dans le nouveau fichier.

Si vous voulez continuer à pouvoir utiliser votre code ActionScript dans de futurs projets Flash, vous préférerez sans doute stocker ce code dans des fichiers ActionScript externes (des fichiers texte dotés de l’extension .as).

Stockage du code dans des fichiers ActionScript

Si votre projet implique une quantité importante de code ActionScript, la meilleure solution consiste à stocker le code dans des fichiers source ActionScript (des fichiers texte dotés de l’extension .as). Un fichier ActionScript peut suivre deux structures, selon l’utilisation que vous prévoyez d’en faire dans votre application.

■ Code ActionScript non structuré : les lignes de code ActionScript, y compris les

instructions et les définitions de fonction, sont écrites comme si elles étaient saisies directement dans un script de scénario, un fichier MXML, etc.

Création d’applications avec ActionScript 51

Ecrit de cette façon, le code est accessible par le biais de l’instruction ActionScript

include ou de la balise <mx:Script> dans Adobe Flex MXML. L’instruction

ActionScript

include provoque l’insertion du contenu d’un fichier ActionScript externe à

un endroit particulier d’un script et sur une étendue donnée, comme s’il avait été saisi directement. Dans le langage Flex MXML, la balise

<mx:Script> vous permet de spécifier

l’attribut source qui identifie le fichier ActionScript externe à charger à cet endroit de l’application. Par exemple, la balise suivante charge un fichier ActionScript externe nommé 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.

52 Prise en main d’ActionScript

■ Ecrivez le code qui fait spécifiquement référence au nom de classe (normalement par

déclaration d’une variable dont le type de données est cette classe et par création d’une instance de la classe à stocker dans la variable). Lorsque vous faites référence à un autre nom de classe dans le code ActionScript, vous indiquez au compilateur de charger la définition de cette classe. Par exemple, si l’on considère une classe externe nommée Box, l’instruction suivante provoque la création d’une nouvelle instance de la classe Box :

var smallBox:Box = new Box(10,20);

Lorsque le compilateur rencontre pour la première fois la référence de la classe Box, il effectue une recherche dans le code source chargé afin de localiser la définition de la classe Box.

Choix de l’outil approprié

Selon les contraintes qu’impose votre projet et les ressources dont vous disposez, vous pouvez avoir le choix entre plusieurs outils (à utiliser individuellement ou en combinaison) pour l’écriture et la modification de votre code ActionScript.

Outil de programmation Flash

Outre ses capacités de création graphique et d’animation, Adobe Flash CS3 Professional comprend des outils qui permettent de manipuler le code ActionScript, qu’il soit joint à des éléments d’un fichier FLA ou regroupé dans des fichiers ActionScript externes. L’outil de programmation Flash s’avère idéal pour les projets impliquant des animations ou vidéos conséquentes, ou lorsque vous désirez créer la plupart des actifs graphiques vous-même, et tout particulièrement lorsque l’interaction utilisateur ou la fonctionnalité assurée par ActionScript est minimale. Cet outil peut également vous paraître adapté au développement de votre projet ActionScript si vous préférez créer les actifs visuels et écrire le code dans une seule et même application. Enfin, cet outil Flash peut vous convenir si vous souhaitez utiliser des composants d’interface préintégrés et que la réduction de la taille du fichier SWF et la facilité d’enveloppement visuel sont des aspects essentiels de votre projet.

Adobe Flash CS3 Professional inclut deux outils permettant l’écriture de code ActionScript :

■ Panneau action : disponible lorsque vous manipulez un fichier FLA, ce panneau vous

permet d’écrire du code ActionScript associé aux images d’un scénario.

■ Fenêtre de script : la fenêtre de script est un éditeur de texte dédié permettant de

travailler sur des fichiers de code ActionScript (.as).

Création d’applications avec ActionScript 53

Flex Builder

Adobe Flex Builder est le principal outil de création de projets avec le cadre d’application Flex. Au-delà de ses outils de présentation visuelle et d’édition MXML, Flex Builder comprend un éditeur ActionScript complet, qui permet de créer des projets Flex ou ActionScript. Les applications Flex présentent de nombreux avantages, notamment un large éventail de commandes d’interface préintégrées et de commandes de disposition dynamique souples, ainsi que des mécanismes intégrés permettant de manipuler des sources de données externes et de lier des données externes aux éléments d’interface utilisateur. Toutefois, ces fonctions nécessitant davantage de code, les applications Flex se caractérisent par une taille de fichier supérieure et leur enveloppe ne peut être remaniée aussi facilement que leurs homologues Flash.

Utilisez Flex Builder si vous voulez créer avec Flex, dans un seul et même outil, des applications de données sur Internet riches en fonctions, tout en modifiant du code ActionScript et MXLM et en disposant les éléments de manière visuelle.

Editeur ActionScript tiers

Les fichiers ActionScript (.as) étant stockés comme de simples fichiers texte, tout programme susceptible de modifier des fichiers texte brut peut servir à écrire des fichiers ActionScript. Outre les produits ActionScript d’Adobe, plusieurs programmes tiers d’édition de texte ont été créés avec des fonctions propres à ActionScript. Vous pouvez écrire un fichier MXML ou des classes ActionScript à l’aide de tout éditeur de texte. A partir de ces fichiers, vous pouvez ensuite créer une application SWF (une application Flex ou ActionScript seul) à l’aide du kit SDK Flex, qui comprend les classes d’application Flex ainsi que le compilateur Flex. Pour de nombreux développeurs, une autre solution consiste à écrire les classes ActionScript dans un éditeur ActionScript tiers, en combinaison avec l’outil de programmation Flash pour la création du contenu graphique.

Vous pouvez choisir un éditeur ActionScript tiers dans les cas suivants :

■ Vous préférez écrire le code ActionScript dans un programme distinct, tout en concevant

les éléments visuels dans Flash.

■ Vous utilisez une application de programmation non ActionScript (par exemple pour la

création de pages HTML ou l’élaboration d’application dans un autre langage de programmation) et vous souhaitez l’utiliser pour le code ActionScript également.

■ Vous voulez créer des projets ActionScript seul ou Flex à l’aide du kit SDK Flex sans avoir

à acquérir Flash ou Flex Builder.

54 Prise en main d’ActionScript

Les principaux éditeurs de code prenant en charge ActionScript sont les suivants :

■ Adobe Dreamweaver® CS3

■ ASDT

■ FDT

■ FlashDevelop

■ PrimalScript

■ SE|PY

■ XCode (avec modèle ActionScript et fichiers conseil de code).

Processus de développement ActionScript

Quelle que soit la taille de votre projet ActionScript, l’utilisation d’un processus de conception et de développement vous aidera à travailler plus efficacement. Les étapes ci-après forment le processus de développement de base pour la conception d’une application avec ActionScript 3.0 :

1. Concevez votre application.

Avant de commencer à construire votre application, vous devez la décrire d’une manière ou d’une autre.

2. Composez votre code ActionScript 3.0.

Vous pouvez créer du code ActionScript dans Flash, Flex Builder, Dreamweaver ou un éditeur de texte.

3. Créez un fichier application Flash ou Flex pour exécuter votre code.

Dans l’outil de programmation Flash, cela implique la création d’un nouveau fichier FLA, la définition des paramètres de publication, l’ajout de composants d’interface à l’application et le référencement du code ActionScript. Dans l’environnement de développement Flex, la création d’un nouveau fichier d’application requiert la définition de l’application et l’ajout de composants d’interface à l’aide de MXML, puis le référencement du code ActionScript.

4. Publiez et testez votre application ActionScript.

Cela implique que vous exécutiez votre application au sein de l’environnement de programmation Flash ou de développement Flex, et que vous vérifiiez qu’elle effectue toutes les opérations voulues.

Création d’applications avec ActionScript 55

Il n’est pas indispensable de suivre ces étapes dans cet ordre ou d’achever l’une d’elle avant de passer à la suivante. Par exemple, vous pouvez concevoir un écran de votre application (étape 1), puis créer les graphiques, boutons, etc. (étape 3), avant d’écrire le code ActionScript (étape 2) et de le tester (étape 4). Vous pouvez tout aussi bien concevoir une partie de l’écran, puis ajouter un bouton ou un élément d’interface à la fois, écrire le code ActionScript correspondant et le tester dès qu’il est prêt. Bien qu’il soit judicieux de garder à l’esprit ces quatre stades du processus de développement, il est en pratique plus efficace d’aller et venir entre ces étapes en fonction des besoins.

Création de vos propres classes

Le processus de création des classes destinées à vos projets peut paraître rébarbatif. Cependant, la partie la plus difficile de la création d’une classe est sa conception, c’est-à-dire l’identification des méthodes, des propriétés et des événements qu’elle comprend.

Stratégies de conception d’une classe

La conception orientée objet est un sujet complexe ; des carrières entières ont été consacrées à l’étude académique et à la pratique professionnelle de cette discipline. Voici tout de même quelques suggestions d’approches qui vous aideront à démarrer votre projet.

1. Réfléchissez au rôle que les instances de la classe auront à jouer dans l’application. En règle

générale, les objets servent l’un des objectifs suivants :

■ Objet de valeur : ces objets constituent avant tout des conteneurs de données, c’est-à-

dire qu’ils possèdent plusieurs propriétés et peu de méthodes (parfois aucune). Il s’agit en général d’une représentation dans le code d’éléments clairement définis, tels qu’une classe Song (représentant une seule chanson) ou une classe Playlist (représentant un groupe conceptuel de chansons) dans une application musicale.

■ Objet d’affichage : ce type correspond à des objets qui s’affichent réellement à l’écran,

par exemple des éléments d’interface, tels que des listes déroulantes ou des libellés d’état, des éléments graphiques tels que des créatures dans un jeu vidéo, etc.

■ Structure d’application : ces objets jouent un large éventail de rôles dans la logique ou

le traitement effectué par les applications. Il s’agit par exemple d’un objet réalisant des calculs dans une simulation de biologie, un objet chargé de synchroniser les valeurs entre une commande physique et le volume de sortie d’une application musicale, un objet que gère les règles d’un jeu vidéo ou un objet qui charge une image enregistrée dans une application de dessin.

56 Prise en main d’ActionScript

2. Décidez de la fonctionnalité requise pour la classe. Les différentes fonctionnalités

constituent souvent les méthodes de la classe.

3. Si la classe est destinée à servir d’objet de valeur, choisissez les données que les instances

pourront inclure. Ces éléments peuvent facilement devenir des propriétés.

4. Puisque que vous concevez la classe spécialement pour votre projet, le plus important est

que vous établissiez la fonctionnalité nécessaire à votre application. Pour vous aider, vous pouvez répondre à ces questions :

■ Quel type d’informations l’application stockera, surveillera et manipulera ? Vous

pourrez alors identifier les objets de valeurs et les propriétés qui vous serviront.

■ Quels jeux d’actions devront être exécutés, par exemple lors du premier chargement de

l’application, lorsque l’utilisateur clique sur un bouton donné, lorsque la lecture de la séquence s’arrête, etc. ? Ces éléments constituent souvent des méthodes (ou des propriétés, si les actions consistent uniquement à modifier des valeurs isolées).

■ Pour chaque action considérée, quelles informations seront nécessaires à la classe pour

son exécution ? Ces éléments deviennent les paramètres de la méthode.

■ Pendant le fonctionnement de l’application, quelles modifications surviendront dans

la classe qui devront être communiquées à d’autres parties de l’application ? Ces éléments forment en général des événements.

5. Si un objet existant est semblable à l’objet dont vous avez besoin mais qu’il lui manque

certaines fonctionnalités que vous souhaitez ajouter, envisagez de créer une sous-classe (une classe qui repose sur la fonctionnalité d’une classe existante plutôt que de définir l’ensemble de sa fonctionnalité propre). Par exemple, si vous voulez créer une classe correspondant à un objet affiché à l’écran, vous pouvez créer votre classe en vous appuyant sur le comportement de l’un des objets d’affichage existants (par exemple, Sprite ou MovieClip). Dans ce cas, MovieClip (ou Sprite) constituerait la classe de base, que votre classe viendrait étendre. Pour plus d’informations sur la création d’une sous-classe, 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 classes 57

2. Saisissez une instruction class afin de définir le nom de la classe. Pour ce faire, entrez les

mots

public class, puis le nom de la classe suivi d’une paire d’accolades qui entoureront

le contenu de la classe (les définitions de méthode et de propriété). Voici un exemple d’utilisation :

public class MyClass { }

Le mot public indique que la classe est accessible par tout autre code. Pour d’autres possibilités, voir « Attributs d’espace de nom pour le contrôle d’accès », à la page 154.

3. Entrez une instruction de package, qui indique le nom du package dans lequel le vôtre

apparaîtra. La syntaxe est le mot 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

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

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

}

58 Prise en main d’ActionScript

■ Pour créer un constructeur (la méthode spéciale appelée pendant la création d’une

instance de classe), créez une méthode dont le nom correspond exactement au nom de la classe :

public function MyClass() {

// définir les valeurs initiales pour les propriétés // et autrement définit l’objet textVariable = "Hello there!"; dateVariable = new Date(2001, 5, 11);

}

Si vous n’incluez aucune méthode constructeur dans votre classe, le compilateur crée automatiquement un constructeur vide (sans paramètres ni instructions) dans votre classe.

D’autres éléments de classe peuvent être définis, mais avec plus d’implication.

■ Les accesseurs constituent un croisement spécial entre une méthode et une propriété.

Lorsque vous écrivez le code de définition d’une classe, l’accesseur s’écrit comme une méthode, de manière à ce que vous puissiez accomplir plusieurs actions, et pas seulement la lecture ou l’attribution d’une valeur, seules actions disponibles lors de la définition d’une propriété. Toutefois, lorsque vous créez une instance de votre classe, vous traitez l’accesseur comme une propriété, en utilisant uniquement son nom pour lire ou attribuer la valeur. Pour plus d’informations, voir « 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 classes 59

Exemple : Création d’une application de base

Il est possible de créer des fichiers source ActionScript externes, dotés de l’extension .as, dans plusieurs applications : Flash, Flex Builder, Dreamweaver ou tout éditeur de texte.

ActionScript 3.0 peut s’utiliser dans divers environnements de développement d’application, notamment l’outil de programmation Flash et Flex Builder.

Cette section étudie les différentes étapes de la création et de l’amélioration d’une simple application ActionScript 3.0 à l’aide de l’outil de programmation Flash ou de l’outil Flex Builder 2. L’application à élaborer présente une manière simple d’utiliser les fichiers de classe externes ActionScript 3.0 dans Flash et Flex. Cette méthode peut s’appliquer à tous les autres exemples d’application proposés dans ce manuel.

Conception d’une application ActionScript

Vous devez avoir une idée de l’application à élaborer avant de commencer. La représentation de cette conception peut être très simple (le nom de l’application et une

brève description de son utilité) ou très compliquée (un ensemble de cahiers des charges contenant de nombreux diagrammes UML). Le but de ce manuel n’est pas de discuter en détail des principes de conception d’un logiciel. Il est toutefois important de garder à l’esprit que la conception de l’application est une étape essentielle du développement dans ActionScript.

Notre premier exemple d’application ActionScript est une application standard de salutation, du type « Hello World ». Sa conception est donc très simple :

■ L’application se nommera HelloWorld.

■ Elle affichera un seul champ texte contenant les termes « Hello World! ».

■ Pour qu’elle soit facilement réutilisable, elle utilisera une seule classe orientée objet,

nommée Greeter, qui pourra être exploitée dans un document Flash ou une application Flex.

■ Une fois la version de base créée, vous pourrez ajouter d’autres fonctionnalités, par

exemple inviter l’utilisateur à saisir son nom et comparer ce nom à une liste d’utilisateurs reconnus.

Cette définition bien établie, vous pouvez commencer à créer l’application elle-même.

60 Prise en main d’ActionScript

Création du projet HelloWorld et de la classe Greeter

Selon les décisions de conception, le code de l’application Hello World doit être facilement réutilisable. Pour satisfaire à cette exigence, l’application utilise une seule classe orientée objet, nommée Greeter, qui est exploitée au sein de l’application que vous allez créer dans Flex Builder ou l’outil de programmation Flash.

Pour créer la classe Greeter dans l’outil de programmation Flash :

1. Dans l’outil de programmation Flash, choisissez Fichier > Nouveau.

2. Dans la boîte de dialogue Nouveau document, sélectionnez un fichier ActionScript et

cliquez sur OK. Une nouvelle fenêtre de modification ActionScript s’affiche.

3. Choisissez Fichier > Enregistrer. Sélectionnez un dossier pour votre application, nommez

le fichier ActionScript 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 base 61

Création d’une application utilisant votre code ActionScript

La classe Greeter que vous avez créée définit un ensemble autonome de fonctions logicielles, mais ne constitue pas pour autant une application complète. Pour l’utiliser, vous devez créer un document Flash ou une application Flex.

L’application HelloWorld crée une nouvelle instance de la classe Greeter. Voici la procédure d’association de la classe Greeter à votre application.

Pour créer une application ActionScript à l’aide de l’outil de programmation Flash :

1. Sélectionnez Fichier > Nouveau.

2. Dans la boîte de dialogue Nouveau document, sélectionnez Document Flash et cliquez

sur OK. Une nouvelle fenêtre Flash apparaît.

3. Choisissez Fichier > Enregistrer. Sélectionnez le même dossier qui contient le fichier de la

classe 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.

Passez à « Publication et test de votre application ActionScript », à la page 63.

62 Prise en main d’ActionScript

Publication et test de votre application ActionScript

Le développement logiciel est un processus itératif. Vous écrivez du code, essayez de le compiler, puis modifiez ce code jusqu’à ce que la compilation soit réussie. Vous exécutez, puis testez l’application compilée, pour voir si elle répond aux intentions de conception. Si ce n’est pas le cas, vous modifiez à nouveau le code, jusqu’à obtenir satisfaction. Les environnements de développement Flash et Flex Builder offrent plusieurs manières de publier, tester et déboguer vos applications.

Voici une liste de base des étapes de test de l’application HelloWorld dans chacun de ces environnements.

Pour publier et tester une application ActionScript à l’aide de l’outil de programmation Flash :

1. Publiez votre application et recherchez les erreurs de compilation. Dans l’outil de

programmation Flash, sélectionnez Contrôle > Tester l’animation pour compiler votre code ActionScript et exécutez l’application HelloWorld.

2. Si des erreurs ou des avertissements s’affichent dans la fenêtre Sortie lorsque vous testez

votre application, résolvez-les dans les fichiers 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 base 63

2. Remplacez son contenu par le suivant (les lignes nouvelles et modifiées sont indiquées en

gras) :

package {

public class Greeter

{

/** * Defines the names that should receive a proper greeting. */ public static var validNames:Array = ["Sammy", "Frank", "Dean"];

/** * Builds a greeting string using the given name. */

public function sayHello(userName:String = ""):String {

var greeting:String;

if (userName == "") {

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

}

64 Prise en main d’ActionScript

La classe Greeter présente maintenant plusieurs fonctions nouvelles :

■ Le tableau validNames répertorie les noms d’utilisateurs valables. Lors du chargement

de la classe Greeter, ce tableau contient trois noms.

■ La méthode sayHello() accepte désormais un nom d’utilisateur et modifie la

salutation en fonction de certaines conditions. Si le nom d’utilisateur 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

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 base 65

7. Dans le panneau Actions, ajoutez les lignes suivantes à la fin du script existant :

mainText.border = true; textIn.border = true;

textIn.addEventListener(KeyboardEvent.KEY_UP, keyPressed);

function keyPressed(event:Event):void {

if (event.keyCode == Keyboard.ENTER) {

mainText.text = myGreeter.sayHello(textIn.text);

}

Le nouveau code ajoute la fonctionnalité suivante :

■ Les deux premières lignes définissent les bordures de deux champs texte.

■ Un champ texte d’entrée tel que le champ textIn a un ensemble d’événements qu’il

peut envoyer. La méthode

addEventListener() vous permet de définir une fonction

exécutée lorsqu’un type d’événement se produit. Dans ce cas, cet événement est le fait d’appuyer sur la touche Entrée du clavier.

■ La fonction personnalisée keyPressed() appelle la méthode sayHello() de l’objet

myGreeter, en transmettant le texte du champ texte textIn comme paramètre. Cette

méthode renvoie une chaîne greeting en fonction de la valeur transmise. La chaîne renvoyée est ensuite affectée à la propriété

text du champ texte mainText.

Le script complet pour l’image 1 est le suivant :

mainText.border = true; textIn.border = true;

var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello("");

textIn.addEventListener(KeyboardEvent.KEY_UP, keyPressed);

function keyPressed(event:Event):void {

if (event.keyCode == Keyboard.ENTER) {

mainText.text = myGreeter.sayHello(textIn.text);

}

Enregistrez le fichier.

9. Choisissez Contrôle > Tester l’animation pour exécuter l’application.

Lorsque vous exécutez l’application, il vous est demandé d’entrer un nom d’utilisateur. S’il est valide (Sammy, Frank, ou Dean), l’application affiche le message de confirmation « hello ».

66 Prise en main d’ActionScript

Exécution des exemples suivants

Maintenant que vous avez développé et exécuté l’application ActionScript 3.0 « HelloWorld », vous devez disposer des connaissances suffisantes pour exécuter les autres exemples de code proposés dans ce manuel.

Test des exemples de code contenus dans un chapitre

Au fur et à mesure que vous avancez dans ce manuel, vous pouvez tester les exemples de code utilisés pour illustrer les différentes rubriques. Ce test peut impliquer l’affichage de la valeur des variables à certains stades du programme, ou bien l’affichage ou l’interaction avec un contenu à l’écran. Pour tester le contenu visuel ou l’interaction, les éléments nécessaires seront décrits avant ou dans le code—il vous suffira de créer un document avec les éléments comme indiqué pour tester le code. Si vous souhaitez afficher la valeur d’une variable à un certain stade du programme, vous disposez de différentes façons pour le faire. Vous pouvez utiliser un débogueur tel que ceux intégrés dans Flex Builder et Flash. Pour un test simple, néanmoins, il peut être plus facile d’imprimer les valeurs des variables pour les visualiser.

Les étapes suivantes vous aideront à créer un document Flash que vous pouvez utiliser pour tester un code et afficher des valeurs de variables :

Pour créer un document Flash afin de tester des exemples contenus dans un chapitre :

1. Créez un document Flash et enregistrez-le sur votre disque dur.

2. Pour afficher des valeurs de test dans un champ texte sur la scène, activez l’outil Texte et

créez un champ texte dynamique sur la scène. Un champ texte haut et large avec le type de ligne défini sur Multiligne et la bordure activée sera très utile. Dans l’inspecteur Propriétés, donnez un nom d’instance au champ texte (par exemple « outputText »). Pour écrire des valeurs dans le champ texte, vous ajouterez un code qui appelle la méthode 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 suivants 67

Etant donné que cette approche sert à afficher les valeurs de variables, vous disposez de deux façons pour effectuer cette opération pendant que vous testez les exemples : écrire des valeurs dans une instance de champ texte sur la scène, ou utiliser la fonction

trace() pour imprimer

des valeurs sur le panneau Sortie.

■ La fonction trace() : La fonction trace() d’ActionScript écrit les valeurs des paramètres

qui lui sont transmis (variables ou expressions littérales) sur le panneau Sortie. Un grand nombre des exemples fournis dans ce manuel comprend déjà un appel de la fonction

trace(). Par conséquent, pour ces exemples, il vous suffit de copier le code dans votre

document et de tester le projet. Si vous souhaitez utiliser 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

68 Prise en main d’ActionScript

Comme le montre l’exemple, la méthode appendText() ajoutera le texte sur la même ligne que le contenu précédent. Par conséquent, il est possible d’ajouter plusieurs valeurs sur la même ligne de texte à l’aide de plusieurs appels 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 suivants 69

70 Prise 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.

Contenu

Présentation du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

Objets et classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Packages et espaces de nom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93

Syntaxe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .118

Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

Boucle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131

Présentation du langage

Les objets sont au centre du langage ActionScript 3.0 : ils constituent ses éléments fondamentaux. Chaque variable que vous déclarez, chaque fonction que vous écrivez et chaque instance de classe que vous créez est un objet. Un programme ActionScript 3.0 peut être comparé à un groupe d’objets qui effectuent des tâches, répondent à des événements et communiquent entre eux.

Les programmeurs qui maîtrisent la programmation orientée objet dans Java ou C++ peuvent considérer les objets comme des modules contenant deux types de membres : les données enregistrées dans des variables de membre ou des propriétés, et le comportement accessible via des méthodes. La version 4 d’ECMAScript, la norme sur laquelle est basée ActionScript 3.0, définit des objets de façon presque identique. Dans la version d’ECMAScript, les objets sont simplement des ensembles de propriétés. Ces propriétés sont des conteneurs pouvant contenir non seulement des données, mais également des fonctions ou d’autres objets. Si une fonction est associée à un objet de cette façon, il s’agit d’une méthode.

Alors qu’en théorie, la définition préliminaire d’ECMAScript peut paraître un peu étrange pour les programmeurs ayant l’habitude d’utiliser le langage Java ou C++, en pratique, la définition de types d’objets avec des classes ActionScript 3.0 est très semblable à la façon dont les classes sont définies dans Java ou C++. Il est important de distinguer les deux définitions d’objet lors de la présentation du modèle d’objet ActionScript et d’autres rubriques plus techniques, mais généralement, le terme propriétés fait référence à des variables de membre de classe, par opposition aux méthodes. La Référence du langage et des composants ActionScript 3.0, par exemple, utilise le terme propriétés pour des variables ou des propriétés de lecture/ définition. Il utilise le terme méthodes pour des fonctions faisant partie d’une classe.

Une légère différence entre les classes dans ActionScript et les classes dans Java ou C++ réside dans le fait que dans ActionScript, elles ne sont pas que des entités abstraites. Les classes ActionScript sont représentées par des objets de classe qui stockent les méthodes et les propriétés de la classe. Ainsi, des techniques pouvant sembler étranges pour les programmeurs de Java et C++ comme l’insertion d’instructions ou de code exécutable au niveau supérieur d’une classe ou d’un package sont autorisées.

72 Syntaxe et langage ActionScript

Une autre différence entre les classes ActionScript et les classes Java ou C++ réside dans le fait que chaque classe ActionScript possède un objet prototype. Dans les versions précédentes d’ActionScript, les objets prototypes, liés les uns aux autres en chaînes de prototypes, servaient de base à l’ensemble de la hiérarchie d’héritage de classe. Dans ActionScript 3.0, néanmoins, les objets prototypes ne jouent qu’un rôle mineur dans le système d’héritage. Cependant, l’objet prototype peut toujours être utile comme solution de rechange aux méthodes et aux propriétés statiques si vous souhaitez partager une propriété et sa valeur parmi toutes les instances d’une classe.

Auparavant, les programmeurs ActionScript expérimentés pouvaient manipuler directement la chaîne du prototype avec des éléments de langage intégrés spéciaux. Maintenant que le langage fournit une implémentation plus avancée d’une interface de programmation basée sur des classes, un grand nombre de ces éléments de langage spéciaux (

__proto__ et __resolve,,

par exemple) ne font plus partie du langage. De plus, les optimisations du mécanisme d’héritage interne qui améliorent nettement les performances de Flash Player empêchent d’accéder directement au mécanisme.

Objets et classes

Dans ActionScript 3.0, chaque objet est défini par une classe. Une classe peut être considérée comme un modèle pour un type d’objet. Les définitions de classe peuvent inclure des variables et des constantes, qui comprennent des valeurs de données, et des méthodes, qui sont des fonctions encapsulant le comportement lié à la classe. Les valeurs stockées dans les propriétés peuvent être des valeurs primitives ou d’autres objets. Les valeurs primitives sont des nombres, des chaînes ou des valeurs booléennes.

ActionScript contient de nombreuses classes intégrées faisant partie du langage de base. Certaines de ces classes intégrées (Number, Boolean et String, par exemple), représentent les valeurs primitives disponibles dans ActionScript. D’autres (Array, Math et XML, par exemple) définissent des objets plus complexes faisant partie de la norme ECMAScript.

Toutes les classes, qu’elles soient intégrées ou définies par l’utilisateur, dérivent de la classe Object. Pour les programmeurs ayant une expérience avec ActionScript, il est important de noter que le type de données Object n’est plus le type de données par défaut, même si toutes les autres classes en dérivent. Dans ActionScript 2.0, les deux lignes de code suivantes étaient équivalentes car l’absence d’une annotation de type signifiait qu’une variable aurait été de type Object :

var someObj:Object; var someObj;

Objets et classes 73

ActionScript 3.0, néanmoins, présente le concept de variables non typées, qui peuvent être désignées des deux façons suivantes :

var someObj:*; var someObj;

Une variable non typée est différente d’une variable de type Object. La différence majeure est que les variables non typées peuvent contenir la valeur spéciale

undefined, alors qu’une

variable de type Object ne le peut pas. Vous pouvez définir vos propres classes à l’aide du mot-clé

class. Vous pouvez déclarer des

propriétés de classe de trois façons différentes : vous pouvez définir des constantes avec le 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.

74 Syntaxe et langage ActionScript

L’exemple suivant utilise la directive package pour créer un simple package contenant une classe :

package samples {

public class SampleCode {

public var sampleGreeting:String; public function sampleFunction() {

trace(sampleGreeting + " from sampleFunction()");

}

Le nom de la classe dans cet exemple est SampleCode. Etant donné que la classe se trouve à l’intérieur du package samples, le compilateur qualifie automatiquement le nom de classe lors de la compilation sous la forme de son nom qualifié : samples.SampleCode. Le compilateur qualifie également les noms des propriétés ou des méthodes, de façon à ce que

sampleGreeting et sampleFunction() deviennent respectivement samples.SampleCode.sampleGreeting et samples.SampleCode.sampleFunction().

Un grand nombre de développeurs (notamment ceux ayant une expérience de programmation Java) placent uniquement des classes au niveau supérieur d’un package. ActionScript 3.0, cependant, prend non seulement en charge des classes au niveau supérieur d’un package, mais également des variables, des fonctions et même des instructions. Une utilisation avancée de cette fonction consiste à définir un espace de nom au niveau supérieur d’un package de façon à ce que toutes les classes contenues dans ce dernier puissent l’utiliser. Il convient néanmoins de noter que seuls deux spécificateurs d’accès,

public et internal, sont autorisés au niveau

supérieur d’un package. Contrairement à Java qui vous permet de déclarer des classes imbriquées privées, ActionScript 3.0 ne prend en charge ni les classes imbriquées, ni les classes privées.

Néanmoins, les packages ActionScript 3.0 et les packages du langage de programmation Java présentent d’autres ressemblances. Comme vous pouvez l’observer dans l’exemple précédent, des références de package entièrement qualifiées sont exprimées à l’aide de l’opérateur point (

.), comme dans Java. Vous pouvez utiliser des packages pour organiser votre code dans une

structure hiérarchique intuitive que d’autres programmeurs peuvent utiliser. Ceci facilite le partage de code en vous permettant de créer votre propre package et de le partager avec d’autres personnes, et d’utiliser des packages créés par d’autres personnes dans votre code.

Packages et espaces de nom 75

L’utilisation de packages vous permet également de vérifier que les noms d’identifiant que vous utilisez sont uniques et qu’ils ne sont pas incompatibles avec d’autres noms d’identifiant. Pour certaines personnes, il s’agit d’ailleurs de l’avantage principal des packages. Par exemple, deux programmeurs qui souhaitent partager leur code peuvent chacun avoir créé une classe appelée SampleCode. Sans packages, il y aurait un conflit de noms, et la seule façon de résoudre le problème serait de renommer l’une des classes. Mais avec des packages, vous pouvez éviter le conflit de noms en plaçant l’une des classes (ou de préférence les deux) dans des packages avec des noms uniques.

Vous pouvez également inclure des points intégrés dans le nom de votre package afin de créer des packages imbriqués. Ceci vous permet de créer une organisation hiérarchique des packages. Le package 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.

76 Syntaxe et langage ActionScript

Création de packages

ActionScript 3.0 vous permet d’organiser vos packages, classes et fichiers source avec une grande souplesse. Les versions précédentes d’ActionScript autorisaient uniquement une classe par fichier source et exigeaient que le nom du fichier source corresponde au nom de la classe. ActionScript 3.0 vous permet d’inclure plusieurs classes dans un fichier source, mais une seule classe dans chaque fichier peut être utilisée par le code externe à ce fichier. En d’autres termes, une seule classe dans chaque fichier peut être déclarée à l’intérieur d’une déclaration de package. Vous devez déclarer toute classe supplémentaire à l’extérieur de votre définition de package pour que ces classes soient invisibles pour le code externe à ce fichier source. Le nom de la classe déclarée à l’intérieur de la définition de package doit correspondre au nom du fichier source.

ActionScript 3.0 permet également de déclarer des packages avec davantage de flexibilité. Dans les versions précédentes d’ActionScript, les packages représentaient simplement des répertoires dans lesquels vous placiez des fichiers source, et vous ne déclariez pas les packages avec l’instruction 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 nom 77

Importation de packages

Si vous souhaitez utiliser une classe se trouvant à l’intérieur d’un package, vous devez importer soit le package soit la classe en question. Ceci diffère d’ActionScript 2.0 où l’importation de classes était facultatif.

Par exemple, revenons à l’exemple de classe SampleCode fourni précédemment dans ce chapitre. Si la classe se trouve dans un package appelé samples, vous devez utiliser l’une des instructions d’importation suivantes avant d’utiliser la classe SampleCode :

import samples.*;

import samples.SampleCode;

En général, les instructions import doivent être aussi spécifiques que possible. Si vous envisagez d’utiliser uniquement la classe SampleCode issue du package samples, importez uniquement la classe SampleCode au lieu du package entier auquel elle appartient. L’importation des packages entiers peut provoquer des conflits de noms inattendus.

Vous devez également placer le code source qui définit le package ou la classe dans votre chemin de classe. Le chemin de classe est une liste définie par l’utilisateur de chemins de répertoire locaux qui détermine l’endroit où le compilateur recherche des classes et des packages importés. Le chemin de classe est parfois appelé chemin de création ou chemin source.

Une fois que vous avez importé correctement la classe ou le package, vous pouvez utiliser le nom entièrement qualifié de la classe (samples.SampleCode) ou simplement le nom de la classe (SampleCode).

Les noms entièrement qualifiés sont utiles lorsque des classes, des méthodes ou des propriétés ayant le même nom génèrent un code ambigu mais ils peuvent être difficiles à gérer si vous les utilisez pour tous les identifiants. Par exemple, l’utilisation du nom entièrement qualifié génère un code détaillé lorsque vous instanciez une instance de classe SampleCode :

var mySample:samples.SampleCode = new samples.SampleCode();

Plus les niveaux de packages imbriqués augmentent, moins votre code est lisible. Lorsque vous pensez que des identifiants ambigus ne sont pas un problème, vous pouvez rendre votre code plus lisible en utilisant des identifiants simples. Par exemple, l’instanciation d’une nouvelle instance de la classe SampleCode est beaucoup moins longue si vous utilisez uniquement l’identifiant de classe :

var mySample:SampleCode = new SampleCode();

Si vous tentez d’utiliser des noms d’identifiant sans importer au préalable la classe ou le package approprié, il est impossible pour le compilateur de trouver les définitions de classe. D’un autre côté, si vous importez un package ou une classe, toute tentative de définition d’un nom qui provoque un conflit avec un nom importé génère une erreur.

78 Syntaxe et langage ActionScript

Lors de la création d’un package, le spécificateur d’accès par défaut pour tous les membres de ce package est

internal, ce qui signifie que, par défaut, les membres du package ne sont

visibles que pour d’autres membres de ce package. Si vous souhaitez qu’une classe soit disponible pour un code externe au package, vous devez la déclarer

public. Par exemple, le

package suivant contient deux classes, SampleCode et CodeFormatter :

// fichier 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 nom 79

Le compilateur n’a aucun moyen de savoir quelle classe SampleCode il doit utiliser. Pour résoudre ce conflit, vous devez utiliser le nom entièrement qualifié de chaque classe, comme suit :

var sample1:samples.SampleCode = new samples.SampleCode(); var sample2:langref.samples.SampleCode = new langref.samples.SampleCode();

REMARQUE

Les programmeurs ayant une expérience C++ confondent souvent l’instruction import avec l’instruction #include. La directive #include est nécessaire dans C++ car les compilateurs C++ traitent un fichier à la fois et ne cherchent pas de définitions de classe dans d’autres fichiers, à moins qu’un fichier d’en-tête soit inclus explicitement. ActionScript 3.0 a une directive include, mais elle n’est pas conçue pour importer des classes et des packages. Pour importer des classes ou des packages dans ActionScript

3.0, vous devez utiliser l’instruction import et placer le fichier source qui contient le package dans le chemin de classe.

Espaces de noms

Les espaces de nom vous permettent de contrôler la visibilité des propriétés et des méthodes que vous créez. Considérez les spécificateurs de contrôle d’accès

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,

80 Syntaxe et langage ActionScript

Lorsque les définitions ne sont pas précédées d’un attribut d’espace de nom, leurs noms sont qualifiés par l’espace de nom

internal par défaut, ce qui signifie qu’ils sont visibles

uniquement aux appelants du même package. Si le compilateur est défini sur le mode strict, il génère un avertissement indiquant que l’espace de nom

internal s’applique à tout identifiant

sans attribut d’espace de nom. Pour vérifier qu’un identifiant est disponible partout, vous devez spécifiquement faire précéder le nom de l’identifiant de l’attribut 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 :

namespace flash_proxy = “http://www.adobe.com/flash/proxy”;

Packages et espaces de nom 81

L’URI sert de chaîne d’identification unique pour cet espace de nom. Si vous omettez l’URI, comme dans l’exemple suivant, le compilateur crée une chaîne d’identification interne unique à la place de l’URI. Vous n’avez pas accès à cette chaîne d’identification interne.

namespace flash_proxy;

Une fois que vous avez défini un espace de nom (avec ou sans URI), vous ne pouvez pas le redéfinir dans le même domaine. Une tentative de définition d’un espace de nom ayant été défini dans le même domaine génère une erreur du compilateur.

Si un espace de nom est défini dans un package ou une classe, il risque de ne pas être visible au code externe à ce package ou à cette classe, à moins que vous utilisez le spécificateur de contrôle d’accès approprié. Par exemple, le code suivant indique l’espace de nom

flash_proxy défini dans le package flash.utils. Dans l’exemple suivant, l’absence de

spécificateur de contrôle d’accès signifie que l’espace de nom

flash_proxy est visible

uniquement au code dans le package flash.utils et non au code externe au package :

package flash.utils {

namespace flash_proxy;

}

Le code suivant utilise l’attribut public pour rendre l’espace de nom flash_proxy visible au code externe au package :

package flash.utils {

public namespace flash_proxy;

}

Application d’espaces de nom

Appliquer un espace de nom signifie placer une définition dans un espace de nom. Les définitions que vous pouvez placer dans des espaces de nom peuvent être des fonctions, des variables et des constantes (vous ne pouvez pas placer une classe dans un espace de nom personnalisé).

82 Syntaxe et langage ActionScript

Supposez, par exemple, que vous avez une fonction déclarée à l’aide de l’espace de nom de contrôle d’accès

public. L’utilisation de l’attribut public dans une définition de fonction

place la fonction dans l’espace de nom public et rend la fonction visible à tout le code. Une fois que vous avez défini un espace de nom, vous pouvez l’utiliser de la même façon que vous utiliseriez l’attribut

public, et la définition est disponible au code pouvant référencer

votre espace de nom personnalisé. Par exemple, si vous définissez un espace de nom

example1, vous pouvez ajouter une méthode appelée myFunction() à l’aide de example1

comme attribut, tel que l’indique l’exemple suivant :

namespace example1; class someClass {

example1 myFunction() {}

}

Déclarer la méthode myFunction() à l’aide de l’espace de nom example1 comme attribut signifie que la méthode appartient à l’espace de nom

example1.

Tenez compte des points suivants lorsque vous appliquez des espaces de nom :

■ Vous pouvez appliquer un espace de nom uniquement à chaque déclaration.

■ Il n’existe aucun moyen d’appliquer un attribut d’espace de nom à plusieurs définitions

simultanément. En d’autres termes, si vous souhaitez appliquer votre espace de nom à dix fonctions différentes, vous devez ajouter votre espace de nom comme attribut à chacune des dix définitions de fonction.

■ Si vous appliquez un espace de nom, vous ne pouvez pas spécifier un spécificateur de

contrôle d’accès car les espaces de nom et les spécificateurs de contrôle d’accès s’excluent mutuellement. En d’autres termes, vous ne pouvez pas déclarer une fonction ou une propriété comme

public, private, protected, ou internal si vous appliquez votre

espace de nom.

Référence d’espaces de nom

Il est inutile de référencer explicitement un espace de nom lorsque vous utilisez une méthode ou une propriété déclarée avec l’un des espaces de nom de contrôle d’accès (

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 nom 83

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

84 Syntaxe et langage ActionScript

L’implémentation des espaces de nom est généralement un processus en trois étapes (définition, application et référence d’un espace de nom). Etant donné que vous n’appelez jamais explicitement une méthode de la classe Proxy, cependant, l’espace de nom

flash_proxy est défini et appliqué uniquement, jamais référencé. L’API de Flash Player

définit l’espace de nom 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.

package {

import flash.utils.Proxy; import flash.utils.flash_proxy;

callProperty(), vous devez utiliser l’espace de

dynamic si vous compilez en mode

dynamic class MyProxy extends Proxy {

flash_proxy override function callProperty(name:*, ...rest):* {

trace("method call intercepted: " + name);

}

Packages et espaces de nom 85

Si vous créez une instance de la classe MyProxy et appelez une méthode non définie (la méthode

testing() appelée dans l’exemple suivant, par exemple), votre objet Proxy

intercepte l’appel de méthode et exécute les instructions se trouvant dans la méthode

callProperty() remplacée (dans ce cas, une instruction trace() simple). var mySample:MyProxy = new MyProxy();

mySample.testing(); // appel de méthode intercepté : test

Le fait que les méthodes de la classe Proxy se trouvent dans l’espace de nom flash_proxy présente deux avantages. Premièrement, le fait d’avoir un espace de nom séparé réduit l’encombrement dans l’interface publique des classes qui étendent la classe Proxy (il existe environ douze méthodes dans la classe Proxy que vous pouvez remplacer. Elles ne sont pas conçues pour être appelées directement. Le fait de toutes les placer dans l’espace de nom public peut prêter à confusion). Deuxièmement, le fait d’utiliser l’espace de nom

flash_proxy évite les conflits de nom si votre sous-classe Proxy contient des méthodes

d’instance avec des noms correspondant à l’une des méthodes de la classe Proxy. Par exemple, vous pouvez nommer l’une de vos méthodes 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.

86 Syntaxe et langage ActionScript

Cet exemple utilise quatre fichiers pour démontrer la technique. Tous les fichiers doivent se trouver dans votre chemin de classe. Le premier fichier, 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 nom 87

// 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

public class NamespaceUseCase extends MovieClip {

public function NamespaceUseCase() {

use namespace myInternal;

Utility.someTask(); Utility.someTask(); trace(Utility.taskCounter); // 2

Helper.someTask(); trace(Helper.lastCalled); // [heure de dernier appel de someTask()]

}

88 Syntaxe et langage ActionScript

Variables

Les variables vous permettent de stocker des valeurs que vous utilisez dans votre programme. Pour déclarer une variable, vous devez utiliser l’instruction 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 :

Variables 89

Si vous avez plusieurs variables à déclarer, vous pouvez le faire sur une ligne de code à l’aide de l’opérateur virgule (

,) pour séparer les variables. Par exemple, le code suivant déclare trois

variables sur une ligne de code :

var a:int, b:int, c:int;

Vous pouvez également affecter des valeurs à chacune des valeurs sur la même ligne de code. Par exemple, le code suivant déclare trois variables (

a, b, et c) et affecte une valeur à chacune

d’entre elles :

var a:int = 10, b:int = 20, c:int = 30;

Bien que vous puissiez utiliser l’opérateur virgule pour regrouper des déclarations de variable dans une instruction, ceci risque de rendre votre code moins lisible.

Présentation du domaine de variable

Le domaine d’une variable est la partie de votre code dans laquelle une référence lexicale peut accéder à la variable. Une variable globale est une variable définie dans toutes les parties de votre code, alors qu’une variable locale est une variable définie dans une seule partie de votre code. Dans ActionScript 3.0, le domaine des variables est toujours limité à la fonction ou à la classe dans laquelle elles sont déclarées. Une variable globale est une variable que vous définissez en dehors de toute définition de classe ou de fonction. Par exemple, le code suivant crée une variable globale indique qu’une variable globale est disponible à la fois à l’intérieur et à l’extérieur de la définition de fonction.

var strGlobal:String = "Global"; function scopeTest() {

trace(strGlobal); // Globale } scopeTest(); trace(strGlobal); // Globale

Vous déclarez une variable locale en déclarant la variable à l’intérieur d’une définition de fonction. La plus petite partie de code pour laquelle vous pouvez définir une variable locale est une définition de fonction. Une variable locale déclarée dans une fonction existe uniquement dans cette fonction. Par exemple, si vous déclarez une variable nommée 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

90 Syntaxe et langage ActionScript

Si le nom utilisé pour votre variable locale est déjà déclaré en tant que variable globale, la définition locale masque la définition globale alors que la variable locale est dans le domaine. La variable globale persiste en dehors de la fonction. Par exemple, le code suivant crée une variable globale de type chaîne appelée 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 () {

var str1:String = "Local";

trace(str1); // Locale } scopeTest(); trace(str1); // Globale

Les variables ActionScript, contrairement aux variables dans C++ et Java, n’ont pas de domaine de niveau bloc. Un bloc de code est un groupe d’instructions placé entre une accolade d’ouverture (

{ ) et une accolade de fermeture ( } ). Dans certains langages de

programmation tels que C++ et Java, les variables déclarées dans un bloc de code ne sont pas disponibles en dehors de ce bloc de code. Cette restriction de domaine est appelée domaine de niveau bloc et n’existe pas dans ActionScript. Si vous déclarez une variable à l’intérieur d’un bloc de code, elle est disponible non seulement dans ce bloc de code mais également dans d’autres parties de la fonction à laquelle le bloc de code appartient. Par exemple, la fonction suivante contient des variables définies dans différents domaines de bloc. Toutes les variables sont disponibles dans la fonction.

function blockTest (testArray:Array) {

var numElements:int = testArray.length;

if (numElements > 0)

{

var elemStr:String = "Element #"; for (var i:int = 0; i < numElements; i++) {

var valueStr:String = i + ": " + testArray[i];

trace(elemStr + valueStr); } trace(elemStr, valueStr, i); // toutes toujours définies

} trace(elemStr, valueStr, i); // toutes définies si numElements > 0

}

blockTest(["Earth", "Moon", "Sun"]);

Variables 91

Une implication intéressante de l’absence de domaine de niveau bloc est que vous pouvez lire ou écrire dans une variable avant de la déclarer, tant qu’elle est déclarée avant que la fonction se termine. Ceci est dû à une technique appelée hissage, qui signifie que le compilateur déplace toutes les déclarations de variable en haut de la fonction. Par exemple, le code suivant compile même si la fonction 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ées Valeur par défaut

Boolean

int 0

Number

Object

String

uint 0

Non déclaré (équivalent à l’annotation de type *)

Toutes les autres classes, y compris celles définies par l’utilisateur.

92 Syntaxe et langage ActionScript

false

NaN

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ées 93

Une valeur complexe est une valeur qui n’est pas une valeur primitive. Les types de données qui définissent des ensembles de valeurs complexes comprennent Array, Date, Error, Function, RegExp, XML, et XMLList.

De nombreux langages de programmation font la distinction entre les valeurs primitives et leurs enveloppes. Java, par exemple, a une valeur primitive int et la classe 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à.

94 Syntaxe et langage ActionScript

Vérification des types lors de la compilation

La vérification des types lors de la compilation est souvent favorisée dans les projets plus importants car au fur et à mesure que la taille du projet augmente, la flexibilité du type de données devient généralement moins importante que la capture d’erreurs de type aussitôt que possible. C’est pourquoi le compilateur d’ActionScript dans Adobe Flash CS3 Professional et dans Adobe Flex Builder 2 est exécuté en mode strict, par défaut.

Pour que la vérification des types lors de la compilation soit exécutée, le compilateur doit connaître les informations de type de données pour les variables ou les expressions dans votre code. Pour déclarer explicitement un type de données pour une variable, ajoutez l’opérateur deux points ( 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ées 95

Même en mode strict, cependant, vous pouvez choisir d’abandonner la vérification des types lors de la compilation en laissant la partie droite d’une instruction d’affectation non typée. Vous pouvez marquer une variable ou une expression comme non typée soit en omettant une annotation de type, soit à l’aide de l’annotation de type astérisque spéciale ( 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

96 Syntaxe et langage ActionScript

Il se peut également que vous obteniez une erreur de type lors de l’exécution alors que vous êtes en mode strict. Ceci est possible si vous utilisez le mode strict mais que vous abandonnez la vérification des types lors de la compilation à l’aide d’une variable non typée. Lorsque vous utilisez une variable non typée, vous n’éliminez pas la vérification des types mais la remettez à plus tard, au moment de l’exécution. Par exemple, si la variable

myNum dans l’exemple

précédent n’a pas de type de données déclaré, le compilateur ne peut pas détecter l’incompatibilité de type, mais Flash Player génère une erreur d’exécution car il compare la valeur d’exécution de 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ées 97

Une sous-classe, néanmoins, ne contient aucune propriété ni méthode que sa classe de base ne contient pas. Par exemple, la classe ClassExtender contient la propriété

someString qui

n’existe pas dans la classe ClassBase. Dans ActionScript 3.0 en mode standard, vous pouvez référencer cette propriété à l’aide de l’instance

myClass sans générer d’erreur d’exécution,

comme indiqué dans l’exemple suivant :

var myClass:ClassBase = new ClassExtender(); myClass.someString = "hello"; // aucune erreur dans ActionScript 3.0 en mode standard

L’opérateur is

L’opérateur is (nouveau pour ActionScript 3.0), vous permet de tester si une variable ou une expression est membre d’un type de données. Dans les versions précédentes d’ActionScript, l’opérateur

instanceof 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.

98 Syntaxe et langage ActionScript

L’exemple suivant présente les mêmes tests que l’exemple précédent, mais avec instanceof au lieu de l’opérateur instance de Sprite ou de DisplayObject, mais il renvoie

mySprite met en oeuvre l’interface IEventDispatcher. trace(mySprite instanceof Sprite); // true

trace(mySprite instanceof DisplayObject); // true trace(mySprite instanceof IEventDispatcher); // false

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ées 99

Si vous instanciez ensuite une instance de la classe Protean, vous pouvez lui ajouter des propriétés ou des méthodes en dehors de la définition de classe. Par exemple, le code suivant crée une instance de la classe 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.

100 Syntaxe et langage ActionScript

ADOBE Flash CS3 Programmation avec ActionScript 3.0 [fr]

Specifications and Main Features

Frequently Asked Questions

User Manual

Table des matières

A propos de ce manuel

Contenu

Utilisation de ce manuel

Accès à la documentation ActionScript

Documentation ActionScript 3.0

Documentation Flash

Ressources ActionScript destinées à la formation

Pôle de développement Adobe

Pôle de création Adobe

Introduction à ActionScript 3.0

Contenu

A propos d’ActionScript

Avantages d’ActionScript 3.0

Nouveautés d’ActionScript 3.0

Fonctions du langage de base

Exceptions d’exécution

Types d’exécution

Classes scellées

Fermetures de méthodes

ECMAScript pour XML (E4X)

Expressions régulières

Espaces de noms

Nouveaux types de primitives

Fonctions API de Flash Player

Modèle d’événements DOM3

API de liste d’affichage

Gestion des données et contenus dynamiques

Accès aux données de bas niveau

Utilisation du texte

Compatibilité avec les versions précédentes

Prise en main d’ActionScript

Contenu

Concepts de programmation de base

Quel est le rôle d’un programme informatique

Variables et constantes

Types de données

Utilisation des objets

Propriétés

Méthodes

Evénements

Gestion des événements de base

Description du processus de gestion des événements

Exemples de gestion d’événements

Création d’instances d’objets

Eléments de programme courants

Opérateurs

Commentaires

Contrôle du flux

Exemple : Elément de portfolio d’animation

Préparation à l’ajout de l’interactivité

Création et ajout de boutons

Ecriture du code

Test de l’application

Création d’applications avec ActionScript

Options d’organisation du code

Stockage de code dans les images d’un scénario Flash

Stockage du code dans des fichiers ActionScript

Choix de l’outil approprié

Outil de programmation Flash

Flex Builder

Editeur ActionScript tiers

Processus de développement ActionScript

Création de vos propres classes

Stratégies de conception d’une classe

Ecriture du code d’une classe

Suggestions d’organisation des classes

Exemple : Création d’une application de base

Conception d’une application ActionScript

Création du projet HelloWorld et de la classe Greeter

Ajout de code à la classe Greeter

Création d’une application utilisant votre code ActionScript

Publication et test de votre application ActionScript

Amélioration de l’application HelloWorld

Exécution des exemples suivants

Test des exemples de code contenus dans un chapitre