Go 语言中的流程控制语句

小石头

发布时间：2026-08-25| 124人浏览过

原创

前言

写 Go 程序时，代码默认是自上而下执行，但真实业务很快就会碰到分支判断、状态选择和重复执行的问题。流程控制看起来只是基础语法，实际上直接决定代码是否清晰、是否容易出错。下面按 `if/else`、`switch` 和 `for` 三类语句拆开讲，并结合示例说明各自更适合解决什么问题。

写 Go 程序时，代码默认是自上而下执行，但真实业务里很少只有一条直线流程。什么时候进入某段逻辑、遇到不同条件如何分支、重复任务怎样收束，都会落到流程控制语句上。下面按判断、选择和循环三个方向拆开讲，并保留可直接上手的示例，帮助你快速判断 Go 在这些场景里的常见写法。

什么是流程控制

流程控制，说白了就是控制程序在不同条件下的执行顺序。哪些代码先执行，哪些代码后执行，哪些代码只有在条件满足时才会运行，都属于流程控制的范围。

一般情况下，程序会按照从上到下的顺序执行；但只要引入条件判断、分支选择或循环，执行路径就会发生变化。Go 里最常见的流程控制主要包括三类：

条件语句：if / else
选择语句：switch / case
循环语句：for

理解这三类语句后，基本就能覆盖日常 Go 入门阶段的大多数控制逻辑。

条件判断：if / else 怎么写

if 用来处理“满足条件就执行”的场景。在 Go 中，if 后面的条件表达式返回结果必须是 bool 类型，不能像某些语言那样直接拿整数或其他类型充当真假值。

下面这段代码根据分数输出不同结果：

var score = 80

if score >= 80 {
    fmt.Println("优秀")
} else if score >= 60 {
    fmt.Println("及格")
} else {
    fmt.Println("不及格")
}

这段逻辑的执行顺序很直接：

先判断 score >= 80，成立就输出“优秀”
如果不成立，再继续判断 score >= 60
前两个条件都不满足时，进入 else

适合用 if / else 的情况通常是：条件范围清晰，而且你希望按先后顺序逐个判断。像成绩分档、参数校验、状态检查这类场景，都会频繁用到这一写法。

多分支选择：switch / case 的匹配方式

当一个变量可能对应多种明确结果时，用 switch 往往比连续写多个 if / else if 更清晰。它会按照从上到下的顺序依次匹配，一旦命中，就不再继续向下判断其他条件。

条件判断与多分支选择的专栏手绘示意图，用纸面卡片区分 if/else 和 switch 的适用场景。 — **if / else 与 switch 怎么分**把条件判断和多分支选择放在同一张图里，便于快速区分 `if/else` 与 `switch`。

var grade = "A"

switch grade {
case "A":
    fmt.Println("优秀")
    // break，go语言中自带break语句
case "B":
    fmt.Println("良好")
case "C":
    fmt.Println("及格")
default: // 如果前面的条件没有命中，则运行defalut里的语句
    fmt.Println("不及格")
}

这段代码有两个初学者容易记错的点：

Go 的 switch 是从上到下匹配的
每个 case 命中后默认就会结束当前分支，不需要手动写 break

如果前面的 case 都没有命中，就会执行 default。因此在枚举值判断、分类输出、状态码分发这类场景中，switch 会比多层 if 更整齐，也更容易读。

循环语句：Go 里只有 for，但写法不少

Go 没有单独的 while 关键字，循环主要依赖 for。但 for 的灵活度很高，既能写传统三段式循环，也能写类 while 结构，甚至还能写无限循环。

Go for 循环多种写法的暖色手绘专栏配图，用便签卡片展示三段式、类 while、无限循环与 break/continue。 — **Go 的 for 为什么能覆盖多种循环场景**一张图梳理 Go 中 `for` 的几种常见形态，以及 `break`、`continue`。

标准三段式 for

这是最常见的一种写法，由初始语句、条件控制语句和结尾语句组成：

// 从0打印到10
for i := 0; i <= 10; i++ {
    fmt.Println(i)
}

其中：

i := 0 是初始语句
i <= 10 是继续循环的条件
i++ 是每轮结束后的更新动作

这种形式最适合次数明确的循环，比如遍历固定区间、按序计数等。

省略初始语句的 for

for 的三个部分并不是必须全部写出。下面这个例子省略了初始语句：

var j = 10
// 省略掉初始语句，从0打印到10
for ; j >= 0; j-- {
    fmt.Println(j)
}

这里的变量 j 已经在循环外定义，所以初始化部分可以留空。只要条件和结尾语句还在，循环仍然成立。

类 while 写法

如果把初始语句和结尾语句都省略，只保留条件判断，for 就很像其他语言里的 while：

var k = 10
for k >= 0 { // 省略初始语句和结尾语句，类似其他语言的while语句
    k--
    fmt.Println(k)
}

这种形式适合“只要条件满足就持续执行”的逻辑，比如等待状态变化、按条件反复处理任务等。

无限循环、break 与 continue

for 还可以连条件都不写，形成无限循环。此时一般会配合 break 和 continue 控制执行节奏：

var l = 0
for {
    if l > 10 {
        break // 终止for循环
    }
    if l == 4 {
        continue // 跳过本次循环
    }
    fmt.Println(l)
    l++
}

这里需要特别注意逻辑顺序：

break 用来直接终止整个循环
continue 用来跳过本次循环剩余代码，进入下一轮

这类写法常见于持续监听、消费任务、等待输入等无法预先确定循环次数的场景。不过写无限循环时也要格外小心，出口条件必须明确，否则很容易让程序一直跑不出来。

用嵌套循环输出九九乘法表

理解完单层循环后，再看一个更完整的例子：用嵌套 for 输出九九乘法表。

九九乘法表的嵌套循环结构手绘示意图，用行列递进和箭头说明两层 for 的分工。 — **九九乘法表背后的双层循环**嵌套循环最容易混淆的是内外层分工，这张图只解释行列关系和边界变化。

for i := 1; i < 10; i++ {
    for j := 1; j <= i; j++ {
        fmt.Printf("%d x %d = %d  ", j, i, j*i)
    }
    fmt.Println("")
}

这段代码的关键在于两层循环的分工：

外层循环控制行数，i 从 1 到 9
内层循环控制每一行输出多少列，j 的上限跟随 i 变化

因此第一行输出 1 个算式，第二行输出 2 个算式，直到第九行输出 9 个算式，最终形成三角形排布。

输出结果如下：

1 x 1 = 1  
1 x 2 = 2  2 x 2 = 4  
1 x 3 = 3  2 x 3 = 6  3 x 3 = 9  
1 x 4 = 4  2 x 4 = 8  3 x 4 = 12  4 x 4 = 16  
1 x 5 = 5  2 x 5 = 10  3 x 5 = 15  4 x 5 = 20  5 x 5 = 25  
1 x 6 = 6  2 x 6 = 12  3 x 6 = 18  4 x 6 = 24  5 x 6 = 30  6 x 6 = 36  
1 x 7 = 7  2 x 7 = 14  3 x 7 = 21  4 x 7 = 28  5 x 7 = 35  6 x 7 = 42  7 x 7 = 49  
1 x 8 = 8  2 x 8 = 16  3 x 8 = 24  4 x 8 = 32  5 x 8 = 40  6 x 8 = 48  7 x 8 = 56  8 x 8 = 64  
1 x 9 = 9  2 x 9 = 18  3 x 9 = 27  4 x 9 = 36  5 x 9 = 45  6 x 9 = 54  7 x 9 = 63  8 x 9 = 72  9 x 9 = 81

这个例子虽然简单，但很适合用来理解嵌套循环、边界条件和格式化输出之间的关系。对于刚接触 Go 的读者来说，它也是把语法规则转成实际结果的一个直观练习。