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 qui ne seront exécutées que si certaines conditions sont remplies.
Les structures de contrôle de Rust sont cruciales pour la gestion du flux de programmes, permettant une exécution efficace du code tout en simplifiant les tâches complexes en composants plus petits et réutilisables.
Déclarations conditionnelles en Rust
Les instructions conditionnelles sont des constructions qui permettent d’exécuter du code en fonction de conditions. Les instructions conditionnelles sont pratiques pour la prise de décision, car l’exécution du programme dépend de l’évaluation ou non de la condition. vrai ou faux. Rust fournit si, autreet match déclarations pour la prise de décision.
Dans les programmes Rust, la fonction si teste si une certaine condition est évaluée comme étant vraie. Si c’est le cas, le programme exécute le bloc de code correspondant. Si la condition est évaluée comme fausse, le programme saute ce bloc de code et passe à l’instruction suivante ou exécute l’instruction else bloc de déclaration s’il y en a un.
Le match est une construction puissante de flux de contrôle qui permet à un programme de comparer des valeurs à une série de motifs et d’exécuter du code en fonction du motif correspondant.
Les instructions if de Rust
Vous déclarerez si dans vos programmes Rust avec la fonction if suivi d’une condition :
if condition {
// code to execute if condition is true
}
Voici un exemple d’utilisation d’une instruction if dans vos programmes Rust :
fn main() {
let x = 15;
if x > 10 {
println!("x is greater than 10");
}
}
L’instruction x contient un entier de 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 instructions else de Rust
Vous utiliserez la fonction autre mot-clé pour exécuter un bloc de code lorsque vous anticipez qu’un si serait évaluée comme étant fausse.
if condition {
// code to execute if condition is true
} else {
// code to execute if the condition is false
}
Voici un exemple où x n’est pas supérieur à 10, le si évalue l’instruction fauxet un autre la déclaration s’exécute.
fn main(){
let x = 5;
if x > 10 {
println!("x is greater than 10");
} else {
println!("x is not greater than 10");
}
}
Depuis x est 5 et que 5 n’est pas supérieur à 10, le programme saute l’étape du calcul de la valeur. si et exécute le bloc else bloc.
Déclarations de concordance de Rust
Vous utiliserez la fonction match mot-clé pour une prise de décision complexe permettant de vérifier une série de motifs et d’exécuter du code en fonction des correspondances. Les instructions Match sont similaires aux instructions Switch en C#, Go et C++.
Voici la structure d’une instruction de correspondance en Rust :
match value {
pattern1 => {
// code to execute if the value matches pattern1
},
pattern2 => {
// code to execute if value matches pattern2
},
// etc.
}
Voici comment vous pouvez utiliser les instructions match dans vos programmes :
let grade = 'B';
match grade {
'A' => println!("Excellent work!"),
'B' => println!("Good job."),
'C' => println!("You could do better."),
_ => println!("That's not a valid grade."),
}
L’instruction grade est un caractère, et la variable match vérifie lequel des caractères est évalué à la valeur de la variable grade avant d’exécuter le code après l’opérateur => ;. Vous pouvez utiliser le motif de soulignement (_) pour faire correspondre des valeurs qui ne correspondent pas à d’autres motifs (motif par défaut).
Les boucles en Rust
Les boucles sont une construction fondamentale utilisée pour les tâches répétitives comme le web scraping et d’autres actions automatisées. Rust propose différents types de boucles, notamment while boucles, pour et les boucles boucle boucle.
Les boucles while de Rust
Les boucles while répètent un bloc de code tant qu’une condition spécifiée est évaluée comme vraie. Avant de spécifier la condition, vous spécifiez les boucles while en Rust avec l’attribut while mot-clé.
while condition {
// code to execute
}
La condition doit être une expression booléenne qui détermine la suite de la boucle. Lorsque la condition est évaluée comme étant fausse, la boucle se termine.
Voici un exemple de boucle while en Rust qui imprime les nombres de un à cinq.
fn main() {
let mut i = 1;
while i <= 5 {
println!("{}", i);
i += 1;
}
}
La boucle while dans le principal parcourt les nombres de un à cinq tout en incrémentant la fonction i variable par un jusqu’à ce que i est supérieure à cinq, où la boucle se termine.
La boucle Loop
La boucle crée une boucle infinie jusqu’à ce que vous indiquiez une sortie avec le mot-clé break mot-clé.
loop {
// code to execute
if condition {
break;
}
}
Le code dans le boucle continuera à s’exécuter jusqu’à ce que la boucle rencontre un bloc break mot-clé.
Voici un exemple d’utilisation du mot-clé boucle boucle pour imprimer les nombres de un à cinq avant de spécifier l’option break mot-clé pour la sortie.
fn main() {
let mut i = 1;
loop {
println!("{}", i);
i += 1;
if i > 5 {
break;
}
}
}
Le principal exécute la boucle, et la fonction si incrémente la valeur de l’instruction i variable. La variable si spécifie la fin de la boucle lorsque l’instruction i La variable est supérieure à cinq.
Rust pour les boucles
En Rust, les boucles for itèrent sur une plage ou une collection de valeurs. Vous utiliserez l’élément for pour lancer une boucle for, avant de spécifier la plage ou la collection sur laquelle elle agit.
for variable in range {
// code to execute
}
L’option gamme est une expression qui s’évalue en une séquence de valeurs, et la variable est une variable qui prend chaque valeur de la séquence à tour de rôle. Le bloc de code s’exécute une fois pour chaque valeur de la séquence.
Voici un exemple de boucle for qui imprime des valeurs allant de un à dix.
fn main() {
for i in 1..=10 {
println!("{}", i);
}
}
La boucle itère à travers les valeurs de 1 à 10. À chaque itération, la variable (i) contient la valeur suivante, que la variable println ! La macro s’imprime alors.
Vous pouvez utiliser la macro continuer pour sauter des valeurs dans les boucles for. Voici comment vous pouvez sauter les nombres pairs lorsque vous opérez sur une plage :
fn main() {
for num in 1..=10 {
if num % 2 == 0 {
continue; // skip even numbers
}
println!("{}", num); // print odd numbers
}
}
Le mot-clé si utilise l’instruction continuer pour spécifier que la boucle doit sauter les nombres divisibles par deux.
En outre, vous pouvez sortir d’une boucle for avec la commande break mot-clé. La boucle se termine lorsqu’elle rencontre le mot-clé break mot-clé.
fn main() {
for num in 1..=10 {
if num == 5 {
break; // exit loop when number equals 5
}
println!("{}", num); // print numbers 1 to 4
}
}
Les si spécifie que la boucle doit se terminer lorsque l’instruction i La variable est égale à cinq.
Les structures de contrôle et les types de données de Rust 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 comme les tableaux, les vecteurs, les structures et les enums.
Rust fournit également des structures. Les structures sont des structures de données qui regroupent des valeurs connexes en un seul objet. Elles sont similaires aux classes des langages orientés objet, et vous pouvez même définir des méthodes sur elles.
