Forums Développement Multimédia

Les formations Mediabox
Les formations Mediabox

Créer un diaporama pas à pas - 7 - Préchargements des images - 1 - this, tableaux et boucles for

Compatible ActionScript 2. Cliquer pour en savoir plus sur les compatibilités.Par lilive (Olivier Tarasse), le 25 août 2008

Présentation

Cette série de tutoriaux, à l'usage des débutants en ActionScript 2, présente des notions fondamentales de programmation par le biais de la réalisation d'un diaporama en ligne.

Si vous n'êtes pas intéressés par la création d'un diaporama, mais par la technique du préchargement de plusieurs MovieClips, vous pouvez également suivre cet article sans problème.

Si vous lisez cet article pour apprendre certaines notions de programmation, vous pouvez directement vous rendre aux sections suivantes:

Pour ceux qui suivent la construction du diaporama, sachez que nous allons temporairement mettre de côté le code que nous avions jusque là, pour y voir plus clair. Créez une copie de votre document de travail et effacez-en tout le code. Nous allons travailler sur cette copie. Nous nous occuperons plus tard des boutons, barres de progression et fondus enchaînés.

Cet article introduit donc les boucles for et les tableaux. Si vous n'avez jamais utilisé ces notions, vous allez voir que sans être compliqué, cela représente un bon morceau à digérer :-D. L'effort en vaut la chandelle puisque cela ouvre bien des possibilités, et je ne pense pas qu'on puisse en faire l'économie si on veut apprendre à programmer. J'ai ajouté des exercices de difficulté progressive, en espérant que cela aiderait à s'approprier ces nouveautés. Je vous souhaite bonne lecture, et vous rappelle que vous pouvez poser des questions ou faire vos remarques sur ces explications.


Objectif

Nous avons dans les dernières parties travaillé au chargement des images et à l'affichage de barres de progression du téléchargement. Nous en sommes arrivé à ce résultat:

L"extension Adobe Flash Plugin est nécessaire pour afficher ce contenu.

Quand l'utilisateur demande à voir une autre image, celle-ci se charge automatiquement dans le diaporama. Si ce chargement dure plus de une seconde, une barre de progression apparaît pour informer l'utilisateur de sa progression.

Mais nous pourrions épargner du temps d'attente à l'utilisateur et augmenter son confort en n'attendant pas qu'il demande à voir une image pour la télécharger: nous pourrions dès le démarrage télécharger toutes les images une fois pour toute dans le diaporama, et les y conserver pour qu'elles soient immédiatement disponibles.

Une telle opération s'appelle préchargement (preloading en anglais), et fait le but de cette partie. Voyez la nouvelle version du diaporama que nous allons confectionner, si vous voulez bien me suivre:

L"extension Adobe Flash Plugin est nécessaire pour afficher ce contenu.

Remarque:

Une deuxième technique de préchargement consiste à charger toutes les images dès le démarrage, mais à ne pas les conserver dans le diaporama en les déchargeant aussitôt. Ainsi, quand l'utilisateur demande l'affichage d'une image, celle-ci va se recharger beaucoup plus rapidement car elle est déjà présente dans le cache du navigateur (comme nous l'avons vu en cinquième partie).

Cette technique à l'avantage d'économiser les ressources de l'ordinateur, en ne conservant pas toutes les images dans la mémoire vive.

Nous n'utiliserons pas cette technique pour privilégier la fluidité du défilement rapide des images: comme toutes les images sont en mémoire, il est possible de feuilleter très rapidement le diaporama ci-dessus. Ceci ne serait pas le cas avec la deuxième technique, car même mises en cache leurs temps de chargements resteraient sensibles (c'est ce qu'on obtient avec le diaparama précédent après que toutes les images aient été vues une fois).


I - Créer les MovieClips pour toutes les images - Les boucles for

Pour commencer, et puisqu'il s'agit de charger et de conserver simultanément toutes les images, nous allons créer autant de MovieClips qu'il y a d'images dans le diaporama.

Pour créer les deux MovieClips que nous utilisions pour charger et afficher les images nous faisions jusque-là:

this.createEmptyMovieClip("image1",this.getNextHighestDepth());
this.createEmptyMovieClip("image2",this.getNextHighestDepth());

(L'utilisation de createEmptyMovieClip a été vue en première partie de cette série de tutoriaux, celle de getNextHighestDepth en deuxième partie)

Nous pourrions répéter ces lignes autant de fois qu'il y a d'images, en faisant:

this.createEmptyMovieClip("image1",this.getNextHighestDepth());
this.createEmptyMovieClip("image2",this.getNextHighestDepth());
this.createEmptyMovieClip("image3",this.getNextHighestDepth());
this.createEmptyMovieClip("image4",this.getNextHighestDepth());
this.createEmptyMovieClip("image5",this.getNextHighestDepth());

Ceci pour 5 images. Cela semble déjà un peu lourd à écrire, alors que dire s'il y avait 40 images?

D'où cette mystérieuse partie du titre :-) : Les boucles for.

1- Les boucles for

En programmation, on utilise le mot boucle pour désigner une opération qui se répète un certain nombre de fois. ActionScript 2 offre plusieurs façons de réaliser des boucles. La première que nous allons aborder s'appelle la boucle for.

Créez un nouveau document et entrez le code suivant:

trace("La boucle va démarrer...");
for (var i:Number = 0; i < 5; i++) {
	trace("La variable i vaut " + i);
}
trace("La boucle est terminée.");

Exécutez, vous devriez obtenir en sortie:

La boucle va démarrer...
La variable i vaut 0
La variable i vaut 1
La variable i vaut 2
La variable i vaut 3
La variable i vaut 4
La boucle est terminée.

L'instruction for annonce à flash qu'il y a ici une boucle et qu'il va devoir répéter un certain nombre de fois le bloc d'instructions compris entre les deux accolades { et } .

La boucle est contrôlée par une variable, qu'ici nous avons choisi d'appeler i. La partie de code suivant le for, entre parenthèses, détaille le fonctionnement de la boucle et se divise en trois parties séparées par des points-virgules:

  • var i:Number = 0

Ceci sera exécuté une fois seulement, au démarrage de la boucle. Une variable i de type Number est déclarée et initialisée à la valeur 0.

  • i < 5

Cette expression sera évaluée avant chaque exécution de la boucle. Si le résultat de cette évaluation est vrai, le bloc d'instructions est exécuté. Si le résultat est faux, la boucle s'arrête et flash passe à l'exécution de la suite du code.

  • i++

Cette partie, qui fait augmenter i de la valeur 1, est exécutée à chaque fois que la boucle se termine.Pour en savoir plus sur les boucles for vous pouvez lire:

  • Aide de Flash > Formation à ActionScript 2.0 dans Adobe Flash > Eléments fondamentaux du langage et de la syntaxe > Présentation des instructions > Répétition d'actions à l'aide de boucles > Utilisation des boucles for.
  • Aide de Flash > Référence du langage ActionScript 2.0 > Eléments du langage ActionScript > Instructions > Instruction for.
  • Cet article du siteduzero.

2- Exercices

Voici quelques exercices d'utilisation des boucles for, si vous souhaitez vous habituer à leur utilisation. Voyez les solutions en pièce jointe en bas de page 1) .

  • Ecrire un programme qui affiche tous les multiples de 2 de 0 jusqu'à 10: Les nombres 0, 2, 4, 6, 8 et 10 doivent s'afficher les uns en dessous des autres dans la fenêtre de sortie.
  • Ecrire un programme qui affiche tous les multiples de 2 de 0 jusqu'à 10, sur une même ligne: “0 2 4 6 8 10” doit s'afficher sur une même ligne dans la fenêtre de sortie.
  • Ecrire un programme qui affiche “X” sur la première ligne, “XX” sur la deuxième ligne, “XXX” sur la troisième ligne, et ainsi de suite jusqu'à “XXXXXXXXXX”.
  • Ecrire un programme qui affiche les nombres de 10 jusqu'à 0, dans l'ordre décroissant.
  • Ecrire un programme qui affiche tous les multiples de 2 de 0 jusqu'à 10, puis de 100 jusqu'à 110, puis de 200 jusqu'à 210, etc , puis de 900 jusqu'à 910: Les nombres 0, 2, 4, 6, 8, 10, 100, 102, 104, 106, 108, 110, 200, 202, 204, … , 906, 908, 910 doivent s'afficher les uns en dessous des autres dans la fenêtre de sortie. Indice: Pour ce programme vous aurez besoin de deux boucles for, l'une contenue dans l'autre: on parle dans ce cas de boucles imbriquées.
  • Ecrire un programme qui affiche “0”, puis “100” et “101”, puis “200”, “201” et “202”, puis “300”, “301”, “302”, “303”, etc. Vous aurez ici aussi besoin de boucles imbriquées.

3- Une erreur classique

Il faut être vigilant quand on utilise des boucles: une mauvaise condition d'arrêt de la boucle peut conduire à une boucle infinie, c'est-à-dire à une boucle qui s'exécute sans jamais s'arrêter.

Par exemple…

for (var i:Number = 0; i >= 0; i++) {
	trace(i);
}

… introduit une boucle infinie car i sera toujours supérieur ou égal à 0, et la boucle ne s'arrêtera pas.

Le symptôme d'une boucle infinie est que le programme ne répond plus pendant un certain temps, tout occupé à l'exécution répétitive de la boucle des centaines de milliers de fois. Au bout d'un certain temps le message suivant est affiché à l'écran: “Un script de cette animation ralentit l'exécution de Flash Player. Si l'exécution n'est pas suspendue, il est possible que votre ordinateur ne réagisse plus. Souhaitez-vous abandonner l'exécution du script?”

Il est conseillé de répondre “oui” à la question, puis d'aller vérifier dans son code qu'il n'y a pas quelque part une boucle infinie.

4- Utiliser la boucle for pour créer les MovieClips

Mettez de côté le diaporama que nous avions obtenu à la fin de la sixième partie en créant une copie de votre document de travail. Nous allons travailler sur cette copie, en laissant l'original intact.

Pour commencer effacez tout le code de ce nouveau document. Pour ceux qui ne suivent pas cette série de tutoriaux et ne veulent pas réaliser un diaporama, créez simplement un document vierge.

Pour créer 4 MovieClips appelés image0, image1, image2 et image3 nous n'avons qu'à écrire:

for (var iImage:Number = 0; iImage < 4; iImage++) {
	this.createEmptyMovieClip("image" + iImage, this.getNextHighestDepth());
}

Comme vous le voyez, j'ai choisi d'appeler la variable iImage (index de l'Image). Notons au passage que cette variable est locale à la boucle, et n'existera plus une fois la boucle terminée.

Et pour pouvoir facilement modifier par la suite le nombre d'images du diaporama, introduisons une nouvelle variable:

var nbrImages:Number = 4;
for (var iImage:Number = 0; iImage < nbrImages; iImage++) {
	this.createEmptyMovieClip("image" + iImage, this.getNextHighestDepth());
}

Une variable de ce genre, dont la valeur ne varie pas lors de l'exécution du programme, s'appelle une variable constante. Certains langages de programmation offrent la possibilité de spécifier qu'une variable est constante, est qu'il n'est pas possible de changer sa valeur plus tard. Ceci permet d'éviter des erreurs. ActionScript 2 n'offre pas cette possibilité.

Il est préférable d'utiliser une variable plutôt que d'écrire le chiffre 4 à chaque fois qu'on a besoin d'utiliser le nombre d'image dans le code. En effet, si on décide par la suite de mettre 8 images dans le diaporama plutôt que quatre, il suffira de changer la valeur de nbrImages au début du code.


II - Enfin quelques éclaircissements sur this

Comme c'était le cas jusqu'à maintenant, nous allons avoir besoin dans la suite du code de faire référence aux MovieClips créés: pour y charger les images, pour faire varier leur opacité lors des fondus, etc.

Nous savons les noms de ces MovieClips: image0, image1, image2, …

Nous savons que si this fait référence à la scène, this[“image0”] fait référence au MovieClip nommé image0 placé sur la scène (voir première partie). Nous pourrions essayer de nous contenter de cela.

Mais il se trouve que this ne fait pas toujours référence à la scène. Je n'ai pas parlé encore de ce point un peu délicat. Voici ce que nous apprend l'Aide de Flash > Référence du langage ActionScript 2.0 > Eléments du langage ActionScript > propriétés globales > this, propriété:

Citation:
this fait référence à un objet ou une occurrence de clip. Lorsqu'un script s'exécute, this référence l'occurrence de clip qui contient le script. Lorsqu'une méthode est appelée, this contient une référence à l'objet qui contient la méthode appelée.

C'est-à-dire que pour le code placé sur la première image du scénario, et exécuté au lancement du programme, this est bien une référence à la scène.

Si, à la suite de notre boucle, nous codons…

trace(this["image0"]._visible);

… nous obtenons en sortie la valeur de la propriété _visible du MovieClip nommé image0 contenu dans la scène, c'est-à-dire “true”.

Mais si nous codons…

unBouton.onPress = function () {
	trace(this["image0"]._visible);
}

… quand on clique sur le bouton, la méthode onPress s'exécute. this fait alors référence à l'objet qui contient la méthode, c'est-à-dire le MovieClip du bouton. this[“image0”] fait donc référence à un MovieClip nommé image0 contenu dans le MovieClip du bouton, et un tel MovieClip n'existe pas. En sortie nous obtiendrons un “undefined”.

D'où l'avantage de la stratégie que nous utilisions jusque-là qui était de faire:

var imageMC:MovieClip = this["image0"];
unBouton.onPress = function () {
	trace(imageMC._visible);
}

A l'exécution de la première ligne this désigne la scène, donc imageMC fait donc référence au MovieClip nommé image0 sur la scène.
Au clic sur le bouton, on obtient bien en sortie la valeur de la propriété _visible de ce MovieClip.


III - Les tableaux

Revenons à nos MovieClips créés lors de la boucle. Pour faire référence à ces MovieClips, nous allons avoir besoin d'autant de variables de type MovieClip qu'il y a de MovieClips créés.

Disons que nous avons une variable de type Number, nommée imageActuelle, qui contient le numéro de l'image que demande à voir l'utilisateur. Nous aurons besoin de pouvoir utiliser la imageActuelle-ième variable pour faire référence au MovieClip correspondant. Si par exemple imageActuelle vaut 3, et que les images sont numérotées à partir de 0, il nous faudrait utiliser la quatrième variable de type MovieClip, qui fait référence à la quatrième image, pour pouvoir la faire apparaître.

Cette situation se résout typiquement par l'usage de ce qu'on appelle un tableau indexé.

1- Présentation des tableaux indexés

En ActionScript 2, un tableau s'appelle Array.
Un objet de type Array est un ensemble ordonné de variables. Chaque variable du tableau est accessible grâce au numéro de sa position dans le tableau, appelé index.

Par exemple:

// Déclaration du tableau:
var unTableau:Array = new Array();
// Affectation de valeurs aux trois premiers éléments:
unTableau[0] = "Ceci est le premier élément du tableau";
unTableau[1] = "Ceci est le deuxième élément";
unTableau[2] = "Et voici le troisième et dernier élément";
// Utilisation des éléments définis:
trace(unTableau[0]);
trace(unTableau[1]);
trace(unTableau[2]);

Ce programme affiche dans la fenêtre de sortie:

Ceci est le premier élément du tableau
Ceci est le deuxième élément
Et voici le troisième et dernier élément

Dans cet exemple, le tableau unTableau est un ensemble de trois variables (trois éléments) contenant chacune une chaîne de caractère.

var unTableau:Array déclare une nouvelle variable de type tableau. Nous avons alors une variable qui peut faire référence à un tableau, mais aucun tableau n'est encore créé.
new Array() crée un objet de classe Array, c'est-à-dire un tableau. Le tableau est encore “vide” et ne contient aucun élément.
var unTableau:Array = new Array() déclare donc une nouvelle variable de type tableau, crée un objet tableau, et initialise la variable avec ce tableau.

On accède à chaque élément du tableau en écrivant le nom de la variable qui fait référence au tableau suivi de son index entre des crochets [ et ].
Ainsi unTableau[0] est la première variable du tableau, unTableau[1] est la deuxième variable, et unTableau[2] est la troisième.

En ActionScript, les éléments d'un tableau ne sont pas strictement typés (voir première partie). On peut mettre dans ces éléments tout type de contenu: des chaînes de caractère (comme dans l'exemple), des nombres, des booléens, des références à des MovieClip, …

var unAutreTableau:Array = new Array();
// Définition d'éléments de types différents
unAutreTableau[0] = "Bonjour";	// Le premier élément est une chaîne
unAutreTableau[1] = 248;	// Le deuxième élément est un nombre
unAutreTableau[2] = true;	// Le troisième élément est un booléen
unAutreTableau[3] = this;	// Le quatrième élément est une référence à un MovieClip (la scène)
 
// Utilisation des éléments, selon leur type:
 
unAutreTableau[0] = unAutreTableau[0] + " le chien";
trace(unAutreTableau[0]);	// Affiche "Bonjour le chien"
 
unAutreTableau[1] += 12;
trace(unAutreTableau[1]);	// Affiche 260
 
unAutreTableau[2] = !unAutreTableau[2];
trace(unAutreTableau[2]);	// Affiche "false"
 
unAutreTableau[3].lineStyle(4, 0xff0000, 100);
unAutreTableau[3].moveTo(0,0);
unAutreTableau[3].lineTo(100,100); // Dessine une ligne sur la scène

Nous utilisons dans cet exemple chaque élément du tableau selon son type:

  • Le premier élément est une chaîne de caractères, nous lui ajoutons une autre chaîne (voir 2ième partie)
  • Le deuxième élément est de type Number, nous lui ajoutons le chiffre 10 (voir 4ième partie pour la signification de +=)
  • Le troisième élément est de type Boolean, nous en prenons la négation (voir 5ième partie pour l'utilisation de l'opérateur !)
  • Le quatrième élément est de type MovieClip, nous y dessinons une ligne (voir 5ième partie)

Pour finir, remarquons que la numérotation des éléments d'un tableau commence à 0. Une conséquence est que pour un tableau contenant 4 éléments, l'index du dernier élément est 3 et non pas 4, ce qui est source d'erreur pour les débutants.

2- Exercices

Pour se faire à l'utilisation des tableaux, quelques exercices dont les solutions sont en pièce jointe 2) :

  • Ecrire un programme qui déclare un tableau et définit ses 10 premiers éléments comme étant les nombres 0, 100, 200, 300, …, 900. Indice: utiliser une boucle for.
  • Rajouter au précédent programme l'affichage des éléments sous la forme “L'élément i à pour valeur xxx”: “L'élément 0 à pour valeur 0”, “L'élément 1 à pour valeur 100”, etc.
  • Modifier le programme précédent pour donner aux 9 premiers éléments les valeurs 19, 28, 37, 46, 55, 64, 73, 82, 91.
  • Ajouter au programme précédent une fonction qui fait la somme des éléments du tableau et affiche: “La somme des éléments du tableau est xxx” (où xxx est le résultat calculé).

Pour en savoir plus sur les tableaux, voir:

  • Aide de Flash > Formation à ActionScript 2.0 dans Adobe Flash > Eléments fondamentaux du langage et de la syntaxe > Présentation des tableaux.
  • Aide de Flash > Référence du langage ActionScript 2.0 > Classes ActionScript > Array.

3- Dans notre cas

Ce qui nous intéresse pour le diaporama, c'est de créer un tableau d'éléments de type MovieClip.

var nbrImages:Number = 4;
var imagesMC:Array = new Array();
for (var iImage:Number = 0; iImage < nbrImages; iImage++) {
	imagesMC[iImage] = this.createEmptyMovieClip("image" + iImage, this.getNextHighestDepth());
}

Ce qui crée quatre éléments dans le tableau qui font chacun référence à un MovieClip créé:

  • imagesMC[0] fait référence au MovieClip nommé image0,
  • imagesMC[1] fait référence au MovieClip nommé image1,
  • imagesMC[2] fait référence au MovieClip nommé image2,
  • imagesMC[3] fait référence au MovieClip nommé image3.


IV - Le chargement de toutes les images

Les MovieClips qui vont accueillir les images sont créés. Nous allons maintenant voir comment charger successivement chaque image sans attendre que l'utilisateur demande à les voir.

Pour commencer, ajoutons le code suivant:

var loadingImage:Number = 0;
var mcl:MovieClipLoader = new MovieClipLoader();
mcl.loadClip("images/image0.jpg", imagesMC[0]);

Comme nous allons charger les images les unes à la suite des autres, en attendant que le chargement d'une image soit terminé avant de commencer à charger la suivante, nous déclarons une variable loadingImage qui sera l'index de l'image actuellement en cours de chargement. Puis nous demandons le chargement de la première image au MovieClipLoader.

Créons une fonction chargerImageSuivante qui demande le chargement de l'image suivant celle qui vient de se charger, et appelons cette fonction à chaque fois que le chargement d'une image est terminé:

function chargerImageSuivante() {
	// Lance le chargement de l'image suivante s'il reste des images à charger
	loadingImage++;
	if (loadingImage >= nbrImages) return; 
	mcl.loadClip("images/image" + loadingImage + ".jpg", imagesMC[loadingImage]);
}
var mclListener:Object = new Object();
mclListener.onLoadInit = function (mc:MovieClip) {
	mc._width = 400;
	mc._height = 300;
	chargerImageSuivante();
}
mcl.addListener(mclListener);

(L'utilisation de MovieClipLoader a été vue en 3ième partie de cette série de tutoriaux)

Si nous exécutons ce programme, nous voyons apparaître successivement les images chargées, qui s'affichent les unes par-dessus les autres. (Le code complet se trouve comme d'habitude en pièce jointe 3) ). Bien sûr ni les boutons ni les barres de progression ne marchent plus.


V - Le préchargement des images

Précharger les images veut dire “charger les images de façon transparente pour l'utilisateur (sans qu'il s'en aperçoive) pour qu'elles soient immédiatement disponibles plus tard”.

Pour l'instant les images s'affichent au fur et à mesure de leur chargement: notre chargement n'est pas encore “transparent”.

Nous allons y remédier, pour que notre chargement devienne vraiment un préchargement.

1- Cacher les images chargées

C'est très simple, il suffit de définir la propriété _visible de chaque MovieClip chargé sur false, à la fin de son chargement:

mclListener.onLoadInit = function (mc:MovieClip) {
	mc._width = 400;
	mc._height = 300;
	mc._visible = false;
	chargerImageSuivante();
}

2- Ajouter une propriété isLoaded à un MovieClip

Si nous exécutons le programme, nous ne voyons plus rien. Les images sont bien préchargées, reste à les utiliser.

Si nous voulons par la suite afficher une image, par exemple quand un bouton est pressé, nous devrons pouvoir tester si cette image a déjà été chargée. Si elle est chargée, nous pouvons l'afficher en définissant sa propriété _visible sur true. Si elle n'est pas encore chargée, le programme doit s'y adapter, en affichant par exemple une barre de progression du téléchargement.

Pour pouvoir tester si le chargement d'un MovieClip est terminé, nous ajouterons aux MovieClip chargés une nouvelle propriété booléenne nommée isLoaded, qui prendra la valeur true quand l'image est chargée. Comme ceci:

mclListener.onLoadInit = function (mc:MovieClip) {
	mc._width = 400;
	mc._height = 300;
	// Il suffit d'écrire ceci pour créer une nouvelle
	// propriété isLoaded et lui donner la valeur true:
	mc.isLoaded = true;
	mc._visible = false;
	chargerImageSuivante();
}

Ainsi, les MovieClips dont le chargement est terminé auront une propriété isLoaded de valeur true, et les MovieClips dont le chargement n'est pas terminé (ou n'a pas commencé) n'auront pas cette propriété.

Le test

if (imagesMC[3].isLoaded) ...

nous permettra par exemple de tester si la quatrième image est bien chargée pour pouvoir réagir en conséquence.


Conclusion

Le code de préchargement des images est terminé. Pour le fonctionnement du diaporama, il nous reste à adapter ce que nous avions déjà écrit à la nouvelle situation, pour retrouver l'usage des boutons, des barres de progression et du fondu enchaîné entre les images. Nous ferons cela dans l'article suivant.

Participez à l'amélioration de ce tutoriel grâce à vos commentaires. Vous pouvez laisser vos remarques sur le forum. Vous pouvez répondre au message concernant ce tutoriel ou ouvrir un nouveau sujet. (Même si vous n'avez pas de critiques particulières, vous pouvez laisser un message, cela me stimulera certainement à continuer l'écriture de cette série :-) ).


Pour en savoir plus

Pour avoir des précisions ou des renseignements complémentaires, vous pouvez consulter 4):

  • Au sujet des boucles for:
    • Aide de Flash > Formation à ActionScript 2.0 dans Adobe Flash > Eléments fondamentaux du langage et de la syntaxe > Présentation des instructions > Répétition d'actions à l'aide de boucles > Utilisation des boucles for.
    • Aide de Flash > Référence du langage ActionScript 2.0 > Eléments du langage ActionScript > Instructions > Instruction for.
    • Cet article du siteduzero.
  • Au sujet des tableaux
    • Aide de Flash > Formation à ActionScript 2.0 dans Adobe Flash > Eléments fondamentaux du langage et de la syntaxe > Présentation des tableaux.
    • Aide de Flash > Référence du langage ActionScript 2.0 > Classes ActionScript > Array.
  • Au sujet de this:
    • Aide de Flash > Référence du langage ActionScript 2.0 > Eléments du langage ActionScript > propriétés globales > this, propriété.
    • Aide de Flash > Formation à ActionScript 2.0 dans Adobe Flash > Gestion d'événements > Domaine du mot-clé this.
  • Au sujet des variables locales:
  • Au sujet des constantes:
    • Aide de Flash > Formation à ActionScript 2.0 dans Adobe Flash > Eléments fondamentaux du langage et de la syntaxe > Présentation des constantes et des mots-clés > Utilisation des constantes.


Navigation: Sommaire page précédente page suivante Index

1) , 2) , 3) Vous pouvez télécharger les fichiers de code correspondants à cet article, les swf compilés, et les images utilisées, le tout dans une archive compressée. Si vous utilisez Flash IDE, cliquez ici. Si vous utilisez un environnement intégrant mtasc et swfmill, cliquez ici
4) Les références à l'aide de Flash concernent la documentation de Flash CS3, accessible par l'IDE de Flash CS3 ou par le site d'Adobe (Support > Documentation).