Go for 循环

在编程中,循环语句指的是在满足某个条件的情况下,反复执行同一段代码的语句。比如计算 “1 + 2 + 3 + ... + 100” 的累加和,或者把同一句话连续输出 1000 次,使用循环语句只需要短短几行代码就能实现。

Go 语言中只有 for 这唯一一个循环关键字,没有 while 和 do...while。通过灵活组合 for 后面的子句,或者配合专门遍历集合的 for range 循环,我们就能应对日常开发中的所有循环场景。

标准三段式 for 循环

在 Go 语言中,很多循环任务都有明确的初始值、结束条件和每轮更新操作。标准 for 循环把这 3 个部分集中写在同一行里,中间用两个英文分号(;)隔开。

语法:

for 初始语句; 条件表达式; 结束语句 {
    // 循环执行的代码
}

说明:

和 if 语句一样,for 后面的三段语句外层不需要加小括号 (),左花括号 { 必须紧跟在第一行末尾。这 3 个部分的作用如下:

  • 初始语句:一般用于定义计数变量的初始值,如 i := 1,它在整个循环开始前只执行一次。
  • 条件表达式:在每一轮循环开始前都会判断一次,如 i <= 5。当结果为 true 时,程序进入 {} 执行循环体;当结果为 false 时,直接退出循环。
  • 结束语句:在每一轮循环体执行完毕后自动运行,通常用来更新计数变量的值,如 i++。

标准 for 循环各部分的执行顺序如下图所示。

Go 标准 for 循环的执行流程

示例 1:使用 for 循环输出 1 到 5

package main

import "fmt"

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

运行结果如下。

1
2
3
4
5

分析:

在这个例子中,我们定义了一个计数变量 i 并赋初值为 1,判断条件设为 i <= 5,每轮结束后的更新操作设为 i++。

for 循环采用的是 “先判断条件,再执行循环体” 的方式。如果初始值一开始就不满足条件,花括号里的代码一次都不会执行。上面代码的具体执行过程如下:

  • 第 1 轮循环:先执行 i := 1,接着判断 i <= 5 返回 true,进入花括号输出 1。循环体结束后执行 i++,i 的值变为 2。
  • 第 2 轮循环:直接判断 i <= 5 返回 true,进入花括号输出 2。循环体结束后执行 i++,i 的值变为 3。
  • 第 3~5 轮循环:按同样步骤依次输出 3、4、5。当第 5 轮执行完 i++ 后,i 的值变为 6。
  • 结束判断:再次判断 i <= 5,此时 i 为 6,条件返回 false,程序正式退出 for 循环。

需要注意的是,最后的结束语句并不是只能写 i++。如果我们希望每次递增 2,可以写成 i += 2;如果希望从 5 倒数输出到 1,也可以写成下面这样:

for i := 5; i >= 1; i-- {
    fmt.Println(i)
}

掌握了按顺序输出数字后,如果我们要计算 “1 + 2 + 3 + ... + 100” 的累加和,又应该怎么写呢?下面我们来看一个例子。

示例 2:计算 1 到 100 的累加和

package main

import "fmt"

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

运行结果如下。

5050

分析:

循环外部定义的变量 sum 用来保存累加结果,初始值为 0,变量 i 则从 1 依次递增到 100。循环体内的 sum += i 用到了前面学过的赋值运算符,等价于 sum = sum + i。前 3 轮的累加过程如下:

  • 第 1 轮循环:计算 sum = 0 + 1,sum 变为 1,随后 i 变为 2。
  • 第 2 轮循环:计算 sum = 1 + 2,sum 变为 3,随后 i 变为 3。
  • 第 3 轮循环:计算 sum = 3 + 3,sum 变为 6,随后 i 变为 4。

以此类推,当第 100 轮循环执行完毕后,sum 就累加了 1 到 100 的所有整数,结果为 5050。随后 i 变为 101,不再满足 i <= 100,程序退出循环并打印最终结果。

对于上面这个例子,如果我们将判断条件 i <= 100 改为 i < 101,计算结果也是一样的,小伙伴们可以思考一下为什么。

此外还要注意,保存总和的变量 sum 必须定义在 for 循环外面。如果我们把 sum := 0 写进循环体内部,每一轮循环 sum 都会重新归零,就没法完成累加了。

注意: 在初始语句中通过 i := 1 定义的变量 i,只在当前 for 循环的花括号内部有效,出了循环之后就无法访问了。

单条件 for 循环

并不是所有循环都能提前数清楚要执行多少次。有时我们只知道 “满足什么条件就继续执行”,并不确定具体要跑几轮。这时我们可以把 for 循环的 “初始语句” 和 “结束语句” 都省略掉,只保留一个条件表达式,这种写法相当于其他语言里的 while 循环。

语法:

for 条件表达式 {
    // 循环执行的代码
}

说明:

只要 for 后面的 “条件表达式” 返回 true,程序就会一直重复执行花括号内的代码,直到条件变为 false 时才退出循环。

示例 3:数值不断翻倍直到超过 100

package main

import "fmt"

func main() {
    num := 1
    for num < 100 {
        fmt.Println(num)
        num *= 2
    }
}

运行结果如下。

1
2
4
8
16
32
64

分析:

在这个例子中,我们把初始值为 1 的 num 不断翻倍,只要小于 100 就打印出来。写循环时不用提前算出要乘几次,只要设好条件 num < 100,在循环体里执行 num *= 2 就可以了。当 num 翻倍到 128 时条件不成立,循环自动结束。

平时写代码时,如果事先清楚要循环多少次,优先使用标准三段式 for 循环;如果只关心结束条件,使用单条件 for 循环会更自然。

这里还有一个语法细节需要小伙伴们留意:如果在三段式循环中只省略初始语句,前后的两个分号依然要保留,比如写成 for ; num < 100; num *= 2。只有当初始语句和结束语句同时省略时,条件表达式前后的分号才可以一并省去。

注意: 使用单条件 for 循环时,循环体内部一定要有能让条件最终不成立的更新语句(比如 num *= 2)。如果漏写了更新语句,num < 100 会一直为 true,程序就会陷入停不下来的 “死循环”。在本地终端遇到死循环时,可以按 Ctrl + C 强制停止程序。

无限循环

如果我们把 for 后面的条件表达式也省略掉,直接写成 for {},循环条件就默认永远为 true,构成一个 “无限循环”。

语法:

for {
    // 循环执行的代码
}

说明:

因为无限循环本身没有结束条件,直接运行会一直重复执行下去。在实际开发中,我们通常会在循环体内部配合 if 语句做判断。一旦满足退出条件,就执行 break 语句立即跳出当前循环。

示例 4:累加到 10 时跳出无限循环

package main

import "fmt"

func main() {
    sum := 0
    n := 1
    for {
        sum += n
        if sum >= 10 {
            fmt.Printf("累加到 %d 时,总和达到 %d\n", n, sum)
            break
        }
        n++
    }
}

运行结果如下。

累加到 4 时,总和达到 10

分析:

for { ... } 本身没有设置循环条件,程序会不断把 n 累加到 sum 中。当 n 加到 4 时,sum 刚好等于 10(1 + 2 + 3 + 4),触发 if sum >= 10 条件,打印完提示后执行 break 立即终止并跳出整个循环。

for 循环嵌套

在一个 for 循环的花括号内部,我们还可以再放入另一个 for 循环,这种结构叫做 for 循环嵌套。双层循环非常适合用来处理具有 “行” 和 “列” 特征的数据或图形。

下面我们通过打印一个 3 行 4 列的星号(*)矩形,来看看双层循环的执行过程。

示例 5:嵌套 for 循环打印星号矩形

package main

import "fmt"

func main() {
    for row := 1; row <= 3; row++ {
        for col := 1; col <= 4; col++ {
            fmt.Print("* ")
        }
        fmt.Println()
    }
}

运行结果如下。

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

分析:

在这个例子中,外层循环的变量 row 控制 “第几行”,从 1 到 3 共 3 行;内层循环的变量 col 控制每行打印 “第几个星号”,从 1 到 4 共 4 个。具体执行过程如下:

  • 第 1 行:当外层 row = 1 时,内层循环从 col = 1 到 col = 4 完整执行一圈。因为 fmt.Print("* ") 不自动换行,4 个星号会打印在同一行,随后外层的 fmt.Println() 负责换行。
  • 第 2~3 行:当外层循环依次进入 row = 2 和 row = 3 时,内层循环同样各自完整执行一圈,分别打印出第 2 行和第 3 行的 4 个星号。

对于双层嵌套循环,小伙伴们只需要抓准一个规律:外层循环每走一步,内层循环都要从头到尾完整执行一圈。因此外层循环执行 3 次,内层循环每次执行 4 次,一共打印了 12 个星号。

如果把内层循环的条件 col <= 4 改成 col <= row,打印出来的图形会变成什么样呢?小伙伴们可以自己动手改一改试一下。

常见问题

1. 为什么 Go 语言不提供 while 和 do...while 关键字?

在其他不少编程语言中,同时存在 for、while 和 do...while 三种循环语法,初学者写代码时经常会纠结到底应该选哪一种。

Go 语言在设计时推崇 “同一件事尽量只保留一种标准写法” 的理念。既然一个 for 关键字通过省略子句就能覆盖按次数循环、按条件循环和无限循环所有场景,还能配合 for range 直接遍历数据集合,就没有必要再额外设计 while 关键字了。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号