## Loops for

loops 'while' são bem adaptados a situações onde você precise realizar uma ação enquanto uma condição se mantém verdadeira, mas são menos preparados para realizar uma ação num número de vezes predeterminado. Por exemplo, quando nós quisemos nos mover `quantidadeDePassos` para trás num exercício anterior, nós tivemos que criar uma nova variável, inicializar ela e mover para trás enquanto aumentávamos esta variável até ela se tornar igual a `quantidadeDePassos`.

Em tais situações, loops `for` se tornam úteis. Suas sintaxes são as seguintes:

    [!java|c]for (inicialização; condição; incremento) {
        ação();
    }[/!][!python]for variável in sequência-de-valores:
        ação()[/!][!scala] for (variável <- primeiroValor to últimoValor) {
        ação();
    }[/!]

Por exemplo, para repetir o corpo do loop `n` vezes, [!python] é útil usar a instrução `range(n)` para gerar a sequência de n valores inteiros de 0 a n-1.[/!] [!java|scala|c] você deve escrever:[/!]

    [!java]for (int iterador=0; iterador<n; iterador++) {
        ação();
    }[/!][!c]int iterador;
    for (iterador=0; iterador<n; iterador++) {
        ação();
    }[/!][!python]for iterador in range(n):
        ação()[/!][!scala] for (iterador <- 1 to n) {
        ação();
    }[/!]

Este código é então equivalente ao seguinte do ponto de vista do computador. Do ponto de vista do programador, uma forma ou outra pode ser mais difícil ou mais fácil de ler, dependendo da situação. Você deve escolher sabiamente em qual situação usar um loop for ou um loop while. Seu objetivo principal deve ser manter seu código simples e fácil de ler, para garantir que seu dia seja agradável e produtivo.

    [!java|c]int iterador = 0;
    while (iterador < n) {
        ação();
        iterador++;
    }[/!][!python]iterador=0
    while iterador < n:
        ação()
        iterador = iterador + 1[/!][!scala]
    var iterador = 1
    while (iterador <= n) {
        ação()
        iterador = iterador + 1
    }[/!]

Neste caso, o loop `for` é fácil de ler, não acha?

[!java|c]

É possível construir loops `for` mais avançados já que qualquer instrução válida pode ser usada como inicialização, condição e instrução de incrementação. O exemplo seguinte é um pouco extremo pois não existe necessidade para um corpo de loop mover um buggle para frente até ele alcançar a parede, mas funciona bem: todo o trabalho é feito nas instruções de condição e incremento.

    for (; !estáDeFrenteParaParede() ; avançar()) {
       /* nada no corpo do loop */
    }
    /* o buggle agora está de cara para uma parede */

[/!] [!scala]

Se você quer aninhar vários loops, você pode fazer isto em uma linha no Scala. Isto significa que os dois blocos seguintes são equivalentes:

    for (iterador1 <- 1 to n) {
        for (iterador2 <- 1 to m) {
           ações()
        }
    }

    for (iterador1 <- 1 to n; iterador2 <- 1 to m) { // Simplesmente separe as duas condições de loop com um ponto-e-vírgula
        ações()
    }

[/!]

### Objetivo do exercício

Você agora tem que refazer o mesmo exercício de antes (mover para frente até estar sobre um baggle, pegá-lo, mover para trás até a localização original, soltar o baggle), mas usando um loop `for` no lugar de um loop `while` para mover de volta ao local inicial.

Uma vez feito, você pode seguir para o próximo exercício.