ActionScript : Créer Le Code Réutilisable

Share

|

Vous voulez effectuer une série d'actions à de diverses heures sans code reproduisant inutilement dans tout votre film.

Créez une fonction et puis appelez-(c.-à-d., appelez) la de nom toutes les fois que vous devez exécuter ces actions.

Il y a davantage que l'one-way pour créer (c.-à-d., définir ou déclarer) une fonction. Voici comment créer une fonction appelée :

le functionName de fonction () {// rapports vont ici} pour
appeler (c.-à-d., exécutez) la fonction appelée, se rapportent à 
elle de nom, comme :

functionName() ;

Voici comment créer une coquille de fonction :

functionName = fonction () {// rapports vont ici} ;

Bien que pas strictement requis, on le considère une meilleure pratique d'inclure un point-virgule suivant le croisillon bouclé de fermeture en définissant une coquille de fonction.

Grouper des rapports dans une fonction vous permet de définir la fonction une fois mais de l'exécuter autant de fois comme vous voudrez. C'est utile quand vous devez effectuer les actions semblables à de diverses heures sans reproduire le même code dans les endroits multiples. Garder votre code a centralisé dans les fonctions le facilite pour comprendre (parce que vous pouvez écrire la fonction une fois et ignorer alors les détails en utilisant la) et plus facile à maintenir (parce que vous pouvez faire des changements dans un endroit plutôt que des endroits multiples).

Il y a deux manières communes de définir des fonctions d'ActionScript : en tant que des fonctions ou coquilles appelées de fonction (a.k.a. fonctions anonymes). Chacune de ces manières de déclarer une fonction a sa propre utilisation.

La déclaration appelée de fonction est le choix le plus commun (en ne définissant pas une fonction à employer comme méthode) et a au moins un avantage par rapport aux coquilles de fonction : les fonctions nommées sont accessibles chez le keyframe entier (ou l'on() ou le traiteur d'onClipEvent()) même si elles viennent après l'appel à la fonction.

Par exemple, quoique la fonction de writeMessage() ne soit pas déclarée jusqu'à ce qu'après qu'elle soit appelée, la fonction est encore disponible :

//appelez la fonction de writeMessage(), qui est 
déclarée plus tard dans le writeMessage(de manuscrit) ;

//déclarez (définissez) la fonction de writeMessage() 
pendant qu'un writeMessage appelé de fonction de fonction () 
{trace("Hello, ami.") ; }

//fonction est disponible avant ou après que 
c'ait été writeMessage(avoué) ;

En revanche, une coquille de fonction est accessible seulement des lignes du code qui viennent après la déclaration :

//interprète d'ActionScript ne pourrez pas trouver une 
fonction avec ce nom,// et ainsi rien ne se produit (il échoue 
silencieusement). writeMessage2() ;

//déclarez (définissez) la fonction de writeMessage2() 
pendant qu'une fonction anonyme littérale writeMessage2 = fonction ()
{trace("Hello, ami.") ; } ;

//cependant, la fonction est fourni par des lignes de code
après que c'ait été writeMessage2(avoué) ;

Cependant, il y a plusieurs raisons d'employer des coquilles de fonction :

Vous pouvez assigner une coquille de fonction à une variable globale de sorte que la fonction puisse être consultée de n'importe quelle chronologie.

Les coquilles de fonction offrent une manière commode, compacte, et intuitive de définir des méthodes pour des objets.

Des coquilles de fonction peuvent être traitées comme d'autres variables, du fait elles peuvent être passées à d'autres fonctions ou faire attribuer à nouveau leurs valeurs.

Ici, nous assignons une coquille de fonction comme propriété _ de l'objet global :

_ global.launchBookExamples = fonction () 
{getURL("http://www.person13.com/ascb", "_ blanc") ; } ; \

Par conséquent, n'importe où dessus de n'importe quelle chronologie, vous pouvez exécuter la fonction en employant simplement son nom. Par exemple, vous pourriez attacher ce manuscrit à un bouton :

myButton.onRelease = fonction () {launchBookExamples() ; 
} ;

Ici, nous définissons la fonction car une méthode d'agrafe de film (où onEnterFrame() est une méthode spéciale et intégrée pour les agrafes de film que vous devez définir avant qu'elle puisse être employée) :

myClip_mc.onEnterFrame = fonction () {trace("Hooray pour 
des méthodes !") ; } ;

Naturellement, vous pouvez définir des méthodes faites sur commande aussi bien en assignant simplement la coquille de fonction à une nouvelle propriété de l'objet :

myClip_mc.myCustomMethod = fonction () {trace("Hooray pour
des méthodes !") ; } ;

C'est également intéressant noter que vous pouvez placer une méthode égale à une autre méthode. Cette technique est souvent employée pour assigner les mêmes actions à une agrafe ou à un bouton de film pour deux événements différents. Vous pouvez définir une fonction anonyme et l'assigner à une des méthodes de traiteur d'événement, et puis assignez simplement une méthode de traiteur d'événement à l'autre. Un exemple commun de ceci est pour le moment où vous voulez définir les mêmes actions quand un utilisateur libère un bouton ou une agrafe de film et quand ils libèrent l'extérieur :

//définissez une méthode d'onRelease() pour une agrafe 
de film myMovieClip.onRelease = fonction () {trace("Hooray pour des 
méthodes !") ; } ;

//assignez la même définition de méthode à la méthode
d'onReleaseOutside() en tant que bien myMovieClip.onReleaseOutside = 
myMovieClip.onRelease ;

Des fonctions peuvent également être passées comme données. Vous pouvez commodément passer une coquille de fonction à une autre fonction qui exige une fonction en tant qu'un de ses arguments, tels que le setInterval() ou à la méthode d'Array.sort() :

//ensemble un intervalle qui appelle une fonction qui des 
incréments une variable, un I, et des affichages// 
setInterval(function de valeur () {trace(++i) ;}, 1000) ;

Les fonctions sont sujettes aux mêmes limitations de portée que des variables. Les fonctions de chronologie sont accessibles seulement tandis que la chronologie sur laquelle elles sont définies existe. Une fonction de chronologie peut être une fonction appelée ou une fonction anonyme assignée à une variable de chronologie. En plus, des fonctions de chronologie peuvent s'appeler seulement en utilisant le chemin approprié de cible. Quand vous accédez à la fonction de la même chronologie, vous n'avez pas besoin d'inclure le chemin de cible, mais quand vous voulez accéder à la fonction d'une autre chronologie, vous devez vous assurer vous fournir le chemin correct.

//appellent explicitement une fonction qui est définie 
sur la chronologie principale _ root.myFunction() ;

Si votre fonction est employée dans la même chronologie seulement, vous n'avez pas besoin de vous inquiéter des issues de portée. Cependant, si vous avez l'intention d'employer la fonction dans toutes beaucoup de chronologies, deux solutions sont généralement utilisées :

Définissez la fonction comme fonction globale. Si vous faites à une fonction une fonction globale, vous pouvez l'appeler de nom de n'importe quelle chronologie dans le film sans devoir s'inquiéter de la portée :

_ global.myFunction = fonction () {les fonctions 
trace("Global sont amusement !") ; } ;

Définissez la fonction comme méthode (statique) de a de classe globale. Toutes les classes intégrées sont globales par défaut, et si vous définissez une classe avec un constructeur global, alors même vos classes faites sur commande peuvent être globales. Cette technique est vraiment une variation sur la première, mais par rapport à l'avantage que les classes offrent vous à une manière d'organiser vos fonctions d'une manière potentiellement signicative (par exemple, la classe intégrée de maths organise beaucoup de fonctions mathématiques).