## Loops for

loops 'while' são bem adaptados a situações onde precise realizar uma ação enquanto uma condição se mantém verdadeira, mas são menos preparados para realizar uma ação numa quantidade predeterminada. Por exemplo, quando nos quisemos mover `quantidadeDePassos` para trás num exercício anterior, 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. As sintaxes delas 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] 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, a depender da situação. Deve escolher sabiamente em qual situação usar um loop for ou um loop while. O seu objetivo principal deve ser manter o seu código simples e fácil de ler, para garantir que o 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é alcançar a parede, mas funciona bem: todo o trabalho é feito nas instruções de condição e incremento.

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

[/!] [!scala]

Se quer aninhar vários loops, pode fazer-lo numa 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

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 a usar um loop `for` no lugar de um loop `while` para mover de volta ao local inicial.

Uma vez feito, pode seguir ao próximo exercício.