02 Langage Et API

Chapitre 2 Langage et API - version 0.
2
Langage et API
LE LANGAGE ACTIONSCRIPT 3..........................................................................1 MACHINES VIRTUELLES...................................................................................................4 TRADUCTION DYNAMIQUE................................................................................................6 GESTION DES TYPES LEXCUTION..................................................................................7 ERREURS LEXCUTION..............................................................................................13 NOUVEAUX TYPES PRIMITIFS..........................................................................................15 VALEURS PAR DFAUT..................................................................................................19 NOUVEAUX TYPES COMPOSITES......................................................................................21 NOUVEAUX MOTS-CLS.................................................................................................21 FONCTIONS.................................................................................................................22 CONTEXTE DEXCUTION...............................................................................................25 BOUCLES....................................................................................................................26 ENRICHISSEMENT DE LA CLASSE ARRAY..........................................................................27 RAMASSE-MIETTES.......................................................................................................30 BONNES PRATIQUES......................................................................................................33 AUTRES SUBTILITS......................................................................................................34
Le langage ActionScript 3
Le langage ActionScript 3 intgre de nombreuses nouveauts que nous allons traiter tout au long de cet ouvrage. Ce chapitre va nous permettre de dcouvrir les nouvelles fonctionnalits et comportements essentiels tout dveloppeur ActionScript 3. Avant de dtailler les nouveauts lies au langage ActionScript 3, il convient de dfinir tout dabord ce que nous entendons par le terme ActionScript. De manire gnrale, le terme ActionScript englobe deux composantes importantes :
1 / 36
Thibault Imbert pratiqueactionscript3.bytearray.org
Chapitre 2 Langage et API - version 0.1
Le cur du langage : il sagit du langage ActionScript bas sur la spcification ECMAScript (ECMA-262) et intgre partiellement certaines fonctionnalits issues de la spcification ECMAScript 4. LAPI du lecteur Flash : il sagit des fonctionnalits du lecteur Flash. Toutes les classes ncessitant dtre importes font partie de lAPI du lecteur et non du cur du langage ActionScript.
Ainsi, linterface de programmation du lecteur ou le langage peuvent tre mise jour indpendamment. Le lecteur Flash 10 devrait normalement intgrer une gestion de la 3D native ainsi quune implmentation plus complte de la spcification ECMAScript 4. La gestion de la 3D concerne ici uniquement linterface de programmation du lecteur Flash, linverse les nouveaux objets dfinis par la spcification ECMAScript 4 sont directement lis au cur du langage ActionScript. Dun ct rside le langage ActionScript 3, de lautre lAPI du lecteur appele gnralement interface de programmation, la figure 2-1 illustre les deux entits :
2 / 36
Figure 2-1. Langage ActionScript 3. Contrairement aux prcdentes versions dActionScript, nous remarquons quen ActionScript 3, les diffrentes fonctionnalits du lecteur Flash sont dsormais stockes dans des paquetages spcifiques. Afin dafficher une vido nous utiliserons les objets issus du paquetage flash.media. A linverse, pour nous connecter un serveur, nous utiliserons les objets issus du paquetage flash.net. Flash CS3 est configur afin dimporter automatiquement toutes les classes issues de lAPI du lecteur Flash. Il nest donc pas ncessaire dimporter manuellement les classes lorsque nous codons au sein de lenvironnement auteur. Un fichier implicitImports.xml situ au sein du rpertoire dinstallation de Flash CS3 (C:\Program Files\Adobe\Adobe Flash
3 / 36
CS3\fr\Configuration\ActionScript 3.0)
contient toutes les
dfinitions de classe importer :

<implicitImportsList> <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name <implicitImport name </implicitImportsList> = = = = = = = = = = = = = = = "flash.accessibility.*"/> "flash.display.*"/> "flash.errors.*"/> "flash.events.*"/> "flash.external.*"/> "flash.filters.*"/> "flash.geom.*"/> "flash.media.*"/> "flash.net.*"/> "flash.printing.*"/> "flash.system.*"/> "flash.text.*"/> "flash.ui.*"/> "flash.utils.*"/> "flash.xml.*"/>
Afin de crer un clip dynamiquement nous pouvons crire directement sur une image du scnario :
var monClip:MovieClip = new MovieClip();
Si nous plaons notre code lextrieur de Flash au sein de classes, nous devons explicitement importer les classes ncessaires :
import flash.display.MovieClip; var monClip:MovieClip = new MovieClip();
Dans cet ouvrage nous nimporterons pas les classes du lecteur lorsque nous programmerons dans lenvironnement auteur de Flash. A linverse ds lintroduction des classes au sein du chapitre 8 intitul Programmation oriente objet, nous importerons explicitement les classes utilises.
A retenir
Le langage ActionScript 3 englobe deux composantes : le cur du langage ActionScript et linterface de programmation du lecteur Flash. Le cur du langage est dfini par la spcification ECMAScript.
Machines virtuelles
Le code ActionScript est interprt par une partie du lecteur Flash appele machine virtuelle. Cest cette dernire qui se charge de retranscrire en langage machine le code binaire (ActionScript byte code) gnr par le compilateur.
4 / 36
Les prcdentes versions du lecteur Flash intgraient une seule machine virtuelle appele AVM1 afin dinterprter le code ActionScript 1 et 2. En ralit, le code binaire gnr par le compilateur en ActionScript 1 et 2 tait le mme, cest la raison pour laquelle nous pouvions faire cohabiter au sein dun mme projet ces deux versions du langage ActionScript. La figure 2-2 illustre la machine virtuelle 1 (AVM1) prsente dans le lecteur Flash 8 :
Figure 2-2. AVM1 au sein du lecteur Flash 8. Le langage ActionScript 3 nest pas compatible avec cette premire machine virtuelle, pour des raisons videntes de rtrocompatibilit, le lecteur Flash 9 embarque donc deux machines virtuelles. Lors de la lecture dun SWF, le lecteur slectionne automatiquement la machine virtuelle approprie afin dinterprter le code ActionScript prsent au sein du SWF. Ainsi, une application ActionScript 1 et 2 sera interprte au sein du lecteur Flash 9 par la machine virtuelle 1 (AVM1) et ne bnficiera daucune optimisation des performances. La figure 2-3 prsente les deux machines virtuelles au sein du lecteur Flash 9 :
5 / 36
Figure 2-3. Le lecteur Flash 9 et les deux machines virtuelles AVM1 et AVM2. Seules les animations compiles en ActionScript 3 pourront bnficier des optimisations ralises par la nouvelle machine virtuelle (AVM2).
A retenir
Les prcdentes versions du lecteur Flash intgraient une seule machine virtuelle afin dinterprter le code ActionScript 1 et 2. La machine virtuelle 1 (AVM1) interprte le code ActionScript 1 et 2. La machine virtuelle 2 (AVM2) interprte seulement le code ActionScript 3. Le lecteur Flash intgre les deux machines virtuelles (AVM1 et AVM2). Le langage ActionScript 3 ne peut pas cohabiter avec les prcdentes versions dActionScript.
Traduction dynamique
Afin doptimiser les performances, la machine virtuelle 2 (AVM2) du lecteur Flash 9 intgre un mcanisme innovant de compilation du code la vole. Bien que le terme puisse paratre tonnant, ce principe appel gnralement traduction dynamique permet dobtenir de meilleures performances dexcution du code en compilant ce dernier lexcution. Dans les prcdentes versions du lecteur Flash, le code prsent au sein du SWF tait directement retranscrit par la machine virtuelle en langage machine sans aucune optimisation lie la plateforme en cours.
6 / 36
En ActionScript 3 la machine virtuelle retranscrit le code binaire (ActionScript byte code) en langage machine laide dun compilateur la vole appel couramment compilateur la vole. (Just-in-time compiler). Ce dernier permet de compiler uniquement le code utilis et de manire optimise selon la plateforme en cours. La machine virtuelle peut donc optimiser les instructions pour un processeur spcifique tout en prenant en considration les diffrentes contraintes de la plateforme. Pour plus dinformations lies la compilation lexcution, rendez vous ladresse suivante : http://en.wikipedia.org/wiki/Just-in-time_compilation http://fr.wikipedia.org/wiki/Compilation_%C3%A0_la_vol%C3%A9e
Gestion des types lexcution

ActionScript 2 introduit au sein de Flash MX 2004 la notion de typage fort. Cela consistait associer un type de donnes une variable laide de la syntaxe suivante :
variable:Type
Dans le code suivant, nous tentions daffecter une chane une variable de type Number :
var distance:Number = "150";
Lerreur suivante tait gnre la compilation :

Incompatibilit de types dans l'instruction d'affectation : String dtect au lieu de Number.
En ActionScript 3, nous bnficions du mme mcanisme de vrification des types la compilation. En compilant le mme code en ActionScript 3, lerreur suivante est gnre :
1067: Contrainte implicite d'une valeur du type String vers un type sans rapport Number.
Ce comportement est appel Mode prcis dans Flash CS3 et peut tre dsactiv par lintermdiaire du panneau Paramtres dActionScript 3.0. A travers le panneau Paramtres de publication, puis de longlet Flash, nous cliquons sur le bouton Paramtres. Nous obtenons un panneau Paramtres dActionScript 3 contenant deux options lies aux erreurs comme lillustre la figure 2-4 :
7 / 36
Figure 2-4. Options du compilateur ActionScript 3. Nous remarquons que par dfaut, le Mode prcis est activ, nous reviendrons trs vite sur le Mode avertissements. En dcochant la case Mode prcis, nous dsactivons la vrification des types la compilation afin de dcouvrir un comportement extrmement important apport par ActionScript 3. En testant le code suivant en mode non prcis, nous remarquons quaucune erreur de compilation nest gnre :
var distance:Number = "150";
A lexcution, la machine virtuelle 2 (AVM2) convertit automatiquement la chane de caractres 150 en un nombre entier de type int. Afin de vrifier cette conversion automatique, nous pouvons utiliser la fonction describeType du paquetage flash.utils :
var distance:Number = "150"; /* affiche : <type name="int" base="Object" isDynamic="false" isFinal="true" isStatic="false"> <extendsClass type="Object"/> <constructor> <parameter index="1" type="*" optional="true"/> </constructor> </type> */ trace( describeType ( distance ) );
La fonction describeType renvoie un objet XML dcrivant le type de la variable. Nous pouvons remarquer que lattribut name du nud type renvoie int. En modifiant la chane de caractres nous obtenons une conversion automatique vers le type Number :
var distance:Number = "150.5"; /* affiche : <type name="Number" base="Object" isDynamic="false" isFinal="true" isStatic="false"> <extendsClass type="Object"/> <constructor> <parameter index="1" type="*" optional="true"/> </constructor> </type> */ trace( describeType ( distance ) );
8 / 36
Si nous tentons daffecter un autre type de donnes celle-ci, la machine virtuelle 2 (AVM2) conserve le type Number et convertit implicitement les donnes lexcution. Contrairement au mode prcis, ce comportement de vrification des types lexcution ne peut pas tre dsactiv. Nous pourrions ainsi en conclure de toujours conserver le mode prcis afin de ne pas tre surpris par ce comportement, mais certaines erreurs de types ne peuvent tre dtectes par le compilateur car celles-ci ninterviennent qu lexcution. Dans le code suivant, le compilateur ne dtecte aucune erreur :
var tableauDonnees:Array = [ "150", "250" ]; // l'entre du tableau est automatiquement convertie en int var distance:Number = tableauDonnees[0];
A lexcution, la chane de caractres prsente lindex 0 est automatiquement convertie en int. Cette conversion reste silencieuse tant que celle-ci russie, au cas chant une erreur lexcution est leve. Dans le code suivant, nous tentons de stocker une chane de caractres au sein dune variable de type MovieClip :
var tableauDonnees:Array = [ "clip", "250" ]; // lve une erreur l'excution var clip:MovieClip = tableauDonnees[0];
A lexcution, la machine virtuelle 2 (AVM2) tente de convertir la chane en MovieClip et choue, lerreur lexcution suivante est leve :
TypeError: Error #1034: Echec de la contrainte de type : conversion de "clip" en flash.display.MovieClip impossible.
Nous pouvons alors nous interroger sur lintrt dun tel comportement, pourquoi la machine virtuelle svertue-t-elle conserver les types lexcution et convertit automatiquement les donnes ? Afin de garantir des performances optimales, la machine virtuelle 2 (AVM2) sappuie sur les types dfinis par le dveloppeur. Ainsi, lorsque nous typons une variable, loccupation mmoire est optimise spcifiquement pour ce type, ainsi que les instructions processeur.
9 / 36
Il ne faut donc pas considrer ce comportement comme un dsagrment mais comme un avantage contribuant de meilleures performances. Ce comportement diffre dActionScript 2, o la machine virtuelle 1 (AVM1) valuait dynamiquement tous les types lexcution, aucune optimisation ntait ralise. Le typage des variables ntait quune aide la compilation. La grande nouveaut lie ActionScript 3 rside donc dans lintrt du typage la compilation comme lexcution. En associant un type une variable en ActionScript 3 nous bnficions dune vrification des types la compilation et dune optimisation des calculs raliss par le processeur et dune meilleure optimisation mmoire. Il est donc primordial de toujours typer nos variables en ActionScript 3, les performances en dpendent trs nettement. Nous typerons systmatiquement nos variables durant lensemble de louvrage. Voici un exemple permettant de justifier cette dcision : Une simple boucle utilise une variable dincrmentation i de type int :
var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { } // affiche : 5 trace( getTimer() - debut );
La boucle ncessite 5 millisecondes pour effectuer 500 000 itrations. Sans typage de la variable i, la boucle suivante ncessite 14 fois plus de temps sexcuter :
var debut:Number = getTimer(); for ( var i = 0; i< 500000; i++ ) { } // affiche : 72 trace( getTimer() - debut );
10 / 36
Dans le code suivant, la variable prenom ne possde pas de type spcifique, la machine virtuelle doit valuer elle-mme le type ce qui ralentit le temps dexcution :
var debut:Number = getTimer(); var prenom = "Bobby"; var prenomRaccourci:String; for ( var i:int = 0; i< 500000; i++ ) { prenomRaccourci = prenom.substr ( 0, 3 ); } // affiche : 430 trace( getTimer() - debut ); // affiche : Bob trace ( prenomRaccourci );
En typant simplement la variable prenom nous divisons le temps dexcution de presque deux fois :
var debut:Number = getTimer(); var prenom:String = "Bobby"; var prenomRaccourci:String; for ( var i:int = 0; i< 500000; i++ ) { prenomRaccourci = prenom.substr ( 0, 3 ); } // affiche : 232 trace( getTimer() - debut ); // affiche : Bob trace ( prenomRaccourci );
Au sein du panneau Paramtres ActionScript 3, nous pouvons apercevoir un deuxime mode de compilation appel Mode avertissements. Ce dernier permet dindiquer plusieurs types derreurs comme par exemple les erreurs lies la migration de code. Supposons que nous tentions dutiliser la mthode dans un projet ActionScript 3 :
attachMovie
var ref:MovieClip = this.attachMovie ("clip", "monClip", 0);
Au lieu dindiquer un simple message derreur, le compilateur nous renseigne que notre code nest pas compatible avec ActionScript 3 et nous propose son quivalent.
11 / 36
Le code prcdent gnre donc le message derreur suivant la compilation :

Warning: 1060: Problme de migration : la mthode 'attachMovie' n'est plus prise en charge. Si le nom de la sous-classe de MovieClip est A, utilisez var mc= new A(); addChild(mc). Pour plus d'informations, consultez la classe DisplayObjectContainer.
Le Mode avertissements permet davertir le dveloppeur de certains comportements lexcution risquant de le prendre au dpourvu. Attention, les avertissements nempchent ni la compilation du code ni son excution, mais avertissent simplement que le rsultat de lexcution risque de ne pas tre celui attendu. Dans le code suivant, un dveloppeur tente de stocker une chane de caractre au sein dune variable de type Boolean :
var prenom:Boolean = "Bobby";
A la compilation, lavertissement suivant est affich :

Warning: 3590: String utilise alors qu'une valeur boolenne est attendue. L'expression va tre transtype comme boolenne.
Il est donc fortement conseill de conserver le Mode prcis ainsi que le mode avertissements afin dintercepter un maximum derreurs la compilation. Comme nous lavons vu prcdemment, le lecteur Flash 9 nchoue plus en silence et lve des erreurs lexcution. Nous allons nous intresser ce nouveau comportement dans la partie suivante.
A retenir
12 / 36
Il est possible de dsactiver la vrification de type la compilation. Il nest pas possible de dsactiver la vrification de type lexcution. Le typage en ActionScript 2 se limitait une aide la compilation. Le typage en ActionScript 3 aide la compilation et lexcution. Dans un souci doptimisation des performances, il est fortement recommand de typer les variables en ActionScript 3. Il est fortement conseill de conserver le mode prcis ainsi que le mode avertissements afin dintercepter un maximum derreurs la compilation.
Erreurs lexcution
Nous avons trait prcdemment des erreurs de compilation laide du mode prcis et abord la notion derreurs lexcution. Une des grandes nouveauts du lecteur Flash 9 rside dans la gestion des erreurs. Souvenez-vous, les prcdentes versions du lecteur Flash ne levaient aucune erreur lexcution et chouaient en silence. En ActionScript 3 lorsque lexcution du programme est interrompue de manire anormale, on dit quune erreur dexcution est leve. Afin de gnrer une erreur lexcution nous pouvons tester le code suivant :
// dfinition d'une variable de type MovieClip // sa valeur par dfaut est null var monClip:MovieClip; // nous tentons de rcuprer le nombre d'images du scnario du clip // il vaut null, une erreur d' excution est leve var nbImages:int = monClip.totalFrames;
La fentre de sortie affiche lerreur suivante :

TypeError: Error #1009: Il est impossible d'accder la proprit ou la mthode d'une rfrence d'objet nul.
Afin de grer cette erreur, nous pouvons utiliser un bloc try catch :
// dfinition d'une variable de type MovieClip // sa valeur par dfaut est null var monClip:MovieClip; var nbImages:int; // grce au bloc try catch nous pouvons grer l'erreur try
13 / 36
{ nbImages = monClip.totalFrames; } { trace ( "une erreur d'excution a t leve !"); } catch ( pErreur:Error )
Bien entendu, nous nutiliserons pas systmatiquement les blocs try catch afin dviter dafficher les erreurs lexcution. Certains tests simples, que nous dcouvrirons au cours de louvrage, nous permettrons quelque fois dviter davoir recours ces blocs. Dans un contexte derreurs lexcution, il convient de dfinir les deux dclinaisons du lecteur Flash existantes :
Version de dbogage (Player Debug) : cette version du lecteur est destine au dveloppement et affiche les erreurs lexcution en ouvrant une fentre spcifique indiquant lerreur en cours. Ce lecteur est install automatiquement lors de linstallation de lenvironnement de dveloppement Flash CS3 ou Flex Builder 2 et 3. Version production (Player Release) : cette version du lecteur est disponible depuis le site dAdobe. Les personnes nayant pas denvironnement de dveloppement install utilisent cette version du lecteur. Ce lecteur naffiche pas les erreurs lexcution afin de ne pas interrompre lexprience de lutilisateur.
Avec le lecteur de dbogage, les erreurs non gres par un bloc try catch ouvrent un panneau derreur au sein du navigateur comme lillustre la figure 2-5 :
Figure 2-5. Exemple derreur lexcution. Lorsquune erreur est leve, lexcution du code est alors mise en pause. Nous pouvons alors dcider de continuer lexcution du code
14 / 36
bien quune erreur vienne dtre leve ou bien de stopper totalement lexcution de lapplication.
A retenir
Le lecteur Flash 9 lve des erreurs lexcution. Ces erreurs ouvrent avec le lecteur de dbogage une fentre indiquant lerreur au sein du navigateur. Toutes les mthodes de lAPI du lecteur en ActionScript 3 peuvent lever des erreurs lexcution. Le lecteur Flash 9 nchoue plus en silence, le dbogage est donc facilit.
Nouveaux types primitifs

En ActionScript 2, seul le type Number existait afin de dfinir un nombre, ainsi pour stocker un nombre entier ou dcimal le type Number tait utilis :
var age:Number = 20; var vitesse:Number = 12.8;
Aucune distinction ntait faite entre les nombres entiers, dcimaux et non ngatifs. ActionScript 3 intgre dsormais trois types afin de reprsenter les nombres :
int : reprsente un nombre entier 32 bit (32 bit signed integer) uint : reprsente un nombre entier non sign 32 bit. (32 bit unsigned integer) Number : reprsente un nombre dcimal 64 bit (64-bit IEEE 754 double-precision floating-point number)
Notons que les deux nouveaux types int et uint ne prennent pas de majuscule, contrairement au type Number dj prsent au sein dActionScript 2. Une variable de type int peut contenir un nombre oscillant entre -2147483648 et 2147483648 :
// affiche : -2147483648 trace( int.MIN_VALUE ); // affiche : 2147483648 trace( int.MAX_VALUE );
Une variable de type uint peut contenir un nombre entier oscillant entre 0 et 4294967295 :
15 / 36
// affiche : 0 trace( uint.MIN_VALUE ); // affiche : 4294967295 trace( uint.MAX_VALUE );
Attention, la machine virtuelle ActionScript 3 conserve les types lexcution, si nous tentons de stocker un nombre virgule flottante au sein dune variable de type int ou uint, le nombre est automatiquement converti en entier par la machine virtuelle :
var age:int = 22.2; // affiche : 22 trace ( age );
Notons, que la machine virtuelle arrondi lentier infrieur :

var age:int = 22.8; // affiche : 22 trace ( age );
Cette conversion automatique assure par la machine virtuelle savre beaucoup plus rapide que la mthode floor de la classe Math. Dans le code suivant, nous arrondissons lentier au sein dune boucle laide de la mthode floor, la boucle ncessite 111 millisecondes :
var distance:Number = 45.2; var arrondi:Number; var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { arrondi = Math.floor ( distance ); } // affiche : 111 trace( getTimer() - debut );
A prsent, nous laissons la machine virtuelle grer pour nous larrondi du nombre :
var distance:Number = 45.2; var arrondi:int; var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { arrondi = distance; }
16 / 36
// affiche : 8 trace( getTimer() - debut ); // affiche : 45 trace( arrondi );
Nous obtenons le mme rsultat en 8 millisecondes, soit un temps dexcution presque 14 fois plus rapide. Partant du principe quune distance est toujours positive, nous pouvons utiliser le type uint qui offre dans ce cas prcis des performances similaires au type int :
var arrondi:uint;
Malheureusement, le type uint savre gnralement beaucoup plus lent, ds lors quune opration mathmatique est effectue. En revanche, le type Number savre plus rapide que le type int lors de division. Lors de la dfinition dune boucle, il convient de toujours prfrer lutilisation dune variable dincrmentation de type int :
var debut:Number = getTimer(); for ( var i:int = 0; i< 5000000; i++ ) { } // affiche : 61 trace( getTimer() - debut );
A linverse, si nous utilisons un type uint, les performances chutent de presque 400% :
var debut:Number = getTimer(); for ( var i:uint = 0; i< 5000000; i++ ) { } // affiche : 238 trace( getTimer() - debut );
Gardez lesprit, quen cas dhsitation, il est prfrable dutiliser le type Number :
var debut:Number = getTimer(); for ( var i:Number = 0; i< 5000000; i++ )
17 / 36
{ } // affiche : 102 trace( getTimer() - debut );
Nous obtenons ainsi un compromis en termes de performances entre le type int et uint. De manire gnrale, il est prfrable dviter le type uint. La mme optimisation peut tre obtenue pour calculer larrondi suprieur. Nous prfrons laisser la machine virtuelle convertir lentier infrieur puis nous ajoutons 1 :
var distance:Number = 45.2; var arrondi:int; var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { arrondi = distance + 1; } // affiche : 12 trace( getTimer() - debut ); // affiche : 46 trace( arrondi );
En utilisant la mthode ceil de la classe Math, nous ralentissons les performances denviron 300% :
var distance:Number = 45.2; var arrondi:Number; var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { arrondi = Math.ceil ( distance ) + 1; } // affiche : 264 trace( getTimer() - debut ); // affiche : 46 trace( arrondi );
18 / 36
Pour plus dastuces lies loptimisation, rendez-vous ladresse suivante : http://lab.polygonal.de/2007/05/10/bitwise-gems-fast-integer-math/
A retenir
Le type int permet de reprsenter un nombre entier 32 bit. Le type uint permet de reprsenter un nombre entier 32 bit non ngatif. Le type Number permet de reprsenter un nombre dcimal 64 bit. Il est conseill dutiliser le type int pour les nombres entiers, son utilisation permet doptimiser les performances. Il est dconseill dutiliser le type uint. En cas dhsitation, il convient dutiliser le type Number.
Valeurs par dfaut

Il est important de noter que les valeurs undefined et null ont un comportement diffrent en ActionScript 3. Dsormais, une variable renvoie undefined uniquement lorsque celle-ci nexiste pas o lorsque nous ne la typons pas :
var prenom; // affiche : undefined trace( prenom );
Lorsquune variable est type mais ne possde aucune valeur, une valeur par dfaut lui est attribue :
var var var var var var var condition:Boolean; total:int; couleur:uint; resultat:Number; personnage:Object; prenom:String; donnees:*;
// affiche : false trace( condition ); // affiche : 0 trace( total ); // affiche : 0 trace( couleur ); // affiche : NaN trace( resultat ); // affiche : null
19 / 36
trace( personnage ); // affiche : null trace( prenom ); // affiche : undefined trace( donnees );
Le tableau suivant illustre les diffrentes valeurs attribues par dfaut aux types de donnes : Type de donnes Boolean int Number Object String uint Non type (quivalent au type *) Autres types Valeur par dfaut false 0 NaN null null 0 undefined null
Tableau 1. Valeurs par dfaut associes aux types de donnes. De la mme manire, si nous tentons daccder une proprit inexistante au sein dune instance de classe non dynamique telle String, nous obtenons une erreur la compilation :
var prenom:String = "Bob"; // gnre une erreur la compilation trace( prenom.proprieteInexistante );
Si nous tentons daccder une proprit inexistante, au sein dune instance de classe dynamique, le compilateur ne procde aucune vrification et nous obtenons la valeur undefined pour la proprit cible :
var objet:Object = new Object(); // affiche : undefined trace( objet.proprieteInexistante );
20 / 36
Attention, une exception demeure pour les nombres, qui ne peuvent tre null ou undefined. Si nous typons une variable avec le type Number, la valeur par dfaut est NaN :
var distance:Number; // affiche : NaN trace( distance );
En utilisant le type int ou uint, les variables sont automatiquement initialises 0 :

var distance:int; var autreDistance:uint; // affiche : 0 trace( distance ); // affiche : 0 trace( autreDistance );
A retenir
Une variable renvoie undefined uniquement lorsque celle-ci nexiste pas ou nest pas type. Lorsquune variable est type mais ne possde aucune valeur, la machine virtuelle attribue automatiquement une valeur par dfaut.
Nouveaux types composites

Deux nouveaux types composites sont intgrs en ActionScript 3 :
Les expressions rgulires (RegExp) : elles permettent deffectuer des recherches complexes sur des chanes de caractres. Nous reviendrons sur les expressions rgulires au cours de certains exercices. E4X (ECMAScript 4 XML) : la spcification ECMAScript 4 intgre un objet XML en tant quobjet natif. Nous reviendrons sur le format XML et E4X au cours de certains exercices.
Nouveaux mots-cls
Le mot cl is introduit par ActionScript 3 remplace lancien mot-cl instanceof des prcdentes versions dActionScript. Ainsi pour tester si une variable est dun type spcifique nous utilisons le mot-cl is :
var tableauDonnees:Array = [5654, 95, 54, 687968, 97851]; // affiche : true trace( tableauDonnees is Array );
21 / 36
// affiche : true trace( tableauDonnees is Object ); // affiche : false trace( tableauDonnees is MovieClip );
Un autre mot-cl nomm as fait aussi son apparition. Ce dernier permet de transtyper un objet vers un type spcifique. Dans le code suivant, nous dfinissons une variable de type DisplayObject, mais celle-ci contient en ralit une instance de MovieClip :
var monClip:DisplayObject = new MovieClip();
Si nous tentons dappeler une mthode de la classe MovieClip sur la variable monClip, une erreur la compilation est gnre. Afin de pouvoir appeler la mthode sans que le compilateur ne nous bloque, nous pouvons transtyper vers le type MovieClip :
// transtypage en MovieClip (monClip as MovieClip).gotoAndStop(2);
En cas dchec du transtypage, le rsultat du transtypage renvoie null, nous pouvons donc tester si le transtypage russit de la manire suivante :
var monClip:DisplayObject = new MovieClip(); // affiche : true trace( MovieClip(monClip) != null );
Nous aurions pu transtyper avec lcriture traditionnelle suivante :

var monClip:DisplayObject = new MovieClip(); // transtypage en MovieClip MovieClip(monClip).gotoAndStop(2);
En termes de performances, le mot cl as savre presque deux fois plus rapide. En cas dchec lors du transtypage lcriture prcdente ne renvoie pas null mais lve une erreur lexcution.
Fonctions
ActionScript 3 intgre de nouvelles fonctionnalits lies la dfinition de fonctions. Nous pouvons dsormais dfinir des paramtres par dfaut pour les fonctions. Prenons le cas dune fonction affichant un message personnalis :
function alerte ( pMessage:String ):void {
22 / 36
trace( pMessage ); }
Cette fonction alerte accepte un paramtre accueillant le message afficher. Si nous souhaitons lexcuter nous devons obligatoirement passer un message :
alerte ("voici un message d'alerte !");
Si nous omettons le paramtre :

// gnre une erreur la compilation alerte ();
Lerreur la compilation suivante est gnre :

1136: Nombre d'arguments incorrect. 1 attendus.
ActionScript 3 permet de dfinir une valeur par dfaut pour le paramtre :

function alerte ( pMessage:String="message par dfaut" ):void { trace( pMessage ); }
Une fois dfinie, nous pouvons appeler la fonction alerte sans passer de paramtres :
function alerte ( pMessage:String="message par dfaut" ):void { trace( pMessage ); } // affiche : message par dfaut alerte ();
Lorsque nous passons un paramtre spcifique, celui-ci crase la valeur par dfaut :
function alerte ( pMessage:String="message par dfaut" ):void { trace( pMessage ); } // affiche : un message personnalis ! alerte ( "un message personnalis !" );
En plus de cela, ActionScript 3 intgre un nouveau mcanisme li aux paramtres alatoires.
23 / 36
Imaginons que nous devions crer une fonction pouvant accueillir un nombre alatoire de paramtres. En ActionScript 1 et 2, nous ne pouvions lindiquer au sein de la signature de la fonction. Nous dfinissions donc une fonction sans paramtre, puis nous utilisions le tableau arguments regroupant lensemble des paramtres :
function calculMoyenne ():Number { var lng:Number = arguments.length; var total:Number = 0; for (var i:Number = 0; i< lng; i++) { total += arguments[i]; } return total / lng; } var moyenne:Number = calculMoyenne ( 50, 48, 78, 20, 90 ); // affiche : 57.2 trace( moyenne );
Bien que cette criture puisse paratre trs souple, elle posait nanmoins un problme de relecture du code. En relisant la signature de la fonction, un dveloppeur pouvait penser que la fonction calculMoyenne nacceptait aucun paramtre, alors que ce ntait pas le cas. Afin de rsoudre cette ambigut, ActionScript 3 introduit un mot-cl permettant de spcifier dans les paramtres que la fonction en cours reoit un nombre variable de paramtres. Pour cela nous ajoutons trois points de suspensions en tant que paramtre de la fonction, suivi dun nom de variable de notre choix. Le mme code scrit donc de la manire suivante en ActionScript 3 :
function calculMoyenne ( ...parametres ):Number { var lng:int = parametres.length; var total:Number = 0; for (var i:Number = 0; i< lng; i++) {
24 / 36
total += parametres[i]; } return total / lng; } var moyenne:Number = calculMoyenne ( 50, 48, 78, 20, 90 ); // affiche : 57.2 trace( moyenne );
En relisant le code prcdent, le dveloppeur ActionScript 3 peut facilement dtecter les fonctions accueillant un nombre de paramtres alatoires.
Contexte dexcution
Afin que vous ne soyez pas surpris, il convient de sattarder quelques instants sur le nouveau comportement des fonctions passes en rfrence. Souvenez-vous, en ActionScript 1 et 2, nous pouvions passer en rfrence une fonction, celle-ci perdait alors son contexte dorigine et pousait comme contexte le nouvel objet :
var personnage:Object = { age : 25, nom : "Bobby" }; // la fonction parler est passe en rfrence personnage.parler = parler; function parler ( ) { trace("bonjour, je m'appelle " + this.nom + ", j'ai " + this.age + " ans"); } // appel de la mthode // affiche : bonjour, je m'appelle Bobby, j'ai 25 ans personnage.parler();
En ActionScript 3, la fonction parler conserve son contexte dorigine et ne sexcute donc plus dans le contexte de lobjet personnage :
var personnage:Object = { age : 25, nom : "Bobby" }; // la fonction parler est passe en rfrence personnage.parler = parler; function parler ( ) { trace("bonjour, je m'appelle " + this.nom + ", j'ai " + this.age + " ans");
25 / 36
} // appel de la mthode // affiche : bonjour, je m'appelle undefined, j'ai undefined ans personnage.parler();
De nombreux dveloppeurs ActionScript se basaient sur ce changement de contexte afin de rutiliser des fonctions. Nous devrons donc garder lesprit ce nouveau comportement apport par ActionScript 3 durant lensemble de louvrage.
Boucles
ActionScript 3 introduit une nouvelle boucle permettant ditrer au sein des proprits dun objet et daccder directement au contenu de chacune dentre elles. Dans le code suivant, nous affichons les proprits de lobjet personnage laide dune boucle for in :
var personnage:Object = { prenom : "Bobby", age : 50 }; for (var p:String in personnage) { /* affiche : age prenom */ trace( p ); }
Attention, lordre dnumration des proprits peut changer selon les machines. Il est donc essentiel de ne pas se baser sur lordre dnumration des proprits. Notons que la boucle for in en ActionScript 3 ne boucle plus de la dernire entre la premire comme ctait le cas en ActionScript 1 et 2, mais de la premire la dernire. Nous pouvons donc dsormais utiliser la boucle for in afin ditrer au sein dun tableau sans se soucier du fait que la boucle parte de la fin du tableau :
var tableauDonnees:Array = [ 5654, 95, 54, 687968, 97851]; for ( var p:String in tableauDonnees ) { /* affiche : 5654 95
26 / 36
54 687968 97851 */ trace( tableauDonnees[p] ); }
La boucle for each accde elle, directement au contenu de chaque proprit :

var personnage:Object = { prenom : "Bobby", age : 50 }; for each ( var p:* in personnage ) { /* affiche : 50 Bobby */ trace( p ); }
Nous pouvons donc plus simplement itrer au sein du tableau laide de la nouvelle boucle for each :
var tableauDonnees:Array = [ 5654, 95, 54, 687968, 97851 ]; for each ( var p:* in tableauDonnees ) { /* affiche : 5654 95 54 687968 97851 */ trace( p ); }
Nous allons nous intresser dans la prochaine partie au concept de ramasse-miettes qui savre trs important en ActionScript 3.
Enrichissement de la classe Array

La classe Array bnficie de nouvelles mthodes en ActionScript 3 facilitant la manipulation de donnes. La mthode forEach permet ditrer simplement au sein du tableau :
// Array.forEach procde une navigation simple // sur chaque lement l'aide d'une fonction spcifique var prenoms:Array = [ "bobby", "willy", "ritchie" ];
27 / 36
function navigue ( element:*, index:int, tableau:Array ):void { trace ( element + " : " + index + " : " + tableau); } /* affiche : bobby : 0 : bobby,willy,ritchie willy : 1 : bobby,willy,ritchie ritchie : 2 : bobby,willy,ritchie */ prenoms.forEach( navigue );
Toutes ces nouvelles mthodes fonctionnent sur le mme principe. Une fonction de navigation est passe en paramtre afin ditrer et de traiter les donnes au sein du tableau. La mthode every excute la fonction de navigation jusqu' ce quelle ci ou llment parcouru renvoient false. Il est donc trs simple de dterminer si un tableau contient des valeurs attendues. Dans le code suivant, nous testons si le tableau donnees contient uniquement des nombres :
var donnees:Array = [ 12, "bobby", "willy", 58, "ritchie" ]; function navigue ( element:*, index:int, tableau:Array ):Boolean { return ( element is Number ); } var tableauNombres:Boolean = donnees.every ( navigue ); // affiche : false trace( tableauNombres );
La mthode map permet la cration dun tableau relatif au retour de la fonction de navigation. Dans le code suivant, nous appliquons un formatage aux donnes du tableau prenoms. Un nouveau tableau de prnoms formats est cre :
var prenoms:Array = ["bobby", "willy", "ritchie"]; function navigue ( element:*, index:int, tableau:Array ):String { return element.charAt(0).toUpperCase()+element.substr(1).toLowerCase(); } // on cre un tableau partir du retour de la fonction navigue var prenomsFormates:Array = prenoms.map ( navigue );
28 / 36
// affiche : Bobby,Willy,Ritchie trace( prenomsFormates );
La mthode map ne permet pas de filtrer les donnes. Toutes les donnes du tableau source sont ainsi places au sein du tableau gnr. Si nous souhaitons filtrer les donnes, nous pouvons appeler la mthode filter. Dans le code suivant nous filtrons les utilisateurs mineurs et obtenons un tableau dutilisateurs majeurs :
var utilisateurs:Array = [ { prenom : "Bobby", age : 18 }, { prenom : "Willy", age : 20 }, { prenom : "Ritchie", age : 16 }, { prenom : "Stevie", age : 15 } ]; function navigue ( element:*, index:int, tableau:Array ):Boolean { return ( element.age >= 18 ); } var utilisateursMajeurs:Array = utilisateurs.filter ( navigue ); function parcourir ( element:*, index:int, tableau:Array ):void { trace ( element.prenom, element.age ); } /* affiche : Bobby 18 Willy 20 */ utilisateursMajeurs.forEach( parcourir );
La mthode some permet de savoir si un lment existe au moins au sein du tableau. La fonction de navigation est excute jusqu ce que celle ci ou un lment du tableau renvoient true :
var utilisateurs:Array = [ { prenom : "Bobby", age : 18, sexe : "H" }, { prenom : "Linda", age : 18, sexe : "F" }, { prenom : "Ritchie", age : 16, sexe : "H"}, { prenom : "Stevie", age : 15, sexe : "H" } ] function navigue ( element:*, index:int, tableau:Array ):Boolean { return ( element.sexe == "F" ); } // y'a t'il une femme au sein du tableau d'utilisateurs ?
29 / 36
var resultat:Boolean = utilisateurs.some ( navigue ); // affiche : true trace( resultat );
Les mthodes indexOf et lastIndexOf font elles aussi leur apparition au sein de la classe Array, celles-ci permettent de rechercher si un lment existe et dobtenir sa position :
var utilisateurs:Array = [ "Bobby", "Linda", "Ritchie", "Stevie", "Linda" ]; var position:int = utilisateurs.indexOf ("Linda"); var positionFin:int = utilisateurs.lastIndexOf ("Linda"); // affiche : 1 trace( position ); // affiche : 4 trace( positionFin );
Les mthodes indexOf et lastIndexOf permettent de rechercher un lment de type primitif mais aussi de type composite. Nous pouvons ainsi rechercher la prsence de rfrences au sein dun tableau :
var monClip:DisplayObject = new MovieClip(); var monAutreClip:DisplayObject = new MovieClip(); // une rfrence au clip monClip est place au sein du tableau var tableauReferences:Array = [ monClip ]; var position:int = tableauReferences.indexOf (monClip); var autrePosition:int = tableauReferences.lastIndexOf (monAutreClip); // affiche : 0 trace( position ); // affiche : -1 trace( autrePosition );
Nous reviendrons sur certaines de ces mthodes au sein de louvrage.
A retenir
Pensez utiliser les nouvelles mthodes de la classe Array afin de traiter plus facilement les donnes au sein dun tableau.
Ramasse-miettes
Tout au long de louvrage nous reviendrons sur le concept de ramassemiettes. Bien que le terme puisse paraitre fantaisiste, ce mcanisme va
30 / 36
savrer extrmement ActionScript 3.
important
durant
nos
dveloppements
Pendant la dure de vie dun programme, certains objets peuvent devenir inaccessibles. Afin, de ne pas saturer la mmoire, un mcanisme de suppression des objets inutiliss est intgr au sein du lecteur Flash. Ce mcanisme est appel ramasse-miettes ou plus couramment Garbage collector en Anglais. Afin de bien comprendre ce mcanisme, nous dfinissons un simple objet rfrenc par une variable personnage :
var personnage:Object = { prenom : "Bobby", age : 50 };
Pour rendre cet objet inaccessible et donc ligible la suppression par le ramasse-miettes, nous pourrions tre tents dutiliser le mot cl delete :
var personnage:Object = { prenom : "Bobby", age : 50 }; // gnre une erreur la compilation delete personnage;
Le code prcdent, gnre lerreur de compilation suivante :

1189: Tentative de suppression de la proprit fixe personnage. proprits dfinies dynamiquement peuvent tre supprimes. Seules les
Cette erreur traduit une modification du comportement du mot cl delete en ActionScript 3, qui ne peut tre utilis que sur des proprits dynamiques dobjets dynamiques. Ainsi, le mot cl delete pourrait tre utilis pour supprimer la proprit prenom au sein de lobjet personnage :
var personnage:Object = { prenom : "Bobby", age : 50 }; // affiche : Bobby trace( personnage.prenom ); // supprime la proprit prenom delete ( personnage.prenom ); // affiche : undefined trace( personnage.prenom );
Afin de supprimer correctement une rfrence, nous devons affecter la valeur null celle-ci :
var personnage:Object = { prenom : "Bobby", age : 50 }; // supprime la rfrence vers lobjet personnage personnage = null;
Lorsque lobjet ne possde plus aucune rfrence, nous pouvons estimer que lobjet est ligible la suppression.
31 / 36
Nous devrons donc toujours veiller ce quaucune rfrence ne subsiste vers notre objet, au risque de le voir conserv en mmoire. Attention, laffectation de la valeur null une rfrence ne dclenche en aucun cas le passage du ramasse-miettes. Nous rendons simplement lobjet ligible la suppression. Il est important de garder lesprit passage du ramassemiettes reste potentiel. Lalgorithme de nettoyage effectu ce dernier tant relativement gourmand en termes de ressources, son dclenchement reste limit au cas o le lecteur utiliserait trop de mmoire. Dans le code suivant, nous supprimons une des deux rfrences seulement :
var personnage:Object = { prenom : "Bobby", age : 50 }; // copie d'une rfrence au sein du tableau var tableauPersonnages:Array = [ personnage ]; // suppression dune seule rfrence personnage = null;
Une autre rfrence vers lobjet personnage subsiste au sein du tableau, lobjet ne sera donc jamais supprim par le ramasse-miettes :
var personnage:Object = { prenom : "Bobby", age : 50 }; // copie d'une rfrence au sein du tableau var tableauPersonnages:Array = [ personnage ]; // supprime une des deux rfrences seulement personnage = null; var personnageOrigine:Object = tableauPersonnages[0]; // affiche : Bobby trace( personnageOrigine.prenom ); // affiche : 50 trace( personnageOrigine.age );
Nous devons donc aussi supprimer la rfrence prsente au sein du tableau afin de rendre lobjet personnage ligible la suppression :
var personnage:Object = { prenom : "Bobby", age : 50 }; // copie d'une rfrence au sein du tableau var tableauPersonnages:Array = [ personnage ]; // supprime la premire rfrence personnage = null; // supprime la seconde rfrence
32 / 36
tableauPersonnages[0] = null;
Si la situation nous le permet, un moyen plus radical consiste craser le tableau contenant la rfrence :
var personnage:Object = { prenom : "Bobby", age : 50 }; // copie d'une rfrence au sein du tableau var tableauPersonnages:Array = [ personnage ]; // supprime la premire rfrence personnage = null; // crase le tableau stockant la rfrence tableauPersonnages = new Array();
Depuis la version 9.0.115 du lecteur Flash 9, il est possible de dclencher le ramasse-miettes manuellement laide de la mthode gc de la classe System. Notons que cette fonctionnalit nest accessible quau sein du lecteur de dbogage. Nous reviendrons sur cette mthode au cours du prochain chapitre intitul Le modle vnementiel.
A retenir
Il est possible de dclencher manuellement le ramassemiettes au sein du lecteur de dbogage 9.0.115. Afin quun objet soit ligible la suppression par le ramassemiettes nous devons passer toutes ses rfrences null. Le ramasse-miettes intervient lorsque la machine virtuelle juge cela ncessaire.
Bonnes pratiques
Durant lensemble de louvrage nous ferons usage de certaines bonnes pratiques, dont voici le dtail : Nous typerons les variables systmatiquement afin doptimiser les performances de nos applications et garantir une meilleure gestion des erreurs la compilation. Lors de la dfinition de boucles, nous utiliserons toujours une variable de rfrence afin dviter que la machine virtuelle ne rvalue la longueur du tableau chaque itration. Nous prfrerons donc le code suivant :
var tableauDonnees:Array = [ 5654, 95, 54, 687968, 97851]; // stockage de la longueur du tableau var lng:int = tableauDonnees.length; for ( var i:int = 0; i< lng; i++ )
33 / 36
{ }
A cette criture non optimise :

var tableauDonnees:Array = [ 5654, 95, 54, 687968, 97851]; for ( var i:int = 0; i< tableauDonnees.length; i++ ) { }
De la mme manire, nous viterons de redfinir nos variables au sein des boucles. Nous prfrerons lcriture suivante :
var tableauDonnees:Array = [5654, 95, 54, 687968, 97851]; var lng:int = tableauDonnees.length; // dclaration de la variable elementEnCours une seule et unique fois var elementEnCours:int; for ( var i:int = 0; i< lng; i++ ) { elementEnCours = tableauDonnees[i]; }
A lcriture suivante non optimise :

var tableauDonnees:Array = [5654, 95, 54, 687968, 97851]; for ( var i:int = 0; i< tableauDonnees.length; i++ ) { // dclaration de la variable elementEnCours chaque itration var elementEnCours:int = tableauDonnees[i]; }
Dcouvrons prsent quelques dernires subtilits du langage ActionScript 3.
Autres subtilits
Attention, le type Void existant en ActionScript 2, utilis au sein des signatures de fonctions prend dsormais un v minuscule en ActionScript 3. Une fonction ActionScript 2 ne renvoyant aucune valeur scrivait de la manire suivante :
34 / 36
function initilisation ( ):Void { }
En ActionScript 3, le type void ne prend plus de majuscule :

function initilisation ( ):void { }
ActionScript 3 intgre un nouveau type de donnes permettant dindiquer quune variable peut accueillir nimporte quel type de donnes. En ActionScript 2 nous nous contentions de ne pas dfinir de type, en ActionScript 3 nous utilisons le type * :
var var var var var var condition:* = true; total:* = 5; couleur:* = 0x990000; resultat:* = 45.4; personnage:* = new Object(); prenom:* = "Bobby";
Nous utiliserons donc systmatiquement le type * au sein dune boucle for each, car la variable p doit pouvoir accueillir nimporte quel type de donnes :
var personnage:Object = { prenom : "Bobby", age : 50 }; for each ( var p:* in personnage ) { /* affiche : 50 Bobby */ trace( p ); }
En utilisant un type spcifique pour la variable ditration p, nous risquons de convertir implicitement les donnes itres. Dans le code suivant, nous utilisons le type Boolean pour la variable p:
var personnage:Object = { prenom : "Bobby", age : 50 }; for each ( var p:Boolean in personnage ) {
35 / 36
/* affiche : true true */ trace( p ); }
Le contenu des proprits est automatiquement converti en boolen. Au cas o une donne ne pourrait tre convertie en boolen, le code prcdent pourrait lever une erreur lexcution. Passons prsent aux nouveauts lies linterface de programmation du lecteur Flash. Les deux grandes nouveauts du lecteur Flash 9 concernent la gestion de laffichage ainsi que le modle vnementiel. Au cours du prochain chapitre intitul Le modle vnementiel nous allons nous intresser ce nouveau modle travers diffrents exercices dapplications. Nous apprendrons matriser ce dernier et dcouvrirons comment en tirer profit tout au long de louvrage. Puis nous nous intresserons au nouveau mcanisme de gestion de laffichage appele Liste daffichage au cours du chapitre 4, nous verrons que ce dernier offre beaucoup plus de souplesse en termes de manipulation des objets graphiques et doptimisation de laffichage. Vous tes prt pour la grande aventure ActionScript 3 ?
36 / 36

02 Langage Et API

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

02 Langage Et API

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 2 Langage et API - version 0.

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

contient toutes les

dfinitions de classe importer :

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

Gestion des types lexcution

Lerreur suivante tait gnre la compilation :

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

var ref:MovieClip = this.attachMovie ("clip", "monClip", 0);

Chapitre 2 Langage et API - version 0.1

Le code prcdent gnre donc le message derreur suivant la compilation :

A la compilation, lavertissement suivant est affich :

Chapitre 2 Langage et API - version 0.1

La fentre de sortie affiche lerreur suivante :

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

Nouveaux types primitifs

Chapitre 2 Langage et API - version 0.1

// affiche : 0 trace( uint.MIN_VALUE ); // affiche : 4294967295 trace( uint.MAX_VALUE );

Notons, que la machine virtuelle arrondi lentier infrieur :

Chapitre 2 Langage et API - version 0.1

// affiche : 8 trace( getTimer() - debut ); // affiche : 45 trace( arrondi );

Chapitre 2 Langage et API - version 0.1

{ } // affiche : 102 trace( getTimer() - debut );

Chapitre 2 Langage et API - version 0.1

Pour plus dastuces lies loptimisation, rendez-vous ladresse suivante : http://lab.polygonal.de/2007/05/10/bitwise-gems-fast-integer-math/

Valeurs par dfaut

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

En utilisant le type int ou uint, les variables sont automatiquement initialises 0 :

Nouveaux types composites

Chapitre 2 Langage et API - version 0.1

Nous aurions pu transtyper avec lcriture traditionnelle suivante :

Chapitre 2 Langage et API - version 0.1

Si nous omettons le paramtre :

Lerreur la compilation suivante est gnre :

ActionScript 3 permet de dfinir une valeur par dfaut pour le paramtre :

En plus de cela, ActionScript 3 intgre un nouveau mcanisme li aux paramtres alatoires.

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

54 687968 97851 */ trace( tableauDonnees[p] ); }

La boucle for each accde elle, directement au contenu de chaque proprit :

Enrichissement de la classe Array

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

// affiche : Bobby,Willy,Ritchie trace( prenomsFormates );

Chapitre 2 Langage et API - version 0.1

var resultat:Boolean = utilisateurs.some ( navigue ); // affiche : true trace( resultat );

Nous reviendrons sur certaines de ces mthodes au sein de louvrage.

Chapitre 2 Langage et API - version 0.1

savrer extrmement ActionScript 3.

Le code prcdent, gnre lerreur de compilation suivante :

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1

Chapitre 2 Langage et API - version 0.1