Labelierte Anweisung
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
Eine labelierte Anweisung ist jede Anweisung, die mit einem Bezeichner versehen ist. Sie können zu diesem Label mit einer verschachtelten break
- oder continue
-Anweisung innerhalb der labelierten Anweisung springen.
Probieren Sie es aus
Syntax
label:
statement
label
-
Jeder JavaScript-Bezeichner, der kein reserviertes Wort ist.
statement
-
Eine JavaScript-Anweisung.
break
kann innerhalb jeder labelierten Anweisung verwendet werden, undcontinue
kann innerhalb labelierter Schleifenanweisungen verwendet werden.
Beschreibung
Sie können ein Label verwenden, um eine Anweisung zu identifizieren, und später mit einer break
- oder continue
-Anweisung darauf verweisen. Beachten Sie, dass JavaScript keine goto
-Anweisung hat; Labels können nur mit break
oder continue
verwendet werden.
Jede break
- oder continue
-Anweisung, die sich auf label
bezieht, muss innerhalb der statement
liegen, die von label
etikettiert wird. Denken Sie an label
wie an eine Variable, die nur im Gültigkeitsbereich der statement
verfügbar ist.
Wenn eine break label;
-Anweisung während der Ausführung von statement
angetroffen wird, wird die Ausführung von statement
beendet und die Ausführung wird bei der Anweisung unmittelbar nach der labelierten Anweisung fortgesetzt.
continue label;
kann nur verwendet werden, wenn statement
eine der Schleifenanweisungen ist. Wenn eine continue label;
-Anweisung während der Ausführung von statement
angetroffen wird, wird die Ausführung von statement
mit der nächsten Iteration der Schleife fortgesetzt. continue;
ohne ein Label kann nur die innerste Schleife fortsetzen, während continue label;
das Fortsetzen einer beliebigen Schleife ermöglicht, auch wenn die Anweisung in anderen Schleifen verschachtelt ist.
Eine Anweisung kann mehrere Labels haben. In diesem Fall sind die Labels alle funktional gleichwertig.
Beispiele
Verwendung eines labelierten continue bei for-Schleifen
// The first for statement is labeled "loop1"
loop1: for (let i = 0; i < 3; i++) {
// The second for statement is labeled "loop2"
loop2: for (let j = 0; j < 3; j++) {
if (i === 1 && j === 1) {
continue loop1;
}
console.log(`i = ${i}, j = ${j}`);
}
}
// Logs:
// i = 0, j = 0
// i = 0, j = 1
// i = 0, j = 2
// i = 1, j = 0
// i = 2, j = 0
// i = 2, j = 1
// i = 2, j = 2
Beachten Sie, wie sowohl "i = 1, j = 1" als auch "i = 1, j = 2" übersprungen werden.
Verwendung eines labelierten break bei for-Schleifen
let i, j;
// The first for statement is labeled "loop1"
loop1: for (i = 0; i < 3; i++) {
// The second for statement is labeled "loop2"
loop2: for (j = 0; j < 3; j++) {
if (i === 1 && j === 1) {
break loop1;
}
console.log(`i = ${i}, j = ${j}`);
}
}
// Logs:
// i = 0, j = 0
// i = 0, j = 1
// i = 0, j = 2
// i = 1, j = 0
Beachten Sie den Unterschied zum vorherigen continue
-Beispiel: Wenn break loop1
angetroffen wird, wird die Ausführung der äußeren Schleife beendet, sodass keine weiteren Logs über "i = 1, j = 0" hinaus vorhanden sind; wenn continue loop1
angetroffen wird, wird die Ausführung der äußeren Schleife in der nächsten Iteration fortgesetzt, sodass nur "i = 1, j = 1" und "i = 1, j = 2" übersprungen werden.
Verwendung einer labelierten continue-Anweisung
Gegeben ein Array von Elementen und ein Array von Tests, zählt dieses Beispiel die Anzahl der Elemente, die alle Tests bestehen.
// Numbers from 1 to 100
const items = Array.from({ length: 100 }, (_, i) => i + 1);
const tests = [
{ pass: (item) => item % 2 === 0 },
{ pass: (item) => item % 3 === 0 },
{ pass: (item) => item % 5 === 0 },
];
let itemsPassed = 0;
itemIteration: for (const item of items) {
for (const test of tests) {
if (!test.pass(item)) {
continue itemIteration;
}
}
itemsPassed++;
}
Beachten Sie, wie die continue itemIteration;
-Anweisung den Rest der Tests für das aktuelle Element sowie die Anweisung, die den itemsPassed
-Zähler aktualisiert, überspringt und mit dem nächsten Element fortfährt. Wenn Sie kein Label verwenden, müssten Sie stattdessen ein boolesches Flag verwenden.
// Numbers from 1 to 100
const items = Array.from({ length: 100 }, (_, i) => i + 1);
const tests = [
{ pass: (item) => item % 2 === 0 },
{ pass: (item) => item % 3 === 0 },
{ pass: (item) => item % 5 === 0 },
];
let itemsPassed = 0;
for (const item of items) {
let passed = true;
for (const test of tests) {
if (!test.pass(item)) {
passed = false;
break;
}
}
if (passed) {
itemsPassed++;
}
}
Verwendung einer labelierten break-Anweisung
Gegeben ein Array von Elementen und ein Array von Tests, bestimmt dieses Beispiel, ob alle Elemente alle Tests bestehen.
// Numbers from 1 to 100
const items = Array.from({ length: 100 }, (_, i) => i + 1);
const tests = [
{ pass: (item) => item % 2 === 0 },
{ pass: (item) => item % 3 === 0 },
{ pass: (item) => item % 5 === 0 },
];
let allPass = true;
itemIteration: for (const item of items) {
for (const test of tests) {
if (!test.pass(item)) {
allPass = false;
break itemIteration;
}
}
}
Auch hier, wenn Sie kein Label verwenden, müssten Sie stattdessen ein boolesches Flag verwenden.
// Numbers from 1 to 100
const items = Array.from({ length: 100 }, (_, i) => i + 1);
const tests = [
{ pass: (item) => item % 2 === 0 },
{ pass: (item) => item % 3 === 0 },
{ pass: (item) => item % 5 === 0 },
];
let allPass = true;
for (const item of items) {
let passed = true;
for (const test of tests) {
if (!test.pass(item)) {
passed = false;
break;
}
}
if (!passed) {
allPass = false;
break;
}
}
Verwendung eines labelierten Blocks mit break
Sie können andere Anweisungen als Schleifen labelieren, z. B. einfache Blöcke, aber nur break
-Anweisungen können Nicht-Schleifen-Labels referenzieren.
foo: {
console.log("face");
break foo;
console.log("this will not be executed");
}
console.log("swap");
// Logs:
// "face"
// "swap"
Labelierte Funktionsdeklarationen
Labels können nur auf Anweisungen, nicht auf Deklarationen angewendet werden. Es gibt eine veraltete Grammatik, die es ermöglicht, Funktionsdeklarationen in nicht-striktem Code zu labeln:
L: function F() {}
Im Strict-Modus-Code wird dies jedoch einen SyntaxError
auslösen:
"use strict";
L: function F() {}
// SyntaxError: functions cannot be labelled
Nicht-gewöhnliche Funktionen, wie Generatorfunktionen und asynchrone Funktionen können weder in striktem noch in nicht-striktem Code gelabelt werden:
L: function* F() {}
// SyntaxError: generator functions cannot be labelled
Die Syntax der labelierten Funktionsdeklaration ist veraltet und sollte nicht verwendet werden, selbst in nicht-striktem Code. Sie können innerhalb des Funktionskörpers nicht tatsächlich zu diesem Label springen.
Spezifikationen
Specification |
---|
ECMAScript Language Specification # sec-labelled-statements |
Browser-Kompatibilität
BCD tables only load in the browser