Switch-instructie in Go

Golang gebruikt, net als de meeste andere programmeertalen, de switch-instructie . Met de switch-instructie in Golang  kunt u een variabele of expressie in meerdere gevallen evalueren. Deze instructie wordt vaak gebruikt wanneer het schrijven van meerdere if-else-instructies de code er lelijk en repetitief uit laat zien.

In Go is de switch-instructie een multidirectionele vertakkingsinstructie die de uitvoering effectief aanstuurt op basis van de waarde (of het type) van een expressie. Er zijn twee hoofdtypen switch-statements in Go :

• Expressieschakelaar
• Type schakelaar

Bijvoorbeeld:

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

Schakelinstructie-syntaxis 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
}

Expressieschakelaar

Expression Switch evalueert een expressie en schakelt over naar een case op basis van de waarde van die expressie. Als er geen expressie wordt opgegeven, staat de schakelaar standaard op true .

Syntaxis

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

optstatement: optionele statement (bijv. variabele declaratie).
opexpression: Optionele expressie (indien weggelaten, standaard true ).

Voorbeeld met optionele opdracht

Hier wordt een optionele instructie geïntroduceerd die een dagvariabele declareert . De switch -instructie evalueert vervolgens de dag op basis van verschillende gevallen.

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

Resultaat:

Thursday

Voorbeeld met optionele expressie

Als er geen expressie is opgegeven, gaat de switch-instructie in Golang ervan uit dat de expressie waar is. Hierdoor kunnen we Booleaanse voorwaarden in case-instructies gebruiken.

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

Resultaat

Thursday

Type schakelaar

Type Switch wordt gebruikt om te vertakken op het type van een interfacewaarde, in plaats van op de waarde ervan. Dit is vooral handig als u werkt met variabelen van een onbekend type.

Syntaxis

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

Bijvoorbeeld:

In dit voorbeeld wordt dezelfde dagvariabele gebruikt , maar dan omhuld met interface{} om typecasting te illustreren.

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

Resultaat:

Thursday