Em baixo traduzi um tutorial sobre loops de Jesse Stratford.

x += 1
ou x++
ou até x = x+1
fazem todos o mesmo.
Mas é chato ter que escrever isto 100 vezes se queremos que x incremente até 100. Como também é chato colocar em 100 frames o incremento (não só é chato como demora 12 segundo); por isso existem os Loops.

for (y=0; y<100; y++) {
x++;
}
1.
O For Loop aceita três tipos de argumentos: o valor de inicialização, a condição, e a acção, respectivamente. Em seguida, todas as acções que quermos que se processem ficam entre as chavetas.
Literalmente este código diz o seguinte: "Começa com uma variável y igual a zero. Perfaz as acções dentro das chavetas (neste caso, adiciona 1 ao x) depois adiciona um ao y. Se, quando estas acções estiverem completas, y continuar a ser menor que 100, repete tudo (vira o disco e torna a girar). Reparem que utilizei duas variáveis, uma para o contador do próprio loop e a outra para a acção que queremos desencadear(incrementar uma variável), isto apenas evitar que o código se tornasse demasiado confuso.

while (x<100) {
x++;
}
2.
Este é o While loop. Funciona quase da mesma maneira mas tens que te adaptar à condição entre chavetas. Se disserem "Ladra como um cão enquanto eu tiver a mão erguida), vocês começam a ladrar e eu posso manter a minha mão erguida para sempre. Para evitar que fiquem com uma garganta maltratada eu tenho que baixar a mão algures no tempo. Isto é o mesmo com o while loop; algures no tempo a sua condição tem que ser encontrada (dentro de um número limitado de cálculos) ou então fará com que o Flash player vá à vida.
No nosso For loop, dizemos que quermos incrementar o contador cada vez que o loop dá a volta (a cada vez que o loop dá uma volta chama-se iteracção), assim não temos que fazer modificações às nossas condições dentro do próprio loop. No entanto, no While e Do While loops, temos que alterar a condição dentro do loop (ou a condição tem que estar a modificar-se dentro do processo do loop) para prevenir esgotamento da performance.
Se tivéssemos:
while (x<100) {
y++;
}
x++
Teríamos "crachado" o flash player porque x será sempre menos que 100, porque não o estamos a alterar dentro do loop. Sim, estamos a alterá-lo fora do loop, mas o Flash quer fazer todos os cáculos dentro do loop antes de continuar, por isso ficará confuso e parará.

do {
x++;
} while (x<100);
3.
Este é o Do While, é basicamente o mesmo que o exempo anterior, mas a sintaxe é distinta. Esxitem diferenças que serão abordadas numa fase mais avançada, por enquanto permanece como o anterior, mas com uma sintaxe diferente."

Ok. Então existem três tipos de loops... Mas de qualquer maneira, quem é que vai contar de 0 a 100. Não serão muitos, pois não. Mas imaginem que quero criar 100 cópias de um movie clip no palco. Eu não quero ter que escrever as instruções para duplicar o movie clip 100 vezes, com um nome diferente e uma profundidade diferente de cada vez, para isso utilizo um loop.

for (x=0; x<100; x++) {
duplicateMovieClip ("targetMC", "dupMC"+x, x);
}

"dupMC"+x pega no string "dupMC" e adiciona no seu final o número guardado na variável x, assim se x = 1, o resultado seria "DupMC1". Como o x está sempre a mudar, isto dá-nos um nome único de cada vez.

Depois de passarmos uma vista de olhos pelo duplicateMovieClip, saberíamos de antemão que todos estes novos duplicados teriam o mesmo _x e _y, por isso temos que movimentá-los um pouco. Mas isso também não é problema com os loops. Para isso basta inserir um tipo de algoritmo no próprio loop. Digamos que queremos fazer com que cada novo duplicado tenha o mesmo_y mas um _x 5 pixeis maior que o prévio (para um efeito gráfico horizontal). Basta fazer isto:

for (x=0; x<100; x++) {
duplicateMovieClip ("targetMC", "dupMC"+x, x);
_root["dupMC"+x]._y = x*5;
}

A linha 3 não é difícil para aqueles que já percebem de setProperty. Em vez de "setProperty(property, target, value)" estou a utilizar o método "infix" para escrever o código. Dou o caminho (path) para o target e adiciono "._y" que indica que quero mexer com a posição Y do target. Começo por definir a posição do target para o valor x vezes 5. Assim o primeiro duplicado terá uma _x de 0 (porque o x começa com 0 e 0*5 = 0), o próximo duplicado terá um _x de 5 e o último um _x de 495 (isto porque estamos a fazer o looping enquanto o x for menor que 100). Note-se que nessa linha eu estou a utilizar um "método array" para determinar qual o nome do clip no qual eu quero inserir a propriedade. Assim acabaos por duplicar um novo clip ao mesmo tempo que lhe damos um nome dinâmico e único, criado apartir da adição entre o valor de x à string "dupMC". Por isso é que eu tenho que dizer ao flash que quero definir a propriedade do MC com esse nome. Isso é feito como indicado em cima e não através da _root.dupMC+x._y = x * 5 como assume muita gente. Os parênteses rectos dizem ao Flash que este tem que calcular o valor que está dentro deles e colocá-lo na linha. Note-se ainda que não existe ponto entre a _root e o parênteses recto no método array.

Partindo de um exemplo parecido, imaginemos que possuímos um campo de texto onde pretendemos que o utilizador insira um valor numérico, e que depois de clicarmos num botão surgissem o número de duplicados que se pretendem. Como conseguimos isto? Com loops.

Assim temos um input text com a variável count. Em seguida temos um botão com o seguinte código.

on (release) {
for (x=0; x duplicateMovieClip ("targetMC", "dupMC"+x, x);
_root["dupMC"+x]._y = x*5;
}
}

O que mudou? Observemos a linha 2. Já não estamos fazer um loop em função de x (x<100). Lembrem-se que só queremos fazer o número de duplicados pedidos pelo utilizador. Assim queremos que o x comece em 0 e vá (iterativamente) até ao número escolhido, (Number(count) ). A função do flash Number() pega num string que contenha um número e converte-o num número. Isto porque qualquer valor introduzido dentro de um text field é um string por defeito. Assim temos que converter o string num número antes de podermos verificar se é maior que x.

E por último, mas não menos importante, lembrem-se que loops em script não podem ser utilizados para modificar eventos visuais num dado período de tempo. O que é que isto quer dizer? Quer dizer que não vamos poder utilizar o loop para animar um objecto a mover-se ao longo do palco, ou para incrementar um contador no qual queremos que seja visível o incrementar. Porque não. Porque os loops são executados mais rapidamente do que um piscar de olhos (literalmente). Muitas vezes ouvimos pessoas a queixarem-se que criaram um loop no qual querem que _x de um MC aumente 100 vezes e "o raio do Flash não o faz!" Errado! O flash fá-lo, não o podemos ver porque está ser feito muito rapidamente.