Go语言循环语句

在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，决定循环的终止条件。

for是 Go 中唯一可用的循环。Go 没有其他语言（如 Java）中存在的 while 或 do while 循环。

for 循环语法

for initialisation; condition; post {  
}

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

所有三个组件，即初始化、条件和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。条件语句将检查 if i <= 10。如果条件为真，则打印 i 的值，否则终止循环。post 语句在每次迭代结束时将 i 加 1。一旦i大于10，循环终止。

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

for 循环中声明的变量仅在循环范围内可用。因此i无法在 for 循环体之外访问。

break

该break语句用于在 for 循环完成正常执行之前突然终止 for 循环，并将控制权移至 for 循环之后的代码行。

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

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        if i > 5 {
            break 
        }
        fmt.Printf("%d ", i)
    }
    fmt.Printf("\n line 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。如果为零，则该数字为偶数，并且continue执行语句，并且控制移至循环的下一次迭代。因此，不会调用 continue 之后的 print 语句，并且循环将继续进行下一次迭代。上述程序的输出是

1 3 5 7 9

嵌套 for 循环

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

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

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

下面的程序使用嵌套的 for 循环来打印序列。第 1 行中的变量n。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()
    }
}

Run in Playground

标签

标签可用于从内部 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相等时停止打印怎么办？为此，我们需要break

从外for循环开始。当i和j相等时在内循环中添加break， 只会从内循环中中断。

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

在上面的程序中，我在内部循环中添加了一个内部循环，当 i和j 相等时。然后会跳出当前内循环，外部循环将继续。此程序将打印。

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相等时，我们需要停止循环。

这就是标签来拯救我们的地方。标签可用于中断外循环。让我们使用标签重写上面的程序。

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

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

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; { 
        fmt.Printf("%d ", i)
        i += 2
    }
}

Run in Playground

我们已经知道 for 循环的所有三个组成部分，即初始化、条件和post 都是可选的。上面的程序中，省略了初始化和post。

i被初始化到for 循环之外。只要循环就会被执行i <= 10。i 在 for 循环中加 2。上述程序输出

0 2 4 6 8 10 

上述程序的for循环中的分号也可以省略。这种格式可以被视为 while 循环的替代方案。上面的程序可以重写为：

package main

import (  
    "fmt"
)

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

Run in Playground

可以在 for 循环中声明和操作多个变量。让我们编写一个程序，使用多个变量声明打印以下序列。

 
package main

import (  
    "fmt"
)

func main() {  
    for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 { 
        fmt.Printf("%d * %d = %d\n", no, i, no*i)
    }

}

Run in Playground

在上面的程序中no， 和i分别声明并初始化为 10 和 1。它们在每次迭代结束时加 1。条件中使用布尔运算符&&，确保i小于或等于10且no小于或等于19。上述程序输出

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

无限循环

创建无限循环的语法是

for {  
}

下面的程序将继续打印Hello World而不终止。

package main

import "fmt"

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

还有一个构造范围可以在循环中用于数组操作。当我们了解数组时，我们将介绍这一点。