Forums Développement Multimédia

Les formations Mediabox
Les formations Mediabox
Compatible ActionScript 3. Cliquer pour en savoir plus sur les compatibilités.Par Nataly, le 26 mai 2011

Variables, fonctions, syntaxe (ici)
Objets, méthodes, propriétés…
Clics et événements souris sur les boutons et les clips
Champs texte et objet String
Structures de contrôle alternatives : if
MovieClip : manipuler
• Structures de contrôle alternatives : switch
• Structures de contrôle répétitives : for - while
Liste d'affichage, imbrication et profondeur des objets
Liste d'affichage, gestion dynamique des objets
Les tableaux

Programmation AS3 premiers pas

Alors ça y est ? C'est décidé ? Aujourd'hui vous franchissez le pas et vous vous lancez dans le grand bain de la programmation AS3 ?

Parfaitement novices en la matière vous vous êtes dit :
“Et pourquoi pas moi ? Un langage du peu que j'en sache, ça a à voire avec les ordinateurs qui sont des engins assez primaires dans leurs fondements puisqu'ils ne peuvent comprendre que deux choses, c'est vrai ou c'est faux.
Ça tombe bien, ce sont deux notions que je maitrise :mrgreen: je ne dois pas être plus bête qu'une machine, pourquoi pas moi ?!

Et bien voilà, on est d'accord : pourquoi pas vous ?
La seule chose qui pourrait vous freiner c'est ne pas connaitre flash du tout. En effet je vais parler ici de AS3 via Flash, et puisque ce langage permet de proposer, via la programmation, des contenus graphiques animés et inter-actifs, encore faut-il que vous soyez au point du début de la phrase : contenus graphiques animés.


Vous devez, pour suivre ce tuto, connaitre flash du point de vue de son interface graphique, savoir créer un document, créer un clip, être au point de notions de bases telles la bibliothèque ou les différents panneaux.

Si ce n'est pas le cas, ça ne vous empêchera probablement pas de suivre ce ce que je vais raconter dans cette page, mais par la suite, si vous voulez continuer, il vous faudra prendre le temps de faire connaissance avec ce merveilleux outil qu'est Flash.



Tout d'abord, et puisque vous êtes appelés à passer un moment en ma compagnie, prenons le temps de faire connaissance, et surtout prenez le temps de vous mettre dans les meilleures conditions qu'il soit pour faire votre apprentissage :

• Traitez vous bien, et n'exigez pas l'impossible de vous. Respectez des pauses fréquentes. Si vous êtes aussi novices que je l'imagine vous allez voir beaucoup de choses, il faut leur laisser le temps de prendre leur place dans la tête.

• Faites les exos, ils sont conçus pour vous confronter à la réalité. Ce qui parait simple sur une démo réserve quelque fois des surprises quand on se retrouve seul à devoir respecter une consigne. Et puis la chose qui ne s'enseigne pas c'est l'expérience. Il faut forger pour devenir forgeron, et coder pour devenir développeur.
Coder c'est anticiper, et pour anticiper il faut avoir déjà fait… Ben voui, ça tombe sous le sens, me criez pas, je ne fais que commencer à énoncer des évidences ;)

• Quand vous n'avez pas compris, relisez attentivement : je m'applique du vocabulaire, je choisis les mots au plus près - puisque c'est quasi la seule chose dont je dispose pour vous aider. Si l'expression écrite qui est mienne vous perturbe un peu au début vous pouvez néanmoins vous appuyer dessus, je confonds rarement les acceptions ;)

• Quand (et si) vous continuez à ne pas comprendre, faites une pause, allez vous servir un café ou faire le tour du pâté de maison, mangez quand vous avez faim, et ne perdez pas de temps à vous demander si vous êtes bêtes - d'abord ça m'étonnerait - et en plus on s'en fout, puisque ça ne vous a pas empêché de vivre jusqu'à aujourd'hui;)

• Si vraiment ça vous résiste, le forum est là pour répondre à vos questions.

Et puis dites vous que cette longue introduction c'est juste parce que j'avais dit qu'on allait faire connaissance, alors voilà : ma grande caractéristique c'est que je suis bavarde. La preuve en est faite et il faudra faire avec, ça fait partie du kit, il faut tout prendre : ma bonne volonté à vous transmettre ce que je sais ET ma grande volubilité. ;)



Trève de bavardage, cette fois on s'y lance, on crée un nouveau fichier Flash, et on choisit ActionScript 3.0.



… Oui, bon… Si je le dis pas il va y en avoir pour râler ;)

panneau action, toutes premières lignes

Nos premières expérimentations, on va les écrire “sur” une image du scénario, et pour prendre de bonnes habitudes, je vous propose de dédier un calque au code.
Pour s'y retrouver on le nomme code (ou action, ou ce que vous voulez, pour peu que ça vous évoque clairement que sur les images de ce calque on trouvera du code).

On va écrire dans la fenêtre Actions. Si ce n'est déjà fait, affichez-la depuis le menu Fenêtre [F9].
Sélectionnez l'image 1 et vérifiez dans l'onglet de la fenêtre Actions que vous vous apprêtez bien à écrire image 11).

trace

Pour commencer, parce-que je sens que le clavier vous démange, on va attaquer par l'incontournable s'il en est : trace.

Une fois n'est pas coutume, on va faire d'abord et je vous explique ensuite :
Dans la fenêtre action, sur le calque qu'on vient de nommer code, écrivez le mot trace (pour l'instant on va dire comme ça), suivi d'une parenthèse ouvrante, d'un texte entre guillemets, d'une parenthèse fermante et d'un point virgule.

trace("un texte quelconque pour commencer à comprendre");



Notez le petit a qui apparait dans l'image du scénario ; a comme actionScript, pour dire que quelque-chose y est écrit.


Ayé voici la première chose à tester.
Choisissez Tester l'animation du menu Contrôle… et… Tada ! Voilà que s'affiche une fenêtre Sortie par dessus le .swf, et dans cette fenêtre, le texte que vous avez saisi entre guillemets.



Il est possible que cette fenêtre ne s'affiche pas par dessus les swf mais reste encastrée dans l'ensemble des différents panneaux. Si vous ne la voyez pas, cherchez-la via le menu Fenêtre. Le raccourci clavier c'est F2.


Si malgré tout vous ne voyez rien c'est peut être une question d'option, vérifiez ça…

trace est une fonction - comprenez un outil - dont l'utilisation a pour conséquence de faire apparaitre dans le panneau de sortie ce qu'on a écrit entre parenthèses.
Elle ne sert que dans le cadre du débogage et de l'écriture du code en général ; Elle permet au programmeur de vérifier ce qu'il se passe, tracer l'exécution du code, s'assurer de la valeur d'une variable…
Et voilà le mot est lâché : variable. Et c'est dans l'idée qu'on puisse “voir”2) ce dont je vais parler que j'ai introduit aussi rapidement cette fonction trace, sans même avoir les billes pour tout en expliquer. Pour la suite il nous suffit d'en savoir ce strict minimum : on voit dans la fenêtre de sortie ce qu'on lui a passé (écrit) entre parenthèses, et on va pas se priver de lui passer des variables.

Commentaires

Une toute petite chose encore à savoir avant d'attaquer le corps de la bête : puisque coder, en fin de compte, ce n'est rien de plus qu'écrire une suite de lignes (composées de mots) qui seront reconnues comme des instructions (des commandes, des ordres) que l'on donne à la machine et exécutées les unes après les autres afin qu'il “se passe” ce qu'on veut, comment écrire dans la fenêtre action des lignes à notre attention, qui ne seront pas interprétées comme du code destiné à être exécuté ?
Ce qu'on appelle des commentaires qui, comme leur nom l'induit, sont destinés à commenter le code en français langage d'être humain.

Deux possibilités :

• Faire précéder chaque ligne destinée à être du commentaire de deux slashs :

//ceci est une ligne de commentaire
//ceci en est une autre
//elle ne seront pas exécutées en tant que code
 
trace("Trop forte, je suis \o/");// cette ligne écrit ds la fenêtre de sortie


• Encadrer plusieurs lignes des séquences de caractère slash-étoile (début) et étoile-slash (fin) :

/*
Et voilà
que tout ce que j'écris
sur autant de lignes que je le souhaite ne sera pas exécuté
*/



On utilise aussi les commentaires pour invalider provisoirement une ligne, n'exécuter qu'une partie du code.

Variables

Bon !
Autant prévenir tout de suite : cette première page ne va pas être terriblement ludique - pour ne pas dire un poil assommante -
C'est qu'aux tous débuts, comme on ne sait par définition rien faire, on passe immanquablement par une étape plus théorique que pratique, la pratique étant réduite à l'utilisation de la fonction trace :(
Ne vous découragez pas, dès la page suivante vous aurez l'occasion d'exemples concrets qui vous permettront d'expérimenter ces fameuses et incontournables variables.

Une variable c'est un mot qu'on invente, choisit à notre gré (en respectant quelques contraintes vous vous en doutez), destiné à représenter quelque chose3).
Une fois la variable “créée” on l'utilise en lieu et place du quelque chose en question.

Reprenons le premier exemple : on a passé (écrit) un texte entre guillemets à la fonction trace et on a eu le bonheur de voir ce texte s'afficher dans la fenêtre de sortie. Ce texte pourrait être “stocké dans” (abus de langage) une variable.

Voyons comment nous y prendre :

Déclarer

Tout d'abord on veut déclarer une variable. Ça se fait à l'aide du mot clé var4), c'est comme ça, c'est une règle.

var


Puis on choisit un mot à notre gré, en faisant attention à ce qu'il ne s'agisse pas d'un mot réservé - comprendre un mot du champ lexical de AS3, ou dit autrement, un mot qui existe dans la doc ;) - en se restreignant aux 26 lettres de l'alphabet, 10 chiffres de zéro à neuf, et au caractère de soulignement (underscore).

- Un nom de variable ne peut pas commencer par un chiffre.
- Majuscule et minuscule ce n'est pas la même chose.


var unePremiereVariable


Là, je viens de dire à l'ordinateur : attention je vais utiliser une variable (var) et je lui donne un nom. Sois gentil de le prendre en considération et de réserver de la mémoire pour stoker ce qu'elle représentera.

On peut utiliser les caractères accentués, mais j'ai encore du mal à m'y faire, vieilles habitudes du millénaire dernier : ça me fait peur ;)

Typer

Vous imaginez bien, sans nécessairement savoir grand chose de la mémoire, qu'il ne faut pas la même place pour stocker une phrase de dix lignes que le bête chiffre 12 par exemple.
On va donc préciser le type de la variable afin que l'ordinateur se débrouille de l'espace de stockage, et puis aussi, ça permettra un code solide et ça nous aidera à éviter les erreurs, voire à les repérer le cas échéant.

Dans le cas qui nous intéresse il s'agit d'une chaine de caractères, nous on pense chaîne, les anglophones ficelle ou kyrielle et utilisent le mot String.
On utilise le caractère : (deux points) pour séparer le nom de la variable de son type.

var unePremiereVariable:String

En soi, ceci est une instruction (pour peu qu'on mette un point virgule à la fin pour signifier “fin d'instruction”). Quand le code est exécuté, le programme “fait quelque chose”.
En l'espèce il réserve en mémoire de quoi stocker une future chaine de caractères quelconque5).
Dit encore plus correctement il “note” une adresse, un endroit, où il pourra aller lire la chaine de caractères en question.

Valoriser

Il s'agit maintenant de valoriser la variable qu'on vient de créer, comprendre lui affecter une valeur (qui ira se stocker à l'adresse que l'ordinateur a associé à la variable). Je parle de valeur au sens large6), ici il s'agit d'une chaine de caractères, ça s'écrit toujours entre guillemets.
Pour affecter une valeur, on a recours à l'opérateur d'affectation = (egal)

var unePremiereVariable:String="Ce que je veux, ce sera reconnu comme caractères";

Voilà à l'issu de cette instruction la variable unePremiereVariable vaut “Ce que je veux, ce sera reconnu comme caractères”.
Vérifions à l'aide de notre désormais copine, la fonction trace :

var unePremiereVariable:String="Ce que je veux, ce sera reconnu comme caractères";
trace(unePremiereVariable);

A l'exécution, nous aurons dans la fenêtre de sortie:

Ce que je veux, ce sera reconnu comme caractères


Depuis Flash, si vous tapez successivement échappe (la touche esc), t, r
… wo magie… Tout s'écrit tout seul : le mot trace, ses parenthèses et le curseur est au milieu, vous n'avez plus qu'à saisir \o/


Bien entendu que vous ne confondez pas : Si on écrit le nom de la variable entre guillemets, alors c'est reconnu comme une chaine.



Ce que représente une variable est réputé varier (sans quoi c'est une constante, mais on en parlera bien plus tard). Changeons donc la chaine de caractères affectée à unePremiereVariable après l'avoir tracée.

La variable est déjà déclarée et typée, on ne recommence pas (et il ne faut surtout pas), on se contente d'affecter une nouvelle valeur à l'aide de l'opérateur égal.

var unePremiereVariable:String="Ce que je veux, ce sera reconnu comme caractères";
trace(unePremiereVariable);
unePremiereVariable="Autre chose";
trace(unePremiereVariable);
Ce que je veux, ce sera reconnu comme caractères
Autre chose



Pour en finir avec le vocabulaire, sachez que la première fois qu'une valeur est affectée à une variable, on dit de cette variable qu'elle est initialisée.

Si on ne la valorise pas explicitement, c'est le programme qui s'en charge en utilisant une valeur par défaut.

Vérifions :

var unePremiereVariable:String;//on la déclare mais on ne valorise pas
trace("Une ligne pour s'y retrouver");// comme le texte l'indique ;)
trace(unePremiereVariable);//voyons voir…
unePremiereVariable="Autre chose";// on valorise
trace(unePremiereVariable);
Une ligne pour s'y retrouver
 
Autre chose


Ce qu'on constate, c'est rien justement. Entre “une ligne pour s'y retrouver” et “Autre chose” il n'y a rien d'écrit, la valeur par défaut d'une variable String c'est donc “rien” on écrira null.

Ne vous y trompez pas, null ce n'est pas pareil que “chaine vide”.
Une chaine vide c'est quelque chose : une chaine, certes sans caractères, mais une chaine quand même.
Ceux qui veulent vraiment s'en convaincre et ont quelques connaissances supplémentaires peuvent tester, les autres en sont réduits à me croire sur parole (ou à vérifier dans la doc ;)).
var laChaine:String;
trace(laChaine==null);
trace(laChaine=="");
true
false



Ne nous attardons pas et continuons sur la lancée avec les différents types de variables.

Les types de variables

Les chaînes : String

On peut donc typer une variable en String, on vient de le voir, et on la valorisera à l'aide d'une chaine (de caractères, pour nous et concrètement du texte entre guillemets). Si on ne l'initialise pas elle vaudra null.

Les nombres : uint, int, Number

Si on souhaite représenter un nombre à l'aide d'une variable, plusieurs types vont se présenter à nous. Il va convenir de faire la différence entre les nombre entiers (sans virgule et possiblement négatifs), les nombres entiers positifs (toujours positifs), et les nombres à virgule (décimaux).
On choisira le type approprié selon la plage de données qu'on se propose d'utiliser. J'ai synthétisé dans le tableau plus bas.

Entiers positifs : uint

Quand on type en uint, on peut utiliser des nombres allant jusqu'à 4 294 967 295 (inclus). La valeur par défaut, c'est zéro.

Par exemple :

var unEntierForcémentPositif:uint=3;// 
unEntierForcémentPositif=500299035;// pas de séparateur de milliers ;)



Entiers : int

On peut utiliser aussi bien des valeurs positives que négatives comprises entre -2 147 483 648 et 2 147 483 647 (bornes incluses). La valeur par défaut, c'est zéro.

Par exemple :

var unEntierToutCourt:int=-145; 
unEntierToutCourt=500299035;



Nombres décimaux (ou pas) : Number

Ce sont des nombres comprenant une partie décimale (avec une virgule quoi ;)), ce qui n'empêche pas d'utiliser des valeurs entières.
Attention la valeur par défaut c'est NaN : Not a Number (pas un nombre), autant dire qu'on ne pourra effectuer aucune opération avant d'avoir initialisé la variable. Pensez-y ! On a tendance à prendre l'habitude de considérer qu'un entier7) vaut zéro par défaut et ne pas toujours prendre la peine de l'initialiser. Avec un type Number, ça nous envoie dans le mur.

Si vous avez besoin de manipuler des entiers en dehors des plages de valeurs des int et uint, typez en Number. Je ne vous fatiguez pas avec les bornes, ce sont des nombres tellement grands que vous aurez oublié d'ici que vienne le jour où ça vous posera problème.

Par exemple :

var unNombreQuelconque:Number= 234.9876;// prenez garde : le séparateur décimal c'est le point
unNombreQuelconque=99147483698;
unNombreQuelconque=-999999999907;// et il y a de la marge, croyez moi ;)
unNombreQuelconque=-0.5;



Mais comment sait-elle tout ça ?
Elle ne le sait pas - et ne compte pas l'apprendre - :mrgreen:

Sur son clavier il y a une touche F1… ;)
Sur le votre aussi (chic). Posez le curseur sur le mot Number, sollicitez F1… Vous voilà dans la doc au bon endroit. Descendez un peu, repérez le lien Descriptions des types de données… Et vous voilà avec de la lecture.
Si ces histoires de 32 bits, 64 et autres ésotérismes ne vous évoquent rien, oubliez, il sera temps plus tard, on peut développer un bon moment, et se faire très correctement la main sans en rien savoir. En revanche, je comprends bien votre curiosité, si vous y tenez, je vous raconterai ça à la machine à café [lien]


En synthèse

Si je résume le choix du type des nombres :
• Entiers compris entre deux milliards et moins deux milliards –> int (vous compliquez pas)
• Entiers plus grand que deux milliards ou inférieurs à quatre milliards deux cents millions –> uint
• Le reste : Number.

Quand vous approchez des deux ou quatre milliards, il est temps d'aller dans la doc vérifier les bornes, avant, vous oubliez ;)



Vrai ou faux : Booléen

Et puis il existe aussi des variables qui ne peuvent valoir que vrai ou faux. On les dit Booléenne, parce que leur type est Boolean. La valeur par défaut, c'est faux.

var variableBool:Boolean;
trace(variableBool);
variableBool=true;
trace(variableBool);
variableBool=false;
trace(variableBool);
false
true
false


On dit des types uint, int, Number, String et Boolean que ce sont des types primitifs.

Tout le reste

Mais ce ne sont pas les seuls, il y a encore… Tout le reste…
Tous ces autres objets que l'on va manipuler à longueur de temps, les clips au hasard, mais aussi des trucs destinés à charger des données, à représenter des structures xml, les champs de textes… sans compter les objets que nous fabriquerons au besoin.

Quoi des “trucs” ? Qu'est-ce qu'elle raconte ? Elle peut pas causer plus précis ?
Si elle peut ;) Elle pourrait parler de classes par exemple, mais vu qu'on n'est pas réputés savoir ce que c'est…

En deux mots - on prendra très largement le temps d'y revenir - une classe ça peut être compris comme une famille d'objets semblables.
Des objets, avant même de les fabriquer on en manipule à longueur de flash. Quand on utilise un symbole clip par exemple, eh bien on manipule un objet de la classe MovieClip. Quand on pose un champ texte sur la scène, il s'agit d'un objet de la classe TextField…
Toutes ces classes, on en retrouve la liste dans le panneau latéral



On y reviendra, ne mélangeons pas tout, retenez seulement que les variables peuvent aussi représenter n'importe quel objet de n'importe quelle classe. Leur type est alors la classe elle même. Ces types, en nombre potentiellement infini puisqu'on peut fabriquer ses propres classes, sont dits types complexes.
Ce qu'il faut en retenir c'est que leur valeur par défaut, c'est null.

Par exemple, quand une variable doit représenter un clip, on la type MovieClip.

var unClip:MovieClip;// Attention unClip est valorisée à null par défaut. 
                     // Tel que, on ne peut rien faire de la variable
                     // elle ne représente encore aucun clip



Tableau récapitulatif

Type valeurs ou plages défaut
Types primitifs
String null
uint 0 à 4 294 967 295 0
int -2 147 483 648 à 2 147 483 647 0 à privilégier dans les boucles for [lien]
Number enoooooorme8) NaN nombres décimaux ou entiers
Boolean true ou false false
Types complexes
Object null
MovieClip null
TextField null
etc… null


Prenez bien garde à la casse : String, Number, Boolean commencent par une majuscule, uint et int non.


Tannoy a fait une synthèse ici .



Les fonctions

Ah ! En voilà un chapitre que j'aime bien : on va pourvoir s'entrainer à écrire un peu plus que de bêtes traces \o/

Une fonction, qu'est-ce que c'est ?
Un outil, ai-je dit en intro quand je vous ai présenté la fonction trace. Métaphore pour métaphore, je vais maintenant parler de machine ; Mettons une machine à hamburgers.

J'ai donc une machine à hamburgers, elle est simple d'emploi : je lui donne une boule de pain au sésame, du bœuf haché, elle découpe le pain, le fait griller, cuit la viande et la glisse au milieu avec de la salade une rondelle de tomate de l'oignon, et hop ! Recrache un hamburger.
Si je lui passe du poulet et du pain classique, elle procède de la même manière (couper, griller, ajouter viande, salade, tomate, oignons) et nous renvoie un hamburger poulet.
Bien sûr notre machine est bien fichue, elle un tiroir destiné à la viande, un autre au pain, et elle en a même un troisième, que je ne suis pas obligée de remplir pour le fromage, ainsi pourra-ton obtenir des cheeseburger le cas échéant.
Bien sûr aussi qu'il s'agit d'être vigilants, si on met le fromage dans le tiroir à pain, ça colle partout, c'est une catastrophe. En plus on est obligé de fournir pain et viande, si on la fait tourner à vide, c'est une catastrophe aussi, on casse tout.
En revanche, pas besoin de lui fournir salade, tomate et oignons, elle se débrouille toute seule - ce sont les limites de la métaphore - on va dire qu'elle est auto-remplissable ;-)
Je pourrais aussi disposer d'une machine à cornet de glace qui fonctionnerait sur le même principe : on lui fournit la gaufrette et les fruits, elle se débrouille pour fabriquer la crème glacée, en remplit le cornet et nous le renvoie.

Ce que ces machines on en commun c'est :
• un nom : fabHamburger, fabGlace,
• des tiroirs pour recevoir les ingrédients d'un certain genre (on pourrait dire type),
• elles fabriquent et renvoient un truc toujours du même type : Hamburger, CornetGlace.



Et bien voilà, pareil pour une fonction.
Si ce n'est que les ingrédients, on les appelle paramètres et que ce seront des nombres, des chaines, des booléens et autres clips.

Quant à la fonction, elle renverra (ou pas) un nombre, une chaine, une valeur booléenne, un clip, n'importe quoi qui nous arrange.

Imaginons par exemple qu'on ait à calculer fréquemment le volume de tonneaux. C'est tout un cirque il est question de grand diamètre, de petit diamètre et de hauteur. On pourrait décider d'une fonction chargée du travail. On lui passerait un grand diamètre, un petit diamètre, une hauteur, elle s'occuperait de mixturer tout ça et nous renverrait le volume, sans qu'on ait à se préoccuper du détail des calculs.

On l'utiliserait comme suit :

var volTonneau1:Number= volumeKepler(90,60,120);// volume d'un grand tonneau
var volTonneau2:Number= volumeKepler(55,30,80);// volume d'un petit tonneau

J'ai inventé le nom volumeKepler9), ça pourrait être n'importe quel autre nom, s'il respecte les restrictions qui sont les mêmes que pour les variables.

Ecrire une fonction

Pour comprendre prenons un cas plus simple, une fonction parfaitement inutile - si ce n'est pour nous entrainer - qui accepte deux entiers, en fait la moyenne et la renvoie. Mettons qu'on la nomme moyenne et on se propose de l'invoquer comme suit :

var toto:Number= moyenne(60,40);
trace (toto);


Et on s'attend à lire 50 dans la fenêtre de sortie (ne testez pas maintenant, la fonction n'existe pas encore, pour l'instant on rêve).
Il s'agit d'écrire la fonction :

function


On a dit qu'on l'appelait moyenne, allons-y donc :

function moyenne


On sait qu'on lui passera deux nombres, potentiellement décimaux, il s'agira donc du type Number.
Nos tiroirs de fabHambuger, qui sont en vrai des paramètres, on les liste entre parenthèses en les séparant par des virgules, et on les type comme on le ferait d'une variable à l'aide du caractère : (deux-points) :

function moyenne(nb1:Number,nb2:Number)


Et il faut encore préciser le type de ce qui sera renvoyé (le genre, avec la métaphore des machines c'était Hamburger ou CornetGlace), en le faisant précéder, comme toujours, du caractère : (deux-points). Ce sera un nombre potentiellement décimal, donc Number.

function moyenne(nb1:Number,nb2:Number):Number



Le corps de la fonction - les rouages pour la métaphore - les calculs qui permettront de fabriquer le résultat donc, on les écrit entre accolades :

function moyenne(nb1:Number,nb2:Number):Number {
   // ici on écrira la suite d'instructions
   // qui aboutiront à obtenir le résultat 
   // à renvoyer
}



la séquence de caractères magique10) : esc f n



Les opérateurs mathématiques

Je vous suppose novices certes, mais tout de même, les opérateurs mathématiques courants : plus, moins, divisé, multiplié… Ça ira ?
Allez ! :mrgreen:

plus +
moins -
multiplié *
divisé /
modulo %


Et comme modulo n'est pas forcément aussi célèbre que ses confrères, je précise qu'il donne le reste d'une division : 7%2 vaut 111), 28%5 vaut 312), 12%6 vaut 013)


Revenons à nos moutons : pour calculer la moyenne, on va utiliser les paramètres comme s'il s'agissait de variables en considérant qu'ils représentent une valeur, celle qu'on passera à la fonction en l'appelant (tel qu'on l'a rêvé nb1 vaudra 60 et nb2 vaudra 40).
Pas grand chose à écrire pour calculer le résultat. Pour le plaisir d'avoir deux lignes, on crée une variable retour, typée en Number qu'on valorise d'un pauvre calcul dont je vous fais grâce du détail ;)

function moyenne(nb1:Number,nb2:Number):Number {
   var retour:Number=(nb1+nb2)/2; // n'oubliez pas les parenthèses
}


Encore faut-il faire ne sorte que la fonction renvoie ce résultat. C'est le mot clé return qui s'en charge :

function moyenne(nb1:Number,nb2:Number):Number {
   var retour:Number=(nb1+nb2)/2; // n'oubliez pas les parenthèses
   return retour;
}



Et voilà vous pouvez tester votre premier bout de code qui fait un peu quelque chose 8-)

var toto:Number= moyenne(60,40);
trace (toto);
 
function moyenne(nb1:Number,nb2:Number):Number {
   var retour:Number=(nb1+nb2)/2; // n'oubliez pas les parenthèses
   return retour;
}
50


Dans quel ordre s'exécute le code ?


Peut-être êtes vous surpris de voir l'appel à la fonction écrit avant la fonction elle même ?

En effet sans que je l'ai explicitement dit jusqu'alors, vous vous êtes bien doutés que les lignes de codes sont exécutées de haut en bas. Non seulement je confirme, mais encore je précise que si on écrit du code sur plusieurs calques (ça peut aider à s'y retrouver) alors c'est le code du calque le plus haut qui est d'abord exécuté, puis celui porté par les autres calques, en descendant.

En revanche pour les fonctions c'est un cas particulier. Il faut bien comprendre que le code contenu dans une fonction n'est exécuté que si on appelle (invoque) la fonction. En quelque sorte au moment de l'exécution le programme “connait déjà” le nom de toutes les fonctions qui ont été décrites et est prêt “à s'y rendre” quand on les appellera.

Bien sûr, dans le corps de la fonction de nouveau la lecture se donne de haut en bas.

Comment s'en convaincre ?
Avec des traces par exemples ;)

trace("toute première ligne");
var toto:Number= moyenne(60,40);// ici le programme va "sauter" jusqu'à la fonction 
                                // pour exécuter les instructions qu'elle contient
                                // et valoriser toto du résultat
trace("suite de l'exécution du code principal");
trace (toto);
 
function moyenne(nb1:Number,nb2:Number):Number {
   trace("on entre dans la fonction moyenne, nb1 et nb2 sont valorisés");
   trace(nb1);
   var retour:Number=(nb1+nb2)/2; // n'oubliez pas les parenthèses
   return retour;
}
toute première ligne
on entre dans la fonction moyenne, nb1 et nb2 sont valorisés
60
suite de l'exécution du code principal
50

Le débogueur pour déboguer… et pour comprendre


Vous pouvez aussi poser un point d'arrêt et tester en mode déboguer14) avec le bouton pas à pas détaillé. Je vous renvoie au au tuto dédié écrit par frangois qui décrit admirablement le principe.




La machine fonction fabHamburger, traduit en respectant la syntaxe AS3, ça nous donnerait ça :

function  robotHamburger(boule:Pain,tranche:Viande,morceau:Fromage=null):Hamburger {
       // couper boule et faire griller
       // mettre viande
       // ajouter salade, tomate, oignons
       // ajouter morceau (de fromage) si pas null
       // renvoyer le hamburger
}

Paramètres facultatifs

Jusque là on a considéré qu'on écrirait et utiliserait des fonctions dont on connait le nombre de paramètres, et on oblige l'utilisateur à passer une valeur par paramètre. En effet si vous tentez d'appeler notre superbe fonction moyenne en lui passant un seul paramètre, une erreur est déclenchée à la compilation. Essayez :

var toto:Number= moyenne(60);// <---- je ne passe qu'un argument, alors que moyenne en attend deux
trace (toto);
 
function moyenne(nb1:Number,nb2:Number):Number {
   var retour:Number=(nb1+nb2)/2; // n'oubliez pas les parenthèses
   return retour;
}
Séquence 1, Calque 'code', Image 1, ligne 1 1136 : Nombre d'arguments incorrect. 2 attendus.

Eh oui, tout est dit : Nombre d'arguments incorrect, 2 attendus.

Si vous double-cliquez sur la description de l'erreur dans le panneau d'erreurs, la ligne incriminées du code est sélectionnée.

Valeur par défaut

On pourrait décider d'une valeur qui sera prise par défaut au cas où l'utilisateur ne saisit rien. Il suffit de le préciser quand on écrit la fonction en faisant suivre le paramètre (plus précisément le type) du signe = (egal) et de la valeur considérée. Par exemple :

function moyenne(nb1:Number,nb2:Number=0):Number {
   var retour:Number=(nb1+nb2)/2; 
   return retour;
}


Ainsi, on pourra l'appeler avec un seul argument, le deuxième vaudra zéro :

var toto:Number= moyenne(60);// <---- je ne passe qu'un argument, le deuxième vaudra 0
trace (toto);
30


Telle qu'on l'a écrite, le premier paramètre est requis le second facultatif, on pourrait les rendre tous deux facultatifs (et sur cet exemple, on est d'accord : ça n'a plus aucun sens ;))

function moyenne(nb1:Number=0,nb2:Number=0):Number {
   var retour:Number=(nb1+nb2)/2; 
   return retour;
}
 
var toto:Number= moyenne();// <---- je ne passe qu'un argument, le deuxième vaudra 0
trace (toto);
 



Prenez garde :
Dès lors qu'un paramètre admet une valeur par défaut les suivants doivent faire de même :

function moyenne(nb1:Number=0,nb2:Number):Number {
   var retour:Number=(nb1+nb2)/2; 
   return retour;
}
Séquence 1, Calque 'code', Image 1, ligne 4 1138 : Les paramètres obligatoires sont interdits après les paramètres facultatifs.


Je vous l'avais bien dit ;)





Une liste de paramètres facultatifs

Je vous en parle ici parce que c'est le lieu mais c'est totalement prématuré.

Toujours est-il qu'on peut aussi écrire une fonction qui attend un nombre indéfini de paramètres. Gardez seulement dans un coin de tête que c'est possible pour le jour où vous en aurez besoin. Ce jour là vous aurez pris de la bouteille, vous saurez ce qu'est un tableau, et vous vous direz “ah mais oui, mais c'est bien sûr : n'avais-je pas lu que c'était possible ?!”.

Il ne vous restera plus qu'à vous rendre au chapitre Le paramètre ... (rest) de la doc qui, à ce moment là, vous sera devenu parfaitement compréhensible :)

Le type void

Il se peut aussi qu'une fonction ne renvoie rien.

Ben alors ? A quoi sert-elle ?
A faire des choses, tout court, et c'est n'est pas rien.

Tiens, prenons par exemple une fonction que vous connaissez : trace. Elle ne renvoie rien15) elle fait.
Ce qu'elle fait, c'est écrire des choses dans la fenêtre de sortie.

C'est le deuxième intérêt des fonctions : regrouper sous un même intitulé une tripoté d'instructions, il suffira ensuite d'appeler la fonction au lieu d'écrire l'ensemble des instructions ; c'est une sorte de raccourci, de recette dis-je souvent.

A l'instant j'ai pris la métaphore de la machine, je pourrais maintenant prendre celle du robot. Imaginez votre nouveau robot tout neuf, qui ne sait encore rien faire. Vous allez le préparer à exécuter les taches courantes auxquelles il est dévolu. Mettons arroser les plantes, il va falloir lui apprendre à parcourir le jardin, repérer chacune des plantes et donner la quantité d'eau nécessaire selon la plante considérée. La première fois ça va être fastidieux : il faut tout lui expliquer, tout lui dire. Evidemment que s'il faut passer autant de temps à lui expliquer (voir plus) qu'à faire, ça n'a pas d'intérêt. C'est pourquoi, l'ensemble de ces taches, actions précises, vous allez lui donner un nom générique, aroserJardin au hasard. Par la suite il suffira de lui “dire” aroserJardin pour qu'il exécute, dans l'ordre que vous lui avez appris, les différentes actions mémorisées dans sa tête de robot.

En fait c'est la même chose qu'une recette de cuisine, il y a un titre et une liste d'ingrédients et de manipulations. Si je veux une tarte aux pommes et que je charge ma petite nièce de la préparer, soit je la guide pas à pas, geste à geste, soit je lui indique la bibliothèque et le titre du bouquin de recettes dans lequel trouver la recette en question, elle n'a plus qu'à aller lire et faire tout bien comme c'est écrit.
C'est la métaphore la plus proche de la réalité.

Bibliothèque, d'ailleurs c'est ce que sont les fameuses Library et autres API ou Frameworks dont regorge la littérature programmatique… Tout ce jargon technique anglophonisant, sous une forme ou une autre, ce ne sont rien d'autre que des bibliothèques, quelqu'en soit l'acception…
Bibliothèque signifie aussi bien le meuble que la pièce qui regroupe les meubles. Plus tard vous verrez que certaines classes ne sont rien d'autres que des livres de recettes - si on considère une fonction comme une recette - et les packages des bibliothèques où trouver les recettes.

Syntaxe

Revenons à nos moutons, et aux fonctions qui ne renvoient rien.
Rien (vide en anglais), ça s'écrit void.

Pour préciser qu'une fonction ne renvoie rien, on typera donc void.

function uneFonctionQuiNeRenvoieRien(unParam:int, unAutre:String):void{
     [… suite d'instructions…]
}


Pas de return, donc, puisque pas de retour ;)

Contexte

On les utilisera pour rendre du code plus lisible et/ou éviter de ré-écrire les mêmes choses.
Par exemple, si vous lisez ces quatre lignes :

init()
traitement()
affichage()
enregistrement()

… vous comprenez tout de suite de quoi il s'agit, et il est simple d'aller inspecter la fonction concernée selon la partie du programme qui vous intéresse.

Selon le même principe si vous souhaitez que plusieurs clips subissent les mêmes modifications à différents moments, il est vivement conseillé de réunir les instructions dans une fonction. Même si on ne sait pas encore l'écrire on peut imaginer une fonction à qui on passe un clip et qui se charge d'en modifier la couleur et la taille.
Si vous appliquez ces modifications dix fois à dix endroits différents du code sans fonction et que vous changez d'idée (pas la bonne couleur, une autre taille…) il vous faudra passer les modifications dix fois. Si vous avez fabriqué une fonction, vous modifiez la fonction et le tour est joué ;)

variables de type *

Mais, mais, mais… se diront certains… si void est un type (c'est bien le titre du chapitre, non ?) alors on peut typer une variable en void ?

Non.
Vous pouvez utiliser void uniquement comme annotation de type renvoyé (précise la doc), autrement dit dans le cadre de l'écriture d'une fonction.

En revanche vous pouvez typer une variable en “n'importe quoi”, à l'aide de * (étoile) et elle vaudra undefined par défaut. Ça signifie que la variable en question va pouvoir changer de type en cours de route.

C'est le type * qui est utilisé quand vous ne typez pas une variable.

var toto
// absolument identique à 
var toto:*



On peut donc déclarer une variable sans la typer (apparemment), c'est vivement déconseillé

Si j'en parle c'est parce qu'on est quelquefois tenté de ne pas typer les variables, soit qu'on ne sache pas (ce qui n'est pas bon signe), soit qu'on fasse vite et fainéant, or c'est toujours une mauvaise solution puisque ne pas typer c'est typer en n'importe quoi.
Ne pas typer c'est se compliquer la vie, et prendre de gros risques, puisque la variable en question est réputée pouvoir passer d'un type sur l'autre, si vous commettez une erreur, ça ne se verra pas à la compilation, votre code s'exécutera et les ennuis arriveront plus tard (une erreur restant une erreur), rendant l'identification du problème plus difficile que si une bonne vieille alerte vous avait prévenu dès le début qu'il y avait un conflit de type.

Typez toujours les variables que vous utilisez, vous vous éviterez bien des déboires, et vous travaillerez “propre”.



Dans les cas d'exception où vous souhaitez expressément qu'une variable puisse être utilisée pour représenter des données de n'importe quel type, précisez le en utilisant * (étoile) sans quoi on pourrait penser que vous avez juste oublié.

Et puisqu'on parle des différents types de données, passons tout de suite au chapitre conversion

Conversion

Il arrive quelque fois qu'on ait besoin de convertir le type des données représentées par une variable.

Prenons par exemple le cas d'une variable de type String :

var toto:String="45";

En manipulant toto, c'est ce qu'il représente qu'on manipule, soit “45”. c'est écrit entre guillemets, il s'agit bien d'une chaine. Pour actionScript c'est la lettre 4 et la lettre 5, ça aurait pu être A ou W ou ce qu'on veut, pour lui pareil : du caractère, quelque chose destiné à être écrit ou lu par un être humain, mais certainement pas calculable. Il n'est pas possible pour lui de faire des calculs avec des lettres.
C'est aussi dénué de sens de multiplier les lettres 4 et 5 par deux que de multiplier TZ, maison, ou clafoutis… Essayez :

var toto:String="45";
trace (toto*2);
1067: Contrainte implicite d'une valeur du type String vers un type sans rapport Number.



Bien sûr, vous n'écrirez jamais quelque chose d'aussi farfelu (ou alors c'est que vous serez bien fatigués ;)), mais il pourra arriver que vous ayez besoin de faire des calculs avec une valeur contenue dans un champ texte ou récupérée depuis un fichier .txt, .xml, .php …
Il vous faudra alors convertir.
Pour convertir d'un type sur l'autre on passe l'expression à convertir16) entre parenthèses derrière le nom du type considéré :

var toto:String = "45";
var totoInt:int=int(toto);
trace (totoInt*2);
90


Ne vous y trompez pas, la variable n'est pas transformée, elle ne change pas de type. Ici toto est toujours de type String. On a seulement utilisé une fonction - maintenant que vous savez ce que c'est ;) - Cette fonction, int, se contente de fabriquer un entier (integer) depuis ce qu'on lui passe et de le renvoyer. Ici on l'a récupéré via la variable totoInt.

typeof

Vous pouvez vérifier que toto n'a pas changé de type à l'aide de la fonction typeof, qui comme son non l'indique, nous dit quel est le type de donnée de ce qu'on lui passe en paramètre.

var toto:String = "45";
var totoInt:int=int(toto);
trace (totoInt*2);
trace(typeof(toto))
90
string


• En vrai, typeof manque de vocabulaire et ne connait que six réponses possibles : boolean, number, string, xml, object, function.
• En vrai de vrai ce n'est pas une fonction mais un opérateur (ce qui au fin fond des choses revient au même), vous pouvez donc l'utiliser comme suit :

var toto:String = "45";
var totoInt:int=int(toto);
trace (totoInt*2);
trace(typeof toto);
trace(typeof totoInt);
90
string
number


Tableaux de conversion

On peut donc sur le même principe qu'illustré avec la fonction int, convertir tous les types vers un type primitif.

Valeur ou type de données Résultat de la conversion en Number, int ou uint
Boolean Si la valeur est true, 1 ; sinon, 0.
Date La représentation interne de l'objet Date, qui est le nombre de millisecondes depuis le 1er janvier 1970, à minuit, heure universelle.
null 0
Object Si l'instance est null et convertie en Number, NaN ; sinon, 0.
String Un nombre si Flash Player peut convertir la chaîne en un nombre ; autrement, NaN si converti en Number ou 0 si converti en int ou uint.
undefined Si converti en Number, NaN ; si converti en int ou uint, 0.


Valeur ou type de données Résultat de la conversion en chaîne
Array Une chaîne composée de tous les éléments du tableau
Boolean “true” ou “false”
Date Une représentation sous forme de chaîne de l’objet Date
null “null” (la chaine de caractères)
Number, int ou uint Une représentation sous forme de chaîne du nombre
Object Si l’occurrence est null, “null” ; sinon, ”[object Object]“


Valeur ou type de données Résultat de la conversion en Boolean
String false si la valeur est null ou la chaîne vide (””); true autrement.
null false
Number, int ou uint false si la valeur est NaN ou 0 ; true autrement.
Object false si l'instance est null ; true autrement.

Conversions implicites

La doc :
Une conversion de type a lieu lorsqu’une valeur est transformée en une valeur d’un type de données différent. Les conversions de type peuvent être implicites ou explicites. Les conversions implicites (ou coercition) sont parfois effectuées lors de l’exécution.



Par exemple essayons ceci :

var b:Boolean=1;
trace(b)
true

Ici, nous avons typé la variable b en tant que booléenne et nous l'avons valorisée d'une valeur numérique… On constate deux choses :

• un message d'avertissement dans la fenêtre erreur de compilation :

Warning: 3590: int utilisée alors qu'une valeur booléenne est attendue. L'expression va être transtypée comme booléenne.


• malgré tout, le code est exécuté et nous récupérons bien une valeur booléenne…

Autrement dit, à la compilation (quand notre code d'être humain a été traduit pour le lecteur Flash) une incohérence a été décelée et nous en sommes avertis, mais à l'exécution b a été converti17). On parle de conversion implicite puisqu'elle a eu lieu sans que nous le demandions clairement, explicitement.
Pour convertir explicitement il aurait fallut écrire… vous le savez… c'est le chapitre précédent…

var b:Boolean=Boolean(1);


Ça aussi c'est farfelu comme écriture, ce n'est que pour les besoins de la démonstration, faisons plus proche de la réalité :

var chiffre:int=1;
var b:Boolean=Boolean(chiffre);
trace(b)


Donc, si on ne fait pas la conversion nous même, elle est faite de façon automatique à l'exécution, comme le dit l'extrait de doc plus haut.
Et comme flash est bon gars, il nous en avertit au cas où ça nous aurait échappé… 8-)

En revanche avec l'exemple choisi pour illustrer le chapitre conversion, on ne pouvait pas aller plus loin c'est une erreur qui était déclenchée, souvenez vous :

var toto:String="45";
trace (toto*2);
1067: Contrainte implicite d'une valeur du type String vers un type sans rapport Number.



Paramètres avancés : mode strict

L'erreur est signalée à la compilation parce que la compilation a lieu en mode strict. C'est une préférence par défaut.
Choisissez Paramètres de publication du menu Fichier :



Si vous décochez la case 'mode précis' vous constatez que, en fin de compte, la conversion implicite a bel et bien eu lieu, on récupère 90 dans la fenêtre de sortie.

La doc :
Pour les types primitifs, les conversions implicites sont gérées en appelant les mêmes algorithmes de conversion internes appelés par les fonctions de conversion explicite.


Vous pourriez donc être tentés de décocher cette case, mais ce n'est pas une bonne idée : l'argument marche dans les deux sens, si ce sont les mêmes algo qui sont utilisés, c'est pas plus lourd de le faire nous même, et au moins on sait ce qu'il se passe. Et puis surtout, quelque fois ça passe la compilation, mais pas l'exécution et vous vous retrouvez avec une erreur à l'exécution, à laquelle il faudra bien circonvenir :

function test(pClip:MovieClip) {
	trace("je passe");
}
var c:int=12;
test(c);


TypeError: Error #1034: Echec de la contrainte de type : conversion de 12 en flash.display.MovieClip impossible at pourTest_fla::MainTimeline/frame1()


… ou pire, pas d'erreur mais un résultat erroné…


• Ce qui est valable pour les variables est valable pour les paramètres des fonctions qui se comportent tout pareil : ne pas typer les paramètres, c'est les typer en void.
Ici j'ai multiplié les facteurs de risque : je ne type pas et je décoche la case 'mode précis' :

function test(pChiffre) {
	trace(pChiffre+6);
}
var toto:String=45;
test(toto);
456



Je passe une chaine là où j'attendais un entier, il se trouve que l'opérateur + (plus) employé avec des chaines les concatène (mettre bout à bout)18), du coup on ne récupère pas du tout ce à quoi on s'attendait, mais il n'y pas d'erreur signalée, nous ne nous rendrons compte de l'embrouille que bien plus tard, quand le programme commencera à faire n'importe quoi …


Paramètres avancés : mode avertissement

Notez que vous pouvez aussi activer ou non les avertissements en cochant, ou non, la case 'Mode avertissements'. Sur ce coup là, rien à ajouter… Une fois n'est pas coutume, profitez-en :p

Portée des variables

Enfin pour terminer, un petit mot de la portée des variable, on parle aussi de visibilité.

Les variables déclarées en dehors des fonctions sont visibles (lisibles, utilisables) partout dans le code, on dit qu'elles sont globales, alors que les variables déclarées dans une fonction sont visibles uniquement dans la fonction considérée, on dit qu'elles sont locales.

Par exemple :

var uneVariableGlobale:int=10;
trace("avant test, la globale :");
trace(uneVariableGlobale);
test();
trace("après test, la globale :");
trace(uneVariableGlobale);
 
function test():void {
	trace("je passe dans test");
	trace(uneVariableGlobale);
	trace("je modifie la globale");
	uneVariableGlobale=3;
}
avant test, la globale :
10
je passe dans test
10
je modifie la globale
après test, la globale :
3


On constate que uneVariableGlobale, peut être lue et valorisée aussi bien dans la fonction qu'à l'extérieur.

Sur cet exemple j'ai abusé des traces.
Sachez qu'on peut mélanger du texte et une ou plusieurs variables dans la fonction trace à l'aide de l'opérateur + (plus). Je l'ai dit à l'instant, cet opérateur lorsqu'il est utilisé avec des chaines, les concatène (on y reviendra). Et comme cette fonction est plutôt très douée, elle transforme tout ce qu'on lui passe en chaine afin de pouvoir l'écrire dans la fenêtre de sortie.
On peut donc écrire des choses de ce genre là :

var uneVariableGlobale:int=10;
trace("avant test, la globale : "+uneVariableGlobale);
test();
trace("après test, la globale : "+uneVariableGlobale);
 
function test():void {
	trace("--> dans test la globale : "+uneVariableGlobale);
	trace("--> je modifie la globale");
	uneVariableGlobale=3;
}
avant test, la globale : 10
--> dans test la globale : 10
--> je modifie la globale
après test, la globale : 3



var uneVariableGlobale:int=10;
trace("avant test, la globale : "+uneVariableGlobale);
test();
trace("après test, la globale : "+uneVariableGlobale);
trace("après test, la locale : "+uneLocale);
 
function test():void {
	var uneLocale:int=98;// une variable déclarée dans la fonction qui ne sera visible que dans la fonction
	trace("--> dans test la globale : "+uneVariableGlobale);
	trace("--> je modifie la globale");
	uneVariableGlobale=3;
}

Si vous exécutez ce code en mode strict, vous déclenchez une splendide erreur à la compilation :

1120: Accès à la propriété non définie uneLocale




Si vous êtes restés en mode standard (pas strict), l'erreur, c'est à l'exécution qu'elle est générée.

avant test, la globale : 10
--> dans test la globale : 10
--> je modifie la globale
après test, la globale : 3
ReferenceError: Error #1065: La variable uneLocale n'est pas définie.
	at pourTestToutVenant_fla::MainTimeline/frame1()


Le code est exécuté normalement, sans rien vérifier à la compilation :
La fonction test est invoquée, la variable uneLocale déclarée et initialisée, mais en sortie de fonction cette variable est supprimée de la mémoire de l'ordinateur, c'est comme si elle n'avait jamais existé. Le programme continue de s'exécuter passe à la ligne qui suit l'appel à test, arrive sur le dernier trace et là, très logiquement, ne trouve pas la variable qu'on lui demande de tracer (pour cause elle n'existe plus) et l'erreur est déclenchée.

Si vous avez coché autoriser le debug dans les paramètres de publication, vous aurez en plus le numéro de ligne où l'erreur s'est produite.

N'hésitez pas à vous convaincre du principe en pistant le déroulement des opération à l'aide du débug.

Dernières petites choses en vrac

Raccourcis clavier

Je vous ai signalé en au fur et à mesure les séquences de caractères qui permettent de “pré-écrire” le code. Esc-f-n, pour function ; esc-t-r, pour trace…
Pour en connaitre la liste, à défaut les repérer, sélectionnez l'item Touches de raccourci Echap dans le menu de la fenêtre action.



Options de la fenêtre de sortie


Si le panneau de sortie s'obstinait à rester vierge, vérifiez que l'option détail est bien cochée ;)

Vers la suite

Et bien ça y est ! Vous voilà au point pour commencer à jouer vraiment avec Flash et AS3, toutes ces notions nous allons avoir largement le loisir de les mettre en œuvre dans les chapitres qui suivent et utiliser des variables et des fonctions autrement qu'en s'ébaudissant devant quelques malheureuses lignes dans la fenêtre de sortie…

L'étape suivante, c'est poser des boutons et des clips sur la scène et permettre l'interaction, si ça vous dit, on se retrouve là pour la suite :).

Si vous êtes un(e) vrai(e) novice et que vous ne connaissez de Flash, rien de plus que ce qui est préconisé dans les prérequis d'introduction, il va tout de même vous falloir faire un bref détour par cette parenthèse qui prend le temps de poser les deux trois choses à savoir pour suivre la suite des péripéties ;)
1) sur ce coup là on ne peut pas faire autrement, mais on a dit qu'on prenait de bonnes habitudes
2) je ne sais pas vous, mais moi j'aime bien vérifier ce qu'on me raconte, ce n'est pas de la défiance, c'est… une forme de curiosité ;)
3) un clip très souvent mais aussi des champs texte, des “valeur”, des occurrences de composant, des noms d'étiquette d'image, d'utilisateur, de fichier… tout et n'importe quoi, tout ce qu'on est appelé à manipuler
4) comme variable
5) ou presque il ne faut pas non plus que ce soit les cinq tomes de la recherche du temps perdu ;-)
6) ce qu'elle vaut(représente)
7) int, uint, d'utilisation courante
8) et si vous voulez les voir , de vous yeux voir, essayez trace(Number.MAX_VALUE) trace(Number.MIN_VALUE)
9) parce qu'il y a différentes formules pour obtenir le volume d'un tonneau
10) même principe que pour trace
11) sept que divise deux : trois et il reste 1
12) vingt-huit que divise cinq : cinq et il reste 3
13) douze que divise six : deux et il ne reste rien
14) menu Déboguer
15) je n'écris pas var résultat:String = trace etc
16) souvent une variable
17) transtypée, étymologiquement “par delà le type”
18) on y reviendra plus tard