Switch-Anweisung in Go

Golang verfügt wie die meisten anderen Programmiersprachen über die Switch-Anweisung . Mit der Switch-Anweisung in Golang  können Sie eine Variable oder einen Ausdruck in mehreren Fällen auswerten. Sie wird häufig verwendet, wenn das Schreiben mehrerer if-else-Anweisungen den Code hässlich und repetitiv aussehen lässt.

In Go ist eine Switch-Anweisung eine multidirektionale Verzweigungsanweisung, die die Ausführung effektiv basierend auf dem Wert (oder Typ) eines Ausdrucks steuert. Es gibt zwei Haupttypen von Switch-Anweisungen in Go :

• Ausdrucksschalter
• Typ Schalter

Zum Beispiel:

package main
import "fmt"

func main() {
    day := 4
    switch day {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday")
    case 3:
        fmt.Println("Wednesday")
    case 4:
        fmt.Println("Thursday")
    case 5:
        fmt.Println("Friday")
    default:
        fmt.Println("Invalid day")
    }
}

Switch-Anweisungssyntax in Golang

switch optstatement; optexpression {
case expression1:
    // Khối code
case expression2:                                                          # Expression Switch
    // Khối code
default:
    // Khối code
}

switch var := interfaceValue.(type) {
case type1:
    // Khối code
case type2:                                                                    # Type Switch
    // Khối code
default:
    // Khối code
}

Ausdrucksschalter

Der Ausdrucksschalter wertet einen Ausdruck aus und wechselt basierend auf dem Wert dieses Ausdrucks zu einem Fall. Wenn kein Ausdruck angegeben ist, ist der Schalter standardmäßig auf true eingestellt .

Syntax

switch optstatement; optexpression {
case expression1:
    // Khối code
case expression2:
    // Khối code
default:
    // Khối code
}

optstatement: Optionale Anweisung (z. B. Variablendeklaration).
optexpression: Optionaler Ausdruck (wenn weggelassen, wird standardmäßig true verwendet ).

Beispiel mit optionalem Befehl

Hier führen wir eine optionale Anweisung ein, die die Variable day deklariert. Die switch -Anweisung wertet dann day in verschiedenen Fällen aus.

package main
import "fmt"
func main() {
    switch day := 4; day {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday")
    case 3:
        fmt.Println("Wednesday")
    case 4:
        fmt.Println("Thursday")
    case 5:
        fmt.Println("Friday")
    default:
        fmt.Println("Invalid day")
    }
}

Ergebnis:

Thursday

Beispiel mit optionalem Ausdruck

Wenn kein Ausdruck angegeben ist, geht die Switch-Anweisung in Golang davon aus, dass der Ausdruck wahr ist. Dies ermöglicht die Verwendung boolescher Bedingungen in Case-Anweisungen.

package main
import "fmt"

func main() {
    day := 4

    switch {
    case day == 1:
        fmt.Println("Monday")
    case day == 4:
        fmt.Println("Thursday")
    case day > 5:
        fmt.Println("Weekend")
    default:
        fmt.Println("Invalid day")
    }
}

Ergebnis

Thursday

Typ Schalter

Mit dem Typschalter wird der Typ eines Schnittstellenwerts anstelle seines Werts verzweigt. Dies ist besonders nützlich bei Variablen unbekannten Typs.

Syntax

switch var := interfaceValue.(type) {
case type1:
    // Khối code
case type2:
    // Khối code
default:
    // Khối code
}

Zum Beispiel:

In diesem Beispiel wird dieselbe Tagesvariable verwendet , jedoch in interface{} eingeschlossen , um die Typumwandlung zu veranschaulichen.

package main
import "fmt"
func main() {
    var day interface{} = 4
    switch v := day.(type) {
    case int:
        switch v {
        case 1:
            fmt.Println("Monday")
        case 2:
            fmt.Println("Tuesday")
        case 3:
            fmt.Println("Wednesday")
        case 4:
            fmt.Println("Thursday")
        case 5:
            fmt.Println("Friday")
        default:
            fmt.Println("Invalid day")
        }
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

Ergebnis:

Thursday