En Go, ¿se rompe una declaración de interrupción de un interruptor / selección?

Sé que las declaraciones switch/ se selectrompen automáticamente después de cada caso. Me pregunto, en el siguiente código:

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

¿La breakdeclaración sale del forbucle o solo del switchbloque?

Declaraciones de ruptura, The Go Programming Language Specification.

Una instrucción "break" termina la ejecución de la instrucción "for", "switch" o "select" más interna.

BreakStmt = "break" [ Label ] .

Si hay una etiqueta, debe ser la de una declaración "for", "switch" o "select" adjunta, y esa es aquella cuya ejecución finaliza (§For declaraciones, §Switch declaraciones, §Seleccione declaraciones).

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

Por lo tanto, la breakdeclaración en su ejemplo termina la switchdeclaración, la declaración "más interna".

Un ejemplo ilustrativo esperanzador:

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

Sí, breakrompe lo interno 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.

Solo de un bloque de interruptores. Hay muchos ejemplos en el propio código de Golang que puede examinar (compare la ruptura interna con la ruptura externa ).

Esto debería explicarlo.

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

Corre por siempre

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

De nuevo, corre por siempre

PERO

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")
    }
}
}

imprimirá sjus ... claro?

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

Solo sale del bloque de interruptores.