In Go, un'istruzione break si interrompe da uno switch / select?

So che le dichiarazioni switch/ si selectinterrompono automaticamente dopo ogni caso. Mi chiedo, nel seguente codice:

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

L' breakistruzione esce dal forciclo o solo dal switchblocco?

Dichiarazioni di break, The Go Programming Language Specification.

Un'istruzione "break" termina l'esecuzione dell'istruzione "for", "switch" o "select" più interna.

BreakStmt = "break" [ Label ] .

Se esiste un'etichetta, deve essere quella di un'istruzione "for", "switch" o "select" racchiusa, e quella è quella la cui esecuzione termina (§Per istruzioni, §Switch istruzioni, §Seleziona istruzioni).

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

Pertanto, l' breakistruzione nel tuo esempio termina l' switchistruzione, l'istruzione "più interna".

Un esempio speranzoso illustrativo:

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 l'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 da un blocco interruttore. Ci sono molti esempi nel codice di Golang che puoi esaminare (confronta l' interruzione interna con l' interruzione esterna ).

questo dovrebbe spiegarlo.

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

Funziona per sempre

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

Ancora una volta, corre per sempre

MA

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

stamperà sjus ... cancella?

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

Esce solo dal blocco interruttori.