Les Boucles en Rust

Introduction

Dans le langage de programmation Rust, une boucle est une structure de contrôle qui permet d'exécuter répétitivement un bloc de code. Les boucles sont très utiles pour exécuter des tâches nécessitant plusieurs passes, par exemple, parcourir une liste, effectuer des calculs, ou attendre qu’une condition précise soit remplie. On peut distinguer principalement trois types de boucles en Rust : for, while, et la boucle infinie.

Boucle For

La boucle for est employée pour itérer sur des collections ou des intervalles. Elle parcourt automatiquement les éléments d’une collection et exécute un bloc de code pour chaque item. On l'utilise souvent pour itérer sur des tableaux, des vecteurs et d'autres structures de données itérables.

Voici un exemple avec un tableau contenant différents types de données :

let valeurs = ["A", 2, 20, 4, 5];
for val in valeurs.iter() {
    // Code à exécuter pour chaque élément du tableau
    println!("Valeur : {}", val);
}

Boucle While

La boucle while exécute continuellement un bloc de code tant qu'une condition donnée est vraie. Elle vérifie cette condition avant de commencer l'itération. Si la condition est fausse dès le début, aucune exécution de la boucle ne se fera. Les boucles while sont particulièrement utiles quand le nombre d'itérations n'est pas défini à l'avance.

Voici un exemple simple :

let mut compteur = 0;
while compteur < 5 {
    // Code à exécuter tant que la condition est vraie
    compteur += 1;
}

Boucle Infinie

La commande loop génère une boucle infinie qui continuera d'exécuter le bloc de code jusqu'à ce qu'elle soit explicitement interrompue par une déclaration break. Cela s'avère utile lorsqu’une tâche doit être effectuée indéfiniment jusqu'à ce qu’une certaine condition soit remplie.

Voici comment implémenter une boucle infinie :

fn main() {
    loop {
        println!("Tapez 'exit' pour quitter : ");
        let mut saisie = String::new();
        std::io::stdin().read_line(&mut saisie).expect("Échec de la lecture de la ligne");

        if saisie.trim() == "exit" {
            break;
        }
    }
}

Exemples de Boucles

Voici deux exemples concrets. Le premier montre une boucle while qui itère à travers les entiers de 5 à 10. Le second utilise for pour parcourir un tableau contenant les chiffres de 1 à 5 :

fn main() {
    let mut compteur = 5;
    while compteur <= 10 {
        println!("Ceci est l'itération numéro : {}", compteur);
        compteur += 1;
    }
    let nombres = [1, 2, 3, 4, 5];
    for nombre in nombres.iter() {
        println!("Nombre : {}", nombre);
    }
}

En exécutant cet exemple, vous obtiendrez la sortie suivante :

Ceci est l'itération numéro : 5
Ceci est l'itération numéro : 6
Ceci est l'itération numéro : 7
Ceci est l'itération numéro : 8
Ceci est l'itération numéro : 9
Ceci est l'itération numéro : 10
Nombre : 1
Nombre : 2
Nombre : 3
Nombre : 4
Nombre : 5