For-Schleifen in Golang

Einführung

Im Gegensatz zu anderen Sprachen hat Go nur das Schlüsselwort "for" für Schleifenanweisungen. Dennoch ist es effizient und flexibel. Lassen Sie uns die "for"-Schleife in Go kennenlernen.

Wissenspunkte:

• For-Schleife
• For-range-Schleife

Skills Graph

Zeichen in einem String

Im vorherigen Abschnitt über grundlegende Datenstrukturen haben wir gelernt, dass ein String eine Sammlung von Zeichen ist. Daher können wir den Index verwenden, um bestimmte Zeichen in einem String abzurufen. Erstellen wir eine Datei namens string.go und schreiben wir den folgenden Code hinein:

cd ~/project
touch string.go

package main

import "fmt"

func main() {
    s := "labex"

    // Zugriff auf jedes Zeichen im String über Indizes
    fmt.Println(s[0], s[1], s[2], s[3], s[4])
    // Ausgabe der Zeichen
    fmt.Printf("%c %c %c %c %c\n", s[0], s[1], s[2], s[3], s[4])
}

Führen Sie das Programm aus:

go run string.go

Die Ausgabe ist wie folgt:

108 97 98 101 120
l a b e x

In diesem Programm deklarieren wir eine String-Variable, um "labex" zu speichern, und verwenden den Index, um auf jedes Zeichen im String zuzugreifen. Beim Ausgeben stellen wir fest, dass das Programm Zahlen anstelle der tatsächlichen Zeichen ausgibt.

Durch Vergleich mit der folgenden ASCII-Tabelle können wir sehen, dass die Zahlen den tatsächlichen Zeichen entsprechen. Beispielsweise entspricht in der ASCII-Tabelle "108" dem Zeichen "l".

Das liegt daran, dass Zeichen tatsächlich die numerische Codierung jedes Zeichens unter der "UTF-8"-Codierung speichern. "UTF-8" ist mit "ASCII" kompatibel, daher speichert die Position des Zeichens "l" tatsächlich die numerische Codierung "108".

Wenn wir Zeichen ausgeben möchten, können wir die fmt.Printf-Funktion mit der Escape-Sequenz %c verwenden, um sie als Zeichen auszugeben. Dies wird in der zweiten Zeile des Codes demonstriert. Sie wird die numerische Codierung in Zeichen umwandeln und diese dann ausgeben.

Um auf jedes Zeichen im String in der Datei string.go zuzugreifen, müssen wir jedes Mal einen Index deklarieren. Dies wird umständlich, wenn es um Hunderte oder Tausende von Daten geht. In diesem Fall können wir eine for-Schleife verwenden, um zu arbeiten.

Syntax der For-Schleife

Eine Schleife führt ein Programm basierend auf einer Bedingung aus. Schauen wir uns die Syntax der for-Schleifenanweisung an:

for initialization; condition; post {
    // code block
}

Die Initialisierungsanweisung initialisiert eine Variable. Die Bedingung sollte einen booleschen Wert zurückgeben. Die post-Anweisung ändert den Wert der Variable in jeder Schleifendurchführung. Schauen wir uns ein konkretes Beispiel an.

Erstellen Sie eine Datei for.go im Verzeichnis ~/project und schreiben Sie den folgenden Inhalt hinein:

cd ~/project
touch for.go

package main

import "fmt"

func main() {
    // Ausgabe der Zahlen von 0 bis 9
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }
}

Führen Sie das Programm aus:

go run for.go

Die Ausgabe ist wie folgt:

0
1
2
3
4
5
6
7
8
9

In diesem Programm initialisieren wir zunächst eine temporäre Variable i mit 0, und in jeder Schleifendurchführung wird der Wert von i um 1 erhöht. Die Bedingung ist, dass die Schleife fortgesetzt wird, solange der Wert von i kleiner als 10 ist. Das bedeutet, dass das Programm die Zahlen von 0 bis 9 ausgibt.

Hinweis: In einer for-Schleife sind die Initialisierungs-, Bedingungs- und post-Anweisungen alle optional. Das bedeutet, dass die for-Schleife auch ohne diese Anweisungen normal funktionieren wird.

Wenn nur die Bedingungsanweisung vorhanden ist, funktioniert die for-Schleife ähnlich wie eine "while"-Schleife in anderen Sprachen.

Der folgende Code verwendet nur die Bedingungsanweisung, um dasselbe Ergebnis wie das vorherige Programm zu erzielen:

package main

import "fmt"

func main() {
    i := 0
    for i < 10 {
        fmt.Println(i)
        i++
    }
}

Sie können sehen, dass wenn nur die Bedingungsanweisung vorhanden ist, das Semikolon ;, das zur Trennung der Anweisungen verwendet wird, weggelassen werden kann.

Verwendung der For-Schleife

Nachdem wir nun die Syntax der For-Schleife verstanden haben, lassen Sie uns das erste Programm string.go unter Verwendung einer For-Schleife neu schreiben.

package main

import "fmt"

func main() {
    s := "labex"
    for i := 0; i < len(s); i++ {
        fmt.Printf("%d %c\n", int(s[i]), s[i])
    }
}

Führen Sie das Programm aus:

go run string.go

Die Ausgabe ist wie folgt:

108 l
97 a
98 b
101 e
120 x

Quiz

Lassen Sie uns ein Quiz machen, um unser Verständnis der For-Schleife zu festigen.

Erstellen Sie eine Datei for2.go. Die Aufgabe besteht darin, jedes Zeichen aus der Zeichenkette "labex" in umgekehrter Reihenfolge auszugeben.

Erwartete Ausgabe:

x
e
b
a
l

Anforderungen:

• Die Datei for2.go sollte im Verzeichnis ~/project platziert werden.
• Verwenden Sie eine For-Schleife, um das Ergebnis zu erzielen.

Hinweis: Der Index beginnt bei 0.

Das Schlüsselwort "break"

Im vorherigen Abschnitt haben wir erwähnt, dass alle drei Anweisungen in einer For-Schleife optional sind. Was würde passieren, wenn keine von ihnen deklariert würde? Lassen Sie uns es ausprobieren.

Schreiben Sie den folgenden Code in die Datei for.go:

package main

import "fmt"

func main() {
    for {
        fmt.Printf("1")
    }
}

Führen Sie das Programm aus:

go run for.go

Wir können sehen, dass wenn die Bedingung in der For-Schleife nicht deklariert wird, die Bedingung als true angenommen wird und die Schleife unendlich fortgesetzt wird.

Tipp: Verwenden Sie Ctrl+C, um das Programm zu beenden.

Wenn wir die Schleife unter einer bestimmten Bedingung beenden möchten, ohne eine Bedingungsanweisung zu deklarieren oder wenn wir keine Bedingungsanweisung schreiben können, können wir das Schlüsselwort "break" verwenden. Es erzwingt einen sofortigen Austritt aus der umschließenden Schleife.

Aktualisieren Sie die Datei for.go mit dem folgenden Code, der das Schlüsselwort "break" verwendet, um 23 "1"s auszugeben:

package main

import "fmt"

func main() {
    i := 0
    for {
        // Erhöhen Sie den Wert von i um 1 in jeder Schleifendurchführung
        i++
        fmt.Printf("1")
        // Beenden Sie die Schleife, wenn der Wert von i 23 ist
        if i == 23 {
            break
        }
    }
}

Das Schlüsselwort "break" kann nicht nur in einer For-Schleife ohne Bedingungsanweisung verwendet werden, sondern auch in einer For-Schleife mit einer Bedingungsanweisung. Wenn die "break"-Bedingung erfüllt ist, überspringt es die Bedingungsanweisung und verlässt die Schleife.

Das Schlüsselwort "continue"

Neben dem Schlüsselwort "break", das einen sofortigen Austritt aus der Schleife erzwingt, gibt es auch das Schlüsselwort "continue", das es Ihnen ermöglicht, den Rest der aktuellen Schleifendurchführung zu überspringen und mit der nächsten Durchführung zu beginnen.

Die Verwendung des Schlüsselworts "continue" ähnelt der des Schlüsselworts "break", aber ihre Funktionen sind unterschiedlich.

Lassen Sie uns die Datei for.go aktualisieren, um die Zahlen 2 und 8 zu überspringen:

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 2 || i == 8 {
            continue
        }
        fmt.Println(i)
    }
}

Führen Sie das Programm aus:

go run for.go

Die Ausgabe ist wie folgt:

0
1
3
4
5
6
7
9

In diesem Programm haben wir eine bedingte Anweisung im Codeblock der For-Schleife hinzugefügt. Wenn der aktuelle Wert der Schleifenvariablen 2 oder 8 ist, wird der Rest des Codes übersprungen und die nächste Schleifendurchführung gestartet. Daher sind die Zahlen 2 und 8 in der Ausgabe nicht enthalten.

Zusammenfassung

In diesem Lab haben wir uns mit der for-Schleife beschäftigt. Lassen Sie uns zusammenfassen:

• Alle drei Parameter in der for-Schleife sind optional.
• Das Schlüsselwort break kann verwendet werden, um die aktuelle Schleife zu verlassen.
• Das Schlüsselwort continue kann verwendet werden, um die aktuelle Schleifendurchführung zu überspringen und mit der nächsten zu beginnen.