Go-Schleifen

In Go gibt es nur eine Schleifenanweisung: for. for kann verwendet werden, um while und do-while-Schleifen zu implementieren. range wird verwendet, um über Arrays, Slices, Maps, Strings und Kanäle zu iterieren.

for

Die for-Schleife ist die einzige Schleifenanweisung in Go. Das Format lautet wie folgt:

for Initialisierung; Bedingung; Inkrement {
   Anweisungen
}

Beispiel:

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

Ausgabe:

45

Die Initialisierung, Bedingung und Inkrement sind optional. Wenn die Bedingung weggelassen wird, wird sie als true betrachtet, was einer Endlosschleife entspricht.

for {
   // Endlosschleife
}

Die Initialisierung und das Inkrement können ebenfalls weggelassen werden.

for sum < 1000 {
   sum += sum
}

Dies entspricht einer while-Schleife in anderen Sprachen.

for-range

Die for-range-Schleife wird verwendet, um über Arrays, Slices, Maps, Strings und Kanäle zu iterieren. Das Format lautet wie folgt:

for index, value := range collection {
   Anweisungen
}

Slice

func main() {
   nums := []int{1, 2, 3, 4, 5}
   for i, num := range nums {
      fmt.Printf("Index: %d, Value: %d\n", i, num)
   }
}

Ausgabe:

Index: 0, Value: 1
Index: 1, Value: 2
Index: 2, Value: 3
Index: 3, Value: 4
Index: 4, Value: 5

Wenn der Index nicht benötigt wird, kann er mit _ ignoriert werden.

func main() {
   nums := []int{1, 2, 3, 4, 5}
   for _, num := range nums {
      fmt.Println(num)
   }
}

Map

func main() {
   m := map[string]int{
      "a": 1,
      "b": 2,
      "c": 3,
   }
   for k, v := range m {
      fmt.Printf("Key: %s, Value: %d\n", k, v)
   }
}

Ausgabe:

Key: a, Value: 1
Key: b, Value: 2
Key: c, Value: 3

TIP

Die Iterationsreihenfolge von Maps ist nicht garantiert. Bei jeder Iteration kann die Reihenfolge unterschiedlich sein.

String

func main() {
   s := "hello"
   for i, r := range s {
      fmt.Printf("Index: %d, Rune: %c\n", i, r)
   }
}

Ausgabe:

Index: 0, Rune: h
Index: 1, Rune: e
Index: 2, Rune: l
Index: 3, Rune: l
Index: 4, Rune: o

TIP

Beim Iterieren über Strings gibt range den Startindex jedes Unicode-Zeichens und den Rune-Wert (int32) zurück.

Kanal

func main() {
   ch := make(chan int)
   go func() {
      for i := 0; i < 5; i++ {
         ch <- i
      }
      close(ch)
   }()
   for v := range ch {
      fmt.Println(v)
   }
}

Ausgabe:

0
1
2
3
4

TIP

Beim Iterieren über Kanäle wird die Schleife beendet, wenn der Kanal geschlossen wird.

break

Das break-Schlüsselwort wird verwendet, um eine Schleife vorzeitig zu beenden.

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

Ausgabe:

0
1
2
3
4

continue

Das continue-Schlüsselwort wird verwendet, um den aktuellen Schleifendurchlauf zu überspringen und mit dem nächsten Durchlauf fortzufahren.

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

Ausgabe:

1
3
5
7
9

goto

Das goto-Schlüsselwort wird verwendet, um zu einer markierten Anweisung zu springen. Es wird im Allgemeinen nicht empfohlen, goto zu verwenden, da es die Lesbarkeit des Codes verringert.

func main() {
   for i := 0; i < 10; i++ {
      if i == 5 {
         goto END
      }
      fmt.Println(i)
   }
END:
   fmt.Println("Ende")
}

Ausgabe:

0
1
2
3
4
Ende

Labels

Labels können verwendet werden, um verschachtelte Schleifen zu steuern.

func main() {
OUTER:
   for i := 0; i < 10; i++ {
      for j := 0; j < 10; j++ {
         if j == 5 {
            break OUTER
         }
         fmt.Printf("i: %d, j: %d\n", i, j)
      }
   }
}

In diesem Beispiel wird die äußere Schleife mit dem Label OUTER markiert. Wenn j == 5 ist, wird die äußere Schleife beendet.

while-Schleife

Go hat keine while-Schleife, aber for kann verwendet werden, um eine while-Schleife zu implementieren.

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

Ausgabe:

100

do-while-Schleife

Go hat keine do-while-Schleife, aber for kann verwendet werden, um eine do-while-Schleife zu implementieren.

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

Ausgabe:

0
1
2
3
4
5
6
7
8
9