第九部分：循环 - 《golangbot 中文文档翻译》

for循环语法
例子
break
continue
嵌套for循环
Labels
更多例子
死循环
原文链接

循环语句用于重复执行代码块。

for 是 Go 中唯一提供的循环语法。Go 没有 while 或 do while 循环语句，而这些循环在其他语言中是存在的，比如C。

for循环语法

for initialisation; condition; post {  
}

初始化语句只执行一次。初始化循环后，将检查条件。如果条件的计算结果为 true，则执行 { } 内的循环体，然后执行 post 语句。 post 语句将在每次成功迭代循环后执行。执行 post 语句后，将重新检查该条件。如果是，则循环将继续执行，否则 for 循环终止。

initialisation、condition 和 post 这三个在 Go 中都是可选的。让我们看一个例子来更好地理解 for循环。

例子

让我们编写一个程序，它使用 for 循环来输出从 1 到 10 的所有数字。

package main
import (  
    "fmt"
)
func main() {  
    for i := 1; i <= 10; i++ {
        fmt.Printf(" %d",i)
    }
}

Run in playground

在上面的程序中，i 被初始化为 1。条件语句将检查 i 是否 i <= 10。如果条件为真，则输出 i 的值，否则循环终止。post 语句在每次迭代结束时将 i 增加 1。当 i 大于 10 时，循环终止。

上面的程序将输出 1 2 3 4 5 6 7 8 9 10

for 循环中声明的变量只在循环范围内可用。因此，不能在 for 循环之外访问 i。

break

break 语句用于跳出 for 循环。

让我们编写一个程序，使用 break 打印 1 到 5 的数字。

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")
}

Run in playground

在上述程序中，在每次迭代期间检查 i 的值。如果 i 大于 5，则执行 break 并终止循环。然后执行 for 循环之后的 print 语句。以上程序将输出，

1 2 3 4 5  
line after for loop

continue

continue 语句用于跳过 for 循环的当前迭代。在 continue 语句之后的 for 循环中出现的所有代码都不会在当前迭代中执行。循环将继续下一次迭代。

让我们编写一个程序，使用 continue 来打印从 1 到 10 的所有奇数。

package main
import (  
    "fmt"
)
func main() {  
    for i := 1; i <= 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Printf("%d ", i)
    }
}

Run in playground

在上面的程序中，语句 if i%2 == 0 检查 i 除以 2 的提示是否为 0。如果为 0，则数字为偶数，并执行 continue 语句并进入下一次迭代。因此，不会调用 continue 之后的print 语句，循环将进入下一次迭代。上述程序的输出为 1 3 5 7 9

嵌套for循环

for 循环里面包含另一个 for 循环被称为嵌套 for 循环。

让我们通过编写打印下面序列的程序来理解嵌套 for 循环。

*
**
***
****
*****

下面的程序使用嵌套的 for 循环来打印序列。变量 n 在第 8 行存储序列中的行数。在我们的例子中 n 是 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()
    }
}

Run in playground

Labels

Labels 可用于从内部 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)
        }
    }
}

Run in playground

程序会输出

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

没什么特别的:)

如果我们想在 i 和 j 相等时停止输出怎么办？要做到这一点，我们需要从外部 for 循环break。当 i 和 j 相等时，在内部 for 循环中添加一个 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
            }
        }
    }
}

Run in playground

在上面的程序中，当第 10 行代码 i 和 j 相等时，我在内部 for 循环中添加了一个break。仅从内部 for 循环 break，外循环将继续。该程序将输出

i = 0 , j = 1  
i = 0 , j = 2  
i = 0 , j = 3  
i = 1 , j = 1  
i = 2 , j = 1  
i = 2 , j = 2

这不是预期的输出。当 i 和 j 相等时，即当它们都等于 1 时，我们需要停止输出。

这就是 label 起作用的地方。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
            }
        }
    }
}

Run in playground

在上面的程序中，我们在第 8 行添加了一个标签 outer 。在 13 行我们通过指定标签来打破外部 for 循环。当 i 和 j 相等时，该程序将停止输出。该程序将输出

i = 0 , j = 1  
i = 0 , j = 2  
i = 0 , j = 3  
i = 1 , j = 1

更多例子

让我们写一些代码来覆盖 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
    }
}

Run in playground

因为我们已经知道 for 循环的所有三个组成，即初始化，条件和 post 是可选的。在上面的程序中，省略了初始化和 post。i 在 for 循环之外初始化为 0。只要 i <= 10，就会执行循环。i 在 for 循环中增加 2。上述程序输出 0 2 4 6 8 10。

上面程序 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
    }
}

Run in playground

可以在 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

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)
    }
}

Run in playground

在上面的程序中，no 和 i 被声明并分别初始化为 10 和 1。在每次迭代结束时，它们都会以 1 为单位递增。布尔运算符 && 用于确保 i 小于或等于 10，no 小于或等于 19。

死循环

创建死循环的语法是

for {  
}

下面的程序将一直输出 Hello World 而不终止。

package main
import "fmt"
func main() {  
    for {
        fmt.Println("Hello World")
    }
}

如果你试图在 go playground 运行上面的程序，将得到报错“process took too long”。请尝试在你的本地系统中运行它，它将无限地输出“Hello World”。

还有一个 range 语法可以用在 for 循环中进行数组操作。我们在学习数组的时候会讲到这一点。

原文链接

https://golangbot.com/loops/