Break et continue en Rust

break et continue vous permettent d’interrompre une boucle plus tôt au lieu de toujours la laisser aller jusqu’au bout. Ils fonctionnent de la même façon dans les trois types de boucles : loop, while et for.

break : sortir complètement de la boucle

break arrête la boucle immédiatement, et l’exécution reprend juste après elle :

fn main() {
    for i in 1..=10 {
        if i == 5 {
            break;
        }
        println!("{i}");
    }
}

Sortie :

1
2
3
4

▶ Essayez par vous-même

Même si l’intervalle va jusqu’à 10, la boucle s’arrête dès que i atteint 5.

continue : passer au tour suivant

continue saute le reste du tour en cours et passe directement au suivant, sans arrêter la boucle :

fn main() {
    for i in 1..=10 {
        if i % 2 == 0 {
            continue; // on saute les nombres pairs
        }
        println!("{i}");
    }
}

Sortie :

1
3
5
7
9

▶ Essayez par vous-même

Chaque nombre pair est sauté : continue se déclenche, et la boucle passe directement à la valeur suivante de i sans exécuter println!.

Les boucles avec étiquette

Quand vous imbriquez une boucle dans une autre, un simple break ou continue n’agit que sur la boucle la plus intérieure. Pour sortir d’une boucle extérieure depuis une boucle imbriquée, donnez une étiquette (label) à la boucle extérieure, écrite 'nom: :

fn main() {
    'outer: for x in 1..=3 {
        for y in 1..=3 {
            if x * y > 4 {
                break 'outer;
            }
            println!("{x} x {y} = {}", x * y);
        }
    }
}

Sortie :

1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
2 x 1 = 2
2 x 2 = 4

▶ Essayez par vous-même

Sans l’étiquette, break n’arrêterait que la boucle intérieure sur y, et x continuerait. break 'outer; arrête les deux d’un coup. continue 'outer; fonctionne de la même manière, si vous voulez passer au tour suivant de la boucle extérieure au lieu de tout arrêter.

Note

Vous aurez rarement besoin d’étiquettes : la plupart du code n’imbrique que deux niveaux de boucles, et bien souvent on n’a jamais besoin de sortir de la boucle extérieure. C’est bon à reconnaître quand vous en croisez une, mais ce n’est pas un réflexe à prendre.

Le piège de continue dans les boucles while

Dans une boucle for, la valeur suivante vient automatiquement de l’intervalle, donc continue est toujours sans danger. Une boucle while est différente : c’est vous qui mettez à jour le compteur, en général en bas du corps. Si continue saute par-dessus cette mise à jour, le compteur ne change jamais et la boucle tourne indéfiniment.

Cette version essaie de sauter le 3, mais elle se bloque. Ne l’exécutez pas :

fn main() {
    let mut i = 0;
    while i < 5 {
        if i == 3 {
            continue; // ❌ remonte au début sans modifier i
        }
        println!("{i}");
        i += 1;
    }
}

Quand i vaut 3, continue revient à la condition. i vaut toujours 3, donc continue se déclenche encore, et encore, sans fin. La solution est de mettre à jour le compteur avant tout ce qui pourrait faire un continue :

fn main() {
    let mut i = 0;
    while i < 5 {
        i += 1; // on met à jour d'abord, pour que continue ne puisse pas le sauter
        if i == 3 {
            continue;
        }
        println!("{i}");
    }
}

Sortie :

1
2
4
5

▶ Essayez par vous-même

Déplacer i += 1 en haut décale les nombres d’une unité : cette boucle affiche 1 à 5 au lieu de 0 à 4. Ajustez donc le départ ou la condition si vous avez besoin de l’ancien intervalle. Mieux encore : si vous ne faites que compter, utilisez une boucle for sur un intervalle, et le problème ne peut plus se produire.

Exercices

1. Sauter les multiples de 3

Affichez les nombres de 1 à 10, mais sautez tous les multiples de 3. Indice : un nombre est un multiple de 3 quand n % 3 == 0. Utilisez continue pour le sauter.

Voir la solution

fn main() {
    for n in 1..=10 {
        if n % 3 == 0 {
            continue;
        }
        println!("{n}");
    }
}

Sortie :

1
2
4
5
7
8
10

▶ Essayez par vous-même

2. Trouver une paire dont le produit vaut 24

Utilisez deux boucles for imbriquées, x et y, toutes deux sur 1..=9. Trouvez la première paire telle que x * y == 24, affichez-la et arrêtez les deux boucles. Indice : mettez une étiquette sur la boucle extérieure et utilisez break 'outer;.

Voir la solution

fn main() {
    'outer: for x in 1..=9 {
        for y in 1..=9 {
            if x * y == 24 {
                println!("Trouvé : {x} x {y} = 24");
                break 'outer;
            }
        }
    }
    println!("Recherche terminée");
}

Sortie :

Trouvé : 3 x 8 = 24
Recherche terminée

▶ Essayez par vous-même

Essayez de remplacer break 'outer; par un simple break;. Cette fois, seule la boucle intérieure s’arrête : la recherche continue et affiche aussi 4 x 6, 6 x 4 et 8 x 3.

Récapitulatif

• break sort immédiatement de la boucle.
• continue saute le reste du tour en cours et passe au suivant.
• Une étiquette ('outer:) permet à break ou continue de viser une boucle extérieure depuis une boucle imbriquée.
• Dans une boucle while, mettez à jour le compteur avant tout continue, sinon la boucle peut rester bloquée pour toujours.

Petit quiz

Petit quiz

1. Que fait continue dans une boucle ?

Il arrête complètement la boucle Il saute le reste du tour en cours et passe au suivant Il redémarre la boucle depuis son tout premier tour

2. Comment écrire une étiquette sur une boucle pour que break puisse la viser depuis une boucle imbriquée ?

#outer @outer 'outer:

3. Une boucle while contenant continue ne se termine jamais. Quelle est la cause la plus probable ?

continue saute la ligne qui met à jour le compteur On ne peut pas utiliser continue dans une boucle while La boucle a besoin d'une étiquette

Score : 0 / 3

Pour aller plus loin

• Loop Labels to Disambiguate Between Multiple Loops — The Rust Book (en anglais) : la présentation officielle des étiquettes, avec un compte à rebours imbriqué.
• Nesting and labels — Rust by Example (en anglais) : un court exemple exécutable de break 'outer et continue 'outer.
• Loop Labels — The Rust Reference (en anglais) : les règles exactes sur l’emploi des étiquettes.
• Expressions break — The Rust Reference (en anglais) : le fonctionnement de break, y compris break avec une valeur.
• Expressions continue — The Rust Reference (en anglais) : ce que fait continue dans chaque type de boucle.