Instruction Switch en Go

Golang, comme la plupart des autres langages de programmation, possède l' instruction switch . L'instruction switch dans Golang  vous permet d'évaluer une variable ou une expression dans plusieurs cas et est souvent utilisée lorsque l'écriture de plusieurs instructions if-else rend le code laid et répétitif.

En Go, l’instruction switch est une instruction de branchement multidirectionnelle qui dirige efficacement l’exécution en fonction de la valeur (ou du type) d’une expression. Il existe deux principaux types d'instructions switch dans Go :

• Commutateur d'expression
• Commutateur de type

Par exemple:

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

Syntaxe de l'instruction Switch en 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
}

Commutateur d'expression

Expression Switch évalue une expression et bascule vers un cas en fonction de la valeur de cette expression. Si aucune expression n'est fournie, le commutateur est défini par défaut sur true .

Syntaxe

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

optstatement : instruction facultative (par exemple, déclaration de variable).
optexpression : expression facultative (si omise, la valeur par défaut est true ).

Exemple avec commande facultative

Voici une instruction facultative qui déclare une variable de jour . L' instruction switch évalue ensuite le jour selon différents cas.

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

Résultat:

Thursday

Exemple avec expression facultative

Si aucune expression n'est spécifiée, l'instruction switch dans Golang supposera que l'expression est vraie. Cela nous permet d'utiliser des conditions booléennes dans les instructions de cas.

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

Résultat

Thursday

Commutateur de type

Le commutateur de type est utilisé pour se ramifier sur le type d'une valeur d'interface, plutôt que sur sa valeur. Ceci est particulièrement utile lorsqu'il s'agit de variables de type inconnu.

Syntaxe

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

Par exemple:

Cet exemple utilise la même variable de jour mais enveloppée dans interface{} pour illustrer le cast de type.

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

Résultat:

Thursday