Rouille - Boucle

Il peut y avoir des cas où un bloc de code doit être exécuté à plusieurs reprises. En général, les instructions de programmation sont exécutées séquentiellement: la première instruction d'une fonction est exécutée en premier, suivie de la seconde, et ainsi de suite.

Les langages de programmation fournissent diverses structures de contrôle qui permettent des chemins d'exécution plus compliqués.

Une instruction de boucle nous permet d'exécuter une instruction ou un groupe d'instructions plusieurs fois. Vous trouverez ci-dessous la forme générale d'une instruction de boucle dans la plupart des langages de programmation.

Rust fournit différents types de boucles pour gérer les exigences de bouclage -

• while
• loop
• for

Boucle définie

Une boucle dont le nombre d'itérations est défini / fixe est appelée boucle définie. lefor loop est une implémentation d'une boucle définie.

Pour la boucle

La boucle for exécute le bloc de code un nombre de fois spécifié. Il peut être utilisé pour parcourir un ensemble fixe de valeurs, tel qu'un tableau. La syntaxe de la boucle for est la suivante

Syntaxe

for temp_variable in lower_bound..upper_bound {
   //statements
}

Un exemple de boucle for est illustré ci-dessous

fn main(){
   for x in 1..11{ // 11 is not inclusive
      if x==5 {
         continue;
      }
      println!("x is {}",x);
   }
}

NOTE: que la variable x n'est accessible que dans le bloc for.

Production

x is 1
x is 2
x is 3
x is 4
x is 6
x is 7
x is 8
x is 9
x is 10

Boucle indéfinie

Une boucle indéfinie est utilisée lorsque le nombre d'itérations dans une boucle est indéterminé ou inconnu.

Des boucles indéfinies peuvent être implémentées en utilisant -

Sr. Non	Nom et description
1	While Le temps boucle exécute les instructions à chaque fois que la condition spécifiée est évaluée à true
2	Loop La boucle est une boucle indéfinie while (vraie)

Illustration - pendant quelque temps

fn main(){
   let mut x = 0;
   while x < 10{
      x+=1;
      println!("inside loop x value is {}",x);
   }
   println!("outside loop x value is {}",x);
}

La sortie est comme indiqué ci-dessous -

inside loop x value is 1
inside loop x value is 2
inside loop x value is 3
inside loop x value is 4
inside loop x value is 5
inside loop x value is 6
inside loop x value is 7
inside loop x value is 8
inside loop x value is 9
inside loop x value is 10
outside loop x value is 10

Illustration −loop

fn main(){
   //while true

   let mut x = 0;
   loop {
      x+=1;
      println!("x={}",x);

      if x==15 {
         break;
      }
   }
}

le breakL'instruction est utilisée pour retirer le contrôle d'une construction. L'utilisation de break in a loop provoque la sortie du programme de la boucle.

Production

x=1
x=2
x=3
x=4
x=5
x=6
x=7
x=8
x=9
x=10
x=11
x=12
x=13
x=14
x=15

Continuer la déclaration

L'instruction continue ignore les instructions suivantes dans l'itération actuelle et ramène le contrôle au début de la boucle. Contrairement à l'instruction break, le continue ne quitte pas la boucle. Il met fin à l'itération en cours et démarre l'itération suivante.

Un exemple de l'instruction continue est donné ci-dessous.

fn main() {

   let mut count = 0;

   for num in 0..21 {
      if num % 2==0 {
         continue;
      }
      count+=1;
   }
   println! (" The count of odd values between 0 and 20 is: {} ",count);
   //outputs 10
}

L'exemple ci-dessus affiche le nombre de valeurs paires entre 0 et 20. La boucle quitte l'itération actuelle si le nombre est pair. Ceci est réalisé en utilisant l'instruction continue.

Le nombre de valeurs impaires entre 0 et 20 est de 10