Boucler avec `for` (sur des plages et collections)

Introduction : répéter des actions avec `for`

Au-delà de la prise de décision (`if`, `when`), une autre tâche fondamentale en programmation est la répétition : exécuter le même bloc de code plusieurs fois de suite. Cela est indispensable pour traiter des ensembles de données, effectuer des calculs répétitifs, ou simplement répéter une action un nombre défini de fois. La structure de contrôle principale pour réaliser ces répétitions, en particulier lorsqu'on travaille avec des séquences d'éléments, est la boucle `for`.

En Kotlin, la boucle `for` est conçue pour être particulièrement expressive et facile à utiliser, notamment pour itérer sur des éléments comme des plages de nombres ou les membres d'une collection (listes, ensembles, etc.). Elle abstrait une grande partie de la complexité souvent associée aux boucles dans d'autres langages (gestion manuelle des indices, conditions d'arrêt).

Ce chapitre explore en détail comment utiliser la boucle `for` en Kotlin pour parcourir efficacement les structures de données séquentielles les plus courantes.

Itérer sur des plages de nombres (Ranges)

Une utilisation très fréquente de la boucle `for` est de répéter une action un certain nombre de fois ou de parcourir une séquence de nombres. Kotlin facilite cela grâce aux plages (ranges).

Syntaxe de base :

for (variable in plage) {
    // Bloc de code exécuté pour chaque valeur dans la plage
    // 'variable' prend successivement chaque valeur de la plage
}

Il existe plusieurs façons de définir des plages :

• `..` (Opérateur d'intervalle inclusif) : Crée une plage incluant la valeur de début et la valeur de fin.

    println("Compter de 1 à 5 (inclus) :")
    for (i in 1..5) {
        print("$i ") // Affiche: 1 2 3 4 5 
    }
    println()

• `until` (Intervalle excluant la fin) : Crée une plage incluant le début mais excluant la valeur de fin. `a until b` est équivalent à `a..(b-1)`. Très utile pour les indices de tableaux/listes qui vont de 0 à taille-1.

    println("Compter de 1 jusqu'à 5 (exclu) :")
    for (i in 1 until 5) {
        print("$i ") // Affiche: 1 2 3 4 
    }
    println()

• `downTo` (Décompte) : Crée une plage qui décrémente de la valeur de début jusqu'à la valeur de fin (incluse).

    println("Décompter de 5 à 1 :")
    for (i in 5 downTo 1) {
        print("$i ") // Affiche: 5 4 3 2 1 
    }
    println()

• `step` (Pas d'itération) : Peut être combiné avec les opérateurs précédents pour spécifier l'incrément (ou le décrément).

    println("Compter de 0 à 10 par pas de 2 :")
    for (i in 0..10 step 2) {
        print("$i ") // Affiche: 0 2 4 6 8 10 
    }
    println()

    println("Décompter de 10 à 0 par pas de 3 :")
    for (i in 10 downTo 0 step 3) {
        print("$i ") // Affiche: 10 7 4 1 
    }
    println()

Itérer sur des collections (`List`, `Set`, `Map`)

L'utilisation la plus idiomatique et la plus courante de la boucle `for` en Kotlin est sans doute l'itération sur les éléments d'une collection. Que vous ayez une liste (`List`), un ensemble (`Set`), ou une table de correspondance (`Map`), la boucle `for` vous permet de parcourir leurs éléments de manière très simple.

Syntaxe pour `List` et `Set` :

for (element in collection) {
    // Traiter l'élément courant ('element')
}

fun main() {
    // Itérer sur une List
    val fruits = listOf("Pomme", "Banane", "Orange")
    println("Fruits dans la liste:")
    for (fruit in fruits) {
        println("- $fruit")
    }

    // Itérer sur un Set (ordre non garanti pour un HashSet)
    val uniqueNumbers = setOf(3, 1, 4, 1, 5, 9) // Le Set contiendra {3, 1, 4, 5, 9}
    println("\nNombres uniques dans l'ensemble:")
    for (number in uniqueNumbers) {
        print("$number ")
    }
    println()
}

fun main() {
    val userScores = mapOf("Alice" to 90, "Bob" to 75, "Charlie" to 88)

    println("\nScores des utilisateurs (clé et valeur) :")
    for ((name, score) in userScores) { // Destructuring: name=entry.key, score=entry.value
        println("- $name a obtenu $score points.")
    }

    // Si vous ne voulez que les clés
    println("\nNoms des utilisateurs (clés) :")
    for (name in userScores.keys) {
        println("- $name")
    }

    // Si vous ne voulez que les valeurs
    println("\nScores (valeurs) :")
    for (score in userScores.values) {
        println("- $score")
    }
}

La syntaxe `for ((key, value) in map)` est particulièrement pratique et lisible pour travailler avec des maps.

Accéder à l'indice pendant l'itération

Parfois, en plus de l'élément lui-même, vous avez besoin de connaître sa position (son indice) dans la collection ou la plage pendant l'itération. Kotlin offre plusieurs façons de faire cela :

• Itérer sur les indices (`indices`) : Chaque collection (comme `List`) possède une propriété `indices` qui est une plage représentant les indices valides (de `0` à `size - 1`). Vous pouvez boucler sur cette plage et accéder à l'élément via `collection[index]`.

    val colors = listOf("Rouge", "Vert", "Bleu")
    println("Couleurs avec indices (via .indices) :")
    for (index in colors.indices) {
        println("  Index $index: ${colors[index]}")
    }

• Utiliser `withIndex()` : C'est souvent la méthode préférée et la plus idiomatique. La fonction d'extension `withIndex()` sur une collection (ou autre itérable) retourne une séquence de paires `(index, valeur)`. Vous pouvez utiliser la destructuring declaration dans la boucle `for` pour obtenir facilement les deux.

    println("\nCouleurs avec indices (via .withIndex()) :")
    for ((index, color) in colors.withIndex()) {
        println("  Index $index: $color")
    }

La méthode `withIndex()` est généralement plus claire et plus sûre que l'itération manuelle sur les indices, car elle évite les erreurs potentielles liées à l'accès par indice.

Ce qui se passe en coulisses

Il est bon de savoir que la boucle `for` en Kotlin est une abstraction puissante. Le compilateur Kotlin est très intelligent et optimise la façon dont la boucle est exécutée en fonction de ce sur quoi vous itérez.

Pour les objets qui ont une méthode `iterator()` bien définie (comme les collections standards), la boucle `for` utilise cet itérateur sous le capot (similaire aux boucles `for-each` en Java). Pour les plages d'entiers ou les progressions (`IntProgression`, `LongProgression`, etc.) et pour l'itération sur `array.indices`, le compilateur peut générer une boucle basée sur un indice simple (similaire à une boucle `for` traditionnelle en Java ou C), ce qui est très efficace.

Vous n'avez généralement pas besoin de vous soucier de ces détails, mais cela explique pourquoi la boucle `for` de Kotlin est à la fois polyvalente et performante.

Récapitulatif : la boucle `for` pour l'itération

La boucle `for` est l'outil principal en Kotlin pour itérer sur des séquences.

• Utilisez `for (item in range)` pour parcourir des plages de nombres créées avec `..`, `until`, `downTo`, et `step`.
• Utilisez `for (item in collection)` pour parcourir les éléments d'une `List`, d'un `Set`, ou les entrées d'une `Map`.
• La syntaxe `for ((key, value) in map)` est idéale pour les `Map`.
• Utilisez `collection.indices` ou, de préférence, `collection.withIndex()` pour accéder à l'indice lors de l'itération sur une collection.

Maîtriser la boucle `for` est essentiel pour traiter des ensembles de données, implémenter des algorithmes et automatiser des tâches répétitives en Kotlin.