Você quer executar tempos múltiplos de uma tarefa dentro de um único frame.
Use um laço executar os mesmos tempos múltiplos da tarefa dentro de um único frame. Para o exemplo, você pode usar a para a indicação:
para (var i = 0; i < 10; i++) {// exposição
o valor do trace(i) do i.; }
Quando você quer executar os mesmos da ação (ou variações ligeiras tempos múltiplos disso) dentro de um único frame, use uma indicação dando laços fazer seu código mais succinct, mais fácil de ler, e mais fácil de atualizar. Você puder usar uma indicação do quando ou um a para a indicação para esta finalidade, mas geralmente a para a indicação é a escolha melhor. Ambas as indicações conseguem o mesmo resultado, mas para a indicação é mais compacto e mais familiar a a maioria de programadores.
A sintaxe de a para a indicação consiste em cinco porções básicas:
|
|
Para o keyword
Cada para a indicação deve começar com o a para o keyword.
Expressão da iniciação
O laço emprega tipicamente uma variável do índice (a.k.a. um contador do laço) que seja inicializada quando a indicação é encontrada primeiramente. A iniciação é executada somente uma vez não obstante quantas vezes o laço é repetido.
Teste a expressão
Um laço deve incluir uma expressão do teste que retorne verdadeiro ou falso. A expressão do teste é avaliada uma vez cada vez através do laço. Geralmente, a expressão do teste compara a variável do índice a um outro valor, tal como um número máximo de iterações do laço. A expressão total deve avaliar para rectificar para para que o corpo da indicação execute (contraste isto com a . . . quando laço, que executa ao menos uma vez, mesmo se a expressão do teste é falsa). Na outra mão, se a expressão do teste nunca se tornar falsa, você criará um laço infinito, tendo por resultado um aviso que o jogador flash esteja funcionando lentamente (que aparece após 15 segundos).
Expressão do update
A expressão do update atualiza geralmente o valor da variável usada na expressão do teste de modo que, em algum ponto, a expressão do teste se torne falsa e nas extremidades do laço. A expressão do update é executada uma vez cada vez através do laço. Um laço infinito é causado frequentemente não atualiza a variável apropriada na expressão do update (geralmente a mesma variável usada na expressão do teste).
Corpo da indicação
O corpo da indicação é um bloco dos substatements incluídos em cintas curly que seja executado cada vez através do laço. Se a expressão do teste for nunca verdadeira, para o corpo da indicação não estará executado.
Para o keyword deve vir primeiramente, e deve ser seguido pela iniciação, pelo teste, e pelas expressões do update incluídas nos parênteses. Os semicolons devem separar as três expressões de uma outras (embora a iniciação, o teste, e as indicações do update sejam opcionais, os semicolons são imperativos). O restante do para o laço é composto do corpo da indicação incluído em cintas curly. O formulário geral é:
para (iniciação; teste; update) {corpo da
indicação}
Está aqui um exemplo de a para a indicação que outputs os números 0 a 999. Porque a variável i do índice é uma variável local, nós prefaciamo-la com o keyword do var na expressão da iniciação.
para (var i = 0; i < 1000; i++) {trace(i);
} traço ("que é a extremidade.");
Para compreender para a indicação, você pode seguir junto com o intérprete de ActionScript como ela processa o comando. No exemplo precedente, para o keyword diz o intérprete para executar tão por muito tempo as indicações dentro do para o laço como a expressão condicional é verdadeira. A expressão da iniciação é executada somente uma vez, e ajusta a variável i a 0. Em seguida, o intérprete verifica a expressão do teste (i < 1000). Porque i é 0, que é menos de 1000, a expressão avalía para rectificar e a ação do trace() dentro do para o corpo da indicação é executada. O intérprete de ActionScript executa então a indicação do update, neste caso i++, que incrementos i por 1. O intérprete repete então o processo do alto do laço (mas salta a etapa da iniciação). Assim o intérprete verifica outra vez se a expressão do teste seja verdadeira e, se assim, execute o corpo da indicação outra vez. Executa então a indicação do update outra vez. Os repeats deste processo até a expressão do teste são não mais longos rectificam. O último valor indicado na janela da saída é 999, porque uma vez que i é incrementado a 1000, a expressão do teste avalía não mais por muito tempo para rectificar e o laço vem a uma extremidade. Uma vez que o laço termina, a execução continua com o que comandos seguem o laço.
as expressões da iniciação e do update podem incluir as ações múltiplas separadas por vírgulas. Os seguintes do exemplo incrementos simultaneamente i e decréscimos j, e exposições seus valores na janela da saída:
para (var i = 0, j = 10; i < 10; i++, --) de j
{o trace("i é" + i); o trace("j é" + j); }
O exemplo precedente não é o mesmo que usando dois aninhados para indicações (que é mostrado no bloco seguinte do código).
É também terra comum ao uso aninhado para indicações. Quando você usa aninhado para a indicação, use uma variável diferente do índice do que aquele usado no outermost para o laço. Pela convenção, o outermost para o laço usa a variável i, e aninhado para o laço usa o j variável. Para o exemplo:
para (var i = 1; i < = 3; i++) {para (var j =
1; j < = 2; j++) {trace(i + "X" + j + "=" + (i * j));
}}
O exemplo precedente indica a seguinte tabela da multiplicação na janela da saída:
1 X 1 = 1 1 X 2 = 2 2 X 1 = 2 2 X 2 = 4 3 X 1 = 3 3 X 2 = 6
É possível aninhar níveis múltiplos para de indicações. Pela convenção, cada nível adicional do assentamento usa o caráter alfabético seguinte como a variável do índice. Conseqüentemente, o terceiro nível do aninhado para indicações usa tipicamente k como a variável do índice:
para (var i = 1; i < = 3; i++) {para (var j =
1; j < = 3; j++) {para (var k = 1; k < = 3;
k++) {trace(i + "X" + j + "X" + k + "=" + (i * j * k));
}}}
Adicionalmente, você pode usar-se para indicações dar laços para trás:
//contagem para trás 10 a 1. para (var i = 10; i >
0; --) i {trace(i); }
Você não deve usar a para a indicação executar tarefas sobre o tempo.
Muitos programadores fazem o erro de tentar usar-se para indicações animate grampos do filme. Para o exemplo:
para (var i = 0; i < 20; i++) {myMovieClip._x
+ = 10; }
Embora o código precedente mova os pixels do grampo 200 do filme para a direita de seu ponto começar, todos os updates ocorrem dentro do mesmo frame. Há dois problemas com este. Primeiramente de tudo, os updates do estágio somente uma vez por o frame, assim somente o último update são mostrados no estágio (que faz com que o grampo do filme salte 200 pixels de repente melhor que que se move lisamente em 20 etapas). E em segundo, nivele se o estágio atualizar mais frequentemente, cada iteração com para o laço faz exame somente de alguns milissegundos, assim que o animation aconteceria demasiado rapidamente. Para ações que você quer ocorrer sobre o tempo, use um alimentador do onEnterFrame().
Além disso, os laços repetindo apertados não devem ser usados executar processos longos (qualquer coisa que faz exame de mais do que uma fração de um segundo). O jogador flash indica um aviso sempre que um único laço executa por mais de 15 segundos. Usar um alimentador do onEnterFrame() ou a função do setInterval() evita a mensagem de advertência e permite que o flash execute outras ações além às ações repetidas que são parte do laço.
|
|