ActionScript: Criando O Código Reusável

Share

|

Você quer executar desnecessariamente uma série das ações em várias horas sem código duplicando durante todo seu filme.

Críe uma função e chame-a então (isto é, invoque) pelo nome sempre que você necessita executar aquelas ações.

Há mais do que o one-way para criar (isto é, para definir ou declarar) uma função. É aqui como criar uma função nomeada:

o functionName da função () {// indicações vai aqui} 
para chamar (isto é, execute) a função nomeada, consulta-lhe pelo 
nome, como:

functionName();

É aqui como criar um literal da função:

functionName = função () {// indicações vai aqui};

Embora requerido não estritamente, considera-se uma mais melhor prática incluir um semicolon depois da cinta curly de fechamento ao definir um literal da função.

Agrupar indicações em uma função permite que você defina a função uma vez mas execute-a tantas como vezes porque você gostaria. Isto é útil quando você necessita executar ações similares em várias horas sem duplicar o mesmo código em lugares múltiplos. Manter seu código centralizou nas funções faz mais fácil de compreender (porque você pode escrever a função uma vez e para ignorar então os detalhes ao a usar) e mais fácil de manter (porque você pode fazer mudanças em um lugar melhor que em lugares múltiplos).

Há duas maneiras comuns de definir funções de ActionScript: como funções ou literals nomeados da função (a.k.a. funções anonymous). Cada uma destas maneiras de declarar uma função tem seu próprio uso.

A declaração nomeada da função é a escolha a mais comum (ao não definir uma função a ser usada como um método) e tem ao menos uma vantagem sobre literals da função: as funções nomeadas são acessíveis dentro do keyframe inteiro (ou do on() ou do alimentador do onClipEvent()) mesmo se vêm após a chamada à função.

Para o exemplo, mesmo que a função do writeMessage() não esteja declarada até que depois que é invocada, a função está ainda disponível:

//invoque a função do writeMessage(), que é declarada 
mais tarde no writeMessage(do certificado);

//declare (defina) a função do writeMessage() enquanto 
um writeMessage nomeado da função da função () {trace("Hello, 
amigo."); }

//função está disponível antes ou depois foi 
writeMessage(declarado);

No contraste, um literal da função é acessível somente das linhas do código que vêm após a declaração:

//intérprete de ActionScript não possa  encontrar uma 
função com este nome,// e assim que nada acontece (falha 
silenciosamente). writeMessage2();

//declare (defina) a função de writeMessage2() enquanto 
uma função anonymous literal writeMessage2 = função () 
{trace("Hello, amigo."); };

//entretanto, a função está disponível das linhas do 
código depois que foi writeMessage2(declarado);

Entretanto, há diversas razões usar literals da função:

Você pode atribuir um literal da função a uma variável global de modo que a função possa ser alcançada de todo o timeline.

Os literals da função oferecem uma maneira conveniente, compacta, e intuitive definir métodos para objetos.

Os literals da função podem ser tratados como outras variáveis, que podem ser passados a outras funções ou ter seus valores atribuídos novamente.

Aqui, nós atribuímos um literal da função como uma propriedade _ do objeto global:

_ global.launchBookExamples = função () 
{getURL("http://www.person13.com/ascb", "_ espaço em branco"); 
}; \

Conseqüentemente, em qualquer lugar sobre de todo o timeline, você pode executar a função simplesmente usando seu nome. Para o exemplo, você pôde unir este certificado a uma tecla:

myButton.onRelease = função () {launchBookExamples(); 
};

Aqui, nós definimos a função porque um método de um grampo do filme (onde onEnterFrame() é um método especial, interno para os grampos do filme que você necessita definir antes que possa ser usado):

myClip_mc.onEnterFrame = função () {trace("Hooray para 
métodos!"); };

Naturalmente, você pode definir métodos feitos sob encomenda também simplesmente atribuindo o literal da função a uma propriedade nova do objeto:

myClip_mc.myCustomMethod = função () {trace("Hooray para
métodos!"); };

É também worth anotar que você pode ajustar um método igual a um outro método. Esta técnica é usada frequentemente atribuir as mesmas ações a um grampo ou a uma tecla do filme para dois eventos diferentes. Você pode definir uma função anonymous e atribui-la a um dos métodos do alimentador do evento, e então atribui simplesmente um método do alimentador do evento ao outro. Um exemplo comum deste é quando você quer definir as mesmas ações para quando um usuário libera uma tecla ou um grampo do filme e quando liberam a parte externa:

//defina um método do onRelease() para um grampo do filme
myMovieClip.onRelease = função () {trace("Hooray para métodos!"); 
};

//atribua a mesma definição do método ao método do 
onReleaseOutside() como bem myMovieClip.onReleaseOutside = 
myMovieClip.onRelease;

As funções podem também ser passadas como dados. Você pode convenientemente passar um literal da função a uma outra função que requeira uma função como um de seus argumentos, tais como o setInterval() ou ao método de Array.sort():

//jogo um intervalo que chame uma função que incrementos
uma variável, um i, e umas exposições// setInterval(function do 
valor () {trace(++i);}, 1000);

As funções são sujeitas às mesmas limitações do espaço que variáveis. As funções de Timeline são acessíveis somente quando o timeline em que estão definidos existir. Uma função do timeline pode ser uma função nomeada ou uma função anonymous atribuída a uma variável do timeline. Adicionalmente, as funções do timeline podem ser chamadas somente usando o trajeto apropriado do alvo. Quando você alcança a função do mesmo timeline, você não necessita incluir o trajeto do alvo, mas quando você quer alcançar a função de um outro timeline, você necessita certificar-se você para fornecer o trajeto correto.

//invoca explicitamente uma função que seja definida no 
timeline. principal _ root.myFunction();

Se sua função for usada dentro do mesmo timeline somente, você não necessita preocupar-se sobre edições do espaço. Entretanto, se você pretender usar a função durante todo muitos timelines, duas soluções são empregadas geralmente:

Defina a função como uma função global. Se você fizer a uma função uma função global, você pode chamá-la pelo nome de todo o timeline no filme sem ter que preocupar-se sobre o espaço:

_ global.myFunction = função () {as funções 
trace("Global são divertimento!"); };

Defina a função como o método (de estática) de a de uma classe global. Todas as classes internas são globais pelo defeito, e se você definir uma classe com um construtor global, a seguir mesmo por suas classes feitas sob encomenda podem ser globais. Esta técnica é realmente uma variação no primeira, mas com a vantagem que as classes oferecem lhe a uma maneira de organizar suas funções em uma maneira potencial significativa (para o exemplo, a classe interna do math organiza muitas funções matemáticas).