Declarație Switch în Go

Golang, ca majoritatea celorlalte limbaje de programare, are declarația switch . Declarația switch din Golang  vă permite să evaluați o variabilă sau o expresie în mai multe cazuri și este adesea folosită atunci când scrieți mai multe instrucțiuni if-else face ca codul să pară urât și repetitiv.

În Go, instrucțiunea switch este o instrucțiune de ramificare multidirecțională care direcționează efectiv execuția pe baza valorii (sau tipului) unei expresii. Există două tipuri principale de declarații switch în Go :

• Comutator de expresie
• Tip comutator

De exemplu:

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

Sintaxa instrucțiunii de comutare în 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
}

Comutator de expresie

Comutare expresie evaluează o expresie și comută la un caz pe baza valorii expresiei respective. Dacă nu este furnizată nicio expresie, comutatorul este implicit la true .

Sintaxă

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

optstatement: instrucțiune opțională (de exemplu, declarație variabilă).
optexpression: expresie opțională (dacă este omisă, implicit este true ).

Exemplu cu comandă opțională

Aici se introduce o instrucțiune opțională care declară o variabilă de zi . Declarația switch evaluează apoi ziua în funcție de diferite cazuri.

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

Rezultat:

Thursday

Exemplu cu expresie opțională

Dacă nu este specificată nicio expresie, declarația switch din Golang va presupune că expresia este adevărată. Acest lucru ne permite să folosim condiții booleene în instrucțiunile 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")
    }
}

Rezultat

Thursday

Tip comutator

Type Switch este folosit pentru a se ramifica pe tipul unei valori de interfață, mai degrabă decât pe valoarea acesteia. Acest lucru este util în special atunci când aveți de-a face cu variabile de tip necunoscut.

Sintaxă

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

De exemplu:

Acest exemplu folosește aceeași variabilă de zi , dar încapsulată în interfață{} pentru a ilustra proiectarea tipului.

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

Rezultat:

Thursday