Aller aux bases du langage - instruction switch

Qu'est-ce qu'une instruction switch

Un switch est une instruction conditionnelle utilisée pour calculer la valeur d'une expression conditionnelle afin de déterminer si la valeur satisfait à l'instruction case . S'il correspond, il exécutera le bloc de code correspondant. est un moyen courant de remplacer des instructions if-else complexes.

Exemple

Un exemple vaut mille mots. Regardons un exemple simple où l'entrée est le numéro du doigt et la sortie est le nom du téléphone, par exemple : 1 représente le pouce, 2 représente l'index, etc.

package main

import (
    "fmt"
)

func main() {
    finger := 4
    fmt.Printf("Finger %d is ", finger)
    switch finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 5:
        fmt.Println("Pinky")

    }
}

Execute ^[1]

Dans le code ci-dessus, le doigt de commutation sur la ligne 10 comparera la valeur du doigt avec chaque cas de haut en bas et exécutera le code de la première pièce de cas correspondante. Dans notre exemple ici, le doigt est 4, ce qui correspond au cas 4, donc le résultat est : Le doigt 4 est Ring.

Les cas en double ne sont pas autorisés

les branches de cas ne sont pas autorisées à avoir la même valeur constante If. vous essayez d'exécuter ce qui suit. Le programme signalera une erreur : ./prog.go:19:7 : dupliquer le cas 4 dans le cas précédent du commutateur à ./prog.go:17:7

package main

import (
    "fmt"
)

func main() {
    finger := 4
    fmt.Printf("Finger %d is ", finger)
    switch finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 4: //duplicate case
        fmt.Println("Another Ring")
    case 5:
        fmt.Println("Pinky")

    }
}

execution^[2]

cas par défaut

Une main n'a que 5 doigts Que se passera-t-il si nous saisissons un mauvais numéro de doigt ? À ce stade, la branche par défaut peut s'avérer utile. Si les autres branches ne correspondent pas, la branche par défaut sera exécutée.

package main

import (
    "fmt"
)

func main() {
    switch finger := 8; finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 5:
        fmt.Println("Pinky")
    default: //default case
        fmt.Println("incorrect finger number")
    }
}

Execute ^[3]

Dans le code ci-dessus, lorsque finger est égal à 8, il ne correspond à aucune branche case À ce moment, la branche par défaut sera exécutée, donc le résultat est : incorrect. numéro de doigt. Dans l'instruction switch, la branche par défaut n'est pas nécessaire et peut être placée n'importe où dans l'instruction, mais nous la plaçons généralement à la fin de l'instruction.

可能你已经注意到声明 finger 时的一点变化，它是在 switch 语句里面声明的。switch 包含一个可选语句，该语句在常量表达式匹配之前被执行。上面代码的第 8 行，先声明 finger，然后在条件表达式中被使用。这种情况下 finger 的作用局仅限于 switch 语句块内。

case 语句有多个表达式

case 语句中可以包括多个表达式，使用逗号分隔。

package main

import (
    "fmt"
)

func main() {
    letter := "i"
    fmt.Printf("Letter %s is a ", letter)
    switch letter {
    case "a", "e", "i", "o", "u": //multiple expressions in case
        fmt.Println("vowel")
    default:
        fmt.Println("not a vowel")
    }
}

执行^[4]

上面的代码判断 letter 是否是元音。第 11 行代码的 case 分支用来匹配所有的元音，因为 "i" 是元音，所有输出：

Letter i is a vowel

无条件表达式 switch 语句

switch 中的表达式是可选的，可以省略。如果表达式省略，switch 语句可以看成是 switch true，将会对 case 语句进行条件判断，如果判断为 true 将会执行相应 case 的代码块。

package main

import (
    "fmt"
)

func main() {
    num := 75
    switch { // expression is omitted
    case num >= 0 && num <= 50:
        fmt.Printf("%d is greater than 0 and less than 50", num)
    case num >= 51 && num <= 100:
        fmt.Printf("%d is greater than 51 and less than 100", num)
    case num >= 101:
        fmt.Printf("%d is greater than 100", num)
    }

}

执行^[5]

上面的代码中，switch 中没有表达式，因此它被认为是 true，将会对 case 语句进行判断，判断 case num >= 51 && num <= 100 为 true，所以输出：

75 is greater than 51 and less than 100

这种类型的 switch 被认为是多个 if-else 子句的替代方案。

fallthrough 语句

Go 语言里，执行完 case 语句的代码块将会立即跳出 switch 语句。使用 fallthrough 语句，可以在执行完该 case 语句后，不跳出，继续执行下一个 case 语句。

我们来写一个示例来好好理解下 fallthrough 语句。该示例将检查输入的数字是否小于 50、100 或 200。例如，如果我们输入 75，程序将打印 75 小于 100 和 200。我们将使用 fallthrough 来实现这一点。

package main

import (
    "fmt"
)

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

func main() {

    switch num := number(); { //num is not a constant
    case num < 50:
        fmt.Printf("%d is lesser than 50\n", num)
        fallthrough
    case num < 100:
        fmt.Printf("%d is lesser than 100\n", num)
        fallthrough
    case num < 200:
        fmt.Printf("%d is lesser than 200", num)
    }

}

执行^[6]

switch 和 case 语句不只是常量，也可以在程序运行时计算得到。上面代码的第 14 行，num 使用 number() 函数的返回值初始化，第 18 行的 case 语句 case num < 100: 判断为 true，所以输出 75 is lesser than 100。执行完 case 语句，下一行代码是 fallthrough 语句，此时程序不会跳出，而是继续执行下一条 case，打印 75 is lesser than 200，所以程序输出：

75 is lesser than 100
75 is lesser than 200

fallthrough 语句必须是 case 语句块中最后一行代码，如果出现在 case 语句中间，编译时将会报错：fallthrough statement out of place。

即使 fallthrough 后面的 case 语句判定为 false，也会继续执行

使用 fallthrough 时需要注意一点，即使后面的 case 语句判定为 false，也会继续执行。

请看下面的代码：

package main

import (
    "fmt"
)

func main() {
    switch num := 25; {
    case num < 50:
        fmt.Printf("%d is lesser than 50\n", num)
        fallthrough
    case num > 100:
        fmt.Printf("%d is greater than 100\n", num)
    }

}</p>
<p data-tool="mdnice编辑器" style="padding-top: 8px;padding-bottom: 8px;color: rgb(103, 97, 97);font-size: 17px;letter-spacing: 1.5px;line-height: 1.75;"><span style="font-weight: bold;color: #ee5408;">执行</span><sup style="line-height: 0;font-weight: bold;color: #ee5408;">[7]</sup></p>
<p data-tool="mdnice编辑器" style="padding-top: 8px;padding-bottom: 8px;color: rgb(103, 97, 97);font-size: 17px;letter-spacing: 1.5px;line-height: 1.75;">上面的代码中，num 等于 25，小于 50，所以第 9 行的 case 判断为 true，执行该语句。这个 case 语句最后一行是 fallthrough，继续执行下一个 case，不满足条件 case num > 100，判断为 false，但是 fallthrough 会忽视这点，即使结果是 false，也会继续执行该 case 块。</p>
<p data-tool="mdnice编辑器" style="padding-top: 8px;padding-bottom: 8px;color: rgb(103, 97, 97);font-size: 17px;letter-spacing: 1.5px;line-height: 1.75;">所以程序输出：</p>
<pre class="brush:php;toolbar:false;">25 is lesser than 50
25 is greater than 100

因此，请确保使用 fallthrough 语句时程序将会发生什么。

还有一点需要注意，fallthrough 不能用在最后一个 case 语句中，否则编译将会报错：

cannot fallthrough final case in switch

break

break 可以用来提前结束 switch 语句。我们通过一个示例来了解下工作原理：

我们添加一个条件，如果 num 小于 0，则 switch 提前结束。

package main

import (
    "fmt"
)

func main() {
    switch num := -5; {
    case num < 50:
        if num < 0 {
            break
        }
        fmt.Printf("%d is lesser than 50\n", num)
        fallthrough
    case num < 100:
        fmt.Printf("%d is lesser than 100\n", num)
        fallthrough
    case num < 200:
        fmt.Printf("%d is lesser than 200", num)
    }

}

执行^[8]

上面的代码，num 初始化为 -5，当程序执行到第 10 行代码的 if 语句时，满足条件 num < 0，执行 break，提前结束 switch，所以程序不会有任何输出。

跳出外部 for 循环

当 for 循环中包含 switch 语句时，有时可能需要提前终止 for 循环。这可以通过给 for 循环打个标签，并且在 switch 语句中通过 break 跳转到该标签来实现。我们来看个例子，实现随机生成一个偶数的功能。

我们将创建一个无限 for 循环，并且使用 switch 语句判断随机生成的数字是否为偶数，如果是偶数，则打印该数字并且使用标签的方式终止 for 循环。rand 包的 Intn() 函数用于生成非负伪随机数。

package main

import (
    "fmt"
    "math/rand"
)

func main() {
randloop:
    for {
        switch i := rand.Intn(100); {
        case i%2 == 0:
            fmt.Printf("Generated even number %d", i)
            break randloop
        }
    }

}

执行^[9]

上面代码的第 9 行，给 for 循环打了个标签 randloop。Intn() 函数会生成 0-99 的随机数，当为偶数时，第 14 行代码会被执行，跳转到标签 randloop 结束 for 循环。

程序输出(因为是随机数，你的执行结果可能与下面的不通)：

Generated even number 18

需要注意的是，如果使用不带标签的 break 语句，则只会中断 switch 语句，for 循环将继续运行，所以给 for 循环打标签，并在 switch 内的 break 语句中使用该标签才能终止 for 循环。

switch 语句还可以用于类型判断，我们将在学习 interface 时再来研究这点。

via: https://golangbot.com/switch/
作者：Naveen R

参考资料

[1]

执行: https://play.golang.org/p/94ktmJWlUom

[2]

执行: https://play.golang.org/p/7qrmR0hdvHH

[3]

执行: https://play.golang.org/p/Fq7U7SkHe1

[4]

执行: https://play.golang.org/p/AAVSQK76Me7

[5]

Exécution : https://play.golang.org/p/KPkwK0VdXII

[6]

Exécution : https://play.golang.org/p/svGJAiswQj

[7]

Exécution : https://play.golang.org/p/sjynQMXtnmY

[8]

Exécution : https://play.golang.org/p /UHwBXPYLv1B

[9]

Exécution : https://play.golang.org/p/0bLYOgs2TUk

Lecture recommandée :

Article Express hebdomadaire (3.21-3.27)

Téléchargement des données

Cliquez sur la carte ci-dessous pour suivre le compte officiel et envoyez des mots-clés spécifiques pour obtenir des informations correspondantes de haute qualité !

• Répondez à "E-book" pour obtenir des livres incontournables pour l'introduction et le niveau avancé du langage Go.

• Répondez à "Vidéo" et obtenez des informations vidéo valant 5 000 océans, y compris des projets pratiques (pas de partage externe) !

• Répondez à « Route » pour obtenir la dernière version de la carte des connaissances Go et de la feuille de route d'apprentissage et de croissance.

• Répondez aux "Questions d'entretien" et obtenez les questions d'entretien en langage Go compilées par Brother Four, y compris l'analyse.

• Répondez à "Backstage" pour obtenir 10 livres incontournables sur le développement backend.

D'ailleurs, après avoir lu l'article, pensez à cliquer sur la fiche ci-dessous. Suivez-moi~???

38 jicwJnxiaPOs8e2UaUBg/0?wx_fmt=png" données - id="MzA5MjkxNDU2Ng==" data-nickname="Apprentissage avancé du langage Go" data-pluginname="mpprofile" data-signature="Ce compte public se concentre sur le partage d'articles techniques, de ressources d'outils, de vidéos d'apprentissage et de contenus liés au langage Go. Matériel d'apprentissage, activités de livraison de livres, etc., votre attention est la source de notre lutte ~~~Suivez-nous, vous gagnerez non seulement des connaissances, mais aussi de l'expérience et des relations !">

------------------- End -------------------

Articles recommandés des numéros précédents :

• Apprenez étape par étape comment implémenter la compilation multiplateforme Golang

• Il suffit de lire cet article

• Créez votre propre empreinte digitale JA3 avec Go

• Choquant ! Il y a une petite fonction tellement intéressante dans Go !
  

Bienvenue à tous aimez , en avant, réimpression, Merci pour votre entreprise et votre soutien

Vous voulez rejoindre Pour les groupes d'étude, veuillez répondre en arrière-plan【Rejoindre le groupe】

Des milliers de montagnes et de rivières ont toujours de l'amour, pouvez-vous cliquer sur [Looking]

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!