ActionScript : Répétant une opération beaucoup de fois

Share

|

Vous voulez exécuter des temps multiples d'un charger dans une armature simple.

Employez une boucle pour exécuter la même chose chargent des périodes multiples dans une armature simple. Par exemple, vous pouvez employer a pour le rapport :

pour (variété i = 0 ; i < 10 ; i++) {// 
affichage la valeur du trace(i) de i. ; }

Quand vous voulez exécuter les mêmes d'action (ou légères variations temps multiples en) dans une armature simple, employez un rapport faisant une boucle pour rendre votre code plus succinct, plus facile à lire, et plus facile à mettre à jour. Vous pouvez employer un rapport de moment ou un a pour le rapport à cette fin, mais généralement a pour le rapport est le choix meilleur. Les deux rapports réalisent le même résultat, mais pour le rapport est plus compact et plus familier à la plupart des programmeurs.

La syntaxe de a pour le rapport se compose de cinq parts de base :

Pour le mot-clé

Chaque pour le rapport doit commencer par a pour le mot-clé.

Expression d'initialisation

La boucle utilise typiquement une variable d'index (a.k.a. un compteur de boucle) qui est initialisée quand le rapport est d'abord produit. L'initialisation est exécutée seulement une fois indépendamment de combien de fois la boucle est répété.

Examinez l'expression

Une boucle devrait inclure une expression d'essai qui renvoie vrai ou faux. L'expression d'essai est évaluée une fois chaque fois par la boucle. Généralement, l'expression d'essai compare la variable d'index à une autre valeur, telle qu'un nombre maximum des itérations de boucle. L'expression globale doit évaluer pour rectifier pour pour que le corps du rapport s'exécute (contrastez ceci avec a . . . tandis que boucle, qui s'exécute au moins une fois, même si l'expression d'essai est fausse). D'autre part, si l'expression d'essai ne devient jamais fausse, vous créerez une boucle infinie, ayant pour résultat un avertissement que le joueur instantané court lentement (qui apparaît après 15 secondes).

Expression de mise à jour

L'expression de mise à jour met à jour habituellement la valeur de la variable utilisée dans l'expression d'essai de sorte que, à un certain point, l'expression d'essai devienne fausse et les extrémités de boucle. L'expression de mise à jour est exécutée une fois chaque fois par la boucle. Une boucle infinie est souvent provoquée par ne met pas à jour la variable appropriée dans l'expression de mise à jour (habituellement la même variable utilisée dans l'expression d'essai).

Corps de rapport

Le corps de rapport est un bloc de substatements inclus dans les croisillons bouclés qui est exécuté chaque fois par la boucle. Si l'expression d'essai n'est jamais vraie, pour le corps du rapport ne sera pas exécuté.

Pour le mot-clé devrait venir d'abord, et il devrait être suivi de l'initialisation, de l'essai, et des expressions de mise à jour jointes entre parenthèses. Les points-virgule doivent séparer les trois expressions les uns des autres (bien que l'initialisation, l'essai, et les rapports de mise à jour soient facultatifs, les points-virgule sont obligatoires). Le reste du pour la boucle se compose de corps de rapport inclus dans les croisillons bouclés. La forme générale est :

pour (initialisation ; essai ; mise à jour) 
{corps de rapport}

Voici un exemple de a pour le rapport qui produit les numéros 0 à 999. Puisque la variable i d'index est une variable locale, nous la préfaçons avec le mot-clé de variété dans l'expression d'initialisation.

pour (variété i = 0 ; i < 1000 ; i++) 
{trace(i) ; } trace ("qui est l'extrémité.") ;

Pour comprendre pour le rapport, vous pouvez suivre avec l'interprète d'ActionScript en tant que lui traite la commande. Dans l'exemple précédent, pour le mot-clé dit l'interprète d'exécuter les rapports dans pour la boucle aussi longtemps que l'expression conditionnelle est vraie. L'expression d'initialisation est exécutée seulement une fois, et elle place la variable i à 0. Après, l'interprète vérifie l'expression d'essai (I < 1000). Puisqu'I est 0, qui est moins de 1000, l'expression évalue pour rectifier et l'action de trace() dans pour le corps de rapport est exécutée. L'interprète d'ActionScript exécute alors le rapport de mise à jour, dans ce cas-ci i++, qui des incréments i par 1. L'interprète répète alors le processus à partir du dessus de la boucle (mais saute l'étape d'initialisation). Ainsi l'interprète vérifie encore si l'expression d'essai est vraie et, si oui, exécute le corps de rapport encore. Il exécute alors le rapport de mise à jour encore. Les répétitions de ce processus jusqu'à l'expression d'essai n'est plus vraie. La dernière valeur montrée dans la fenêtre de rendement est 999, parce qu'une fois qu'I est incrémenté à 1000, l'expression d'essai n'évalue plus pour rectifier et la boucle se termine. Une fois que la boucle se termine, l'exécution continue avec quelque commandes suivent la boucle.

Les expressions d'initialisation et de mise à jour peuvent inclure des actions multiples séparées par des virgules. D'exemple les incréments suivants simultanément i et décroissances j, et affichages leurs valeurs dans la fenêtre de rendement :

pour (variété i = 0, j = 10 ; i < 10 ; i++, 
--) de j {le trace("i est" + i) ; le trace("j est" + j) ; 
}

L'exemple précédent n'est pas identique qu'en utilisant deux nichés pour des rapports (qui est montré dans le prochain bloc de code).

C'est également terrain communal à l'utilisation nichée pour des rapports. Quand vous employez niché pour le rapport, employez une variable différente d'index que cela utilisé dans l'extérieur pour la boucle. Par convention, l'extérieur pour la boucle emploie la variable i, et niché pour la boucle emploie le j variable. Par exemple :

pour (variété i = 1 ; i < = 3 ; i++) {pour 
(variété j = 1 ; j < = 2 ; j++) {trace(i + "X" + j + "="
+ (I * j)) ; }}

L'exemple précédent montre la table suivante de multiplication dans la fenêtre de rendement :

1 X 1 = 1 1 X 2 = 2 2 X 1 = 2 2 X 2 = 4 3 X 1 = 3 3 X 2 = 
6

Il est possible de nicher les niveaux multiples de pour des rapports. Par convention, chaque niveau additionnel de l'emboîtement emploie la prochaine lettre comme variable d'index. Par conséquent, le troisième niveau d'niché pour des rapports emploie typiquement k comme variable d'index :

pour (variété i = 1 ; i < = 3 ; i++) {pour 
(variété j = 1 ; j < = 3 ; j++) {pour (variété k = 1 ;
k < = 3 ; k++) {trace(i + "X" + j + "X" + k + "=" + (I * j
* k)) ; }}}

En plus, vous pouvez employer pour des rapports pour faire une boucle vers l'arrière :

//compte vers l'arrière de 10 à 1. pour (variété i = 
10 ; i > 0 ; --) i {trace(i) ; }

Vous ne devriez pas employer a pour le rapport pour exécuter charge le temps fini.

Beaucoup de programmeurs font l'erreur de l'essai d'employer pour des rapports pour animer des agrafes de film. Par exemple :

pour (variété i = 0 ; i < 20 ; i++) 
{myMovieClip._x + = 10 ; }

Bien que le code précédent déplace les Pixel de l'agrafe 200 de film à la droite de son point de départ, toutes les mises à jour ont lieu dans la même armature. Il y a deux problèmes avec ceci. Tout d'abord, les mises à jour d'étape seulement une fois par armature, ainsi seulement la dernière mise à jour est montrées sur l'étape (faisant sauter l'agrafe de film 200 Pixel soudainement plutôt que de se déplacer sans à-coup 20 étapes). Et en second lieu, même si l'étape met à jour plus souvent, chaque itération par pour la boucle prend seulement quelques millisecondes, ainsi l'animation se produirait trop rapidement. Pour des actions que vous voulez avoir lieu avec le temps, employez un traiteur d'onEnterFrame().

D'ailleurs, des boucles de répétition serrées ne devraient pas être employées pour effectuer des processus prolongés (quelque chose qui prennent plus qu'une fraction d'une seconde). Le joueur instantané montre un avertissement toutes les fois qu'une boucle simple s'exécute pendant plus de 15 secondes. Employer un traiteur d'onEnterFrame() ou la fonction de setInterval() évite le message d'avertissement et permet au flash d'effectuer d'autres actions en plus des actions répétées qui font partie de la boucle.