for-Schleifensyntax
for initialisation; condition; post {
}Nach dem Login kopieren
Initialisierung Die Initialisierungsanweisung wird nur einmal ausgeführt. Nach Abschluss der Initialisierung wird überprüft, ob die Bedingung erfüllt ist. Wenn ja, wird der Code in {. } wird ausgeführt, und dann wird die Post-Anweisung ausgeführt. Jedes Mal, wenn die Schleifenanweisung in {} erfolgreich wiederholt wird, wird die Post-Anweisung ausgeführt und anschließend wird die Bedingung erneut überprüft, um festzustellen, ob sie wahr ist. Bei „true“ wird die Ausführung der Schleifenanweisung fortgesetzt, andernfalls wird die Schleife beendet.
In Go sind Initialisierung, Bedingung und Post allesamt optional. Schauen wir uns ein Beispiel an, um die for-Schleife besser zu verstehen.
Beispiel
Wir schreiben ein Programm zum Drucken aller Ganzzahlen von 1-10 mithilfe einer for-Schleife.
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 10; i++ {
fmt.Printf(" %d",i)
}
}Nach dem Login kopieren
Execute
Im obigen Code wird i auf 1 initialisiert und die bedingte Anweisung prüft, ob i <= 10 ist. Wenn die Bedingung wahr ist, geben Sie den Wert von i aus, andernfalls beenden Sie die Schleife. Die Post-Anweisung erhöht i am Ende jeder Iteration um 1, und sobald i größer als 10 wird, wird die Schleife beendet.
Der obige Code gibt Folgendes aus: 1 2 3 4 5 6 7 8 9 10
In einer for-Schleife deklarierte Variablen sind nur im Rahmen des Schleifenkörpers verfügbar. Daher kann außerhalb des Körpers der for-Schleife nicht auf die Variable i zugegriffen werden.
break
break wird verwendet, um die for-Schleife zu beenden und aus der Schleife zu springen, um mit der Ausführung der Anweisungen nach der for-Schleife fortzufahren.
Wir ändern den vorherigen Code und verwenden die break-Anweisung, um nur alle Ganzzahlen zwischen 1 und 5 auszugeben.
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 10; i++ {
if i > 5 {
break //loop is terminated if i > 5
}
fmt.Printf("%d ", i)
}
fmt.Printf("\nline after for loop")
}Nach dem Login kopieren
Ausführung
Im obigen Code wird der Wert von i bei jeder Iteration überprüft. Wenn i größer als 5 ist, wird break ausgeführt und die Schleife beendet. Anschließend wird die print-Anweisung nach der for-Schleife ausgeführt.
上面的程序会输出：
1 2 3 4 5
line after for loop
Nach dem Login kopieren
continue
continue 语句用于跳过 for 循环的当前迭代。本次迭代中，for 循环里面、continue 语句之后的代码都不会执行，继续进行下一次迭代。
让我们编写一个程序，使用 continue 打印从 1-10 的所有奇数。
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 10; i++ {
if i%2 == 0 {
continue
}
fmt.Printf("%d ", i)
}
}Nach dem Login kopieren
执行
在上面的代码行 if i%2 == 0，检查 i 除以 2 的余数是否为 0。如果为零，则该数为偶数，执行 continue 语句，则不会调用 continue 之后的 print 语句，并且循环继续进行下一次迭代。
上述程序的输出：1 3 5 7 9。
嵌套循环
一个 for 循环内部有另一个 for 循环称为嵌套 for 循环。
我们通过编写一个打印以下序列的程序来理解嵌套的 for 循环。
*
**
***
****
*****
Nach dem Login kopieren
下面的程序使用嵌套 for 循环打印上述序列。
第 8 行的变量 8 存储序列的行数，我们这里是 5。外部 for 循环将 i 从 0 迭代到 4，内部 for 循环将 j 从 0 迭代到 i 的当前值。内部循环为每次迭代打印 * ，外部循环在每次迭代结束时打印一个新行。
运行这个程序将会输出上面的有序序列。
package main
import (
"fmt"
)
func main() {
n := 5
for i := 0; i < n; i++ {
for j := 0; j <= i; j++ {
fmt.Print("*")
}
fmt.Println()
}
}Nach dem Login kopieren
执行
标签
标签(label)可用于在内部 for 循环中断外部循环。让我们通过一个简单的例子来理解下：
package main
import (
"fmt"
)
func main() {
for i := 0; i < 3; i++ {
for j := 1; j < 4; j++ {
fmt.Printf("i = %d , j = %d\n", i, j)
}
}
}Nach dem Login kopieren
执行
上面的程序比较容易理解，将会输出：
i = 0 , j = 1
i = 0 , j = 2
i = 0 , j = 3
i = 1 , j = 1
i = 1 , j = 2
i = 1 , j = 3
i = 2 , j = 1
i = 2 , j = 2
i = 2 , j = 3
Nach dem Login kopieren
上面的代码没什么特别的，我们继续往下看。
如果我们想实现当 i 和 j 相等时，停止打印该怎么办？我们需要做的是从内部循环破坏外部 for 循环。我们尝试在内部 for 循环判断当 i 和 j 相等时，执行 break 语句看能够实现中断外部 for 循环。
package main
import (
"fmt"
)
func main() {
for i := 0; i < 3; i++ {
for j := 1; j < 4; j++ {
fmt.Printf("i = %d , j = %d\n", i, j)
if i == j {
break
}
}
}
}Nach dem Login kopieren
执行
上面的代码，当判断 i 和 j 相等时，我们在内部 for 循环中会执行 break 语句，但这只会中断本次内部 for 循环，外部循环将继续执行。
程序输出：
i = 0 , j = 1
i = 0 , j = 2
i = 0 , j = 3
i = 1 , j = 1
i = 2 , j = 1
i = 2 , j = 2
Nach dem Login kopieren
这显然不是我们预期的输出。当 i 和 j 都相等时，即它们都等于 1 时，我们需要停止打印。
这时候标签(label)就可以派上用场了。标签可用于中断外部循环，让我们用 label 重写上面的程序。
package main
import (
"fmt"
)
func main() {
outer:
for i := 0; i < 3; i++ {
for j := 1; j < 4; j++ {
fmt.Printf("i = %d , j = %d\n", i, j)
if i == j {
break outer
}
}
}
}Nach dem Login kopieren
执行
在上面的代码，我们在第 8 行循环的外部添加了名为 outer 的标签，在第 13 行通过指定跳转到该标签来终止外部循环，当 i 和 j 相等时，程序将停止打印。
执行代码输出：
i = 0 , j = 1
i = 0 , j = 2
i = 0 , j = 3
i = 1 , j = 1
Nach dem Login kopieren
更多示例
我们通过更多的示例学习下 for 语句的不用用法。
下面的代码打印从 0 到 10 的所有偶数。
package main
import (
"fmt"
)
func main() {
i := 0
for ;i <= 10; { // initialisation and post are omitted
fmt.Printf("%d ", i)
i += 2
}
}Nach dem Login kopieren
执行
我们已经知道，for 语句中 initialisation、condition 和 post 都是可选的。上面代码中，initialisation 和 post 都被忽略了，在循环外部，变量 i 已经初始化为 0。只要 i <= 10，就会执行循环，在 for 循环内部 i 每次都增加 2.
上述代码的 for 循环语句的分号也可以省略。这种格式可以认为是 while 循环的替代方案。上面的代码可以重写为：
package main
import (
"fmt"
)
func main() {
i := 0
for i <= 10 { //semicolons are ommitted and only condition is present
fmt.Printf("%d ", i)
i += 2
}
}Nach dem Login kopieren
执行
可以在 for 语句中声明和操作多个变量。让我们编写一个程序，使用多个变量声明打印以下序列。
10 * 1 = 10
11 * 2 = 22
12 * 3 = 36
13 * 4 = 52
14 * 5 = 70
15 * 6 = 90
16 * 7 = 112
17 * 8 = 136
18 * 9 = 162
19 * 10 = 190
Nach dem Login kopieren
package main
import (
"fmt"
)
func main() {
for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 { //multiple initialisation and increment
fmt.Printf("%d * %d = %d\n", no, i, no*i)
}
}Nach dem Login kopieren
执行
在上面的代码中，no 和 i 分别被声明和初始化为 10 和 1，每次迭代结束时都递增 1。在 condition 条件中使用布尔运算符 && 来确保 i 小于或等于 10 并且 no 小于或等于 19。
无限循环
无限循环的语法如下：
for {
}Nach dem Login kopieren
下面的代码将会循环不停地打印 Hello World。
package main
import "fmt"
func main() {
for {
fmt.Println("Hello World")
}
}Nach dem Login kopieren
如果你在 go playground 中运行上面程序，将会报错：“process took too long”。在本地环境执行时将无限打印 Hello World。
