Break und Continue in Rust

Mit break und continue unterbrichst du eine Schleife vorzeitig, statt sie immer bis zum Ende laufen zu lassen. Beide funktionieren in allen drei Schleifenarten gleich: loop, while und for.

break – die Schleife ganz verlassen

break stoppt die Schleife sofort. Das Programm macht direkt mit dem weiter, was nach der Schleife kommt:

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

Ausgabe:

1
2
3
4

▶ Selbst ausprobieren

Obwohl der Bereich bis 10 geht, hört die Schleife in dem Moment auf, in dem i die 5 erreicht.

continue – weiter zur nächsten Runde

continue überspringt den Rest des aktuellen Durchlaufs und springt direkt zum nächsten. Die Schleife selbst läuft weiter:

fn main() {
    for i in 1..=10 {
        if i % 2 == 0 {
            continue; // gerade Zahlen überspringen
        }
        println!("{i}");
    }
}

Ausgabe:

1
3
5
7
9

▶ Selbst ausprobieren

Jede gerade Zahl wird übersprungen: continue greift, und die Schleife geht sofort zum nächsten Wert von i, ohne println! auszuführen.

Schleifen mit Labels

Steckt eine Schleife in einer anderen, wirken break und continue nur auf die innerste Schleife. Willst du aus einer verschachtelten Schleife heraus die äußere verlassen, gib der äußeren Schleife ein Label (eine Marke). Du schreibst es als 'name::

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);
        }
    }
}

Ausgabe:

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

▶ Selbst ausprobieren

Ohne das Label würde break nur die innere y-Schleife stoppen, und x würde weiterlaufen. break 'outer; stoppt beide auf einmal. continue 'outer; funktioniert genauso – damit springst du zur nächsten Runde der äußeren Schleife, statt ganz aufzuhören.

Hinweis

Schleifen mit Labels brauchst du nicht oft. Meist sind Schleifen höchstens zwei Ebenen tief verschachtelt, und oft musst du die äußere gar nicht verlassen. Du solltest sie erkennen, wenn sie dir begegnen – aber greif nicht standardmäßig zu ihnen.

Die continue-Falle in while-Schleifen

In einer for-Schleife kommt der nächste Wert automatisch aus dem Bereich, continue ist dort also immer sicher. Bei einer while-Schleife ist das anders: Du aktualisierst den Zähler, meist ganz unten im Rumpf. Springt continue über diese Aktualisierung hinweg, ändert sich der Zähler nie, und die Schleife läuft endlos.

Diese Version soll die 3 überspringen, bleibt aber hängen. Führ sie nicht aus:

fn main() {
    let mut i = 0;
    while i < 5 {
        if i == 3 {
            continue; // ❌ springt zurück nach oben, ohne i zu ändern
        }
        println!("{i}");
        i += 1;
    }
}

Wenn i gleich 3 ist, springt continue zurück zur Bedingung. i ist immer noch 3, also greift continue wieder und wieder – für immer. Die Lösung: Aktualisiere den Zähler vor allem, was continue auslösen könnte:

fn main() {
    let mut i = 0;
    while i < 5 {
        i += 1; // zuerst erhöhen, damit continue es nicht überspringen kann
        if i == 3 {
            continue;
        }
        println!("{i}");
    }
}

Ausgabe:

1
2
4
5

▶ Selbst ausprobieren

Wenn du i += 1 nach oben verschiebst, verschieben sich die Zahlen um eins: Diese Schleife gibt 1 bis 5 aus statt 0 bis 4. Pass also den Startwert oder die Bedingung an, wenn du den alten Bereich brauchst. Noch besser: Wenn du nur zählst, nimm eine for-Schleife über einen Bereich – dann kann das Problem gar nicht erst auftreten.

Übungen

1. Vielfache von 3 überspringen

Gib die Zahlen von 1 bis 10 aus, aber überspring jedes Vielfache von 3. Tipp: Eine Zahl ist ein Vielfaches von 3, wenn n % 3 == 0 gilt. Überspring sie mit continue.

Lösung anzeigen

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

Ausgabe:

1
2
4
5
7
8
10

▶ Selbst ausprobieren

2. Ein Paar finden, dessen Produkt 24 ist

Nimm zwei verschachtelte for-Schleifen, x und y, beide über 1..=9. Finde das erste Paar mit x * y == 24, gib es aus und stoppe beide Schleifen. Tipp: Gib der äußeren Schleife ein Label und nimm break 'outer;.

Lösung anzeigen

fn main() {
    'outer: for x in 1..=9 {
        for y in 1..=9 {
            if x * y == 24 {
                println!("Gefunden: {x} x {y} = 24");
                break 'outer;
            }
        }
    }
    println!("Suche beendet");
}

Ausgabe:

Gefunden: 3 x 8 = 24
Suche beendet

▶ Selbst ausprobieren

Ersetz break 'outer; einmal durch ein einfaches break;. Dann stoppt nur die innere Schleife, die Suche geht weiter, und es werden auch 4 x 6, 6 x 4 und 8 x 3 ausgegeben.

Zusammenfassung

• break verlässt die Schleife sofort.
• continue überspringt den Rest des aktuellen Durchlaufs und macht mit dem nächsten weiter.
• Mit einem Label ('outer:) können break und continue aus einer verschachtelten Schleife heraus eine äußere Schleife ansteuern.
• Aktualisiere in einer while-Schleife deinen Zähler vor jedem continue, sonst kann die Schleife für immer hängen bleiben.

Kurzer Check

Kurzer Check

1. Was macht continue in einer Schleife?

Es stoppt die Schleife komplett Es überspringt den Rest des aktuellen Durchlaufs und macht mit dem nächsten weiter Es startet die Schleife wieder ganz von vorn

2. Wie schreibst du ein Label an eine Schleife, damit break sie aus einer verschachtelten Schleife heraus ansteuern kann?

#outer @outer 'outer:

3. Eine while-Schleife mit continue endet nie. Was ist die wahrscheinlichste Ursache?

continue überspringt die Zeile, die den Zähler aktualisiert continue darf in while-Schleifen nicht verwendet werden Die Schleife braucht ein Label

Punkte: 0 / 3

Weiterlesen

• Schleifenlabel zur eindeutigen Unterscheidung – Das Rust-Buch: die offizielle Einführung in Labels, mit einem verschachtelten Countdown als Beispiel.
• Nesting and labels – Rust by Example (auf Englisch): ein kurzes, ausführbares Beispiel für break 'outer und continue 'outer.
• Loop Labels – The Rust Reference (auf Englisch): die genauen Regeln dafür, wo Labels erlaubt sind.
• break-Ausdrücke – The Rust Reference (auf Englisch): wie break funktioniert, auch break mit einem Wert.
• continue-Ausdrücke – The Rust Reference (auf Englisch): was continue in jeder Schleifenart bewirkt.