Rust Basics Series #7 : Utiliser des boucles dans Rust

Dans l’article précédent de la série Rust, j’ai passé en revue l’utilisation des mots-clés if et else pour gérer le flux de contrôle de votre programme Rust.

C’est une façon de gérer le flux de contrôle de votre programme. L’autre façon de faire est d’utiliser des boucles. Examinons donc les boucles dans cet article de suivi.

Boucles disponibles en Rust

Le langage de programmation Rust a trois boucles différentes en fonction de ce que vous voulez réaliser et de ce qui est disponible :

Je suppose que vous connaissez for et while mais loop peut être nouveau ici. Commençons d’abord par des concepts familiers.

La boucle for

Le for La boucle est principalement utilisée pour itérer sur quelque chose appelé un itérateur.

Cet itérateur peut être créé à partir de n’importe quoi, d’un tableau, d’un vecteur (sera bientôt couvert !), d’une plage de valeurs ou de n’importe quoi de personnalisé. Le ciel est la limite ici.

Examinons la syntaxe du for boucle.

for iterating_variable in iterator {
    <statement(s)>;
}

Le iterating_variable est plus généralement connu sous le nom de i dans la plupart des autres tutoriels de langage de programmation 😉

Et un iteratorcomme je l’ai dit, peut être vraiment tout ce qui indique quelle est la prochaine valeur, le cas échéant.

Comprenons cela à l’aide d’un programme.

fn main() {
    let my_arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

    println!("iteration over an array");
    for element in my_arr {
        println!("{}", element);
    }

    println!("\niteration over a real iterator");
    for element in my_arr.iter() {
        println!("{}", element);
    }

    println!("\nPython-style range");
    for element in 0..10 {
        println!("{}", element);
    }
}

Ici, j’ai déclaré un tableau contenant 10 nombres, de 0 à 9. Sur le for boucle qui est sur la ligne 5, je spécifie simplement ce tableau comme itérateur et Rust gère automatiquement l’itération sur tous les éléments de ce tableau pour moi. Pas de fantaisie my_arr[i] la magie est nécessaire.

Mais sur la ligne 10, j’appelle le .iter() fonction sur le tableau. Il s’agit d’une mention explicite de l’obtention d’un itérateur basé sur les valeurs qui my_arr consiste en. La seule différence entre cette boucle et la boucle de la ligne 5 est qu’ici vous êtes explicite en appelant le .iter() fonction sur le tableau.

Appelant le .iter() fonction sur un type de données, dans ce contexte, n’est pas strictement nécessaire. Puisqu’il s’agit d’un tableau, qui est un type de données fourni par le langage lui-même, Rust sait déjà comment le gérer. Mais toi sera besoin avec des types de données personnalisés.

Enfin, à la ligne 15, nous avons une boucle for qui boucle sur une plage. Eh bien en quelque sorte. Si vous regardez attentivement, cette gamme ressemblera beaucoup au “type” Slice. Rust le sait aussi et gère l’itération pour vous (haha, compris ?).

La sortie ressemble à ceci :

iteration over an array
0
1
2
3
4
5
6
7
8
9

iteration over a real iterator
0
1
2
3
4
5
6
7
8
9

Python-style range
0
1
2
3
4
5
6
7
8
9

La boucle while

Le while boucle peut être considérée comme très similaire à une if énoncé conditionnel. Avec le if déclaration, à condition que la condition fournie par l’utilisateur évalue à truele code dans le if le corps de l’instruction est exécuté une fois.

Mais avec le while boucle, si la condition est évaluée à true, la boucle commence à boucler sur le corps de la boucle. La boucle continuera son itération tant que la condition continue d’être évaluée pour true.

Le while la boucle ne s’arrête que lorsque la boucle a terminé l’exécution de toutes les instructions de l’itération en cours et lors de la vérification de la condition, elle évalue à false.

Regardons la syntaxe d’une boucle while…

while condition {
    <statement(s)>;
}

Voir? Très semblable à un if énoncé conditionnel ! Non else bloque quand même 😉

Regardons un programme pour mieux comprendre cela.

fn main() {
    let mut var = 0;

    while var 

J’ai une variable mutable, varavec une valeur initiale de 0. Le while boucle bouclera tant que la valeur stockée dans la variable mutable var est inférieur à 3.

A l’intérieur de la boucle, varLa valeur de est imprimée et plus tard, sa valeur est incrémentée de 1.

Vous trouverez ci-dessous la sortie du code écrit ci-dessus :

0
1
2

La boucle

Rust a une boucle infinie. Oui, un sans condition de démarrage et sans condition d’arrêt. Il continue juste à boucler encore et encore jusqu’à l’infini. Mais bien sûr, a des déclencheurs pour arrêter l’exécution de la boucle à partir du code lui-même.

La syntaxe de cette boucle infinie est la suivante :

loop {
    <statement(s)>;
}

Avant même de vous donner un exemple, puisque cette boucle est assez particulière, regardons d’abord comment sortie ça :p

Pour arrêter l’exécution d’une boucle infinie, le break mot-clé est utilisé à l’intérieur de la boucle.

Regardons un exemple où seuls les nombres entiers entre 0 et 3 (inclus) sont imprimés sur la sortie du programme.

fn main() {
    let mut var = 0;

    loop {
        if var > 3 {
            break;
        }

        println!("{}", var);
        var += 1;
    }
}

La meilleure façon d’interpréter cet exemple particulier est de le considérer comme une forme inutilement développée d’un while boucle 😉

Vous avez une variable mutable var avec une valeur initiale de 0 qui est utilisée comme itérateur, en quelque sorte. La boucle infinie commence par un if condition que devrait varla valeur de est supérieure à 3, le break le mot clé doit être exécuté. Plus tard, comme dans l’exemple précédent du while boucle, varLa valeur de est imprimée sur la sortie standard, puis sa valeur est incrémentée de 1.

Il produit la sortie suivante :

0
1
2
3

Boucles étiquetées

Disons qu’il y a deux boucles infinies, l’une imbriquée dans l’autre. Pour une raison quelconque, la condition de sortie est vérifiée dans la boucle la plus interne, mais cette condition de sortie sert à sortir de la boucle la plus externe.

Dans un tel cas, l’étiquetage de la ou des boucles peut être bénéfique.

Voici comment étiqueter une boucle.

'label: loop {}

Pour indiquer au compilateur qu’une boucle est étiquetée, commencez par un guillemet simple, tapez son étiquette et faites-la suivre de deux-points. Ensuite, continuez avec la façon dont vous définissez régulièrement une boucle.

Lorsque vous avez besoin de casser certaines boucles, spécifiez simplement l’étiquette de la boucle comme suit :

    break 'label;

Prenons un exemple pour mieux comprendre cela.

fn main() {
    let mut a = 0;
    let mut b = 0;

    'parent: loop {
        a += 1;

        loop {
            println!("a: {}, b: {}", a, b);
            b += 1;

            if a + b == 10 {
                println!("\n{} + {} = 10", a, b);
                break 'parent;
            }
        }
    }
}

Ici, j’ai pris deux variables mutables a et b avec les valeurs initiales fixées à 0 pour les deux.

Plus tard, la boucle la plus externe est étiquetée parent. La boucle ‘parent’ incrémente la valeur de variable a par 1 et a une boucle interne/enfant.

Cette boucle enfant (sur la ligne 8) imprime les valeurs des variables a et b. A l’intérieur de cette boucle, la valeur de b est incrémenté de 1. Et la condition de sortie est que a + b == 10. Signification chaque fois que les valeurs stockées dans des variables a et blorsqu’ils sont additionnés, donnent 10, le parent boucle est rompue. Même si le break condition sur la ligne 14 “appartient” à la boucle interne, elle casse le parent boucle.

Regardons maintenant la sortie du programme.

a: 1, b: 0
a: 1, b: 1
a: 1, b: 2
a: 1, b: 3
a: 1, b: 4
a: 1, b: 5
a: 1, b: 6
a: 1, b: 7
a: 1, b: 8

1 + 9 = 10

Comme le montre la sortie du programme, la boucle s’arrête dès que a et b ont respectivement les valeurs 1 et 9.

Le mot clé continue

Si vous avez déjà utilisé des boucles dans un autre langage de programmation comme C/C++/Java/Python, vous connaissez peut-être déjà l’utilisation du continue mot-clé.

Tandis que le break mot clé est d’arrêter complètement l’exécution de la boucle, le continue le mot-clé est utilisé pour “sauter” le itération en cours de l’exécution de la boucle et commencer par l’itération suivante (si les conditions le permettent).

Prenons un exemple pour comprendre comment le continue mot clé fonctionne.

fn main() {
    for i in 0..10 {
        if i % 2 == 0 {
            continue;
        }
        println!("{}", i)
    }
}

Dans le code ci-dessus, j’ai un for boucle qui itère sur des nombres entiers entre 0 et 9 (inclus). Dès que la boucle commence, je mets une vérification conditionnelle pour voir si le nombre est pair ou non. Si le nombre est pair, le continue mot-clé est exécuté.

Mais si le nombre est impair, le nombre est imprimé sur la sortie du programme.

Regardons d’abord la sortie de ce programme.

1
3
5
7
9

Comme vous pouvez le voir, la boucle semble avoir “continué” même s’il y a clairement des nombres pairs entre 0 et 9. Mais parce que j’ai utilisé le continue mot-clé, l’exécution de la boucle s’est arrêtée lorsque ce mot-clé a été rencontré.

La boucle a sauté tout ce qui se trouvait en dessous et a continué avec l’itération suivante. C’est pourquoi les nombres pairs ne sont pas imprimés, mais tous les nombres impairs entre 0 et 9 sont imprimés sur la sortie du programme.

Conclusion

Pour conclure ce long article, j’ai démontré l’utilisation de 3 boucles différentes : for, while et loop. J’ai également discuté de deux mots clés qui affectent le flux de contrôle de ces boucles : break et continue.

J’espère que vous comprenez maintenant le cas d’utilisation approprié pour chaque boucle. S’il vous plaît laissez-moi savoir si vous avez des questions.