web-dev-qa-db-fra.com

Dans Go, une instruction break est-elle interrompue par un commutateur / select?

Je sais que les instructions switch/select se cassent automatiquement après chaque cas. Je me demande, dans le code suivant:

for {
    switch sometest() {
    case 0:
        dosomething()
    case 1:
        break
    default:
        dosomethingelse()
    }
}

L'instruction break ferme-t-elle la boucle for ou juste le bloc switch?

selectswitch-statementgobreak
116
Matt

Instructions Break, Spécification du langage de programmation Go.

Une instruction "break" met fin à l'exécution de l'instruction "for", "switch" ou "select" la plus interne.

BreakStmt = "break" [ Label ] .

S'il existe une étiquette, il doit s'agir d'une instruction "for", "switch" ou "select" englobante, et c'est celle dont l'exécution est terminée (instructions §For, instructions §Switch, instructions §Select).

L:
  for i < n {
      switch i {
      case 5:
          break L
      }
  }

Par conséquent, l'instruction break de votre exemple met fin à l'instruction switch, l'instruction "la plus interne".

159
peterSO

Un exemple illustratif, espérons-le:

loop:
for {
        switch expr {
        case foo:
                if condA {
                        doA()
                        break // like 'goto A'
                }

                if condB {
                        doB()
                        break loop // like 'goto B'                        
                }

                doC()
        case bar:
                // ...
        }
A:
        doX()
        // ...
}

B:
doY()
// ....
45
zzzz

Oui, break casse le switch intérieur.

https://play.golang.org/p/SZdDuVjic4

package main

import "fmt"

func main() {

    myloop:for x := 0; x < 7; x++ {
        fmt.Printf("%d", x)
        switch {
        case x == 1:
            fmt.Println("start")
        case x == 5:
            fmt.Println("stop")
            break myloop
        case x > 2:
            fmt.Println("crunching..")
            break
        default:
            fmt.Println("idling..")
        }
    }
}

0idling..
1start
2idling..
3crunching..
4crunching..
5stop

Program exited.
11
anatoly techtonik

Juste d'un bloc de commutation. Il existe de nombreux exemples dans le code personnel de Golang que vous pouvez examiner (comparez coupure intérieure avec coupure extérieure ).

7
raina77ow

cela devrait l'expliquer.

for{
    x := 1
    switch {
    case x >0:
        fmt.Println("sjus")
    case x == 1:
        fmt.Println("GFVjk")
    default:
        fmt.Println("daslkjh")
    }
}
}

Fonctionne pour toujours

for{
    x := 1
    switch {
    case x >0:
        fmt.Println("sjus")
        break
    case x == 1:
        fmt.Println("GFVjk")
    default:
        fmt.Println("daslkjh")
    }
}
}

Encore une fois, fonctionne pour toujours

MAIS

package main

import "fmt"

func main() {
d:
for{
x := 1
    switch {
    case x >0:
        fmt.Println("sjus")
        break d
    case x == 1:
        fmt.Println("GFVjk")
    default:
        fmt.Println("daslkjh")
    }
}
}

imprimera sjus ... clair?

http://play.golang.org/p/GOvnfI67ih

1
Jasmeet Singh

Une autre utilisation de break pour switch est associée à une instruction fallthrough. Il faudra peut-être un peu de créativité pour l’utiliser correctement dans les situations appropriées, mais c’est peut-être une combinaison utilisable.

Voici un exemple simple:

a := 25
fallThrough := true

switch {
case a > 10 :
    fmt.Println("a>10")
    if fallThrough != true {
        break
    }
    fallthrough
case a > 20:
    fmt.Println("a>20")
}
0
Andreas Gajdosik

Il ne fait que quitter le bloc de commutation.

0
Sebastian