Structures de contrôle de la rouille et comment les utiliser

Les structures de contrôle sont une construction de programmation qui vous permet de contrôler le flux d'exécution de vos programmes. Les structures de contrôle vous permettent de spécifier des instructions à exécuter uniquement si certaines conditions sont remplies.

Les structures de contrôle de Rust sont cruciales pour gérer le flux du programme, permettant une exécution efficace du code tout en simplifiant les tâches complexes en composants plus petits et réutilisables.

Instructions conditionnelles de rouille

Les instructions conditionnelles sont des constructions qui vous permettent d'exécuter du code en fonction de conditions. Les instructions conditionnelles sont utiles pour la prise de décision car l'exécution du programme dépend de la valeur de la condition. vrai ou FAUX. La rouille fournit si, autre, et correspondre déclarations pour la prise de décision.

Dans les programmes Rust, le

si teste si une certaine condition est vraie. Si c'est le cas, le programme exécute le bloc de code associé. Si la condition est fausse, le programme ignore ce bloc de code et passe à l'instruction suivante ou exécute la autre bloc d'instructions s'il y en a.

Le correspondre instruction est une puissante construction de flux de contrôle qui permet à un programme de faire correspondre des valeurs à une série de modèles et d'exécuter du code basé sur le modèle correspondant.

Les instructions if de Rust

Vous déclarerez si déclarations dans vos programmes Rust avec les si mot clé suivi d'une condition :

si condition {
// code à exécuter si la condition est vraie
}

Voici un exemple d'utilisation d'une instruction if dans vos programmes Rust :

fnprincipal() {
laisser x = 15;
si x> 10 {
imprimez !("x est supérieur à 10");
 }
}

Le X La variable contient un entier 32 bits et l'instruction if vérifie si la valeur de x est supérieure à dix avant d'exécuter le bloc de code qui l'imprime.

Les autres déclarations de Rust

Vous utiliserez le autre mot clé pour exécuter un bloc de code lorsque vous anticipez qu'un si déclaration serait évaluée comme fausse.

si condition {
// code à exécuter si la condition est vraie
} autre {
// code à exécuter si la condition est fausse
}

Voici un exemple où X n'est pas supérieur à 10, le si instruction évalue FAUX, Et un autre l'instruction s'exécute.

fnprincipal(){
laisser x = 5;
si x> 10 {
imprimez !("x est supérieur à 10");
 } autre {
imprimez !("x n'est pas supérieur à 10");
 }
}

Depuis X est 5 et 5 n'est pas supérieur à 10, le programme saute le si bloquer et exécute le autre bloc.

Déclarations de correspondance de Rust

Vous utiliserez le correspondre mot-clé pour la prise de décision complexe pour vérifier une série de modèles et exécuter du code basé sur des correspondances de modèles. Les instructions de correspondance sont similaires à instructions switch en C#, Go et C++.

Voici la structure d'une instruction de correspondance Rust :

correspondre valeur {
 motif1 => {
// code à exécuter si la valeur correspond à pattern1
 },
 motif2 => {
// code à exécuter si la valeur correspond à pattern2
 },
// etc.
}

Voici comment utiliser les instructions de correspondance dans vos programmes :

laisser note = 'B';
correspondre grade {
'UN' => imprimez !("Excellent travail!"),
'B' => imprimez !("Bon travail."),
'C' => imprimez !("Tu peux faire mieux."),
 _ => imprimez !("Ce n'est pas une note valide."),
}

Le grade la variable est un caractère, et la correspondre L'instruction vérifie pour lequel des caractères correspond la valeur de la variable de grade avant d'exécuter le code après l'opérateur =>. Vous pouvez utiliser le modèle de trait de soulignement (_) pour faire correspondre des valeurs qui ne correspondent pas à d'autres modèles (le modèle par défaut).

Boucles en rouille

Les boucles sont une construction fondamentale utilisée pour les tâches répétitives comme grattage Web et d'autres actions automatisées. Rust fournit différents types de boucles, y compris alors que boucles, pour boucles, et les boucle boucle.

Boucles while de Rust

Les boucles While répètent un bloc de code tant qu'une condition spécifiée est évaluée vraie. Avant de spécifier la condition, vous spécifierez while boucles dans Rust avec le alors que mot-clé.

alors que condition {
// code à exécuter
}

La condition doit être une expression booléenne qui détermine la poursuite de la boucle. Lorsque la condition est fausse, la boucle se termine.

Voici un exemple de boucle Rust while qui imprime des nombres de un à cinq.

fnprincipal() {
laissermuet je = 1;
alors que je <= 5 {
imprimez !("{}", je);
 je += 1;
 }
}

La boucle while dans le principal la fonction parcourt les nombres un à cinq tout en incrémentant le je variable de un jusqu'à je variable est supérieure à cinq, où la boucle se termine.

La boucle Boucle

Le boucle Le mot clé crée une boucle infinie jusqu'à ce que vous indiquiez une sortie avec le casser mot-clé.

boucle {
// code à exécuter
si condition {
casser;
 }
}

Le code dans le boucle bloc continuera à s'exécuter jusqu'à ce que la boucle rencontre un casser mot-clé.

Voici un exemple d'utilisation de boucle boucle pour imprimer les numéros un à cinq avant de spécifier le casser mot-clé pour la sortie.

fnprincipal() {
laissermuet je = 1;
boucle {
imprimez !("{}", je);
 je += 1;
si je > 5 {
casser;
 }
 }
}

Le principal la fonction exécute la boucle, et la si l'instruction incrémente la je variable. Le si L'instruction spécifie la fin de la boucle lorsque la je variable dépasse cinq.

Rust pour les boucles

Dans Rust, les boucles for parcourent une plage ou une collection de valeurs. Vous utiliserez le pour mot-clé pour démarrer une boucle for, avant de spécifier la plage ou la collection sur laquelle il agit.

pour variable dans gamme {
// code à exécuter
}

Le gamme est une expression qui évalue une séquence de valeurs, et la variable est une variable qui prend tour à tour chaque valeur de la séquence. Le bloc de code s'exécutera une fois pour chaque valeur de la séquence.

Voici un exemple de boucle for qui imprime des valeurs allant de un à dix.

fnprincipal() {
pour je dans1..=10 {
imprimez !("{}", je);
 }
}

La boucle parcourt les valeurs de 1 à 10. A chaque itération, la variable (i) contient la valeur suivante, que imprimez ! macro s'imprime ensuite.

Vous pouvez utiliser le continuer mot-clé pour ignorer les valeurs dans les boucles for. Voici comment vous pouvez ignorer les nombres pairs lorsque vous travaillez sur une plage :

fnprincipal() {
pour nombre dans1..=10 {
si nombre % 2 == 0 {
continuer; // saute les nombres pairs
 }
imprimez !("{}", nombre); // affiche les nombres impairs
 }
}

Le si l'instruction utilise la continuer mot-clé pour spécifier que la boucle doit ignorer les nombres divisibles par deux.

De plus, vous pouvez quitter une boucle for avec le casser mot-clé. La boucle se termine en rencontrant le casser mot-clé.

fnprincipal() {
pour nombre dans1..=10 {
si nombre == 5 {
casser; // sort de la boucle lorsque le nombre est égal à 5
 }
imprimez !("{}", nombre); // affiche les nombres 1 à 4
 }
}

Le si indique que la boucle doit se terminer lorsque la je variable vaut cinq.

Utiliser les structures de contrôle de Rust avec des types de données pour maîtriser le langage

Rust fournit ces structures de contrôle flexibles pour les opérations sur les types de données intégrés et personnalisés. Vous pouvez utiliser ces structures de contrôle pour opérer sur des structures de données composées et composites telles que des tableaux, des vecteurs, des structures et des énumérations.

Rust fournit également des structures. Les structures sont des structures de données qui regroupent des valeurs liées dans un seul objet. Ils sont similaires aux classes des langages orientés objet et vous pouvez même y définir des méthodes.