switch — Anweisung · JavaScript-Referenz

Signatur

switch (expression) { case caseExpression1: statements … default: statements }

Beschreibung

Die switch-Anweisung wertet einen Ausdruck aus, vergleicht dessen Wert mit einer Reihe von case-Klauseln und führt die Anweisungen nach der ersten case-Klausel mit übereinstimmendem Wert aus, bis eine break-Anweisung erreicht wird. Die default-Klausel einer switch-Anweisung wird ausgeführt, wenn kein case mit dem Wert des Ausdrucks übereinstimmt.

Eine switch-Anweisung wertet zunächst ihren Ausdruck aus. Anschließend sucht sie die erste case-Klausel, deren Ausdruck denselben Wert wie das Ergebnis des Eingabeausdrucks ergibt (unter Verwendung des Vergleichs auf strikte Gleichheit), und übergibt die Kontrolle an diese Klausel, wobei alle Anweisungen nach dieser Klausel ausgeführt werden.

Die Klausel-Ausdrücke werden nur bei Bedarf ausgewertet — wenn bereits eine Übereinstimmung gefunden wurde, werden nachfolgende case-Klausel-Ausdrücke nicht ausgewertet, selbst wenn sie durch Fall-Through besucht würden.

Wenn keine passende case-Klausel gefunden wird, sucht das Programm nach der optionalen default-Klausel und übergibt bei deren Vorhandensein die Kontrolle an diese Klausel, wobei die Anweisungen nach dieser Klausel ausgeführt werden. Wird keine default-Klausel gefunden, setzt das Programm die Ausführung mit der Anweisung nach dem Ende von switch fort. Konventionell ist die default-Klausel die letzte Klausel, dies muss aber nicht so sein. Eine switch-Anweisung darf nur eine default-Klausel enthalten; mehrere default-Klauseln führen zu einem SyntaxError.

Breaking und Fall-Through

Sie können die break-Anweisung innerhalb eines switch-Rumpfes verwenden, um vorzeitig auszusteigen, oft wenn alle Anweisungen zwischen zwei case-Klauseln ausgeführt wurden. Die Ausführung wird mit der ersten Anweisung nach switch fortgesetzt.

Wird break weggelassen, fährt die Ausführung mit der nächsten case-Klausel fort, sogar mit der default-Klausel, unabhängig davon, ob der Wert des Klausel-Ausdrucks übereinstimmt. Dieses Verhalten wird „Fall-Through" genannt.

Im passenden Kontext haben auch andere Kontrollfluss-Anweisungen den Effekt, aus der switch-Anweisung auszubrechen. Zum Beispiel beendet eine return-Anweisung, wenn die switch-Anweisung in einer Funktion enthalten ist, die Ausführung des Funktionsrumpfes und damit auch der switch-Anweisung. Ist die switch-Anweisung in einer Schleife enthalten, stoppt eine continue-Anweisung die switch-Anweisung und springt zur nächsten Iteration der Schleife.

Lexikalisches Scoping

Die case- und default-Klauseln sind wie Labels: Sie zeigen mögliche Sprungziele des Kontrollflusses an. Sie erzeugen jedoch selbst keine lexikalischen Scopes (und brechen auch nicht automatisch aus — wie oben gezeigt). Um das zu beheben, sollten Sie eine case-Klausel, in der Sie let- oder const-Deklarationen verwenden müssen, in einen Block einwickeln.

Parameter

Name	Typ	Default	Beschreibung
$expression Pflicht	any	—	Ein Ausdruck, dessen Ergebnis mit jeder `case`-Klausel abgeglichen wird.
$caseExpressionN	any	—	Eine `case`-Klausel zum Vergleich mit `expression`. Stimmt der Wert von `expression` mit dem Wert eines `caseExpressionN` überein, beginnt die Ausführung mit der ersten Anweisung nach dieser `case`-Klausel und läuft entweder bis zum Ende der `switch`-Anweisung oder zum ersten angetroffenen `break`.
$default	clause	—	Eine `default`-Klausel; wenn angegeben, wird diese Klausel ausgeführt, falls der Wert von `expression` mit keiner der `case`-Klauseln übereinstimmt. Eine `switch`-Anweisung kann nur eine `default`-Klausel enthalten.

Rückgabewert

Typ

void

Beschreibung

Die switch-Anweisung hat keinen Rückgabewert; sie steuert den Kontrollfluss des Programms.

Beispiele

switch verwenden

switch (expr) {
  case "Oranges":
    console.log("Oranges are $0.59 a pound.");
    break;
  case "Apples":
    console.log("Apples are $0.32 a pound.");
    break;
  case "Bananas":
    console.log("Bananas are $0.48 a pound.");
    break;
  case "Cherries":
    console.log("Cherries are $3.00 a pound.");
    break;
  case "Mangoes":
  case "Papayas":
    console.log("Mangoes and papayas are $2.79 a pound.");
    break;
  default:
    console.log(`Sorry, we are out of ${expr}.`);
}

console.log("Is there anything else you'd like?");

Fall-Through-Beispiel mit break

const foo = 0;
switch (foo) {
  case -1:
    console.log("negative 1");
    break;
  case 0: // Value of foo matches this criteria; execution starts from here
    console.log(0);
  // Forgotten break! Execution falls through
  case 1: // no break statement in 'case 0:' so this case will run as well
    console.log(1);
    break; // Break encountered; will not continue into 'case 2:'
  case 2:
    console.log(2);
    break;
  default:
    console.log("default");
}
// Logs 0 and 1

Lexikalisches Scoping — Fehlerfall

const action = "say_hello";
switch (action) {
  case "say_hello":
    const message = "hello";
    console.log(message);
    break;
  case "say_hi":
    const message = "hi";
    console.log(message);
    break;
  default:
    console.log("Empty action received.");
}

Lexikalisches Scoping — Lösung mit Blöcken

const action = "say_hello";
switch (action) {
  case "say_hello": {
    const message = "hello";
    console.log(message);
    break;
  }
  case "say_hi": {
    const message = "hi";
    console.log(message);
    break;
  }
  default: {
    console.log("Empty action received.");
  }
}

default-Klausel zwischen zwei case-Klauseln platzieren

const foo = 5;
switch (foo) {
  case 2:
    console.log(2);
    break; // it encounters this break so will not continue into 'default:'
  default:
    console.log("default");
  // fall-through
  case 1:
    console.log("1");
}

Fall-Through nutzen — mehrere Werte pro Anweisung

const Animal = "Giraffe";
switch (Animal) {
  case "Cow":
  case "Giraffe":
  case "Dog":
  case "Pig":
    console.log("This animal is not extinct.");
    break;
  case "Dinosaur":
  default:
    console.log("This animal is extinct.");
}

Sequentielle Fall-Through-Anweisungen

const foo = 1;
let output = "Output: ";
switch (foo) {
  case 0:
    output += "So ";
  case 1:
    output += "What ";
    output += "Is ";
  case 2:
    output += "Your ";
  case 3:
    output += "Name";
  case 4:
    output += "?";
    console.log(output);
    break;
  case 5:
    output += "!";
    console.log(output);
    break;
  default:
    console.log("Please pick a number from 0 to 5!");
}

switch (true) mit Fall-Through

switch (true) {
  case isSquare(shape):
    console.log("This shape is a square.");
  // Fall-through, since a square is a rectangle as well!
  case isRectangle(shape):
    console.log("This shape is a rectangle.");
  case isQuadrilateral(shape):
    console.log("This shape is a quadrilateral.");
    break;
  case isCircle(shape):
    console.log("This shape is a circle.");
    break;
}

// Wichtig · Fallstricke

Strikter Vergleich: Der switch-Ausdruck wird mit === verglichen. Das bedeutet: switch ('1') trifft nicht auf case 1: zu – Typ-Koercion findet nicht statt.

Vergessenes break: Der häufigste Fehler. Ohne break am Ende eines case-Blocks fällt die Ausführung in den nächsten Block durch (fall-through), auch wenn dessen Bedingung nicht passt.
Variablen-Deklarationen: let und const im switch-Block ohne geschweifte Klammern teilen sich einen einzigen Block-Scope. Das kann zu „already been declared"-Fehlern führen, wenn derselbe Variablenname in mehreren case-Klauseln vorkommt. Lösung: jede case-Klausel in { } kapseln.
default-Position: default darf an beliebiger Stelle stehen, wird aber immer nur dann ausgeführt, wenn kein case übereinstimmt – unabhängig von seiner Position. Steht default nicht am Ende und fehlt ein break, kann es danach in weitere case-Blöcke hineinfallen.
Alternative – Objekt-Lookup: Für reine Wert-zu-Wert-Mappings ist ein Objekt oder eine Map oft lesbarer und performanter: const label = { 0: 'Sonntag', 1: 'Montag' }[tag] ?? 'Unbekannt';
Browser-Kompatibilität: switch ist seit ES1 Teil der Sprachspezifikation und in allen Umgebungen vollständig unterstützt.

Siehe auch

if...else break continue return

← Vorheriger Eintrag super Nächster Eintrag → Template-Literale (Template-Zeichenketten)