Boucles Rust

Outre des instructions conditionnelles flexibles, les structures de boucle de Rust sont également très bien conçues. En tant que développeur aguerri, vous devriez pouvoir le sentir.

Boucle while

La boucle while est la boucle conditionnelle la plus typique :

Exemple

fn main() {
let mut number = 1;
while number != 4 {
println!("{}", number);
nombre += 1;
}
println!("EXIT");
}

Sortie :

1
2
3
EXIT

Au moment de la rédaction de ce tutoriel, Rust ne dispose pas d'une construction do-while, mais `do` est spécifié comme mot réservé et pourrait être utilisé dans de futures versions.

En C, la boucle for utilise une instruction à trois expressions pour contrôler la boucle, mais Rust n'a pas cette construction, donc une boucle while doit être utilisée à la place :

Langage C

int i;
for (i = 0; i < 10; i++) {
// corps de la boucle
}

Rust

let mut i = 0;
while i < 10 {
// corps de la boucle
i += 1;
}

Boucle for

La boucle for est la construction de boucle la plus couramment utilisée, souvent employée pour parcourir une structure de données linéaire (comme un tableau). Une boucle for parcourt un tableau :

Exemple

fn main() {
let a = [10, 20, 30, 40, 50];
for i in a.iter() {
println!("La valeur est : {}", i);
}
}

Sortie :

值为 : 10
值为 : 20
值为 : 30
值为 : 40
值为 : 50

La boucle for de ce programme parcourt le tableau a. `a.iter()` représente l'itérateur de a ; nous n'entrerons pas dans les détails avant d'avoir étudié les objets.

Bien sûr, la boucle for peut aussi accéder au tableau par index :

Exemple

fn main() {
let a = [10, 20, 30, 40, 50];
for i in 0..5 {
println!("a[{}] = {}", i, a[i]);
}
}

Sortie :

a[0] = 10
a[1] = 20
a[2] = 30
a[3] = 40
a[4] = 50

Boucle loop

Les développeurs chevronnés ont certainement rencontré des situations où une boucle ne peut pas déterminer, au début ou à la fin, si elle doit continuer, et où l'exécution de la boucle doit être contrôlée quelque part au milieu du corps de la boucle. Dans de tels cas, nous implémentons souvent une sortie anticipée de la boucle à l'intérieur d'une boucle `while (true)`.

Rust dispose d'une construction native de boucle infinie — `loop` :

Exemple

fn main() {
let s = ['R', 'U', 'N', 'O', 'O', 'B'];
let mut i = 0;
loop {
let ch = s[i];
if ch == 'O' {
break;
}
println!("\'{}\'", ch);
i += 1;
}
}

Sortie :

'R' 
'U' 
'N'

Une boucle `loop` peut utiliser le mot-clé `break`, de manière similaire à `return`, pour sortir de toute la boucle et fournir une valeur de retour vers l'extérieur. C'est une conception très astucieuse, car une boucle `loop` est souvent utilisée comme outil de recherche ; si quelque chose est trouvé, bien sûr, le résultat doit être transmis :

Exemple

fn main() {
let s = ['R', 'U', 'N', 'O', 'O', 'B'];
let mut i = 0;
let location = loop {
let ch = s[i];
if ch == 'O' {
break i;
}
i += 1;
};
println!(" \'O\'a pour index {}", location);
}

Sortie :

 'O' 的索引为 3

Autres extensions