For-Schleifen in Golang

Einführung

Im Gegensatz zu vielen anderen Sprachen kennt Go nur das Schlüsselwort for für Schleifenanweisungen. Dennoch ist diese Umsetzung äußerst effizient und flexibel. In diesem Lab schauen wir uns die For-Schleife in Go genauer an.

Wissenspunkte:

For-Schleife
For-Range-Schleife

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 auf bestimmte Zeichen in einem String zuzugreifen. Erstellen wir eine Datei namens string.go und schreiben 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])
    // Zeichen ausgeben
    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 sieht wie folgt aus:

108 97 98 101 120
l a b e x

In diesem Programm deklarieren wir eine String-Variable mit dem Wert "labex" und verwenden den Index, um auf jedes Zeichen zuzugreifen. Bei der ersten Ausgabe stellen wir fest, dass das Programm Zahlen anstelle der eigentlichen Buchstaben ausgibt.

Ein Blick in die ASCII-Tabelle zeigt, dass diese Zahlen den tatsächlichen Zeichen entsprechen. In der ASCII-Tabelle steht beispielsweise die "108" für den Buchstaben "l".

Das liegt daran, dass Zeichen intern als numerische Kodierung (unter UTF-8) gespeichert werden. Da UTF-8 abwärtskompatibel zu ASCII ist, wird an der Position des Zeichens "l" der Wert "108" gespeichert.

Wenn wir die tatsächlichen Zeichen ausgeben möchten, nutzen wir die Funktion fmt.Printf mit dem Platzhalter %c. Dies wird in der zweiten Zeile des Codes demonstriert: Die numerische Kodierung wird in das entsprechende Zeichen umgewandelt und ausgegeben.

Um auf jedes Zeichen im String in der Datei string.go zuzugreifen, mussten wir bisher jedes Mal manuell einen Index angeben. Bei hunderten oder tausenden von Daten wäre das extrem mühsam. In solchen Fällen nutzen wir eine for-Schleife.

Syntax der For-Schleife

Eine Schleife führt einen Programmteil basierend auf einer Bedingung wiederholt aus. Schauen wir uns die Syntax der for-Schleife an:

for initialization; condition; post {
    // Codeblock
}

Die Initialisierung (initialization) setzt eine Startvariable. Die Bedingung (condition) muss einen booleschen Wert zurückgeben. Die Nachbearbeitung (post) ändert den Wert der Variable nach jedem Schleifendurchlauf. Betrachten wir ein konkretes Beispiel.

Erstellen Sie eine Datei for.go im Verzeichnis ~/project mit folgendem Inhalt:

cd ~/project
touch for.go

package main

import "fmt"

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

Führen Sie das Programm aus:

go run for.go

Die Ausgabe lautet:

In diesem Programm initialisieren wir eine temporäre Variable i mit 0. In jedem Durchlauf wird i um 1 erhöht. Die Bedingung besagt, dass die Schleife fortgesetzt wird, solange i kleiner als 10 ist. Das Ergebnis ist die Ausgabe der Zahlen 0 bis 9.

Hinweis: In einer for-Schleife sind Initialisierung, Bedingung und Nachbearbeitung optional. Das bedeutet, die Schleife funktioniert auch, wenn Teile davon weggelassen werden.

Wenn nur die Bedingung vorhanden ist, verhält sich die for-Schleife wie eine "while"-Schleife in anderen Programmiersprachen.

Der folgende Code nutzt nur die Bedingung, um das gleiche Ergebnis wie zuvor zu erzielen:

package main

import "fmt"

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

Wie Sie sehen, können die Semikolons ; weggelassen werden, wenn nur die Bedingung angegeben wird.

Anwendung der For-Schleife

Nachdem wir die Syntax verstanden haben, schreiben wir unser erstes Programm string.go mithilfe einer For-Schleife um.

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:

Quiz

Machen wir eine kleine Übung, um das Gelernte zu festigen.

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

Erwartete Ausgabe:

x
e
b
a
l

Anforderungen:

Die Datei for2.go muss im Verzeichnis ~/project liegen.
Verwenden Sie eine For-Schleife für die Lösung.

Hinweis: Der Index beginnt bei 0.

Das Schlüsselwort "break"

Wir haben erwähnt, dass alle drei Teile einer For-Schleife optional sind. Was passiert, wenn gar keiner deklariert wird? Probieren wir es aus.

Schreiben Sie 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

Sie werden sehen, dass die Bedingung automatisch als true angenommen wird, wenn sie fehlt. Die Schleife läuft unendlich weiter.

Tipp: Drücken Sie Ctrl+C, um das Programm abzubrechen.

Wenn wir eine Schleife unter einer bestimmten Bedingung verlassen wollen, ohne eine formale Schleifenbedingung zu nutzen (oder wenn diese nicht ausreicht), verwenden wir das Schlüsselwort break. Es erzwingt das sofortige Verlassen der aktuellen Schleife.

Aktualisieren Sie for.go mit folgendem Code, der break nutzt, um genau 23-mal die "1" auszugeben:

package main

import "fmt"

func main() {
    i := 0
    for {
        // Erhöhe i in jedem Durchlauf um 1
        i++
        fmt.Printf("1")
        // Verlasse die Schleife, wenn i den Wert 23 erreicht
        if i == 23 {
            break
        }
    }
}

Das Schlüsselwort break kann nicht nur in Endlosschleifen, sondern in jeder For-Schleife verwendet werden. Sobald die break-Bedingung erfüllt ist, wird die reguläre Schleifenprüfung übersprungen und die Schleife beendet.

Das Schlüsselwort "continue"

Neben break, das die Schleife komplett beendet, gibt es das Schlüsselwort continue. Es erlaubt Ihnen, den Rest des aktuellen Schleifendurchlaufs zu überspringen und sofort mit der nächsten Iteration zu beginnen.

Die Verwendung von continue ähnelt der von break, aber die Auswirkung ist eine andere.

Aktualisieren wir for.go, 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:

In diesem Programm haben wir eine Bedingung in den Schleifenblock eingefügt. Wenn der aktuelle Wert von i entweder 2 oder 8 ist, wird der restliche Code (die Println-Anweisung) übersprungen und die Schleife springt direkt zum nächsten Wert. Deshalb fehlen die 2 und die 8 in der Ausgabe.

Zusammenfassung

In diesem Lab haben wir die for-Schleife kennengelernt. Hier ist ein kurzer Rückblick:

Alle drei Parameter der for-Schleife sind optional.
Mit dem Schlüsselwort break kann eine Schleife vorzeitig beendet werden.
Mit dem Schlüsselwort continue kann der aktuelle Durchlauf übersprungen werden, um direkt mit dem nächsten zu starten.