Part9:循环

欢迎来到Golang系列教程的第 9 节

for 是 Go 中唯一可用的循环，Go 没有 while 或 do-while 循环，这些在出现在其他语言中，比如C。

for 循环语法

for initialisation; condition; post {
}

初始化(initialisation) 语句仅被执行一次。当循环初始化后，将检查条件(condition)。当条件是真，在 {``}中的循环体将被执行，然后执行 post 语句。每次成功迭代循环后，执行 post 语句。当 post 语句执行后，条件将被复查。如果它为真，循环继续执行，否则循环终止。

在 Go 中，名为 initialisation，condition 和 post 的三个部分都是可选的。我们来看个例子以更好地理解循环。

示例

我们写一个程序，使用循环来打印从 1 到 10 的所有数字。

package main

import (  
    "fmt"
)

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

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

上面的程序打印 1 2 3 4 5 6 7 8 9 10

在 for 循环中声明的变量，作用域为该循环内，因此 i 不可以在 for 循环外部访问。

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

在上面的程序中，i 的值在每次迭代中被检查。如果 i 的值大于 5，break 被打造 ，循环终止。 for 循环后的打印语句被执行，上面的程序输出

1 2 3 4 5  
line after for loop  

continue

continue 语句被用来跳过当前循环。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)
    }
}

上面程序中，if i % 2 == 0 这一行检查提醒 i 对 2 取余是否等于 0 。如果为0，则该数是偶数，continue 语句被执行，控制移到循环的下一次迭代。因此在 continue 后面的打印语句不被调用，循环处理下一次迭代。程序输出 1 3 5 7 9。

循环嵌套

for 循环内部有另一个 for 循环被称为 for 循环嵌套。

我们写一个循环嵌套的程序来打印下面的序列。

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

下面的程序使用循环嵌套打印序列。第 8 行的变量 n 存储序列中的行数。在我们例子中，它是 5。外部的循环从 0 到 4 迭代 i，内部的循环从 0 到当前 i 的值迭代 j。在每次迭代中内部循环打印 *，外部的循环在每次内部迭代结束打印一个换行。运行这个程序，你会看到序列打印如输出

package main

import (  
    "fmt"
)

func main() {  
    n := 5
    for i := 0; i < n; i++ {
        for j := 0; j <= i; j++ {
            fmt.Print("*")
        }
        fmt.Println()
    }
}

标签(Labels)

标签可以用来从内部循环中中断外部循环。我们使用一个简单的例子来理解我说的是什么意思。

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

    }
}

上面的程序是自解释的，它打印

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 的值相等时，怎么停止打印呢。实现这个，我们需要 break 外部的 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
            }
        }

    }
}

上面的程序中，我已经在第 10 行的内部 for 循环中，当 i 和 j 相等时添加了break。这个 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 时。

这就是标签来拯救我们的地方。标签可以被用来从外部终止循环。

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

    }
}

在上面的程序，我们在第 8 行的 for 循环外添加一个 outer 标签，而在第 13 行，我们通过指定这个标签来终止外部循环。这个程序在 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
    }
}

正如我们已经知道的，for 循环名为 initialisation，condition 和 post 的三个部件都是可选的。上面的程序，我们省略了 initialisation 和 post。i 在 for 循环外部被初始化为 0。循环执行，直到 i <= 10。i 在循环中每次增加 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
    }
}

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

}

在上面程序中，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"。

在 for 循环中还有一个 range 被用在数组操作上。当我们讨论数组时，将会涵盖它。

** 下一教程 - switch 语句 **