在编程中,循环语句指的是在满足某个条件的情况下,反复执行同一段代码的语句。比如计算 “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 循环各部分的执行顺序如下图所示。

示例 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 关键字了。
