Go Switch-Anweisungen

Der Switch-Befehl ist ein mehrstufiger Zweigbefehl. Er bietet eine effektive Methode, um die Ausführung auf verschiedene Teile des Codes zu lenken, basierend auf dem Wert eines Ausdrucks (auch als case bezeichnet). Die Programmiersprache Go unterstützt zwei Arten von Switch-Befehlen:

1. 表达式switch

2. Typswitch

表达式switch

表达式switch类似于C，C ++，Java语言中的switch语句。它提供了一种简单的方法，可以根据表达式的值将执行分派到代码的不同部分。

Syntax:

switch optstatement; optexpression{
　　　　case expression1: Statement...
　　　　case expression2: Statement...
　　　　...
　　　　Standard: Statement...
}

Wichtig zu beachten:

• 表达式switch中的optstatement和optexpression都是可选语句。

• 如果同时存在optstatement和optpression，则在它们之间需要使用分号（;）。

• 如果switch不包含任何表达式，则编译器会假定该表达式为true。

• 可选语句，即optstatement包含简单的语句，例如变量声明，递增或赋值语句或函数调用等。

• 如果可选语句中存在变量，则该变量的范围限于该switch语句。

• 在switch语句中，case和default语句不包含任何break语句。但是如果您的程序需要，您可以使用break和fallthrough语句。

• 默认（default）语句在switch语句中是可选的。

• Wenn ein case mehrere Werte enthalten kann, die durch Kommata (,) getrennt sind.

• 如果一个case不包含任何表达式，则编译器假定该表达式为true。

获取指定数字是星期几的示例：

package main
import "fmt"
func main() {
　　　　//　Switch语句同时使用两种语句，例如可选语句，day :=4　和表达式，例如：day
　　　　switch day :=　4; day {
　　　　case　1:
　　　　　　　　fmt.Println("Montag")
　　　　case　2:
　　　　　　　　fmt.Println("Dienstag")
　　　　case　3:
　　　　　　　　fmt.Println("Mittwoch")
　　　　case　4:
　　　　　　　　fmt.Println("Donnerstag")
　　　　case　5:
　　　　　　　　fmt.Println("Freitag")
　　　　case　6:
　　　　　　　　fmt.Println("Samstag")
　　　　case　7:
　　　　　　　　fmt.Println("Sonntag")
　　　　Standard:
　　　　　　　　fmt.Println("Invalid")
　　　　}
}

Ausgabe:

Donnerstag

switch语句不带可选语句和表达式的示例：

package main　
　　
import "fmt"
　　
func main() {　
　　　　var value int =　2　
　　　　　　
　　　　　　//　switch语句不带可选语句和表达式
　　　switch {　
　　　　　　　case value ==　1:　
　　　　　　　fmt.Println("Hello")　
　　　　　　　case value ==　2:　
　　　　　　　fmt.Println("Bonjour")　
　　　　　　　case value ==　3:　
　　　　　　　fmt.Println("Namstay")　
　　　　　　　Standard:　　
　　　　　　　fmt.Println("Invalid")　
　　　}　
　　
}

Ausgabe:

Bonjour

以下是不带默认语句的switch语句，case语句中的多个值：

package main
import "fmt"
func main() {
　　　　var value string = "five"
　　　　//Switch-Anweisung ohne Standardfall, mehrere Werte im case-Ausdruck
　　　　switch value {
　　　　case "one":
　　　　　　　　fmt.Println("C#")
　　　　case "two", "three":
　　　　　　　　fmt.Println("Go")
　　　　case "four", "five", "six":
　　　　　　　　fmt.Println("Java")
　　　　}
}

Ausgabe:

Java

Typswitch

Verwenden Sie den typeswitch, wenn Sie Typen vergleichen möchten. In diesem switch enthalten die case-Elemente die Typen, die mit den Typen im Switch-Ausdruck verglichen werden sollen.

Syntax:

switch optstatement; typeswitchexpression{
　　　　case typelist　1: Statement...
　　　　case typelist　2: Statement...
　　　　...
　　　　Standard: Statement...
}

Wichtig zu beachten:

• Optionaler Ausdruck, d.h. optstatement, der ähnlich wie im Switch-Ausdruck ist.

• Wenn ein case mehrere Werte enthalten kann, die durch Kommata (,) getrennt sind.

• In der typeswitch-Anweisung enthalten neither die case- noch die Standardanweisungen Break- oder Fallthrough-Anweisungen. Allerdings können Break- und Fallthrough-Anweisungen verwendet werden, wenn dies erforderlich ist.

• In der typeswitch-Anweisung ist das Standardfall-Element optional.

• typeswitchexpressionist ein Ausdruck, dessen Ergebnis ein Typ ist.

• Wenn ein Ausdruck in einem typeswitch-Ausdrucksausdruck mit dem =-Operator zugewiesen wird, hängt der Typ der Variablen von dem Typ ab, der in den case-Untersuchen angegeben ist. Wenn die case-Untersuchen zwei oder mehr Typen enthalten, ist der Typ der Variablen derjenige, der im typeswitch-Ausdrucksausdruck erstellt wurde.

package main
import "fmt"
func main() {
　　　　var value interface{}
　　　　switch q := value.(type) {
　　　　case bool:
　　　　　　　　fmt.Println("Der Wert ist vom Typ bool")
　　　　case float64:
　　　　　　　　fmt.Println("Der Wert ist float")64Typ)
　　　　case int:
　　　　　　　　fmt.Println("Der Wert ist vom Typ int")
　　　　Standard:
　　　　　　　　fmt.Printf("Der Typ des Wertes ist: %T", q)
　　　　}
}

Ausgabe:

Der Typ der Werte ist: <nil>