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

package main

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

package main

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

package main

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

import "fmt"

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

package main

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

package main

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.

Schleifenanweisungen in der Go-Sprache

Weitere Erweiterungen