Instrukcja Switch w Go

W języku Go, podobnie jak w większości innych języków programowania, występuje polecenie switch . Instrukcja switch w języku Golang  umożliwia ocenę zmiennej lub wyrażenia w wielu przypadkach i jest często stosowana, gdy pisanie wielu instrukcji if-else sprawia, że ​​kod wygląda nieestetycznie i powtarzalnie.

W języku Go instrukcja switch jest wielokierunkową instrukcją rozgałęziającą, która skutecznie kieruje wykonywaniem na podstawie wartości (lub typu) wyrażenia. W języku Go istnieją dwa główne typy instrukcji switch :

• Przełącznik ekspresji
• Przełącznik typu

Na przykład:

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")
    }
}

Składnia instrukcji Switch w języku 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
}

Przełącznik ekspresji

Expression Switch ocenia wyrażenie i przełącza przypadek na podstawie wartości tego wyrażenia. Jeżeli nie podano żadnego wyrażenia, przełącznik domyślnie przyjmuje wartość true .

Składnia

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

optstatement: Opcjonalne polecenie (np. deklaracja zmiennej).
optexpression: Opcjonalne wyrażenie (jeśli pominięte, przyjmuje wartość domyślną true ).

Przykład z opcjonalnym poleceniem

Tutaj wprowadzono opcjonalne polecenie deklarujące zmienną dnia . Następnie instrukcja switch ocenia dzień na podstawie różnych przypadków.

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")
    }
}

Wynik:

Thursday

Przykład z opcjonalnym wyrażeniem

Jeżeli nie określono żadnego wyrażenia, instrukcja switch w języku Go przyjmie, że wyrażenie jest prawdziwe. Pozwala nam to na stosowanie warunków boolowskich w poleceniach case.

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")
    }
}

Wynik

Thursday

Przełącznik typu

Przełącznik typu służy do rozgałęziania się według typu wartości interfejsu, a nie jego wartości. Jest to szczególnie użyteczne w przypadku zmiennych o nieznanym typie.

Składnia

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

Na przykład:

W tym przykładzie użyto tej samej zmiennej day , ale zawartej w interfejsie{} w celu zilustrowania rzutowania typów.

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)
    }
}

Wynik:

Thursday