Istruzione Switch in Go

Golang, come la maggior parte degli altri linguaggi di programmazione, ha l' istruzione switch . L'istruzione switch in Golang  consente di valutare una variabile o un'espressione in più casi e viene spesso utilizzata quando scrivere più istruzioni if-else rende il codice brutto e ripetitivo.

In Go, l'istruzione switch è un'istruzione di diramazione multidirezionale che dirige efficacemente l'esecuzione in base al valore (o tipo) di un'espressione. Esistono due tipi principali di istruzioni switch in Go :

• Interruttore di espressione
• Tipo di interruttore

Per esempio:

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

Sintassi dell'istruzione switch 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
}

Interruttore di espressione

Expression Switch valuta un'espressione e passa a un caso in base al valore di tale espressione. Se non viene specificata alcuna espressione, l'opzione è impostata di default su true .

Sintassi

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

optstatement: istruzione facoltativa (ad esempio dichiarazione di variabile).
optexpression: espressione facoltativa (se omessa, il valore predefinito è true ).

Esempio con comando facoltativo

Qui viene introdotta un'istruzione facoltativa che dichiara una variabile giorno . L' istruzione switch valuta quindi il giorno in base a diversi casi.

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

Risultato:

Thursday

Esempio con espressione facoltativa

Se non viene specificata alcuna espressione, l'istruzione switch in Golang presuppone che l'espressione sia vera. Ciò ci consente di utilizzare condizioni booleane nelle istruzioni 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")
    }
}

Risultato

Thursday

Tipo di interruttore

Il Type Switch viene utilizzato per passare dal tipo di valore di un'interfaccia al suo valore. Ciò è particolarmente utile quando si ha a che fare con variabili di tipo sconosciuto.

Sintassi

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

Per esempio:

In questo esempio viene utilizzata la stessa variabile day ma racchiusa nell'interfaccia {} per illustrare il casting di tipo.

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

Risultato:

Thursday