Go语言for循环语句 | 小菜学Go语言

Go 语言只有一种循环结构—— for 循环。

最基本的 for 语句包含 3 部分，以分号 ; 分隔：

初始语句 ：在第一次迭代判断之前；
条件语句（表达式） ：在每次迭代前求值并判断；
迭代后语句 ：在每次迭代后执行；

1
2
3


for 初始语句; 条件语句; 迭代后语句 {
    代码体
}

当条件表达式求值为 false 时，循环将停止迭代并退出。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
    sum := 0
    for i := 0; i < 10; i++ {
        sum += i
    }
    fmt.Println(sum)
}

跟 C 、 Java 或者 JavaScript 等其他语言不同， Go 语言 for 语句 3 部分不需要用括号包住，但花括号是必要的，任何时候都 不能省略 。

另外，与其他语言类似，初始语句与迭代后语句也是可选的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
    sum := 1
    for ; sum < 1000; {
        sum += sum
    }
    fmt.Println(sum)
}

实际上， Go 也是支持 while 语句的，只不过关键字还换成 for ：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
    sum := 1
    for sum < 1000 {
        sum += sum
    }
    fmt.Println(sum)
}

无限循环

如果省略循环条件，循环将 永远执行 。这种循环就是众所周知的 死循环 ，也叫做 无限循环 。对我来说，我更愿意用 无限循环 。因为， 死循环 更应该用在程序有问题，循环行为不符合作者预期的场景。

无限循环是 Go 语言中最紧凑的循环结构：

1
2
3
4
5
6


package main

func main() {
    for {
    }
}

使用无限循环时要特别小心！以免造成意外的死循环！

控制外层循环

循环可以嵌套，但 continue 和 break 关键字默认只能控制当层循环。如果想在内层循环来控制外层循环，就比较麻烦了，通常需要分为几步：

定义一个退出标志变量；
在内层循环设置退出标志，并跳出内层循环；
在外层循环检查退出标志，视情况跳出外层循环；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


for _, item := range items {
    // 定义一个退出标志变量
    var quit bool

    for _, child := range item.Children {
        if xxxx {
            // 在内层循环设置退出标志，并跳出内层循环；
            quit = true
            break
        }
    }

    // 在外层循环检查退出标志，视情况跳出外层循环；
    if quit {
        break
    }
}

Go 语言给 continue 和 break 关键字赋能，让它们能够直接控制外层循环。我们来看一个例子：

1
2
3
4
5
6
7
8


OuterLoop:
for _, item := range items {
    for _, child := range item.Children {
        if xxxx {
            break OuterLoop
        }
    }
}

例子中有两层循环，其中外层循环定义了一个标签 OuterLoop ，这相当于给外层循环取了一个名字。在内层循环，continue 关键字加载标签 OuterLoop 表示跳出 OuterLoop 标记的循环，即跳出外层循环。

break 关键字也支持指定控制循环，例子第 5 行表示让外层循环进入下一轮：

1
2
3
4
5
6
7
8


OuterLoop:
for _, item := range items {
    for _, child := range item.Children {
        if xxxx {
            continue OuterLoop
        }
    }
}

这个特性使得 Go 语言的循环实现更加简洁清晰，更聚焦于核心程序逻辑。

【小菜学Go语言】系列文章首发于公众号【小菜学编程】，敬请关注：