Comment utiliser l'instruction switch en langage Go ?

Le langage Go est un langage de programmation émergent. Il présente les caractéristiques d'efficacité, de simplicité, de sécurité et de concurrence, et est très approprié pour une utilisation dans des domaines tels que le développement Web, les systèmes distribués et le cloud computing. Dans le langage Go, l'instruction switch est une structure de langage très couramment utilisée, qui peut sélectionner différentes branches à exécuter en fonction de la valeur d'une expression. Cet article présentera l'utilisation de base et les précautions des instructions switch en langage Go.

1. Syntaxe de base

L'instruction switch dans le langage Go est similaire à l'instruction switch dans d'autres langages de programmation, mais contrairement à d'autres langages, l'instruction switch dans le langage Go n'a pas besoin d'utiliser une instruction break pour éviter les "chutes" ( effet de pénétration). Voici un exemple simple :

func main() {
    num := 2
    switch num {
    case 1:
        fmt.Println("The number is 1")
    case 2:
        fmt.Println("The number is 2")
    case 3:
        fmt.Println("The number is 3")
    default:
        fmt.Println("Unknown number")
    }
}

Dans le code ci-dessus, nous définissons d'abord une variable num égale à 2, puis faisons correspondre la valeur de cette variable pour sélectionner différentes branches à exécuter. Puisque la valeur de num est égale à 2, la deuxième branche est sélectionnée et « Le nombre est 2 » est affiché. Si la valeur de num est modifiée à 4, la branche par défaut sera exécutée et "Numéro inconnu" sera affiché.

2. Correspondance multi-conditions

Dans la programmation réelle, vous devez parfois faire correspondre plusieurs valeurs et vous pouvez utiliser des virgules pour séparer plusieurs conditions. Voici un exemple :

func main() {
    num := 3
    switch num {
    case 1, 2:
        fmt.Println("The number is 1 or 2")
    case 3, 4:
        fmt.Println("The number is 3 or 4")
    default:
        fmt.Println("Unknown number")
    }
}

Dans le code ci-dessus, nous utilisons des virgules pour séparer plusieurs conditions afin de correspondre à différentes plages de valeurs. Si la valeur de num est 1 ou 2, alors la première branche sera exécutée et « Le nombre est 1 ou 2 » sera affiché ; si la valeur de num est 3 ou 4, alors la deuxième branche sera exécutée et « Le nombre est 1 ou 2 » ; le numéro de sortie" est 3 ou 4".

3. Expressions correspondantes

Dans certains cas, il est nécessaire d'utiliser des expressions pour faire correspondre les conditions, et pas seulement la valeur de la variable elle-même. Voici un exemple :

func main() {
    num1 := 10
    num2 := 20
    switch {
    case num1 > num2:
        fmt.Println("num1 is greater than num2")
    case num2 > num1:
        fmt.Println("num2 is greater than num1")
    default:
        fmt.Println("num1 is equal to num2")
    }
}

Dans le code ci-dessus, nous n'avons pas spécifié d'expression de condition de commutation, mais avons utilisé une expression différente dans chaque branche case pour correspondre à la condition. Si la valeur de num1 est supérieure à num2, alors la première branche sera exécutée et « num1 est supérieur à num2 » sera affiché ; si la valeur de num2 est supérieure à num1, alors la deuxième branche sera exécutée et « num2 est supérieur à num2 » ; supérieur à num1" sera affiché ; Si la valeur de num1 est égale à num2, alors la branche par défaut sera exécutée et "num1 est égal à num2" sera affiché.

4. Type Switch

En plus d'utiliser des expressions, vous pouvez également utiliser des types pour la correspondance. Ce type de commutateur est appelé commutateur de type. Voici un exemple :

func main() {
    var i interface{} = 10
    switch i.(type) {
    case int:
        fmt.Println("i is an integer")
    case float64:
        fmt.Println("i is a float")
    case bool:
        fmt.Println("i is a boolean")
    case string:
        fmt.Println("i is a string")
    default:
        fmt.Println("i is an unknown type")
    }
}

Dans le code ci-dessus, nous définissons une variable d'interface vide i et lui attribuons la valeur 10. Utilisez ensuite un commutateur de type pour faire correspondre le type de i et exécutez différentes branches en fonction de différents types. Puisque le type de i est int, la première branche sera exécutée et "i est un entier" sera affiché.

5. Remarques

Lors de l'utilisation des instructions switch, vous devez faire attention aux points suivants :

• Les instructions switch ne peuvent avoir aucune expression Dans ce cas, les expressions doivent être utilisées dans la branche case pour correspondre aux conditions.
• Contrairement à d'autres langages de programmation, la branche switch du langage Go ne "tombe" pas automatiquement (effet de pénétration), il n'est donc pas nécessaire d'utiliser une instruction break pour sortir de la branche switch.
• S'il n'y a pas de branche correspondante, aucune branche ne sera exécutée et aucune erreur ne sera signalée.
• Si vous utilisez l'instruction fallthrough pour continuer à exécuter la branche case suivante après une branche case, vous devez faire attention pour éviter une boucle infinie.

Résumé :

L'instruction switch dans le langage Go est une structure de langage très courante qui peut sélectionner différentes branches à exécuter en fonction de différentes conditions. Lorsque vous utilisez des instructions switch, vous devez faire attention aux cas particuliers tels que la correspondance multi-conditions, l'utilisation d'expressions pour faire correspondre les conditions, le type switch, etc. Une utilisation compétente des instructions switch peut nous aider à écrire un code plus clair, plus efficace et plus sûr.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!