Rust
Boucles

Syntaxe

• loop { block } // boucle infinie

• tandis que condition { bloc }

• while let pattern = expr { bloc }

• pour pattern dans expr { block } // expr doit implémenter IntoIterator

• continue // saut à la fin du corps de la boucle, commence une nouvelle itération si nécessaire

• pause // arrête la boucle

• ' label : loop { block }

• ' label : while condition { block }

• ' label : while let pattern = expr { bloc }

• ' label : pour le pattern dans expr { block }

• continuer label // saut à la fin du corps de la boucle étiquette marquée, le démarrage d' une nouvelle itération si nécessaire

• break ' label // arrête l' étiquette libellée de la boucle

Les bases

Il y a 4 constructions en boucle dans Rust. Tous les exemples ci-dessous produisent la même sortie.

Boucles infinies

let mut x = 0;
loop {
    if x > 3 { break; }
    println!("{}", x);
    x += 1;
}

Pendant que les boucles

let mut x = 0;
while x <= 3 {
    println!("{}", x);
    x += 1;
}

Voir aussi: Quelle est la différence entre loop et while true ?

Boucles de motifs assorties

Celles-ci sont parfois connues sous le nom de « while let , pour des raisons de brièveté.

let mut x = Some(0);
while let Some(v) = x {
    println!("{}", v);
    x = if v < 3 { Some(v + 1) }
        else     { None };
}

Ceci est équivalent à une match dans un bloc de loop :

let mut x = Some(0);
loop {
    match x {
        Some(v) => {
            println!("{}", v);
            x = if v < 3 { Some(v + 1) }
                else     { None };
        }
        _       => break,
    }
}

Pour les boucles

Dans Rust, for loop ne peut être utilisé qu'avec un objet "itérable" (c'est-à-dire qu'il doit implémenter IntoIterator ).

for x in 0..4 {
    println!("{}", x);
}

Cela équivaut à l'extrait de code suivant impliquant while let :

let mut iter = (0..4).into_iter();
while let Some(v) = iter.next() {
    println!("{}", v);
}

Remarque: 0..4 renvoie un objet Range qui implémente déjà le trait Iterator . Par conséquent, into_iter() est inutile, mais est conservé pour illustrer ce for fait. Pour un regard en profondeur, voir les documents officiels sur for boucles et IntoIterator .

Voir aussi: Itérateurs

En savoir plus sur les boucles

Comme mentionné dans Basics, nous pouvons utiliser tout ce qui implémente IntoIterator avec la boucle for :

let vector = vec!["foo", "bar", "baz"]; // vectors implement IntoIterator
for val in vector {
    println!("{}", val);
}

Production attendue:

foo  
bar  
baz

Notez que l'itération sur vector de cette manière la consomme (après la boucle for , le vector ne peut plus être utilisé). En effet , IntoIterator::into_iter se déplace self .

IntoIterator est également implémenté par &Vec<T> et &mut Vec<T> (produisant des valeurs avec les types &T et &mut T respectivement), vous pouvez donc empêcher le déplacement du vector en le faisant simplement passer par référence:

let vector = vec!["foo", "bar", "baz"];
for val in &vector {
    println!("{}", val);
}
println!("{:?}", vector);

Notez que val est de type &&str , puisque le vector est de type Vec<&str> .

Contrôle de boucle

Toutes les constructions en boucle permettent l'utilisation d'instructions break et continue . Ils affectent la boucle immédiatement environnante (la plus interne).

Contrôle de boucle de base

break termine la boucle:

for x in 0..5 {
    if x > 2 { break; }
    println!("{}", x);
}

0
1
2

continue finit l'itération en cours tôt

for x in 0..5 {
    if x < 2 { continue; }
    println!("{}", x);
}

2
3
4

Contrôle de boucle avancé

Maintenant, supposons que nous avons des boucles imbriquées et que vous voulez break vers la boucle extérieure. Ensuite, nous pouvons utiliser des étiquettes de boucle pour spécifier à quelle boucle une break ou une continue s'applique. Dans l'exemple suivant, 'outer est l'étiquette donnée à la boucle externe.

'outer: for i in 0..4 {
    for j in i..i+2 {
        println!("{} {}", i, j);
        if i > 1 {
            continue 'outer;
        }
    }
    println!("--");
}

0 0
0 1
--
1 1
1 2
--
2 2
3 3

Pour i > 1 , la boucle interne n'a été itérée qu'une seule fois et -- n'a pas été imprimée.

Remarque: Ne confondez pas une étiquette de boucle avec une variable de durée de vie. Les variables de durée de vie apparaissent uniquement à côté d'un paramètre & ou en tant que paramètre générique dans <> .