Dans Go, une instruction break s'interrompt-elle d'un commutateur / select?

Je sais que switch/ les selectdéclarations 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' breakinstruction quitte- t-elle la forboucle ou juste le switchbloc?

Instructions de rupture, 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 y a une étiquette, elle doit être celle d'une instruction englobante «for», «switch» ou «select», et c'est celle dont l'exécution se termine (§Pour les instructions, §Switch, §Select).

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

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

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()
// ....

Oui, breakbrise l'intérieur switch.

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.

Juste à partir d'un bloc de commutation. Il y a beaucoup d'exemples dans le code de Golang que vous pouvez examiner (comparez la rupture interne avec la rupture externe ).

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, court 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

Il sort uniquement du bloc de commutation.