{{jsSidebar("Statements")}}

Die**`switch`**-Anweisung wertet einen[Ausdruck](/de/docs/Web/JavaScript/Guide/Expressions_and_operators) aus, vergleicht den Wert des Ausdrucks mit einer Reihe von`case`-Klauseln und führt[Anweisungen](/de/docs/Web/JavaScript/Reference/Statements) nach der ersten`case`-Klausel mit einem passenden Wert aus, bis eine`break`-Anweisungangetroffen wird. Die`default`-Klausel einer`switch`-Anweisung wird angesprungen, wenn keine`case`-Klausel mit dem Wert des Ausdrucks übereinstimmt.

Die**`switch`**-Anweisung wertet einen[Ausdruck](/de/docs/Web/JavaScript/Guide/Expressions_and_operators) aus, vergleicht den Wert des Ausdrucks mit einer Reihe von`case`-Klauseln und führt[Anweisungen](/de/docs/Web/JavaScript/Reference/Statements) nach der ersten`case`-Klausel mit einem passenden Wert aus, bis eine`break`-Anweisungauftritt. Die`default`-Klausel einer`switch`-Anweisung wird angesprungen, wenn keine`case`-Klausel mit dem Wert des Ausdrucks übereinstimmt.

{{EmbedInteractiveExample("pages/js/statement-switch.html", "taller")}}

- : Ein Ausdruck, dessen Ergebnis mit jeder`case`-Klausel verglichen wird.

-`caseExpressionN` {{optional_inline}}

- : Eine`case`-Klausel, die mit`expression` verglichen wird. Wenn der Wert von`expression`mitdem Wert vonirgendeinem`caseExpressionN`übereinstimmt, beginnt die Ausführungab der ersten Anweisung nach dieser`case`-Klausel, bis entwederdas Ende der`switch`-Anweisung oderdas erste angetroffene`break`.

- : Eine`case`-Klausel, die mit`expression` verglichen wird. Wenn der Wert von`expression` dem Wert von`caseExpressionN`entspricht, beginnt die Ausführungmit der ersten Anweisung nach dieser`case`-Klausel bis entwederzum Ende der`switch`-Anweisung oderzum ersten`break`.

-`default` {{optional_inline}}

- : Eine`default`-Klausel; wenn vorhanden, wird diese Klausel ausgeführt, wenn der Wert von`expression` mit keiner der`case`-Klauseln übereinstimmt. Eine`switch`-Anweisung kann nur eine`default`-Klausel haben.

Eine`switch`-Anweisung wertet zuerst ihren Ausdruck aus.Danach suchtsie nach der ersten`case`-Klausel, deren AusdruckdenselbenWert wie das Ergebnis desEingabeausdrucks ergibt(unter Verwendung des[strikten Gleichheitsvergleichs](/de/docs/Web/JavaScript/Reference/Operators/Strict_equality)) und überträgt dieKontrolle an diese Klausel,um alle nachfolgenden Anweisungenauszuführen.

Eine`switch`-Anweisung wertet zuerst ihren Ausdruck aus.Sie suchtdann nach der ersten`case`-Klausel, deren Ausdruckden gleichenWerthatwie das Ergebnis desEingabewerts(unter Verwendung des[strikten Gleichheitsvergleichs](/de/docs/Web/JavaScript/Reference/Operators/Strict_equality)) und überträgt dieSteuerung an diese Klausel,wobei alle nachfolgenden Anweisungenausgeführt werden.

Die Klauselausdrücke werden nur bei Bedarf ausgewertet — wennein Treffer bereits gefunden wurde, werden nachfolgende`case`-Klauselausdrücke nicht ausgewertet, selbst wenn sie durch[Durchfall](#brechen_und_durchfallen) besucht werden.

Die Klauselausdrücke werden nur bei Bedarf ausgewertet — wennbereits eine Übereinstimmung gefunden wurde, werden nachfolgende`case`-Klauselausdrücke nichtmehrausgewertet, selbst wenn sie durch[Fall-through](#brechen_und_fall-through) besucht werden.

switch (undefined) {

Wenn keine passende`case`-Klausel gefunden wird, sucht das Programm nach der optionalen`default`-Klausel und überträgt, wenn gefunden,dieKontrolle an diese Klausel,um die nachfolgenden Anweisungen auszuführen. Wenn keine`default`-Klausel gefunden wird, setzt das Programm die Ausführungbei der Anweisung nach dem Endevon`switch` fort.Konventionell ist die`default`-Klausel die letzte Klausel,muss es aber nicht sein. Eine`switch`-Anweisung darf nur eine`default`-Klausel haben; mehrere`default`-Klauseln führen zu einem {{jsxref("SyntaxError")}}.

Wenn keine passende`case`-Klausel gefunden wird, sucht das Programm nach der optionalen`default`-Klausel und, falls vorhanden, überträgtdieSteuerung an diese Klausel,wobei Anweisungen nach dieser Klausel ausgeführt werden. Wenn keine`default`-Klausel gefunden wird, setzt das Programm die Ausführungmit der Anweisung nach dem Endedes`switch` fort.Üblicherweise ist die`default`-Klausel die letzte Klausel,aber das muss nicht der Fall sein. Eine`switch`-Anweisung darf nur eine`default`-Klausel haben; mehrere`default`-Klauseln führen zu einem {{jsxref("SyntaxError")}}.

Sie können die[`break`](/de/docs/Web/JavaScript/Reference/Statements/break)-Anweisung innerhalb des Körpers einer`switch`-Anweisung verwenden, um frühzeitig auszubrechen, oftnachdem alle Anweisungen zwischen zwei`case`-Klauseln ausgeführt wurden. Die Ausführung wird bei der ersten Anweisung nach`switch` fortgesetzt.

Sie können die[`break`](/de/docs/Web/JavaScript/Reference/Statements/break)-Anweisung innerhalb des Körpers einer`switch`-Anweisung verwenden, um frühzeitig auszubrechen, oftwenn alle Anweisungen zwischen zwei`case`-Klauseln ausgeführt wurden. Die Ausführung wird bei der ersten Anweisung nach`switch` fortgesetzt.

Wenn`break`weggelassen wird, wird die Ausführung zur nächsten`case`-Klauselfortgesetzt, sogar zur`default`-Klausel, unabhängig davon, ob der Wert des Ausdrucks dieser Klausel übereinstimmt. Dieses Verhalten wird als "Durchfallen" bezeichnet.

Wird`break`ausgelassen, geht die Ausführung zur nächsten`case`-Klauselüber, sogar zur`default`-Klausel, unabhängig davon, ob der Wert des Ausdrucks dieser Klausel übereinstimmt oder nicht. Dieses Verhalten wird als "Fall-through" bezeichnet.

constfoo=0;

Im entsprechendenKontext haben auch andereKontrollflussanweisungen den Effekt, die`switch`-Anweisung zudurchbrechen. Beispielsweise, wenn die`switch`-Anweisung in einer Funktion enthalten ist,beendet eine[`return`](/de/docs/Web/JavaScript/Reference/Statements/return)-Anweisung die Ausführung des Funktionskörpers und damitder`switch`-Anweisung. Wenn die`switch`-Anweisung in einer Schleife enthalten ist,dann beendet eine[`continue`](/de/docs/Web/JavaScript/Reference/Statements/continue)-Anweisung die`switch`-Anweisung und springt zur nächsten Iteration der Schleife.

In einem geeignetenKontext haben auch andereSteuerflussanweisungen die Wirkung, die`switch`-Anweisung zuverlassen. Beispielsweise, wenn die`switch`-Anweisung in einer Funktion enthalten ist,führt eine[`return`](/de/docs/Web/JavaScript/Reference/Statements/return)-Anweisungdazu, dassdie Ausführung des Funktionskörpers und damitdie`switch`-Anweisung beendet wird. Wenn die`switch`-Anweisung in einer Schleife enthalten ist,stoppt eine[`continue`](/de/docs/Web/JavaScript/Reference/Statements/continue)-Anweisung die`switch`-Anweisung und springt zur nächsten Iteration der Schleife.

Die`case`- und`default`-Klauseln sind wie[Labels](/de/docs/Web/JavaScript/Reference/Statements/label): Siegeben mögliche Stellen an, zu denen der Kontrollfluss springen kann. Sie erzeugen jedoch selbst keine lexikalischen {{Glossary("Scope", "Bereiche")}} (auch brechensie nicht automatischab —wie oben gezeigt).Beispielsweise:

Die`case`- und`default`-Klauseln sind wie[Labels](/de/docs/Web/JavaScript/Reference/Statements/label): Siezeigen mögliche Stellen an, zu denen der Kontrollfluss springen kann. Sie erzeugen jedoch selbst keine lexikalischen {{Glossary("Scope", "Gültigkeitsbereiche")}} (sie brechenauch nicht automatischaus,wie oben gezeigt).Zum Beispiel:

```js-nolint example-bad

Dieses Beispielgibt den Fehler "Uncaught SyntaxError: Identifier 'message' has already been declared"aus, weil die erste`const message = 'hello';`-Deklaration mit der zweiten`const message = 'hi';`-Deklaration in Konflikt steht, selbst wenn sie inihren eigenenseparaten`case`-Klauselnstehen. Letztendlich liegt das daran, dass beide`const`-Deklarationen im selbenBlock Scope stehen, der durch den`switch`-Körper erstellt wird.

Dieses Beispielwird den Fehler "Uncaught SyntaxError: Identifier 'message' has already been declared"ausgeben, da die erste`const message = 'hello';`-Deklaration mit der zweiten`const message = 'hi';`-Deklaration in Konflikt steht, selbst wenn siesichin separaten`case`-Klauselnbefinden. Letztendlich liegt das daran, dass beide`const`-Deklarationensichim selbenBlockbereich befinden, der durch den`switch`-Körper erstellt wird.

Um dies zu beheben,kapseln Siedie`let` oder`const`-Deklarationen in einer`case`-Klausel in einen Blockein.

Um dies zu beheben,sollten Sieimmer, wenn Sie`let` oder`const`-Deklarationen in einer`case`-Klauselverwenden müssen, diesein einen Blockeinwickeln.

constaction="say_hello";

}

Dieser Code wird jetzt`hello` in der Konsole ausgeben, wie esseinsollte, ohne Fehler.

Dieser Code wird jetzt`hello` in der Konsole ausgeben, wie es sollte, ohne Fehler.

Im folgenden Beispiel, wenn`expr`als`Bananas`ausgewertet wird, stimmt der Programmwertmit`case 'Bananas'`übereinund führt die zugehörige Anweisung aus. Wenn`break`angetroffen wird, springt das Programm aus`switch` heraus und führt die Anweisung nach`switch` aus. Wäre`break`weggelassen worden, würde auch die Anweisung für`case 'Cherries'` ausgeführt werden.

Im folgenden Beispiel, wenn`expr`den Wert`Bananas`ergibt, vergleicht das Programm den Wertmit`case 'Bananas'` und führt die zugehörige Anweisung aus. Wenn`break`auftritt, bricht das Programm ausder`switch`-Anweisung aus und führt die Anweisung nach`switch` aus. Wäre`break`ausgelassen worden, würde auch die Anweisung fürden`case 'Cherries'` ausgeführt.

switch (expr) {

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

Wennkein Treffer gefunden wird, beginnt die Ausführungbei der`default`-Klausel und führt alle nachfolgenden Anweisungen aus.

Wennkeine Übereinstimmung gefunden wird, beginnt die Ausführungmit der`default`-Klausel und führt alle nachfolgenden Anweisungen aus.

constfoo=5;

}

Es funktioniert auch, wenn Sie`default` vor allen anderen`case`-Klauselnsetzen.

Es funktioniert auch, wenn Sie`default` vor allen anderen`case`-Klauselnplatzieren.

Diese Methode nutztdie Tatsacheaus, dass, wennes kein`break` unter einer`case`-Klauselgibt, die Ausführung zur nächsten`case`-Klauselfortgesetzt wird, unabhängig davon, ob diese`case` die Kriterien erfüllt.

Diese Methode nutzt aus, dass, wennsich kein`break` unter einer`case`-Klauselbefindet, die Ausführung zur nächsten`case`-Klauselübergeht, unabhängig davon, ob diese`case`-Klausel die Kriterien erfüllt.

DasFolgende ist ein Beispiel für eine einzelneoperationelle sequenzielle`case`-Anweisung, bei der vier verschiedene Wertegenau dasselbeausführen.

Dasfolgende ist ein Beispiel für eine einzelneOperation einer sequentiellen`case`-Anweisung, bei der vier verschiedene Werteexakt dasselbetun.

constAnimal="Giraffe";

}

Das folgende Beispielzeigt eineMehrfachoperation in einersequenziellen`case`-Klausel, bei der Sie je nachübergebener Ganzzahl unterschiedliche Ausgaben erhalten können. Dies zeigt Ihnen, dasses in der Reihenfolge durchlaufen wird, in der Siedie`case`-Klauseln festlegen, unddass es nicht numerischaufeinanderfolgendsein muss. In JavaScript können Sie sogar die Definitionen vonZeichenfolgen in diese`case`-Anweisungenmischen.

Das folgendeist einBeispielfür einemehrfache Operation einersequentiellen`case`-Klausel, bei der Sie, je nachübergebenem Integer, unterschiedliche Ausgaben erhalten können. Dies zeigt, dasssie in der Reihenfolge durchlaufen wird, in der Siesie angeordnet haben, undsie muss nicht numerisch sein. In JavaScript können Sie sogar die Definitionen vonZeichenketten in diese`case`-Anweisungeneinmischen.

constfoo=1;

| Wert| Protokolltext|

| ------------------------------------------------------------| ---------------------------------------|

|`foo` ist`NaN` oder nicht`1`,`2`,`3`,`4`,`5`, oder`0`| Bitte wählen Sie eine Zahl von 0 bis 5!|

|`0`| Ausgabe:Also Wie lautet Ihr Name?|

|`1`| Ausgabe:Wie lautet Ihr Name?|

|`2`| Ausgabe:Ihr Name?|

|`0`| Ausgabe:So What Is Your Name?|

|`1`| Ausgabe:What Is Your Name?|

|`2`| Ausgabe:Your Name?|

|`3`| Ausgabe: Name?|

|`4`| Ausgabe: ?|

|`5`| Ausgabe: !|

Sie finden sichmöglicherweise häufig beim Ausführen einerSerie von[`if...else`](/de/docs/Web/JavaScript/Reference/Statements/if...else)-Vergleichen.

Oftmals findenSiesichwieder, eineSerie von[`if...else`](/de/docs/Web/JavaScript/Reference/Statements/if...else)-Übereinstimmungen vornehmen zu wollen.

if ("fetch"inglobalThis) {

}

Dieses Muster führt keineSequenz von`===`-Vergleichen aus,kannaberdennochin eine`switch`-Konstruktionumgewandelt werden.

Dieses Muster führt keineFolge von`===`-Vergleichen aus, aberSie können es trotzdemin eine`switch`-Konstruktionumwandeln.

switch (true) {

}

Das`switch (true)`-Muster als Alternative zu`if...else` ist besonders nützlich, wenn Sie dasDurchfallverhalten nutzen möchten.

Das`switch (true)`-Muster als Alternative zu`if...else` ist besonders nützlich, wenn Sie dasFall-through-Verhalten nutzen möchten.

switch (true) {