Bedingungen mit switch in

Über Bedingungen mit switch

Eine switch-Anweisung wertet einen Ausdruck aus und führt den ersten case aus, der zu ihrem Wert passt. Sie ist oft eine sauberere Alternative zu langen if ... else if-Ketten.

Grundlegende Verwendung

operatingSystem := "windows"

switch operatingSystem {
case "windows":
    // do something if the operating system is windows
case "linux":
    // do something if the operating system is linux
case "macos":
    // do something if the operating system is macos
default:
    // do something if the operating system is none of the above
}

Mit einem Komma kannst du mehrere Werte zu einem einzigen case zusammenfassen. Der case greift, wenn der Ausdruck einem der Werte entspricht:

switch operatingSystem {
case "windows", "linux":
    // do something if the operating system is windows or linux
case "macos":
    // do something if the operating system is macos
default:
    // do something if the operating system is none of the above
}

Switch ohne Ausdruck

Der Ausdruck nach switch kann auch ganz weggelassen werden. Jeder case enthält dann einen booleschen Ausdruck, und der erste, der zu true ausgewertet wird, wird ausgeführt.

age := 21

switch {
case age > 20 && age < 30:
    // do something if age is between 20 and 30
case age == 10:
    // do something if age is equal to 10
default:
    // do something else for every other case
}

Initialisierungsanweisung

Wie if kann auch ein switch eine kurze Initialisierungsanweisung vor dem Ausdruck enthalten. Variablen, die dort deklariert werden, haben ihren Gültigkeitsbereich im switch-Block:

switch v := getValue(); {
case v < 0:
    // do something if v is less than 0
case v == 0:
    // do something if v is 0
default:
    // do something else for every other case
}
// v will not be accessible here

Fallthrough

fallthrough bewirkt, dass der Block des nächsten case-Zweigs ausgeführt wird, unabhängig davon, ob dessen Ausdruck zutreffen würde. Es muss die letzte Anweisung im case-Zweig sein, und es muss einen nächsten case-Zweig geben, der ausgeführt werden kann.

fallthrough ist in idiomatischem Go ungewöhnlich, weil es benachbarte case-Zweige voneinander abhängig macht. Dadurch ist es schwieriger, die case-Zweige isoliert zu betrachten, und der switch wird schwerer lesbar. Wenn case-Zweige dasselbe Verhalten haben sollen, ist es klarer, sie mit einem Komma zu gruppieren. Wenn Logik aus anderen Gründen über mehrere case-Zweige hinweg gemeinsam genutzt wird, solltest du erwägen, sie in eine Hilfsfunktion auszulagern.

s := "hello"

switch s {
case "hello":
    fmt.Println("hello")
    fallthrough
case "world":
    fmt.Println("world") // also runs, even though s != "world"
}
// Output:
// hello
// world

Wenn du mehr erfahren möchtest, schau dir Go by Example: Switch oder die Go-Sprachspezifikation an.