La déclaration switch

Switch est une déclaration qui évalue une expression et qui la compare à une liste de cas possibles et exécute le bloc du code selon le cas correspondant.

Voici un exemple qui aide à comprendre switch.

Exemple:

package main

import (  
    "fmt"
)

func main() {  
    finger := 4
    switch doigt {
    case 1:
        fmt.Println("Pouce")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Majeur")
    case 4:
        fmt.Println("Chaine")
    case 5:
        fmt.Println("Pinky")

    }
}

Dans le programme ci-dessus switch doigt compare la valeur de doigt à chaque déclaration case. Les cas sont évalués du début à la fin et le premier cas à correspondre à l'expression va être exécuté. Dans ce cas, doigt a la valeur de 4, par conséquent chaine est affiché.

Les cases(cas) qui ont la même valeur constante ne sont pas permises. Si vous essayez d'exécuter le programme ci-dessous, une erreur sera signalée main.go:18:2: duplicate case 4 in switch previous case at tmp/sandbox887814166/main.go:16:7

package main

import (  
    "fmt"
)

func main() {  
    finger := 4
    switch finger {
    case 1:
        fmt.Println("Pouce")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Majeur")
    case 4:
        fmt.Println("chaine")
    case 4://duplicate case
        fmt.Println("Autre Chaine")
    case 5:
        fmt.Println("Pinky")

    }
}

Default case

Default case est exécutée lorsque aucune des cases(cas) ne correspond à la valeur de doigt(dans notre cas).

package main

import (  
    "fmt"
)

func main() {  
    switch doigt := 8; doigt {
    case 1:
        fmt.Println("Pouce")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Majeur")
    case 4:
        fmt.Println("chaine")
    case 5:
        fmt.Println("Pinky")
    default: //default case
        fmt.Println("numéro de doigt est incorrect")
    }
}

Dans le programme ci-dessus, doigt est 8 ce qui ne correspond à aucun case(cas), par conséquent, il est nécessaire que default soit le dernier case(cas) dans le déclaration de switch.

Vous avez sûrement remarqué un petit changement dans la déclaration de doigt, switch peut inclure une déclaration optionnel qui est exécutée avant que l'expression soit évaluée. Dans cette ligne, switch doigt := 8; doigt doigt est déclaré en premier et utilisé dans l'expression. La portée de doigt est limitée au bloc de switch.

Plusieurs expressions dans case

Il est possible d'inclure plusieurs expressions dans case en les séparant avec une virgule.

package main

import (  
    "fmt"
)

func main() {  
    lettre := "i"
    switch lettre {
    case "a", "e", "i", "o", "u":
        fmt.Println("voyelle")
    default:
        fmt.Println("n'est pas voyelle")
    }
}

Switch sans expression

Une expression dans switch est optionnelle, elle peut être omise ,switch est considérée switch true et chacune des expressions de case est évaluée et le bloc correspondant est exécuté.

package main

import (  
    "fmt"
)

func main() {  
    num := 65
    switch { // expression omise
    case num >= 0 && num <= 34:
        fmt.Println("le nombre est plus grand que 0 est inférieur à 34")
    case num >= 35 && num <= 90:
        fmt.Println("le nombre est inférieur à 35 et supérieur à 90")
    case num >= 91:
        fmt.Println("le nombre est plus grand que 91")
    }

}

Dans le programme ci-dessus, l'expression est absente dans switch, par conséquent elle est considérée vraie et chacun des cas est évalué. case num >= 35 && num <= 90: est vraie et la sortie du programme est le nombre est inféérieur à 35 et supérieur à 90.

Fallthrough

En Go, le control sort de la déclaration switch immédiatement après qu'un case (cas)est exécuté. Une déclaration fallthrough est utilisé pour transférer control à la première déclaration de case qui est présente immédiatement après l'exécution de case.

Voici un programme qui nous permettra de mieux comprendre fallthrough:

package main

import (  
    "fmt"
)

func nombre() int {  
        num := 15 * 5 
        return num
}

func main() {

    switch num := number(); { //num n'est pas constant
    case num < 50:
        fmt.Printf("%d iest inférieur à 50\n", num)
        fallthrough
    case num < 100:
        fmt.Printf("%d est inférieur à 100\n", num)
        fallthrough
    case num < 200:
        fmt.Printf("%d est inférieur à 200", num)
    }

}

Les expressions de case et switch doivent être variables, elle peuvent être évaluées au moment de l'exécution. Dans le programme ci-dessus, num est initialisé à la valeur retournée par la fonction nombre(). Le control entre dans le switch et les cases(cas) sont évalués case num < 100 est vraie, le programme affiche alors 75 est inférieur à 100. La prochaine déclaration est fallthrough. Quand fallthrough est rencontrée, le control passe à la première déclaration du case(cas) suivante et affiche aussi 75 est inférieur à 200.

**fallthrough doit être la dernière déclaration dans un case. Si cette condition n'est pas vérifiée, le compilateur va lancer une erreur fallthrough statement out of place **

---

Posted on Utopian.io - Rewarding Open Source Contributors

---