switch-Anweisung in der Sprache Go
Bedingte Anweisung in der Go-Sprache
Die switch-Anweisung wird verwendet, um abhängig von unterschiedlichen Bedingungen verschiedene Aktionen auszuführen. Jeder case-Zweig ist eindeutig und wird von oben nach unten einzeln getestet, bis eine Übereinstimmung gefunden wird.
Die switch-Anweisung wird von oben nach unten ausgeführt, bis eine Übereinstimmung gefunden wird, und es ist nicht nötig, nach dem passenden case ein break hinzuzufügen.
Standardmäßig enthält jeder case in switch am Ende eine break-Anweisung, sodass nach einer erfolgreichen Übereinstimmung andere case-Zweige nicht ausgeführt werden. Wenn wir nachfolgende case-Zweige ausführen müssen, können wirfallthrough verwenden. 。
Syntax
Die Syntax der switch-Anweisung in der Programmiersprache Go lautet wie folgt:
switch var1 {
case val1:
...
case val2:
...
default:
...
}
Die Variable var1 kann von beliebigem Typ sein, während val1 und val2 beliebige Werte desselben Typs sein können. Der Typ ist nicht auf Konstanten oder Ganzzahlen beschränkt, sondern muss derselbe Typ sein; oder Ausdrücke, deren Endergebnis denselben Typ hat.
Sie können mehrere Werte testen, die gleichzeitig übereinstimmen könnten, und sie durch Kommas trennen, zum Beispiel: case val1, val2, val3.
Flussdiagramm:
Beispiel
import "fmt"
func main() {
/* Lokale Variablen definieren */
var grade string = "B"
var marks int = 90
switch marks {
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}
switch {
case grade == "A" :
fmt.Printf("Ausgezeichnet!\n" )
case grade == "B", grade == "C" :
fmt.Printf("Gut\n" )
case grade == "D" :
fmt.Printf("Bestanden\n" )
case grade == "F":
fmt.Printf("Nicht bestanden\n" )
default:
fmt.Printf("Schlecht\n" );
}
fmt.Printf("Deine Note ist %s\n", grade );
}
Das Ausführungsergebnis des obigen Codes ist:
优秀! 你的等级是 A
Typ-Switch
Die switch-Anweisung kann auch für einen Typ-Switch verwendet werden, um den tatsächlichen Typ zu bestimmen, der in einer Interface-Variablen gespeichert ist.
Die Syntax des Type Switch ist wie folgt:
switch x.(type){
case type:
statement(s);
case type:
statement(s);
/* 你可以定义任意个数的case */
default: /* 可选 */
statement(s);
}
Beispiel
import "fmt"
func main() {
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" Der Typ von x ist %T",i)
case int:
fmt.Printf("x ist vom Typ int")
case float64:
fmt.Printf("x ist vom Typ float64")
case func(int) float64:
fmt.Printf("x ist vom Typ func(int)")
case bool, string:
fmt.Printf("x ist vom Typ bool oder string" )
default:
fmt.Printf("Unbekannter Typ")
}
}
Das Ausführungsergebnis des obigen Codes ist:
x 的类型 :<nil>
fallthrough
Die Verwendung von fallthrough erzwingt die Ausführung der folgenden case-Anweisung; fallthrough wertet nicht aus, ob das Ausdrucksergebnis des nächsten case true ist.
Beispiel
import "fmt"
func main() {
switch {
case false:
fmt.Println("1. Die bedingte case-Anweisung ist falsch")
fallthrough
case true:
fmt.Println("2. Die bedingte case-Anweisung ist wahr")
fallthrough
case false:
fmt.Println(3. Die case-Bedingung ist falsch)
fallthrough
case true:
fmt.Println(4. Die case-Bedingung ist wahr)
case false:
fmt.Println(5. Die case-Bedingung ist falsch)
fallthrough
default:
fmt.Println(6. Default-Fall)
}
}
Das Ausführungsergebnis des obigen Codes ist:
2、case 条件语句为 true 3、case 条件语句为 false 4、case 条件语句为 true
Anhand der Ausgabe des obigen Codes ist ersichtlich, dass switch mit der Ausführung ab dem ersten case beginnt, dessen Auswertungsausdruck true ist. Wenn der case ein fallthrough enthält, setzt das Programm die Ausführung mit dem nächsten case fort und wertet nicht aus, ob der Ausdruck des nächsten case true ist.
Weitere Erweiterungen