Les différentes boucles en Rust

En Rust il existe 3 types de boucles :

• Les boucles loop
• Les boucles while
• Les boucles for

Les mots clés réservés aux boucles

Peut importe le type de boucle qu’on va utiliser, il exsite 2 mots clés qu’on va pouvoir utiliser dans chacune des différentes boucles

• Le mot clé break qui va arrêter la boucle et passer à la suite du code
• Le mot clé continue qui va terminer le tour de boucle actuel et passer au suivant

Les boucles loop

Les boucles loop sont un peu spéciales car elles sont infinies, ou plus précisémment elles ne s’arrêteront QUE lorsqu’ elles rencontreront le mot clé break

Voici un exemple :

fn main() {
    let mut count = 0;

    loop {
        count += 1;

        if count == 5 {
            println!("OK, c'est la fin de la boucle");
            break;
        }
    }
}

Elles fonctionnent donc à l’inverse des boucles while qui ne s’executent QUE si une condition est remplie, là les boucles loop ne s’arrêtent QUE si une condition est remplie.

La boucle while

Comme dans la quasi totalié des languages la boucle while s’execute uniquement si la condition est vérifiée.

Un exemple :

fn main() {
    let mut count = 0;

    while count < 20 {
        count += 1;
    }

    println!("OK, La boucle est finie");
}

La boucle for

La boucle for permet de parcourir des éléments d’une collection, comme d’un array par exemple.

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("The value is {}", element);
    }
}

La particularité avec Rust c’est qu’on ne peut pas itérer directement sur les éléments d’une collection.

Pour ça il faut d’abord transformer la collection en itérable via la méthode iter().

On peut aussi utiliser les boucles for quand on veut itérer un certains nombre de fois sur une collection.

Les range et la boucle for

On va pouvoir utiliser ce qu’on appelle un range pour lancer une boucle un certains nombre de fois.

Les range sont des itérateurs (c’est à dire des éléments qu’on peut itérer mais on verra ça dans un article dédié).

Voici la syntaxe des range :

• 1..4 Un range de 1 à 4 exclus (donc 1, 2 et 3)
• 1..=4 Un range de 1 à 4 inclus (donc 1, 2, 3 et 4)

Pour générer un range qui va de 1 à 4 exclus voici la syntaxe Et donc si on veut lancer une boucle for 4 fois on va faire

fn main() {
    for number in 1..=4 {
        println!("{}", number);
    }
    // 1
    // 2
    // 3
    // 4
}

Conclusion

Voici tout ce qu’il y a à savoir sur les boucles en Rust.

En règle général on préfera les boucles for même quand on veut itérer un nombre précis de fois car elles sont plus éléguantes que les autres qui nécéssitent d’écrire plus de code et de conditions.