Rust - Prise de décision

Les structures de prise de décision exigent que le programmeur spécifie une ou plusieurs conditions à évaluer ou à tester par le programme, ainsi qu'une ou plusieurs instructions à exécuter si la condition est jugée vraie, et éventuellement d'autres instructions à exécuter si le condition est considérée comme fausse.

Vous trouverez ci-dessous la forme générale d'une structure de prise de décision typique trouvée dans la plupart des langages de programmation -

Sr. Non	Déclaration et description
1	if statement Une instruction if consiste en une expression booléenne suivie d'une ou plusieurs instructions.
2	if...else statement Une instruction if peut être suivie d'une instruction else facultative , qui s'exécute lorsque l'expression booléenne est fausse.
3	else...if and nested ifstatement Vous pouvez utiliser une instruction if ou else if dans une autre instruction if ou else if .
4	match statement Une instruction de correspondance permet à une variable d'être testée par rapport à une liste de valeurs.

Si déclaration

La construction if… else évalue une condition avant qu'un bloc de code ne soit exécuté.

Syntaxe

if boolean_expression {
   // statement(s) will execute if the boolean expression is true
}

Si l'expression booléenne a la valeur true, le bloc de code à l'intérieur de l'instruction if sera exécuté. Si l'expression booléenne a la valeur false, le premier ensemble de code après la fin de l'instruction if (après l'accolade fermante) sera exécuté.

fn main(){
   let num:i32 = 5;
   if num > 0 {
      println!("number is positive") ;
   }
}

L'exemple ci-dessus s'imprimera number is positive car la condition spécifiée par le bloc if est vraie.

instruction if else

Un if peut être suivi d'une option elsebloquer. Le bloc else s'exécutera si l'expression booléenne testée par l'instruction if est évaluée à false.

Syntaxe

if boolean_expression {
   // statement(s) will execute if the boolean expression is true
} else {
   // statement(s) will execute if the boolean expression is false
}

Organigramme

le ifblock protège l'expression conditionnelle. Le bloc associé à l'instruction if est exécuté si l'expression booléenne prend la valeur true.

Le bloc if peut être suivi d'une instruction else facultative. Le bloc d'instructions associé au bloc else est exécuté si l'expression est évaluée à false.

Illustration - Simple si… sinon

fn main() {
   let num = 12;
   if num % 2==0 {
      println!("Even");
   } else {
      println!("Odd");
   }
}

L'exemple ci-dessus indique si la valeur d'une variable est paire ou impaire. Le bloc if vérifie la divisibilité de la valeur par 2 pour déterminer la même chose. Voici la sortie du code ci-dessus -

Even

Imbriqué si

le else…ifladder est utile pour tester plusieurs conditions. La syntaxe est la suivante -

Syntaxe

if boolean_expression1 {
   //statements if the expression1 evaluates to true
} else if boolean_expression2 {
   //statements if the expression2 evaluates to true
} else {
   //statements if both expression1 and expression2 result to false
}

Lorsque vous utilisez des déclarations if… else… if et else, il y a quelques points à garder à l'esprit.

• Un if peut avoir zéro ou un autre et il doit venir après tout autre..if.
• Un if peut avoir zéro à beaucoup d'autre..if et ils doivent venir avant l'autre.
• Une fois qu'un else..if réussit, aucun des autres..if ou else ne sera testé.

Exemple: sinon… si échelle

fn main() {
   let num = 2 ;
   if num > 0 {
      println!("{} is positive",num);
   } else if num < 0 {
      println!("{} is negative",num);
   } else {
      println!("{} is neither positive nor negative",num) ;
   }
}

L'extrait de code indique si la valeur est positive, négative ou nulle.

Production

2 is positive

Déclaration de correspondance

L'instruction match vérifie si une valeur actuelle correspond à partir d'une liste de valeurs, ceci est très similaire à l'instruction switch en langage C. En premier lieu, notez que l'expression qui suit le mot-clé match n'a pas à être placée entre parenthèses.

La syntaxe est la suivante.

let expressionResult = match variable_expression {
   constant_expr1 => {
      //statements;
   },
   constant_expr2 => {
      //statements;
   },
   _ => {
      //default
   }
};

Dans l'exemple ci-dessous, state_code correspond à une liste de valeurs MH, KL, KA, GA- si une correspondance est trouvée, une valeur de chaîne est renvoyée à l' état de variable . Si aucune correspondance n'est trouvée, le cas par défaut _ correspond et la valeur Unkown est renvoyée.

fn main(){
   let state_code = "MH";
   let state = match state_code {
      "MH" => {println!("Found match for MH"); "Maharashtra"},
      "KL" => "Kerala",
      "KA" => "Karnadaka",
      "GA" => "Goa",
      _ => "Unknown"
   };
   println!("State name is {}",state);
}

Production

Found match for MH
State name is Maharashtra