Rouille pour boucle

Les boucles sont comme la seule chose qui définit un langage de programmation. Ils sont une construction essentielle qui offre la possibilité d'exécuter en continu une action tant qu'une condition est vraie.

Cet article discutera de la façon dont nous pouvons implémenter et utiliser des constructions de boucle dans le langage de programmation Rust.

Constructions de boucle de rouille

Rust nous fournit les constructions en boucle suivantes

1. A pour boucle
2. Pendant la boucle
3. Une boucle

Explorons comment chaque construction fonctionne et comment l'utiliser.

Rouille pour boucle

Une boucle pour la rouille est utilisée pour itérer les éléments d'un objet itérable à l'aide d'un itérateur. Il renvoie une série de valeurs jusqu'à ce que l'itérateur soit vide. La valeur de la boucle pour peut ensuite être utilisée pour effectuer une action à l'intérieur du corps de la boucle.

La syntaxe pour une boucle pour la rouille est comme indiqué:

pour le modèle dans l'expression
//faire

L'exemple d'utilisation d'une boucle pour une boucle est d'itérer les éléments d'un tableau. Un exemple est comme indiqué ci-dessous:

fnmain ()
Letarr: [i32; 3] = [10,20,30];
pour l'article inarr
println!("", article);

Un autre exemple de la boucle FOR est d'itérer sur une gamme d'entiers en utilisant le mot-clé. Par exemple:

fnmain ()
foriin1… 10
println!("", je);

L'exemple ci-dessus itère sur les éléments de 1 à 10, à l'exclusion du dernier élément. Si vous souhaitez inclure 10 dans les valeurs, utilisez la syntaxe:

pour je en 1… = 10
println!("", je);

Rouille en boucle

La boucle while exécute un bloc de code jusqu'à ce que la condition spécifiée soit fausse. Par conséquent, tant qu'une condition est vraie, le bloc à l'intérieur du corps entier fonctionnera en continu.

Un exemple est comme indiqué:

fnmain ()
letmuti = 0;
alors que je<= 5
println!("", je);
i + = 1;

Pour le code ci-dessus, nous commençons par définir une variable mutable i. Nous utilisons ensuite une boucle while pour exécuter en continu un bloc de code tandis que la valeur de i est inférieure ou égale à 5.

Gardez à l'esprit que nous mettons à jour la valeur de I sur chaque itération pour empêcher une boucle infinie.

Boucle de rouille

L'expression de boucle dans la rouille, indiquée par le mot-clé LOOP, montre une boucle infinie. Cette construction de boucle utilise les mots clés de pause et continue pour quitter et sauter une itération.

Un exemple est comme indiqué:

fnmain ()
letmuti = 0U32;
boucle
i + = 1;
ifi == 5
println!("", je);
continuer;

ifi == 10
println!("", je);
casser;

Le code ci-dessus s'exécutera infiniment jusqu'à ce qu'il contrecarre l'instruction de pause.

Conclusion

Cet article explore diverses constructions en boucle dans le langage de programmation de rouille. En utilisant cet article, vous êtes en mesure de répondre aux besoins en boucle dans vos programmes de rouille.

Nous espérons que vous avez apprécié l'article et merci de l'avoir lu!