Switch-Case-Verzweigungen in Golang

GolangBeginner
Jetzt üben

Einführung

Im vorangegangenen Experiment haben wir uns mit der Verwendung von if-else-Verzweigungen vertraut gemacht. In diesem Lab werden wir uns mit Switch-Case-Verzweigungen beschäftigen. Im Vergleich zu if-else-Anweisungen eignen sich Switch-Anweisungen besser für Szenarien mit mehreren Bedingungen.

Wissenspunkte:

  • Switch-Case-Anweisungen
  • Das Schlüsselwort default
  • Das Schlüsselwort fallthrough
Dies ist ein geführtes Lab, das Schritt-für-Schritt-Anleitungen bietet, um Ihnen beim Lernen und Üben zu helfen. Folgen Sie den Anweisungen sorgfältig, um jeden Schritt abzuschließen und praktische Erfahrungen zu sammeln. Historische Daten zeigen, dass dies ein Lab für Anfänger ist, mit einer Abschlussquote von 100%. Es hat eine positive Bewertung von 100% von den Lernenden erhalten.

Grundlegende Syntax

Die Syntax der switch-Verzweigung ähnelt der der if-Verzweigung, da beide auf Bedingungsprüfungen basieren. Die grundlegende Struktur sieht wie folgt aus:

switch condition {
    case val1:
        // Codeblock
    case val2:
        // Codeblock
    ...
    default:
        // Codeblock
}

Die Bedingung (condition) kann ein beliebiger Ausdruckstyp sein. Wenn die Bedingung mit dem Wert einer bestimmten case-Anweisung übereinstimmt, wird der entsprechende Codeblock ausgeführt und das Programm verlässt anschließend die aktuelle switch-Verzweigung.

Die Werte in den case-Anweisungen müssen denselben Typ haben wie der Bedingungsausdruck.

Das Programm wertet die case-Anweisungen von oben nach unten aus und führt den ersten passenden Treffer aus. Nach Abschluss der Ausführung wird die switch-Struktur beendet.

Die default-Anweisung verhält sich ähnlich wie der else-Zweig. Wenn keine der case-Anweisungen auf die Bedingung zutrifft, wird der Code unter default ausgeführt.

Schauen wir uns ein Beispiel für eine Wettervorhersage an. Erstellen Sie eine neue Datei namens switch.go und schreiben Sie den folgenden Code:

cd ~/project
touch switch.go
package main

import (
    "fmt"
)

func main() {
    // Heutiges Wetter
    weather := "rainy"
    switch weather {
    case "snow":
        fmt.Println("Remember to wear a scarf today.🧣")
    case "rainy":
        fmt.Println("Remember to bring an umbrella today.🌂")
    default:
        fmt.Println("Today is sunny.☀")
    }
}

Führen Sie den Code aus:

go run switch.go

Die Ausgabe lautet:

Remember to bring an umbrella today.🌂

Diese Wettervorhersage gibt je nach Wetterlage unterschiedliche Ergebnisse aus. Zuerst setzen wir das heutige Wetter auf "rainy". In der folgenden switch-case-Verzweigung haben wir drei Bedingungen definiert: Bei Schnee erinnern wir an den Schal, bei Regen an den Regenschirm, und in allen anderen Fällen gehen wir von einem sonnigen Tag aus.

Mehrere Werte in einem Zweig

Eine case-Anweisung kann auch mehrere Werte gleichzeitig prüfen, wie hier gezeigt:

switch condition {
    case val1, val2:
        // Codeblock
    ...
}

Wir haben das Wetterprogramm wie folgt aktualisiert:

package main

import (
    "fmt"
)

func main() {
    // Heutiges Wetter
    weather := "snow"
    switch weather {
    case "snow", "stormy":
        fmt.Println("Remember to wear a scarf today.🧣")
    case "haze", "sandstorm":
        fmt.Println("Remember to wear a mask today.😷")
    case "rainy":
        fmt.Println("Remember to bring an umbrella today.🌂")
    default:
        fmt.Println("Today is sunny.☀")
    }
}
go run switch.go

Nach der Ausführung des Codes lautet die Ausgabe:

Remember to wear a scarf today.🧣

Wir haben weitere Wetterbedingungen hinzugefügt. Bei Dunst oder Sandsturm wird nun beispielsweise empfohlen, eine Maske zu tragen.

Switch-Anweisungen ohne Bedingungsvariable

Die Bedingungsvariable in einer switch-Anweisung ist optional. Wenn sie weggelassen wird, verhält sich die switch-Anweisung ähnlich wie eine Kette von if-else-Anweisungen.

Wir haben das Programm zur Ausgabe des aktuellen Wochentags aus dem vorherigen Abschnitt so umgeschrieben, dass es eine switch-Anweisung ohne explizite Variable verwendet:

package main

import (
    "fmt"
    "time"
)

func main() {
    today := time.Now().Weekday()
    switch {
    case today == time.Monday:
        fmt.Println("Today is Monday.")
    case today == time.Tuesday:
        fmt.Println("Today is Tuesday.")
    case today == time.Wednesday:
        fmt.Println("Today is Wednesday.")
    case today == time.Thursday:
        fmt.Println("Today is Thursday.")
    case today == time.Friday:
        fmt.Println("Today is Friday.")
    case today == time.Saturday:
        fmt.Println("Today is Saturday.")
    default:
        fmt.Println("Today is Sunday.")
    }
}
go run switch.go

Nach der Ausführung des Codes lautet die Ausgabe (je nach aktuellem Tag):

Today is Monday.

In diesem Programm wurde die Variable direkt hinter dem switch-Schlüsselwort entfernt. Bei der Ausführung prüft das Programm stattdessen, ob die Bedingungen in den einzelnen case-Zweigen wahr (true) ergeben. Sobald eine Bedingung erfüllt ist, wird der entsprechende Code ausgeführt und der switch-Block verlassen.

Die fallthrough-Anweisung

Wie bereits erwähnt, verlässt ein Programm normalerweise die switch-Struktur, sobald ein case-Zweig ausgeführt wurde.

Wenn Sie jedoch möchten, dass nach der Ausführung eines Zweigs auch der direkt darauf folgende Zweig ausgeführt wird, können Sie die fallthrough-Anweisung verwenden.

Hier sind die Regeln für die Verwendung von fallthrough:

  • Standardmäßig stoppt die Ausführung nach einem Treffer (z. B. case 10). fallthrough erzwingt das "Durchfallen" in den nächsten Zweig.
  • fallthrough wirkt sich nur auf den unmittelbar nächsten case-Zweig aus und führt diesen aus, ohne dessen Bedingung erneut zu prüfen.
  • fallthrough darf nicht im letzten Zweig einer switch-Anweisung stehen.

Betrachten wir ein konkretes Beispiel:

package main

import (
    "fmt"
)

func main() {
    n := 10
    switch n {
    case 10:
        fmt.Println(10)
        fallthrough
    case 3:
        fmt.Println(3)
    }
}
go run switch.go

Nach der Ausführung des Codes lautet die Ausgabe:

10
3

Die Verzweigung gibt 10 aus, da case 10 zutrifft. Durch das fallthrough wird anschließend auch der Code von case 3 ausgeführt und 3 ausgegeben.

Initialisierungsanweisung in switch

In Go verfügen nicht nur if-Verzweigungen über Initialisierungsanweisungen, sondern auch switch-Verzweigungen. Sie können eine Initialisierung vor der Bedingungsvariablen schreiben, getrennt durch ein Semikolon.

Quiz

Ihre Aufgabe ist es nun, das Programm aus dem vorherigen Abschnitt umzuschreiben und die Initialisierung direkt in die Switch-Anweisung zu verschieben.

Erstellen Sie eine neue Datei namens switch2.go. Schreiben Sie den folgenden Code in die Datei switch2.go. Ändern Sie das Programm so ab, dass die Variable n innerhalb des switch-Statements initialisiert wird.

cd ~/project
touch switch2.go

Der Ausgangscode lautet:

package main

import (
    "fmt"
)

func main() {
    n := 10
    switch n {
    case 10:
        fmt.Println(1)
        fallthrough
    case 3:
        fmt.Println(3)
    }
}

Anforderungen:

  • Die Datei switch2.go muss im Verzeichnis ~/project liegen.

Hinweis: Sie können sich am Abschnitt über Initialisierungen im if-else-Lab orientieren, um die Änderung vorzunehmen.

✨ Lösung prüfen und üben

Zusammenfassung

In diesem Lab haben wir die switch-Verzweigung behandelt. Die wichtigsten Punkte sind:

  • Wenn eine case-Anweisung übereinstimmt und ausgeführt wird, verlässt das Programm standardmäßig den switch-Block.
  • Mit fallthrough kann die Ausführung im nächsten case-Zweig fortgesetzt werden.
  • switch unterstützt ebenfalls eine Initialisierungsanweisung, die durch ein Semikolon vom Bedingungsausdruck getrennt wird.