break-Anweisung in der Go-Sprache
Schleifenanweisungen in der Go-Sprache
In der Go-Sprache wird die break-Anweisung verwendet, um die Ausführung der aktuellen Schleife oder switch-Anweisung zu beenden und aus dem Codeblock dieser Schleife oder switch-Anweisung herauszuspringen.
Die break-Anweisung kann in den folgenden Aspekten verwendet werden:
- Sie wird verwendet, um in einer Schleifenanweisung aus der Schleife auszubrechen und mit der Ausführung der Anweisungen nach der Schleife zu beginnen.
- Die break-Anweisung in einer switch-Anweisung wird verwendet, um nach der Ausführung eines case aus der switch-Anweisung herauszuspringen.
- break kann in select-Anweisungen angewendet werden.
- In mehreren Schleifen kann ein Label verwendet werden, um die Schleife zu markieren, aus der ausgebrochen werden soll.
Syntax
Das Syntaxformat von break ist wie folgt:
break
Das Flussdiagramm der break-Anweisung ist wie folgt:

Beispiel
Verwendung von break in einer for-Schleife:
Beispiel
import "fmt"
func main() {
for i := 0; i < 10; i++ {
if i == 5 {
break // Verlasse die Schleife, wenn i gleich 5 ist
}
fmt.Println(i)
}
}
Ausgabeergebnis:
0 1 2 3 4
Verlasse die Schleife, wenn die Variable a größer als 15 ist:
Beispiel
import "fmt"
func main() {
/* Lokale Variablen definieren */
var a int = 10
/* for-Schleife */
for a < 20 {
fmt.Printf("Der Wert von a ist: %d\n", a);
a++
if a > 15 {
/* Verwende die break-Anweisung, um die Schleife zu verlassen, wenn a größer als 15 ist */
break
}
}
}
Im obigen Beispiel wird, wenn der Wert von a größer als 15 ist, die break-Anweisung ausgeführt und die gesamte Schleife beendet. Das Ausführungsergebnis ist:
a 的值为 : 10 a 的值为 : 11 a 的值为 : 12 a 的值为 : 13 a 的值为 : 14 a 的值为 : 15
Das folgende Beispiel enthält mehrere Schleifen und zeigt den Unterschied zwischen der Verwendung von Labels und der Nichtverwendung von Labels:
Beispiel
import "fmt"
func main() {
// ohne Label
fmt.Println("---- break ----")
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
break
}
}
// mit einem Label
fmt.Println("---- break-Label ----")
re:
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
break re
}
}
}
Das Ausführungsergebnis des obigen Beispiels ist:
---- break ---- i: 1 i2: 11 i: 2 i2: 11 i: 3 i2: 11 ---- break label ---- i: 1 i2: 11
Verwendung von break in einer switch-Anweisung:
Beispiel
func main() {
day := "Dienstag"
switch day {
case "Montag":
fmt.Println("Es ist Montag.")
case "Dienstag":
fmt.Println("Es ist Dienstag.")
break // Aus der switch-Anweisung ausbrechen
case "Mittwoch":
fmt.Println("Es ist Mittwoch.")
}
}
Ausgabeergebnis:
It's Tuesday.
Verwendung von break in einer select-Anweisung:
Beispiel
import (
"fmt"
"time"
)
func main() {
ch1 := make(chan int)
ch2 := make(chan int)
go func() {
time.Sleep(2 * time.Second)
ch1 <- 1
}()
go func() {
time.Sleep(1 * time.Second)
ch2 <- 2
}()
select {
case <-ch1:
fmt.Println("Von ch1 empfangen.")
case <-ch2:
fmt.Println("Von ch2 empfangen.")
break // Aus der select-Anweisung ausbrechen
}
}
Ausgabeergebnis:
Received from ch2.
In der Sprache Go ist die Anwendung der break-Anweisung in einer select-Anweisung relativ speziell. Aufgrund der Eigenschaften der select-Anweisung kann die break-Anweisung nicht direkt verwendet werden, um aus der select-Anweisung selbst auszubrechen, weil die select-Anweisung nicht blockierend ist und immer darauf wartet, dass alle Kommunikationsoperationen bereit sind. Wenn Sie die Ausführung der select-Anweisung vorzeitig beenden müssen, können Sie return- oder goto-Anweisungen verwenden, um denselben Effekt zu erzielen.
Das folgende Beispiel zeigt den Fall, in dem return in einer select-Anweisung verwendet wird, um die Ausführung vorzeitig zu beenden:
Beispiel
import (
"fmt"
"time"
)
func process(ch chan int) {
for {
select {
case val := <-ch:
fmt.Println("Empfangener Wert:", val)
// Etwas Logik ausführen
if val == 5 {
return // Die Ausführung der select-Anweisung vorzeitig beenden
}
default:
fmt.Println("Noch kein Wert empfangen.")
time.Sleep(500 * time.Millisecond)
}
}
}
func main() {
ch := make(chan int)
go process(ch)
time.Sleep(2 * time.Second)
ch <- 1
time.Sleep(1 * time.Second)
ch <- 3
time.Sleep(1 * time.Second)
ch <- 5
time.Sleep(1 * time.Second)
ch <- 7
time.Sleep(2 * time.Second)
}
Im obigen Beispiel verwendet die Funktion process eine select-Anweisung in einer Endlosschleife, um auf Daten am Kanal ch zu warten. Wenn Daten empfangen werden, wird eine gewisse Logik ausgeführt. Wenn der empfangene Wert gleich 5 ist, wird return verwendet, um die Ausführung der select-Anweisung vorzeitig zu beenden.
Ausgabeergebnis:
No value received yet. No value received yet. Received value: 1 No value received yet. Received value: 3 No value received yet. Received value: 5
Durch die Verwendung von return können wir die Ausführung in der select-Anweisung vorzeitig beenden und zum Code des Aufrufers zurückkehren.
Es ist zu beachten, dass die Verwendung der return-Anweisung die Ausführung der aktuellen Funktion sofort beendet. Entscheiden Sie daher je nach tatsächlichem Bedarf, welche Methode verwendet werden soll, um die Ausführung in der select-Anweisung vorzeitig zu beenden.
Weitere Erweiterungen