## Boucles pour `(for)`

Les boucles `while` sont bien adaptées aux situations où l'on veut réaliser une action tant qu'une condition est réalisée, mais elles sont moins pratiques pour réaliser une action un nombre prédéterminé de fois. Par exemple, lorsque nous voulions reculer de `nbPas` dans l'exercice précédent, il fallait créer une nouvelle variable, l'initialiser, et demander à reculer tant que la nouvelle variable n'était pas égale à `nbPas`, en incrémentant cette variable à la main à la fin du corps de la boucle.

Dans ce genre de cas, les boucles de type `for` sont plus pratique. Leur syntaxe est la suivante :

    [!java|c]for (initialisation; condition; increment) {
        action();
    }[/!][!python]for variable in sequence de valeurs:
        action()[/!][!scala] for (variable <- premiereValeur to derniereValeur) {
        action();
    }[/!]

Par exemple, pour répéter le corps de boucle `n` fois, [!python]il est pratique d'utiliser l'instruction `range(n)` pour générer la séquence de n entiers allant de 0 à n-1.[/!] [!java|scala|c]il faut écrire:[/!]

    [!java]for (int compteur=0; compteur<n; compteur++) {
        action();
    }[/!][!c]int compteur;
    for (compteur=0; compteur<n; compteur++) {
        action();
    }[/!][!python]for compteur in range(n):
        action()[/!][!scala] for (compteur <- 1 to 10) {
        action();
    }[/!]

Ce code est équivalent du point de vue de l'ordinateur, mais du point de vue du programmeur, ce n'est pas forcément la même chose. L'une ou l'autre forme peut rendre le code plus facile à lire, en fonction de la situation. C'est donc à vous, le programmeur, de choisir la forme de boucle est la plus adaptée à chaque cas. L'objectif absolu doit être de garder votre code aussi simple que possible en toute situation. De la sorte, vos journées resteront plaisantes et productives.

    [!java|c]int compteur = 0;
    while (compteur < n) {
        action();
        compteur++;
    }[/!][!python]compteur=0
    while compteur < n:
        action()
        compteur = compteur + 1[/!][!scala]
    var compteur = 0
    while (compteur < n) {
        action()
        compteur = compteur + 1
    }[/!]

Dans ce cas, le code avec une boucle `for` est plus simple à lire, non?

[!java|c]

On peut imaginer des utilisations bien plus avancées des boucles `for` car toute instruction valide peut être utilisée comme initialisation, condition et incrémentation. L'exemple suivant est un peu extrême, puisqu'il n'y a même pas de corps de boucle. La buggle est avancée jusqu'à se retrouver face au mur dans la condition et l'incrémentation.

    for (; !estFaceMur() ; avance()) {
       /* rien dans le corps de boucle */
    }
    /* la buggle est maintenant face à un mur */

[/!] [!scala]

Si vous avez l'intention d'imbriquer plusieurs boucles, il est possible de l'écrire en une seule ligne en Scala. Les deux morceaux de code sont équivalents:

    for (compteur1 <- 1 to n) {
        for (compteur2 <- 1 to m) {
           actions()
        }
    }

    for (compteur1 <- 1 to n; compteur2 <- 1 to m) { // Séparez simplement les deux conditions de boucle par un point-virgule (;)
        actions()
    }

[/!]

### Objectif de cet exercice

Il s'agit maintenant de refaire le même exercice que précédemment (avancer jusqu'à trouver un baggle, le ramasser, revenir là où on était au début puis reposer le baggle), mais en utilisant une boucle `for` pour revenir au point de départ à la place d'une boucle `while`.

Une fois ceci fait, vous pouvez passez à l'exercice suivant.