Go
Schleifen

Einführung

Grundschleife

for ist die einzige Schleifenanweisung in go, daher könnte eine grundlegende Schleifenimplementierung folgendermaßen aussehen:

// like if, for doesn't use parens either.
// variables declared in for and if are local to their scope.
for x := 0; x < 3; x++ { // ++ is a statement.
    fmt.Println("iteration", x)
}

// would print:
// iteration 0
// iteration 1
// iteration 2

Pause und fortfahren

Das Ausbrechen der Schleife und das Fortfahren mit der nächsten Iteration wird wie in vielen anderen Sprachen auch in Go unterstützt:

for x := 0; x < 10; x++ { // loop through 0 to 9
    if x < 3 { // skips all the numbers before 3
        continue
    } 
    if x > 5 { // breaks out of the loop once x == 6
        break
    }
    fmt.Println("iteration", x)
}

// would print:
// iteration 3
// iteration 4
// iteration 5

Die break und continue Anweisungen akzeptieren zusätzlich eine optionale Beschriftung, mit der äußere Schleifen für das Targeting mit der Anweisung identifiziert werden:

OuterLoop:
for {
    for {
        if allDone() {
            break OuterLoop
        }
        if innerDone() {
            continue OuterLoop
        }
        // do something
    }
}

Bedingte Schleife

Das Schlüsselwort for wird auch für bedingte Schleifen verwendet, üblicherweise while Schleifen in anderen Programmiersprachen.

package main

import (
    "fmt"
)

func main() {
    i := 0
    for i < 3 { // Will repeat if condition is true
        i++
        fmt.Println(i)
    }
}

spiele es auf dem Spielplatz

Wird ausgegeben:

1
2
3

Endlosschleife:

for {
    // This will run until a return or break.
}

Verschiedene Formen von for-Schleife

Einfaches Formular mit einer Variablen:

for i := 0; i < 10; i++ {
    fmt.Print(i, " ")
}

Verwendung von zwei Variablen (oder mehr):

for i, j := 0, 0; i < 5 && j < 10; i, j = i+1, j+2 {
    fmt.Println(i, j)
}

Ohne Initialisierungsanweisung:

i := 0
for ; i < 10; i++ {
    fmt.Print(i, " ")
}

Ohne einen Testausdruck:

for i := 1; ; i++ {
    if i&1 == 1 {
        continue
    }
    if i == 22 {
        break
    }
    fmt.Print(i, " ")
}

Ohne Zuwachsausdruck:

for i := 0; i < 10; {
    fmt.Print(i, " ")
    i++
}

Wenn alle drei Initialisierungs-, Test- und Inkrementierungsausdrücke entfernt werden, wird die Schleife unendlich:

i := 0
for {
    fmt.Print(i, " ")
    i++
    if i == 10 {
        break
    }
}

Dies ist ein Beispiel für eine Endlosschleife mit einem mit Null initialisierten Zähler:

for i := 0; ; {
    fmt.Print(i, " ")
    if i == 9 {
        break
    }
    i++
}

Wenn nur der Testausdruck verwendet wird (verhält sich wie eine typische while-Schleife):

i := 0
for i < 10 {
    fmt.Print(i, " ")
    i++
}

Verwenden Sie nur einen inkrementierten Ausdruck:

i := 0
for ; ; i++ {
    fmt.Print(i, " ")
    if i == 9 {
        break
    }
}

Über einen Bereich von Werten mit Index und Wert iterieren:

ary := [5]int{0, 1, 2, 3, 4}
for index, value := range ary {
    fmt.Println("ary[", index, "] =", value)
}

Durchlaufen Sie einen Bereich nur mit dem Index:

for index := range ary {
    fmt.Println("ary[", index, "] =", ary[index])
}

Durchlaufen Sie einen Bereich nur mit dem Index:

for index, _ := range ary {
    fmt.Println("ary[", index, "] =", ary[index])
}

Über einen Bereich iterieren, indem nur der Wert verwendet wird:

for _, value := range ary {
    fmt.Print(value, " ")
}

Durchlaufen eines Bereichs mithilfe des Schlüssels und des Werts für die Karte (möglicherweise nicht in der richtigen Reihenfolge):

mp := map[string]int{"One": 1, "Two": 2, "Three": 3}
for key, value := range mp {
    fmt.Println("map[", key, "] =", value)
}

Durchlaufen Sie einen Bereich nur mit der Taste für die Karte (möglicherweise nicht in der richtigen Reihenfolge):

for key := range mp {
    fmt.Print(key, " ") //One Two Three
}

Durchlaufen Sie einen Bereich nur mit der Taste für die Karte (möglicherweise nicht in der richtigen Reihenfolge):

for key, _ := range mp {
    fmt.Print(key, " ") //One Two Three
}

Durchlaufen Sie einen Bereich nur mit dem Wert für map (möglicherweise nicht in der richtigen Reihenfolge):

for _, value := range mp {
    fmt.Print(value, " ") //2 3 1
}

Durchlaufe einen Bereich für Kanäle (wird beendet, wenn der Kanal geschlossen ist):

ch := make(chan int, 10)
for i := 0; i < 10; i++ {
    ch <- i
}
close(ch)

for i := range ch {
    fmt.Print(i, " ")
}

Durchlaufen Sie einen Bereich für string (gibt Unicode-Codepunkte an):

utf8str := "B = \u00b5H" //B = µH
for _, r := range utf8str {
    fmt.Print(r, " ") //66 32 61 32 181 72
}
fmt.Println()
for _, v := range []byte(utf8str) {
    fmt.Print(v, " ") //66 32 61 32 194 181 72
}
fmt.Println(len(utf8str)) //7

Wie Sie sehen, hat utf8str 6 Runen (Unicode-Codepunkte) und 7 Bytes.

Zeitgesteuerte Schleife

package main

import(
    "fmt"
    "time"
)

func main() {
    for _ = range time.Tick(time.Second * 3) {
        fmt.Println("Ticking every 3 seconds")
    }
}