Section courante

A propos

Section administrative du site

break

 Arrêt
Rust

Syntaxe

loop {
   if condition {
      break;
   }
}
let valeur = loop {
   if condition {
      break valeur; // renvoie la valeur spécifié
   }
};
'label_externe: loop {
   loop {
      break 'label_externe;
   }
}

Paramètres

Nom Description
break valeur Ce paramètre permet de quitter la boucle en renvoyant une valeur spécifique à l'expression de boucle, utilisable quand la boucle est affectée à une variable.
'label_externe Ce paramètre permet de spécifier un label de boucle externe pour sortir d'une boucle imbriquée particulière, en ciblant précisément la boucle à interrompre.

Description

Ce mot réservé permet de quitter une boucle immédiatement.

Remarques

Quittez prématurément une boucle ou un bloc étiqueté.

Lorsqu'une interruption survient, l'exécution du corps de la boucle associée est immédiatement interrompue.

  1. let mut last = 0;
  2.  
  3. for x in 1..100 {
  4.     if x > 12 {
  5.         break;
  6.     }
  7.     last = x;
  8. }
  9.  
  10. assert_eq!(last, 12);
  11. println!("{last}");

Une expression de rupture est normalement associée à la boucle la plus interne entourant la rupture, mais une étiquette peut être utilisée pour spécifier quelle boucle englobante est affectée.

  1. 'outer: for i in 1..=5 {
  2.     println!("itération externe (i): {i}");
  3.  
  4.     '_inner: for j in 1..=200 {
  5.         println!(" itération interne (j): {j}");
  6.         if j >= 3 {
  7.             // rompt la boucle intérieure et laisse la boucle extérieure continuer.
  8.             break;
  9.         }
  10.         if i >= 2 {
  11.             // s'arrête à partir de la boucle externe et passe directement à «Au revoir».
  12.             break 'outer;
  13.         }
  14.     }
  15. }
  16. println!("Au revoir.");

Lorsqu'elle est associée à une boucle, une expression break peut être utilisée pour renvoyer une valeur de cette boucle. Ceci n'est valable qu'avec une boucle et non avec d'autres types de boucles. Si aucune valeur n'est spécifiée pour break, elle renvoie (). Chaque break dans une boucle doit renvoyer le même type.

  1. let (mut a, mut b) = (1, 1);
  2. let result = loop {
  3.     if b > 10 {
  4.         break b;
  5.     }
  6.     let c = a + b;
  7.     a = b;
  8.     b = c;
  9. };
  10. // premier nombre de la suite de Fibonacci supérieur à 10 :
  11. assert_eq!(result, 13);
  12. println!("{result}");

Il est également possible de quitter tout bloc étiqueté renvoyant la valeur plus tôt que prévu. Si aucune valeur n'est spécifiée pour break, la fonction renvoie ().

  1. let inputs = vec!["Vache", "Chat", "Chien", "Serpent", "Morue"];
  2.  
  3. let mut results = vec![];
  4. for input in inputs {
  5.     let result = 'filter: {
  6.         if input.len() > 4 {
  7.             break 'filter Err("Trop long");
  8.         };
  9.  
  10.         if !input.contains("C") {
  11.             break 'filter Err("Pas de C");
  12.         };
  13.  
  14.         Ok(input.to_uppercase())
  15.     };
  16.  
  17.     results.push(result);
  18. }
  19.  
  20. // [Ok("Trop long"), Ok("CHAT"), Err("Pas de C"), Err("Trop long"), Ok("Trop long")]
  21. println!("{:?}", results)

Dernière mise à jour : Vendredi, le 1er Août 2025