1 Übersicht über Schleifenanweisungen

In der Go-Sprache ermöglichen Schleifenanweisungen die mehrfache Ausführung eines Codeblocks. Schleifenanweisungen sind sehr nützlich, wenn bestimmte Operationen wiederholt ausgeführt werden müssen. Beispielsweise möchten Sie möglicherweise durch jedes Element in einem Array iterieren oder eine Operation wiederholen, bis eine bestimmte Bedingung erfüllt ist. In Go werden Schleifenanweisungen hauptsächlich unter Verwendung des Schlüsselworts for implementiert, das die einzige Schleifenanweisung in der Go-Sprache ist. Die korrekte Verwendung von Schleifenanweisungen ist entscheidend für das Schreiben effizienten und wartbaren Codes.

2 Grundlagen der for-Schleife

2.1 Struktur der for-Schleife

Die for-Schleife in der Go-Sprache besteht aus drei Teilen:

  1. Initialisierungsanweisung: Wird vor der ersten Iteration ausgeführt und wird normalerweise zum Deklarieren eines Schleifenzählers verwendet.
  2. Bedingungsausdruck: Wird vor jeder Iteration ausgewertet. Wenn die Bedingung true ist, wird der Schleifenrumpf ausgeführt.
  3. Nachfolgeanweisung: Wird nach dem Codeblock jeder Iteration ausgeführt und wird normalerweise verwendet, um den Schleifenzähler zu aktualisieren.

Die Syntax der for-Schleife lautet wie folgt:

for Initialisierungsanweisung; Bedingungsausdruck; Nachfolgeanweisung {
    // Code des Schleifenrumpfs
}

2.2 Einfaches Beispiel der for-Schleife

Lassen Sie uns den Ausführungsprozess der for-Schleife anhand eines einfachen Beispiels verstehen:

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println("Der Wert von i ist:", i)
    }
}

In diesem Beispiel wird die Variable i auf 0 initialisiert. Die for-Schleife überprüft, ob die Bedingung i < 5 wahr ist. Wenn die Bedingung wahr ist, wird der Schleifenrumpf ausgeführt und der Wert von i wird gedruckt. Nach Ausführung des Schleifenrumpfs wird der Wert von i durch i++ (Inkrementoperation) aktualisiert, und dann überprüft die Schleife erneut die Bedingung, bis der Wert von i 5 erreicht, wodurch die Bedingung falsch wird und die for-Schleife beendet wird.

2.3 Weitere Beispiele der for-Schleife

2.3.1 Unendliche Schleife

In Go können Sie die Initialisierungsanweisung, den Bedingungsausdruck und die Nachfolgeanweisung der for-Schleife auslassen, um eine unendliche Schleife zu erstellen, die so lange ausgeführt wird, bis sie durch eine break-Anweisung oder einen Rückgabewert aus einer Funktion beendet wird.

for {
    // Code innerhalb einer unendlichen Schleife
    if someCondition {
        break // Schleife beenden, wenn eine bestimmte Bedingung erfüllt ist
    }
}

2.3.2 Schleife mit nur Bedingung

In Go können Sie auch eine for-Schleife verwenden, die nur eine Bedingung enthält, ähnlich einer while-Schleife in anderen Programmiersprachen.

n := 0
for n < 5 {
    fmt.Println(n)
    n++
}

Der obige Code wird 0 bis 4 drucken, und die Schleife wird enden, wenn n 5 erreicht.

2.3.3 Schleife durch ein Array oder Slice

In Go wird das Schlüsselwort range verwendet, um die Iteration durch jedes Element eines Arrays oder Slices zu vereinfachen.

items := []int{1, 2, 3, 4, 5}
for index, value := range items {
    fmt.Printf("Index: %d, Wert: %d\n", index, value)
}

Der obige Code wird den Index und den Wert jedes Elements drucken. Wenn Sie nur den Wert der Elemente benötigen, können Sie _ verwenden, um den Index zu ignorieren.

for _, value := range items {
    fmt.Printf("Wert: %d\n", value)
}

Hinweis: Die Verwendung von Arrays wird in nachfolgenden Kapiteln ausführlich erläutert. Wenn Sie diesen Teil nicht verstehen, ist das in Ordnung, solange Sie verstehen, dass die for-Schleife auf diese Weise verwendet werden kann.

2.3.4 Durchlauf von Maps

Beim Iterieren durch eine Map ist die Kombination aus der for-Schleife und dem range-Ausdruck sehr leistungsstark. Dadurch kannst du jedes Schlüssel-Wert-Paar der Map erhalten.

colors := map[string]string{"red": "#ff000", "green": "#00ff00", "blue": "#000ff"}
for key, value := range colors {
    fmt.Printf("Schlüssel: %s, Wert: %s\n", key, value)
}

In diesem Beispiel geben wir alle Schlüssel und ihre entsprechenden Werte in der colors-Map aus. Ähnlich wie beim Iterieren durch Slices kannst du, wenn du nur den Schlüssel oder den Wert benötigst, wählen, den anderen zu ignorieren.

Hinweis: Die Verwendung von Maps wird in den nachfolgenden Kapiteln detailliert erläutert. Wenn du diesen Teil nicht verstehst, ist das in Ordnung, solange du verstehst, dass die for-Schleife auf diese Weise verwendet werden kann.

3 Steuerung des Schleifenflusses

3.1 Verwendung von break, um eine Schleife zu beenden

Manchmal müssen wir die Schleife vorzeitig beenden, wenn eine bestimmte Bedingung erfüllt ist, und in solchen Fällen kann die break-Anweisung verwendet werden. Hier ist ein Beispiel für die Verwendung von break, um eine Schleife zu beenden:

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("Der Wert von i ist:", i)
    }
    // Die Ausgabe enthält nur Werte von 0 bis 4
}

3.2 Verwendung von continue, um Iterationen zu überspringen

In bestimmten Situationen möchten wir möglicherweise die aktuelle Iteration überspringen und mit der nächsten Iteration in der Schleife fortfahren. Dies kann mithilfe der continue-Anweisung erreicht werden. Hier ist ein Beispiel:

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i%2 != 0 {
            continue // Überspringe diese Iteration, wenn i ungerade ist
        }
        fmt.Println("Gerade Zahl:", i)
    }
}