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]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]il faut écrire:[/!]

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

Ce code est parfaitement équivalent à celui-ci :

[!java]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
}[/!]

Le code avec une boucle for est plus simple à lire, non?

[!java]

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.