三个控制结构:if、for、switch

难度 ★☆☆☆☆ · 前置:变量、常量、类型:Go 为什么不做隐式转换 | 一句话结论:Go 的流程控制只有 if、for、switch 三个关键字,每个的写法定得很死,习惯之后反而没什么可猜的。

三个关键字管住了所有分支和循环

我学 Go 的第一个下午没卡在指针,也没卡在接口,卡在一个花括号上。从别的语言带过来的肌肉记忆是先写条件、换一行、再开括号,这套动作在 Go 里直接编译不过,编译器甩过来一句 syntax error: unexpected newline, expected { after if clause,我盯着那行看了很久,才反应过来这语言对排版有硬性要求,而且它不打算让任何工具替你改。写顺了之后回头看,这类别扭全集中在三个关键字上,if、for、switch,合起来就是 Go 全部的流程控制。没有 while,没有 do while,没有三目运算符,switch 的每个分支也不用手动收尾。三个关键字管住一门语言所有的分支和循环,代价是每个的写法都被规定得很死,收益是读别人的代码时基本不用猜他到底想干什么。这种取舍在 Go 里到处都是,拿少一种写法换少一次犹豫,只是控制流这块最扎眼。这一篇把它们摆开,一个一个跑给你看,连会报错的地方也一起跑,环境还是上一篇那个,一个 main.go,go run 就能看见结果。

if 的写法有三种

先拆 if,它有三种写法,一种比一种能装。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package main

import (
"errors"
"fmt"
)

func level(n int) int { return n }

func load(name string) (int, error) {
if name == "missing" {
return 0, errors.New("no such file: " + name)
}
return 42, nil
}

func main() {
x := 7

// 形态一,只有条件
if x > 0 {
fmt.Println("shape1: x is positive")
}

// 形态二,先算一个值,再拿这个值判断
if v := level(x); v > 5 {
fmt.Println("shape2: v =", v)
}

// 形态三,接住一个可能出错的返回值,再判断
if err := errors.New("disk full"); err != nil {
fmt.Println("shape3: err =", err)
} else {
fmt.Println("shape3: no error")
}

if n, err := load("missing"); err != nil {
fmt.Printf("shape4: n=%d err=%v\n", n, err)
} else {
fmt.Printf("shape4: n=%d ok\n", n)
}
}
1
2
3
4
5
$ go run .
shape1: x is positive
shape2: v = 7
shape3: err = disk full
shape4: n=0 err=no such file: missing

形态一最普通,条件位置放一个 bool 表达式,判断完直接开大括号。形态二中间多出一个分号,分号前面是初始化语句,先算出一个值,后半句拿这个值做判断,v 的作用域锁在这对大括号里面,出了门就查无此人,这件事我下面就单跑了一次来确认。形态三把两件事合成一件,先接住一个可能出错的返回值,再判断它是不是 nil。三段代码的差别只在分号前面那半句,读起来却像两种完全不同的东西,我刚学的时候最不习惯形态二,总觉得它把两句话挤成了一行,用久了才发现它省掉的是一整层临时变量。

四行输出对得上四段判断,v 是 7,错误是 disk full,找不到的那个文件叫 missing。

1
2
3
4
5
6
7
func main() {
x := 7
if v := x * 2; v > 10 {
fmt.Println("inside, v =", v)
}
fmt.Println("outside, v =", v)
}
1
2
3
$ go run .
# h3flow/scope
.\main.go:10:30: undefined: v

报错指向 if 外面那一行,编译器没说错,v 从来就不属于那儿,它只在分号后面那对大括号里活着。这个设计不是为了耍花样,它主要服务错误处理。if err := do(); err != nil 这句话我一天要敲几十遍,它把一个只活三行的错误变量关进了 if 里面,函数往下走的时候 err 这个名字还能重新声明,前后几个错误变量互相不打架。别的语言得用一个 try 块把这段围起来,Go 用一行 if 就够了,代价是你得习惯把那个分号当成分界线。

带初始化语句的写法还有一个好处,它把取值和判断绑在了一起。if v, ok := m[k]; ok 这一句里,取值和判断是同一件事,读代码的人一眼就知道 v 只在 ok 为真的时候才有意义。换成先取值再判断的两行写法,中间能插进任何东西,读者还得自己确认这个 v 后面有没有被人改过。Go 把这种常见的两步操作收进了一个语法位置,这是它少见的在语法层面主动帮忙的地方。

分号前面那半句,才是这个写法的重点。

花括号不能另起一行

回到开头那个报错。我把出问题的代码缩到五行,单独跑了一次,编译器说得很具体,第几行第几个字符,它在等什么都写清楚了。这条规矩在 Go 里没有例外,if 的条件写完,左花括号必须留在同一行,中间不能断开。规定不是为了好看,它有语法层面的原因,Go 会在每一行的末尾自动补一个分号,if x > 0 这行末尾被补上分号之后,编译器就认为语句结束了,下一行单独出现的那个左花括号自然对不上号,这跟你在源码里写不写分号没关系,是词法分析阶段就替你加了。

1
2
3
4
5
6
7
func main() {
x := 7
if x > 0
{
fmt.Println("positive")
}
}
1
2
3
$ go run .
# h3flow/ifbrace
.\main.go:7:10: syntax error: unexpected newline, expected { after if clause

报错里的 newline 指的就是那个换行,它等的那个左花括号始终没有出现。

else 有同样的规矩,右大括号和 else 必须贴在一起,中间断一次就是另一条报错,syntax error: unexpected keyword else, expected },连解释的机会都不给。这两条听起来霸道,用起来反而省事,团队里不用再争论括号该放哪一行,也不用在 code review 里为缩进吵架。条件本身还有两条硬规矩,一是括号写了不算错,gofmt 会替你删掉,二是条件必须是 bool,写个 1 进去直接编译不过。

1
2
3
4
5
6
func main() {
x := 3
if 1 {
fmt.Println("truthy")
}
}
1
2
3
$ go run .
# h3flow/boolcond
.\main.go:7:5: non-boolean condition in if statement
1
2
3
4
5
6
7
8
9
func main() {
x := 3
if (x > 0) {
fmt.Println("paren ok, x =", x)
}
if x > 0 && x < 10 {
fmt.Println("chained without paren, x =", x)
}
}
1
2
3
$ go run .
paren ok, x = 3
chained without paren, x = 3
1
2
3
4
5
6
7
8
9
10
11
12
13
$ gofmt -d main.go
diff main.go.orig main.go
--- main.go.orig
+++ main.go
@@ -4,7 +4,7 @@

func main() {
x := 3
- if (x > 0) {
+ if x > 0 {
fmt.Println("paren ok, x =", x)
}
if x > 0 && x < 10 {

for 是唯一的循环关键字

Go 没有 while,只有 for。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import "fmt"

func main() {
// 形态一,三段式
for i := 0; i < 3; i++ {
fmt.Println("three-part i =", i)
}

// 形态二,只留条件,等于别的语言的 while
n := 0
for n < 5 {
n++
}
fmt.Println("while-style ended at n =", n)

// 形态三,什么都不写,靠 break 出去
k := 0
for {
k++
if k == 4 {
fmt.Println("break out at k =", k)
break
}
}
}
1
2
3
4
5
6
$ go run .
three-part i = 0
three-part i = 1
three-part i = 2
while-style ended at n = 5
break out at k = 4

三种形态其实是一种。三段式把初始化、条件、步进塞进了 for 后面那对括号里,用两个分号隔开,中间那句是条件,前后两句分别是开场和收尾。只写条件的时候,开场和收尾被挪到了循环外面,于是 for n < 5 读起来就跟别的语言的 while n < 5 一模一样。什么都不写的时候,条件默认为真,循环就只剩下 break 这一个出口。这三种写法编译出来的东西是同一个结构,先判断条件,成立就进循环体,跑完回到条件那里再判一次,判不成立就出来,差别只在于你把开场和收尾写在了哪儿。

三种 for 写法编出来是同一个循环

画成图是这样,左边是三种写法,右边是编译器眼里的那个循环,四个格子加一条回边。那条回边才是循环的本质,只要还会回到条件那里,它就是个循环,至于源码里写的是三段式还是光秃秃一个条件,编译器根本不在乎。

三段式的三个部分都能省,省法不同,名字也不同。

省掉初始化和步进就是形态二,省掉条件就是无限循环,三个都省只留下 for {},那是一个纯靠 break 出来的死循环。日常写代码的时候,遍历用三段式或者 range,等一个状态变化用形态二,服务的常驻循环用形态三,这三种用法基本覆盖了所有场景。我写过的 Go 代码里形态二出现得最少,因为大多数等待后来都被 channel 和 context 接管了。

所以在 Go 里 while 这个关键字根本没有位置,硬写会怎么样,我试了一次。

1
2
3
4
5
6
7
func main() {
n := 0
while n < 3 {
n++
}
fmt.Println(n)
}
1
2
3
4
$ go run .
# h3flow/while
.\main.go:7:8: syntax error: unexpected name n at end of statement
.\main.go:10:2: syntax error: non-declaration statement outside function body

两条报错,第一条说 n 这个名字不该出现在这儿,因为它把 while 当成了一个标识符,后面跟个表达式,语法上圆不过来,第二条是被第一条带偏的,整个函数体被判成了函数外的语句。这类报错通常会连着出好几条,第一条才是真的,后面的多半是它带出来的,读报错只读第一条能省不少时间。

编译器压根不认识这个词。

range 一次遍历三种东西

range 是 for 的一个变体,专门用来遍历。它在切片上按下标走,在 map 上按 key 走,在字符串上按字符走,三种容器三种语义,写法都是 for k, v := range x。我拿一段代码把三样都跑了一遍,字符串挑的是 héllo世,这个串里有两个非 ASCII 字符,正好能看出索引是怎么跳的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import "fmt"

func main() {
nums := []int{10, 20, 30}
for i, v := range nums {
fmt.Printf("slice i=%d v=%d\n", i, v)
}

m := map[string]int{"a": 1, "b": 2, "c": 3}
for k, v := range m {
fmt.Printf("map k=%s v=%d\n", k, v)
}

s := "héllo世"
for i, r := range s {
fmt.Printf("str i=%d r=%c code=%d\n", i, r, r)
}
fmt.Println("len(s) =", len(s))
fmt.Println("len([]rune(s)) =", len([]rune(s)))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$ go run .
slice i=0 v=10
slice i=1 v=20
slice i=2 v=30
map k=b v=2
map k=c v=3
map k=a v=1
str i=0 r=h code=104
str i=1 r=é code=233
str i=3 r=l code=108
str i=4 r=l code=108
str i=5 r=o code=111
str i=6 r=世 code=19990
len(s) = 9
len([]rune(s)) = 6

切片的索引是 0 1 2,map 打出来的顺序跟插入的顺序对不上,而且每次跑还可能换个样子。这一点进阶线那篇讲 range 的文章掰开说过,这里只需要记住一句,别指望 map 的输出顺序,要稳定就先把 key 排一次。

字符串那一段最值得看,索引是 0 1 3 4 5 6,中间跳过了 2,因为 é 占了两个字节,世 占了三个字节。也就是说 range 给出的 i 是字节偏移,r 才是那个字符本身,%c 打出来是字,%d 打出来是它的码点。这个区别在只处理英文的时候完全看不出来,一旦碰到中文或者表情符号,按字节切就会切出半个字。

len(s) 是 9,len([]rune(s)) 是 6,前者数字节,后者数字符,这两个数在中文场景里经常对不上。要按字符处理就转成 []rune,要按字节处理就直接用下标,别混着来,混着来的代码在测试里跑得好好的,上线遇到第一个生僻字就出事。

break 和 continue 只退一层

break 和 continue 是循环里的两个刹车,一个下车,一个跳过这一站。break 直接结束整个循环,后面的轮次不再执行,continue 只结束当前这一轮,回到条件那里接着判。这两个词在任何语言里都差不多,Go 没有额外发明什么,唯一要适应的是它们只管一层,嵌套循环里 break 打断的是最里面那层,外面的照转。我跑了一段最小的例子,把两个都试了一下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

func main() {
for i := 1; i <= 5; i++ {
if i == 3 {
fmt.Println("break at", i)
break
}
fmt.Println("before break i =", i)
}

for i := 1; i <= 5; i++ {
if i == 3 {
continue
}
fmt.Println("after continue i =", i)
}
}
1
2
3
4
5
6
7
8
$ go run .
before break i = 1
before break i = 2
break at 3
after continue i = 1
after continue i = 2
after continue i = 4
after continue i = 5

上面那段打到 3 就停了,下面那段只少了 3,其余四轮照打。

这里有个容易写错的地方,continue 写在三段式循环里,跳过的只是循环体,i++ 照样会执行,所以不会死循环。但如果把步进写在循环体末尾而不是塞进 for 后面,continue 一执行,步进就被跳过了,条件永远成立,程序当场卡住,而且代码看上去一点毛病都没有。

差别只在一轮还是一整个。

switch 走完一个分支就停

还剩 switch 这一个。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
func main() {
// 值匹配
for _, v := range []int{1, 2, 9} {
switch v {
case 1:
fmt.Println("value 1 -> one")
case 2:
fmt.Println("value 2 -> two")
default:
fmt.Println("value other -> many")
}
}

// 一个 case 挂多个值
for _, v := range []int{1, 2, 3, 4} {
switch v {
case 1, 2, 3:
fmt.Println(v, "hits 1,2,3")
default:
fmt.Println(v, "misses")
}
}

// 不带表达式,当 if-else 链用
for _, x := range []int{5, 15, 25} {
switch {
case x > 20:
fmt.Println(x, "-> big")
case x > 10:
fmt.Println(x, "-> mid")
default:
fmt.Println(x, "-> small")
}
}
}
1
2
3
4
5
6
7
8
9
10
11
$ go run .
value 1 -> one
value 2 -> two
value other -> many
1 hits 1,2,3
2 hits 1,2,3
3 hits 1,2,3
4 misses
5 -> small
15 -> mid
25 -> big

三段代码对应三种用法。拿一个值去比对,把几个值塞进同一个 case,或者干脆不写表达式,让每个 case 自己带条件,第三种其实就是 if-else 链换了身衣服,好处是几个分支看起来是平级的,不像 else if 那样一行比一行往右缩。

不写表达式的那个 switch 从上往下求值,命中一个就停,后面的条件不再算。

和 C 家族不一样,Go 的 case 走完自动就出来了,不用在每个分支末尾补一个 break。这件事我专门跑了一次,来证明它真的不往下掉。

1
2
3
4
5
6
switch 1 {
case 1:
fmt.Println("case1: one")
case 2:
fmt.Println("case2: two")
}
1
2
$ go run .
case1: one

只打了一行,case 2 那一段完全没执行。这个默认值跟 C 正好相反,很多从 C 过来的人第一次写 Go 的 switch 会习惯性补一个 break,gofmt 不拦,编译器也不拦,但那个 break 是多余的。

倒是有个反过来的关键字叫 fallthrough,你想掉下去的时候得手动写出来,它就落进下一个 case 的第一句,不再判断条件。

1
2
3
4
5
6
7
8
9
10
11
switch 2 {
case 1:
fmt.Println("ft case1")
case 2:
fmt.Println("ft case2")
fallthrough
case 3:
fmt.Println("ft case3")
case 4:
fmt.Println("ft case4")
}
1
2
3
$ go run .
ft case2
ft case3

从 case 2 掉进了 case 3,掉完就收住。

日常代码里这个关键字很少出现,真要用的时候,多半是几个分支共享同一段收尾逻辑。

标签是嵌套循环的出口

两层循环里,单独的 break 只退得动一层。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func main() {
// 不带标签
for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
if j == 1 {
break
}
fmt.Printf("no-label i=%d j=%d\n", i, j)
}
}

fmt.Println("---")

outer:
for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
if i == 1 && j == 1 {
fmt.Printf("labeled break at i=%d j=%d\n", i, j)
break outer
}
fmt.Printf("labeled i=%d j=%d\n", i, j)
}
}
fmt.Println("after loop")
}
1
2
3
4
5
6
7
8
9
10
11
$ go run .
no-label i=0 j=0
no-label i=1 j=0
no-label i=2 j=0
---
labeled i=0 j=0
labeled i=0 j=1
labeled i=0 j=2
labeled i=1 j=0
labeled break at i=1 j=1
after loop

上半段那个 break 只打断了内层,外层 i 转了三圈,所以打了三行。下半段给外层循环贴了个 outer: 标签,break outer 直接跳到标签那层循环的外面,整段循环立刻收工,after loop 紧接着就出来了。标签的写法是名字加冒号,贴在 for 前面,中间不许夹别的语句,跳的时候在 break 后面跟一个标签名。

continue 也能挂标签,挂上就跳到那一层的下一轮。这两个用法都属于知道就行,真写出来的时候通常意味着这个函数已经该拆了。下一站是函数,多返回值会正式登场。