Bezeichnete Anweisung

label:
  statement

label

Jeder JavaScript-Bezeichner, der kein reserviertes Wort ist.

statement

Eine JavaScript-Anweisung. break kann innerhalb jeder bezeichneten Anweisung verwendet werden und continue kann innerhalb von bezeichneten Schleifenanweisungen verwendet werden.

Sie können eine Bezeichnung verwenden, um eine Anweisung zu identifizieren und später mit einer break- oder continue-Anweisung darauf zu verweisen. Beachten Sie, dass JavaScript keine goto-Anweisung hat; Sie können Bezeichnungen nur mit break oder continue verwenden.

Jede break oder continue, die sich auf label bezieht, muss innerhalb der statement sein, die durch label bezeichnet wird. Betrachten Sie label als eine Variable, die nur im Geltungsbereich von statement verfügbar ist.

Wenn eine break label;-Anweisung bei der Ausführung von statement erreicht wird, wird die Ausführung von statement beendet und die Ausführung wird bei der Anweisung direkt nach der bezeichneten Anweisung fortgesetzt.

continue label; kann nur verwendet werden, wenn statement eine der Schleifenanweisungen ist. Wenn eine continue label;-Anweisung bei der Ausführung von statement erreicht wird, wird die Ausführung von statement bei der nächsten Iteration der Schleife fortgesetzt. continue; ohne Bezeichnung kann nur die innerste Schleife fortsetzen, während continue label; das Fortsetzen einer beliebigen Schleife ermöglicht, selbst wenn die Anweisung in anderen Schleifen verschachtelt ist.

Eine Anweisung kann mehrere Bezeichnungen haben. In diesem Fall sind die Bezeichnungen funktional gleichwertig.

// 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.

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 erreicht wird, wird die Ausführung der äußeren Schleife beendet, sodass es keine weiteren Ausgaben über "i = 1, j = 0" hinaus gibt; wenn continue loop1 erreicht wird, wird die Ausführung der äußeren Schleife bei der nächsten Iteration fortgesetzt, sodass nur "i = 1, j = 1" und "i = 1, j = 2" übersprungen werden.

Angenommen, es gibt 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 keine Bezeichnung verwenden, müssten Sie stattdessen eine boolesche Variable 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++;
  }
}

Angenommen, es gibt 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;
    }
  }
}

Erneut, wenn Sie keine Bezeichnung verwenden, müssten Sie stattdessen eine boolesche Variable 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;
  }
}

Sie können auch andere Anweisungen als Schleifen kennzeichnen, wie einfache Blöcke, aber nur break-Anweisungen können sich auf nicht-Schleifen-Bezeichnungen beziehen.

foo: {
  console.log("face");
  break foo;
  console.log("this will not be executed");
}
console.log("swap");

// Logs:
// "face"
// "swap"

Bezeichnungen können nur auf Anweisungen, nicht auf Deklarationen angewendet werden. Es gibt eine veraltete Grammatik, die es erlaubt, Funktionsdeklarationen in nicht-striktem Code zu kennzeichnen:

L: function F() {}

In Strict-Modus-Code führt dies jedoch zu einem SyntaxError:

"use strict";
L: function F() {}
// SyntaxError: functions cannot be labelled

Nicht-einfache Funktionen, wie Generatorfunktionen und asynchrone Funktionen können weder in strikt noch in nicht-striktem Code gekennzeichnet werden:

L: function* F() {}
// SyntaxError: generator functions cannot be labelled

Die Syntax der bezeichneten Funktionsdeklaration ist veraltet und sollte nicht verwendet werden, selbst in nicht-striktem Code. Sie können tatsächlich nicht innerhalb des Funktionskörpers zu dieser Bezeichnung springen.

• break
• continue