Go - Schleifen: Beherrschen der Wiederholung in der Programmierung

Hallo, angehende Programmierer! Heute tauchen wir in eines der fundamentalsten Konzepte der Programmierung ein: Schleifen. Als dein freundlicher Nachbarschaftsinformatiklehrer freue ich mich darauf, dich durch die faszinierende Welt der Go-Schleifen zu führen. Verlass dich darauf, bis zum Ende dieses Tutorials wirst du wie ein Profi Schleifen programmieren können!

Was sind Schleifen?

Bevor wir ins Detail gehen, lassen wir uns_once was Schleifen sind. Stell dir vor, du bist mit dem Schreiben von "Ich liebe Programmieren" 100 Mal beauftragt. Mühsam, oder? Genau hier kommen Schleifen ins Spiel! Sie erlauben es uns, einen Satz von Anweisungen mehrmals auszuführen, ohne denselben Code immer wieder zu schreiben.

Arten von Schleifen in Go

Go bietet drei Hauptarten von Schleifen:

1. For-Schleife
2. While-Schleife (mittels For implementiert)
3. Range-basierte For-Schleife

Lassen wir uns jede dieser Schleifen genauer ansehen.

1. Die klassische For-Schleife

Die For-Schleife ist die am häufigsten verwendete Art von Schleife in Go. Sie ist wie das Schweizer Army-Messer der Schleifen – vielseitig und kraftvoll.

package main

import "fmt"

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

In diesem Beispiel:

• i := 0 initialisiert die Schleifenvariable
• i < 5 ist die Bedingung, die vor jeder Iteration überprüft wird
• i++ wird nach jeder Iteration ausgeführt

Ausgabe:

Iteration: 0
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4

2. Die While-Schleife (Go-Stil)

Go hat keinen while-Schlüsselwort, aber wir können die for-Schleife verwenden, um das gleiche Ergebnis zu erzielen. Es ist wie ein Smoking-Shirt – formally eine For-Schleife, aber funktional eine While-Schleife!

package main

import "fmt"

func main() {
count := 0
for count < 3 {
fmt.Println("Zähler ist:", count)
count++
}
}

Hier setzt die Schleife fort, solange count < 3 wahr ist.

Ausgabe:

Zähler ist: 0
Zähler ist: 1
Zähler ist: 2

3. Die Range-basierte For-Schleife

Diese ist mein persönlicher Favorit – sie ist wie ein Navigationsgerät für deine Datenstrukturen. Sie ist perfekt zum Iterieren über Arrays, Slices, Maps und mehr.

package main

import "fmt"

func main() {
fruits := []string{"Apfel", "Banane", "Kirsche"}
for index, fruit := range fruits {
fmt.Printf("Frucht an Index %d ist %s\n", index, fruit)
}
}

Diese Schleife iteriert automatisch über den fruits-Slice und gibt uns sowohl den Index als auch den Wert in jeder Iteration.

Ausgabe:

Frucht an Index 0 ist Apfel
Frucht an Index 1 ist Banane
Frucht an Index 2 ist Kirsche

Schleifensteuerungsanweisungen

Nun, da wir die Grundlagen kennen, lassen wir uns mit Steuerungsanweisungen für unsere Schleifen etwas Würze hinzufügen. Diese sind wie die DJs der Programmierwelt – sie steuern den Fluss unserer Schleifenparty!

Break-Anweisung

Die break-Anweisung ist wie der Notausschalter. Sie beendet die Schleife sofort.

package main

import "fmt"

func main() {
for i := 0; i < 10; i++ {
if i == 5 {
fmt.Println("Wir haben 5 erreicht! Es ist Zeit zu brechen!")
break
}
fmt.Println("Aktuelle Zahl:", i)
}
}

Diese Schleife wird stoppen, sobald i 5 erreicht.

Ausgabe:

Aktuelle Zahl: 0
Aktuelle Zahl: 1
Aktuelle Zahl: 2
Aktuelle Zahl: 3
Aktuelle Zahl: 4
Wir haben 5 erreicht! Es ist Zeit zu brechen!

Continue-Anweisung

Die continue-Anweisung ist wie das Überspringen eines Songs, den du nicht magst. Sie springt zur nächsten Iteration der Schleife.

package main

import "fmt"

func main() {
for i := 0; i < 5; i++ {
if i == 2 {
fmt.Println("Überspringe 2!")
continue
}
fmt.Println("Aktuelle Zahl:", i)
}
}

Diese Schleife überspringt das Drucken, wenn i 2 ist.

Ausgabe:

Aktuelle Zahl: 0
Aktuelle Zahl: 1
Überspringe 2!
Aktuelle Zahl: 3
Aktuelle Zahl: 4

Die unendliche Schleife

Last but not least, lassen wir uns über die berüchtigte unendliche Schleife unterhalten. Es ist wie ein Song, der niemals endet – es geht und geht,除非 du ihm sagst, anzuhalten.

package main

import (
"fmt"
"time"
)

func main() {
count := 0
for {
fmt.Println("Dies ist Iteration:", count)
count++
time.Sleep(time.Second)
if count == 5 {
fmt.Println("Gut, das ist genug!")
break
}
}
}

Diese Schleife wird für immer laufen,除非 wir sie unterbrechen. In diesem Fall brechen wir nach 5 Iterationen aus.

Ausgabe:

Dies ist Iteration: 0
Dies ist Iteration: 1
Dies ist Iteration: 2
Dies ist Iteration: 3
Dies ist Iteration: 4
Gut, das ist genug!

Schleifenmethodentabelle

Hier ist eine praktische Tabelle, die die Schleifenmethoden zusammenfasst, die wir behandelt haben:

Methode	Beschreibung	Beispiel
For-Schleife	Standard-Schleife mit Initialisierung, Bedingung und Nachanweisung	for i := 0; i < 5; i++ { ... }
While-style For-Schleife	Schleife, die so lange läuft, bis eine Bedingung wahr ist	for count < 3 { ... }
Range-basierte For-Schleife	Schleife zum Iterieren über Arrays, Slices, Maps usw.	for index, value := range collection { ... }
Unendliche Schleife	Schleife, die endlos läuft,除非 sie unterbrochen wird	for { ... }

Und da hast du es, Leute! Du hast deine ersten Schritte in die loopy Welt der Go-Programmierung gemacht. Denke daran, Übung macht den Meister,also fürchte dich nicht, mit diesen Konzepten zu experimentieren. Frohes Coden und mögen deine Schleifen immer dann enden, wenn du willst!

Credits: Image by storyset