break, continue & Labels

break in Schleifen

break verlässt die Schleife sofort. Die Ausführung springt zur ersten Anweisung nach der Schleife.

function findeErsteGerade(arr) {
    for (const x of arr) {
        if (x % 2 === 0) {
            return x;   // alternativ: break + Variable
        }
    }
    return undefined;
}

console.log(findeErsteGerade([1, 3, 7, 4, 9])); // 4

// Klassisch mit break
const arr = [1, 3, 7, 4, 9];
let gefunden;
for (const x of arr) {
    if (x % 2 === 0) {
        gefunden = x;
        break;   // sofortiger Ausstieg
    }
}
console.log(gefunden); // 4

4
4

In Funktionen ist meist return lesbarer als break mit Variable — keine Zwischen-Schritte, keine Variable außerhalb der Schleife. break ist relevant, wenn man die Schleife verlässt, aber nicht die ganze Funktion.

break in switch

break ist in switch der Standard-Terminator, um Fall-through zu verhindern. Detail-Behandlung im switch-Artikel.

function farbe(level) {
    let result;
    switch (level) {
        case 'info':  result = 'blue';   break;
        case 'warn':  result = 'orange'; break;
        case 'error': result = 'red';    break;
        default:      result = 'gray';
    }
    return result;
}

console.log(farbe('warn')); // 'orange'

orange

continue — zur nächsten Iteration

continue überspringt den Rest des aktuellen Schleifen-Durchlaufs. In for springt es zum Update-Teil (i++ etc.), in while direkt zur Bedingung.

// Nur gerade Zahlen verarbeiten
for (let i = 0; i < 10; i++) {
    if (i % 2 !== 0) continue;
    console.log('gerade:', i);
}

gerade: 0
gerade: 2
gerade: 4
gerade: 6
gerade: 8

continue ist eine Stil-Frage: manche Style-Guides bevorzugen die invertierte Form if (gerade) { ... } ohne continue, andere finden continue als Guard-Clause der Schleife klarer. Für lange Schleifen-Bodies mit mehreren Filter-Bedingungen sind frühe continue-Statements analog zu Early-Returns oft die Sieger.

Standardmäßig nur die innerste Schleife

Sowohl break als auch continue wirken nur auf die innerste umschließende Schleife.

for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (j === 1) break;   // bricht NUR die innere Schleife ab
        console.log(`i=${i}, j=${j}`);
    }
}

i=0, j=0
i=1, j=0
i=2, j=0

Die äußere i-Schleife läuft normal weiter. Für „beide Schleifen verlassen" braucht es entweder ein Label, ein Flag, eine ausgelagerte Funktion mit return oder eine throw-Konstruktion (zu drastisch).

Labels — name: schleife

Eine Label-Definition ist ein Identifier gefolgt von Doppelpunkt, direkt vor einer Schleife oder einem Block. Mit break name; oder continue name; adressiert man dann genau dieses Label.

aussen: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (j === 1) break aussen;   // bricht BEIDE Schleifen
        console.log(`i=${i}, j=${j}`);
    }
}

i=0, j=0

Das gleiche funktioniert mit continue: continue label springt in den Update-/Bedingungs-Teil der labelten Schleife.

aussen: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (j === 1) continue aussen;  // nächstes i
        console.log(`i=${i}, j=${j}`);
    }
}

i=0, j=0
i=1, j=0
i=2, j=0

Diese Form ist die einzige, in der continue label außerhalb der labelten Schleife semantisch Sinn ergibt: vom Inneren der inneren Schleife direkt in den nächsten Durchlauf der äußeren springen.

Labels auf Blöcken

Labels können auch Blöcke kennzeichnen — nicht nur Schleifen. Mit break label; lässt sich der Block dann „nach unten" verlassen.

verarbeitung: {
    console.log('Start');

    if (true) break verarbeitung;  // verlässt den Block

    console.log('Nie erreicht');
}
console.log('Nach Block');

Start
Nach Block

Das ist eine sehr seltene Form. Manche Codebasen nutzen sie als „strukturiertes goto" für komplexe Validierungs-Logik. In den meisten Fällen ist eine Funktion mit Early-Returns lesbarer.

Alternativen zu Labels

In modernen Codebasen sind Labels selten. Die häufigeren Wege, denselben Effekt zu erreichen:

// Variante 1: Funktion mit return
function suche(matrix, ziel) {
    for (let i = 0; i < matrix.length; i++) {
        for (let j = 0; j < matrix[i].length; j++) {
            if (matrix[i][j] === ziel) return [i, j];
        }
    }
    return null;
}
console.log(suche([[1, 2], [3, 4]], 4)); // [1, 1]

// Variante 2: Flag
function sucheFlag(matrix, ziel) {
    let pos = null;
    outerSearch:
    for (let i = 0; i < matrix.length; i++) {
        for (let j = 0; j < matrix[i].length; j++) {
            if (matrix[i][j] === ziel) {
                pos = [i, j];
                break outerSearch;
            }
        }
    }
    return pos;
}
console.log(sucheFlag([[1, 2], [3, 4]], 4));

// Variante 3: some / find — fertige Methoden
function sucheFunctional(matrix, ziel) {
    const i = matrix.findIndex(row => row.includes(ziel));
    if (i < 0) return null;
    return [i, matrix[i].indexOf(ziel)];
}
console.log(sucheFunctional([[1, 2], [3, 4]], 4));

[ 1, 1 ]
[ 1, 1 ]
[ 1, 1 ]

Faustregel: Funktion mit return ist meist die sauberste Form. Labels sind das letzte Mittel, wenn die Funktion aus anderen Gründen nicht zerlegt werden soll.

Label-Konventionen

Labels sind keine Variablen — sie leben in einem eigenen Namensraum. Aber Style-Guides empfehlen klare Konvention:

• Labels GROSSGESCHRIEBEN oder mit Suffix (_loop, _block) — visuell von Variablen unterscheidbar.
• Nur direkt vor der Schleife/dem Block — kein Code dazwischen.
• Niemals mit Variablen-Namen kollidieren — auch wenn die Sprache es erlauben würde.

// Empfohlene Konvention
OUTER: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (i * j > 4) break OUTER;
        console.log(i, j);
    }
}

0 0
0 1
0 2
1 0
1 1
1 2
2 0
2 1
2 2

ESLint hat dazu die Regeln no-labels (Labels komplett verbieten) und no-extra-label (unnötige Labels). Viele Codebasen aktivieren no-labels als Default und erlauben sie nur per // eslint-disable-next-line.

break/continue funktioniert NICHT in forEach

arr.forEach(callback) ruft den Callback in einer eigenen Funktion auf. Innerhalb einer Funktion sind break und continue ungültig — SyntaxError.

[1, 2, 3].forEach(x => {
    if (x === 2) break;  // SyntaxError: Illegal break statement
    console.log(x);
});

Lösungsalternativen, wenn man Abbruch braucht:

• for...of mit break — die idiomatische Wahl.
• Array.prototype.some() — bricht ab, sobald der Callback truthy zurückgibt.
• Array.prototype.every() — bricht ab, sobald der Callback falsy zurückgibt.
• Array.prototype.find()/findIndex() — wenn man genau ein Element sucht.

// some als Abbruch-Mechanik
[1, 2, 3, 4].some(x => {
    console.log('verarbeite', x);
    return x === 2;   // true → some bricht ab
});

verarbeite 1
verarbeite 2

some als Abbruch-Werkzeug ist syntaktisch ein bisschen schräg (der Boolean-Rückgabewert ist „eigentlich" der Treffer-Indikator, nicht ein „brich-jetzt-ab"-Signal). Lesbarer ist meist die for...of-Version.

Weiterführende Ressourcen

Externe Quellen

• break – MDN
• continue – MDN
• label – MDN
• Break Statement – ECMAScript Spec
• no-labels – ESLint

Verwandte Artikel

• for / while / do-while
• for-of vs. for-in
• switch und Fall-through
• if / else / Ternary
• try / catch / finally Grundlagen