Compétences d'application de l'instruction de commutation de fonction Golang

Alors que Golang continue de se développer rapidement ces dernières années, il est devenu l'un des langages de programmation préférés​​pour de nombreux développeurs. Parmi les nombreuses structures grammaticales de Golang, l'instruction switch est sans aucun doute une partie très importante. Cependant, de nombreux développeurs n'utilisent peut-être que l'instruction switch la plus simple, mais ne connaissent pas grand-chose des compétences d'application ultérieures de l'instruction switch. Cet article présentera quelques techniques d'application courantes des instructions switch dans les fonctions Golang, afin d'aider les lecteurs à mieux comprendre et appliquer les instructions switch.

1. Aucune expression requise

Dans une instruction switch générale, nous fournirons une expression, afin que le programme puisse déterminer quelle instruction case exécuter en fonction de la valeur de l'expression. Cependant, dans Golang, nous pouvons utiliser une instruction switch sans expression pour permettre au programme de passer à la première instruction case qui satisfait la condition. Voici un exemple :

package main

import "fmt"

func main() {
    i := 3
    switch {
    case i < 3:
        fmt.Println("i is less than 3")
    case i == 3:
        fmt.Println("i is equal to 3")
    case i > 3:
        fmt.Println("i is greater than 3")
    }
}

Selon la valeur de i, le programme affichera "i est égal à 3". Cette fonctionnalité est très utile lorsque vous devez évaluer plusieurs conditions en séquence, mais que vous ne souhaitez pas utiliser plusieurs instructions if.

2. Vous pouvez utiliser plusieurs expressions

Dans une instruction switch générale, nous ne pouvons utiliser qu'une seule expression. Cependant, en Golang, nous pouvons utiliser plusieurs expressions séparées par des virgules. Voici un exemple :

package main

import "fmt"

func main() {
    i, j := 3, 4
    switch i, j {
    case 1, 2:
        fmt.Println("i is either 1 or 2")
    case 3, 4:
        fmt.Println("i is either 3 or 4")
    }
}

En fonction des valeurs de i et j, le programme affichera "i vaut 3 ou 4". Cette fonctionnalité est très utile lorsque plusieurs conditions doivent être évaluées, mais chaque condition ne s’exclut pas mutuellement.

3. Vous pouvez utiliser des assertions de type

Dans Golang, nous pouvons utiliser des assertions de type pour déterminer le type d'une valeur. Par conséquent, dans l’instruction switch, nous pouvons également utiliser des assertions de type pour effectuer un jugement de type. Voici un exemple :

package main

import "fmt"

func main() {
    var i interface{} = 1
    switch i.(type) {
    case int:
        fmt.Println("i is an int")
    case float64:
        fmt.Println("i is a float64")
    case string:
        fmt.Println("i is a string")
    }
}

Le programme affichera "i is an int". Cette fonctionnalité est très utile lorsque vous devez juger différents types de valeurs.

4. Vous pouvez utiliser le mot-clé fallthrough

Dans Golang, nous pouvons utiliser le mot-clé fallthrough pour permettre au programme d'exécuter l'instruction case suivante sans porter de jugements conditionnels. Voici un exemple :

package main

import "fmt"

func main() {
    i := 1
    switch i {
    case 1:
        fmt.Println("i is 1")
        fallthrough
    case 2:
        fmt.Println("i is 2")
    }
}

Le programme affichera "i is 1" et "i is 2". Cette fonctionnalité est très utile lorsque plusieurs instructions case doivent être exécutées.

5. Vous pouvez utiliser l'instruction par défaut

Dans une instruction switch générale, si aucune des conditions d'une instruction case n'est remplie, le programme quittera l'instruction switch. Cependant, dans Golang, nous pouvons utiliser l'instruction par défaut dans l'instruction switch pour gérer de telles situations. Voici un exemple :

package main

import "fmt"

func main() {
    i := 5
    switch i {
    case 1:
        fmt.Println("i is 1")
    case 2:
        fmt.Println("i is 2")
    default:
        fmt.Println("i is neither 1 nor 2")
    }
}

Le programme affichera "i n'est ni 1 ni 2". Cette fonctionnalité est très utile lorsqu'un type de situation doit être traité mais qu'il n'y a pas de jugement conditionnel spécifique.

6. Vous pouvez utiliser l'instruction switch comme valeur de retour de fonction

Dans Golang, l'instruction switch peut être utilisée comme valeur de retour de fonction. Cette fonctionnalité est très utile car elle rend les programmes plus concis et plus lisibles. Voici un exemple :

package main

import "fmt"

func main() {
    i, j := 1, 2
    switch {
    case i < j:
        fmt.Printf("%d is less than %d
", i, j)
    case i == j:
        fmt.Printf("%d is equal to %d
", i, j)
    case i > j:
        fmt.Printf("%d is greater than %d
", i, j)
    }
}

Le programme affichera "1 est inférieur à 2". Cette fonctionnalité est très utile dans les situations où différents types de valeurs doivent être renvoyés.

Pour résumer, les compétences d'application des instructions switch dans les fonctions Golang sont très riches. Nous pouvons utiliser ces compétences de manière flexible en cas de besoin pour rendre le programme plus rationalisé, efficace et facile à lire.

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!