Go-Sprache for-Schleife
Schleifenanweisungen in der Go-Sprache
Eine for-Schleife ist eine Schleifenkontrollstruktur, die eine Schleife eine bestimmte Anzahl von Malen ausführen kann.
Syntax
Die for-Schleife in Go hat 3 Formen, von denen nur eine Semikolons verwendet.
Entspricht dem for in C:
for init; condition; post { }
Entspricht der while-Schleife in C:
for condition { }
Entspricht for(;;) in C:
for { }
- init: im Allgemeinen ein Zuweisungsausdruck, der der Steuervariable einen Anfangswert zuweist;
- condition: ein relationaler Ausdruck oder logischer Ausdruck, die Schleifensteuerbedingung;
- post: im Allgemeinen ein Zuweisungsausdruck, der die Steuervariable erhöht oder verringert.
Der Ausführungsprozess der for-Anweisung ist wie folgt:
1. Zuerst wird Ausdruck 1 ein Anfangswert zugewiesen;
2. Bestimmen Sie, ob der Zuweisungsausdruck init die gegebene Bedingung erfüllt. Wenn sein Wert true ist und die Schleifenbedingung erfüllt ist, führen Sie die Anweisungen im Schleifenkörper aus, führen Sie dann post aus, treten Sie in den zweiten Schleifendurchlauf ein und prüfen Sie condition erneut; andernfalls, wenn der Wert von condition false ist und die Bedingung nicht erfüllt ist, beenden Sie die for-Schleife und führen Sie die Anweisungen außerhalb des Schleifenkörpers aus.
Das range-Format der for-Schleife kann über Slices, Maps, Arrays, Strings und mehr iterieren. Das Format ist wie folgt:
for key, value := range oldMap {
newMap[key] = value
}
Im obigen Code können key und value weggelassen werden.
Wenn Sie nur den Schlüssel lesen möchten, ist das Format wie folgt:
for key := range oldMap
Oder so:
for key, _ := range oldMap
Wenn Sie nur den Wert lesen möchten, ist das Format wie folgt:
for _, value := range oldMap
Der Syntaxablauf der for-Anweisung ist in der folgenden Abbildung dargestellt:

Beispiel
Berechnen Sie die Summe der Zahlen von 1 bis 10:
Beispiel
import "fmt"
func main() {
sum := 0
for i := 0; i <= 10; i++ {
sum += i
}
fmt.Println(sum)
}
Das Ausgabeergebnis ist:
55
Die Parameter init und post sind optional. Wir können sie direkt weglassen, ähnlich wie bei einer While-Anweisung.
Das folgende Beispiel berechnet den Wert von sum nach der Selbstaddition, wenn sum kleiner als 10 ist:
Beispiel
import "fmt"
func main() {
sum := 1
for ; sum <= 10; {
sum += sum
}
fmt.Println(sum)
// Auf diese Weise funktioniert es auch, eher wie die Form einer While-Anweisung.
for sum <= 10{
sum += sum
}
fmt.Println(sum)
}
Das Ausgabeergebnis ist:
16 16
Endlosschleife:
Beispiel
import "fmt"
func main() {
sum := 0
for {
sum++ // Endlos wiederholen
}
fmt.Println(sum) // Keine Ausgabe möglich
}
Um eine Endlosschleife zu stoppen, können Sie im Befehlsfensterctrl-c drücken 。
For-Each-Range-Schleife
Diese Form der Schleife kann Elemente von Strings, Arrays, Slices und so weiter durchlaufen und ausgeben.
Beispiel
import "fmt"
func main() {
strings := []string{"google", "example"}
for i, s := range strings {
fmt.Println(i, s)
}
numbers := [6]int{1, 2, 3, 5}
for i,x:= range numbers {
fmt.Printf("Der Wert von x an Position %d = %d\n", i,x)
}
}
Das Ausgabeergebnis des obigen Beispiels ist:
0 google 1 example 第 0 位 x 的值 = 1 第 1 位 x 的值 = 2 第 2 位 x 的值 = 3 第 3 位 x 的值 = 5 第 4 位 x 的值 = 0 第 5 位 x 的值 = 0
Die Range-Form der for-Schleife kann Schlüssel und Wert weglassen, wie im folgenden Beispiel gezeigt:
Beispiel
import "fmt"
func main() {
map1 := make(map[int]float32)
map1[1] = 1.0
map1[2] = 2.0
map1[3] = 3.0
map1[4] = 4.0
// Schlüssel und Wert lesen
for key, value := range map1 {
fmt.Printf("Schlüssel ist: %d - Wert ist: %f\n", key, value)
}
// Schlüssel lesen
for key := range map1 {
fmt.Printf("Schlüssel ist: %d\n", key)
}
// Wert lesen
for _, value := range map1 {
fmt.Printf("Wert ist: %f\n", value)
}
}
Das Ausgabeergebnis des obigen Beispiels ist:
key is: 4 - value is: 4.000000 key is: 1 - value is: 1.000000 key is: 2 - value is: 2.000000 key is: 3 - value is: 3.000000 key is: 1 key is: 2 key is: 3 key is: 4 value is: 1.000000 value is: 2.000000 value is: 3.000000 value is: 4.000000Weitere Erweiterungen