数组、切片、map:日常怎么用

难度 ★☆☆☆☆ · 前置:函数:多返回值是常态 | 一句话结论:数组的长度写死在类型里,切片是能长大的窗口,map 是按键找值,日常要记的就是这三样各自怎么建、怎么加、怎么删、怎么遍历、怎么判空。

我第一次把一堆数据塞进 Go,是在写一个统计日志行数的小工具。日志是一行行读出来的,读到哪儿算哪儿,事先根本不知道有多少条,我却理所当然地写了一行 var lines [1000]string,心里想的是先给一千,多了再说。程序跑起来一声不响,第二天日志过了两千行,它安安静静地只数到一千就停了,后面那些行像从来没存在过。我盯着屏幕看了很久才明白,方括号里那个数字不是上限,是死数,它规定了这一块内存占多大,一个字节都多不了。后来换上切片,装是装得下了,可我又在一个还没初始化的 map 上直接赋值,程序当场 panic,屏幕上那一行 assignment to entry in nil map 我一个词都看不懂,只能逐字猜。这一篇讲的就是这三样东西日常怎么用:怎么建、怎么加、怎么删、怎么遍历、怎么判空,顺便把那两次翻车翻在哪一步说清楚。

三样东西,三种脾气。

数组:方括号里那个数字是死数

数组在 Go 里用得不算多,可它得先讲,因为长度写死在类型里这个极端你不先看见,后面切片的脾气就不好懂。建法有三种,var a [3]int 得到三个零,b := [3]int{1, 2, 3} 当场填好,c := [...]string{"x", "y"} 里那三个点让编译器自己去数大括号里有几个值。数出来两个,c 的类型就是 [2]string,只认两个格子,它跟 [3]string 是两个毫不相干的类型,互相赋值编译器直接拒绝,压根等不到运行时。这一条我当初理解反了,我以为 [2]string 能塞进 [3]string,多出来的位置补个空字符串就行,结果编译器一句话把我堵回来,它根本不认为这两个是同一种东西。数组的长度不是它的一个属性,是它名字的一部分,[2]string 和 [3]string 之间的差别,跟你叫张三跟我叫李四一样大。

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() {
var a [3]int
b := [3]int{1, 2, 3}
c := [...]string{"x", "y"}

fmt.Println("a =", a, " len =", len(a), " cap =", cap(a))
fmt.Println("b =", b, " len =", len(b), " cap =", cap(b))
fmt.Println("c =", c, " len =", len(c), " cap =", cap(c))

fmt.Println("a == b ?", a == b)

d := a
d[0] = 99
fmt.Println("d =", d, " a =", a)
fmt.Println("d == a ?", d == a)
}
1
2
3
4
5
6
7
$ go run .
a = [0 0 0] len = 3 cap = 3
b = [1 2 3] len = 3 cap = 3
c = [x y] len = 2 cap = 2
a == b ? false
d = [99 0 0] a = [0 0 0]
d == a ? false

输出末尾两行是重点。d := a 把三个格子整个抄了一份,改 d 的第 0 位,a 的第 0 位还是零,所以 d == a 是 false。这就是数组的值语义,赋值抄一份,传参也抄一份,函数里怎么改都动不到外面那个。它有个副产品挺好用,数组能直接当 map 的键,因为长度是类型的一部分,编译器知道该比几个格子,标准库里 sha256.Sum256 返回的就是 [32]byte,拿来做键没有任何问题。

切片的三种建法,nil 只是其中一种

切片能长大,这是它跟数组的分水岭。

建法有三种,差别全在 nil 上。var s []int 声明出来是 nil,长度和容量都是零,它压根没有底层数组。s2 := []int{} 长度也是零,可它已经指向一块实实在在的、长度为 0 的数组。s3 := make([]int, 0, 8) 一样不是 nil,但提前把容量要到 8,以后加到第八个才需要另找地方。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
var s []int
s2 := []int{}
s3 := make([]int, 0, 8)

fmt.Println("s == nil ?", s == nil, " len =", len(s), " cap =", cap(s))
fmt.Println("s2 == nil ?", s2 == nil, " len =", len(s2), " cap =", cap(s2))
fmt.Println("s3 == nil ?", s3 == nil, " len =", len(s3), " cap =", cap(s3))

fmt.Printf("s = %#v\ns2 = %#v\ns3 = %#v\n", s, s2, s3)
}
1
2
3
4
5
6
7
$ go run .
s == nil ? true len = 0 cap = 0
s2 == nil ? false len = 0 cap = 0
s3 == nil ? false len = 0 cap = 8
s = []int(nil)
s2 = []int{}
s3 = []int{}

前两个的 len 和 cap 一模一样,区别只在 == nil 那一行。

那这个区别在什么时候会咬人?我自己踩过一次,写了个函数判断参数是不是空,if s == nil,测试里传 []int{} 进去,它说不是空,后面就多循环了一轮。空的切片本来就有两个来源,一个是声明没初始化,一个是字面量初始化过,业务上它们是一个意思,可 == nil 只能认出前者。

三种在建完之后用起来没有任何区别,nil 切片照样能 append,append 会替你分配一块新的,谁也不欠谁。所以真正该改的不是建法,是判断的写法:判空一律写 len(s) == 0,两种来源一起覆盖掉。

%#v 打出来的样子能看出底细,一个是 []int(nil),一个是 []int{},第三个长得跟前两个一样,但容量是 8。

第三种建法什么时候值得用,你事先知道大概要装多少的时候。

判空一律用长度。

append 之后要接住返回值

append 的签名是 func append(s []T, 值...) []T,它返回一个切片,后面那半句是重点。很多人第一次用它,以为 append 是把原来那个切片改长,其实它改不了,因为长度根本不存在数据里,它记在那个切片头上,而头是按值传进来的。

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() {
var s []int
for i := 1; i <= 3; i++ {
s = append(s, i)
fmt.Printf("append %d 次后: %v len = %d cap = %d\n", i, s, len(s), cap(s))
}

t := []int{1, 2, 3}
t = append(t, 4, 5, 6)
fmt.Printf("一次加三个: %v len = %d cap = %d\n", t, len(t), cap(t))

u := []int{1, 2}
v := []int{3, 4}
fmt.Println("append 另一个切片:", append(u, v...))

w := []string{"a"}
fmt.Println("字符串切片:", append(w, "b"))
}
1
2
3
4
5
6
7
$ go run .
append 1 次后: [1] len = 1 cap = 1
append 2 次后: [1 2] len = 2 cap = 2
append 3 次后: [1 2 3] len = 3 cap = 4
一次加三个: [1 2 3 4 5 6] len = 6 cap = 6
append 另一个切片: [1 2 3 4]
字符串切片: [a b]

看前三行,len 和 cap 一起从 1 涨到 2 再涨到 4。为什么不是 3,因为容量见底时 append 不会只加一格,它另找一块更大的地,把旧的抄过去,再把新的写进去,旧的那块地还在,只是没人指着它了。这也解释了返回值为什么必须接住:append 拿到的是切片头的副本,它在副本上改了指针和长度,副本一扔,你手里那个还是老的。不接的情况我试过一次,效果凭空消失,程序不报错,只是少了一行数据,这种错最难查,因为没有任何东西提示你,你只会纳闷为什么统计结果比实际少一条。写 s = append(s, x) 就是把副本收回来,左手接住,右手才生效。

append 不是原地加长,它返回一个新的。

切片的切法,和共享的那块数组

切法只有四种,从左闭右开开始。

s[1:3] 拿第 1 格到第 2 格,不含第 3 格。s[:2] 省略起点就是从头开始,s[2:] 省略终点就是一直到末尾,s[:] 两头都省,拿回整段。四种各跑一次,顺便把每种的 len 和 cap 打出来,cap 那一列才是真正有信息量的地方。

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
s := []int{10, 20, 30, 40, 50}
fmt.Printf("s = %v len = %d cap = %d\n", s, len(s), cap(s))
fmt.Printf("s[1:3] = %v len = %d cap = %d\n", s[1:3], len(s[1:3]), cap(s[1:3]))
fmt.Printf("s[:2] = %v len = %d cap = %d\n", s[:2], len(s[:2]), cap(s[:2]))
fmt.Printf("s[2:] = %v len = %d cap = %d\n", s[2:], len(s[2:]), cap(s[2:]))
fmt.Printf("s[:] = %v len = %d cap = %d\n", s[:], len(s[:]), cap(s[:]))
}
1
2
3
4
5
6
$ go run .
s = [10 20 30 40 50] len = 5 cap = 5
s[1:3] = [20 30] len = 2 cap = 4
s[:2] = [10 20] len = 2 cap = 5
s[2:] = [30 40 50] len = 3 cap = 3
s[:] = [10 20 30 40 50] len = 5 cap = 5

看 s[1:3] 那行,长度是 2,容量却是 4,为什么是 4,因为起点挪到了第 1 格,从那儿往后数到数组末尾还剩 4 格。容量数的是起点到末尾的余量,跟你这个切片自己有多长没有关系,这是新手最容易看错的一处,比看错长度常见得多。

上下界写错直接 panic,报错原文把数字都告诉你了。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
s := []int{1, 2, 3}
fmt.Println("s =", s, " len =", len(s), " cap =", cap(s))
_ = s[0:5]
}
1
2
3
4
5
6
7
8
$ go run .
s = [1 2 3] len = 3 cap = 3
panic: runtime error: slice bounds out of range [:5] with capacity 3

goroutine 1 [running]:
main.main()
F:/Work/AI/Blog/_local/golab/h5/oob/main.go:8 +0x130
exit status 2

它说的是 capacity 不是 length,Go 允许你切到容量那儿,超了才崩。这条报错还有个用处,它能顺手告诉你手上这个切片的容量到底是多少。

共享底层数组这件事光看文字不容易信。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
a := []int{1, 2, 3, 4, 5}
b := a[1:3]
fmt.Println("a =", a)
fmt.Println("b = a[1:3] =", b)

b[0] = 99
fmt.Println("b[0] = 99 之后")
fmt.Println("a =", a)
fmt.Println("b =", b)
}
1
2
3
4
5
6
$ go run .
a = [1 2 3 4 5]
b = a[1:3] = [2 3]
b[0] = 99 之后
a = [1 99 3 4 5]
b = [99 3]

两个切片头指着同一块底层数组

b 的第 0 位就是 a 的第 1 位,两个头指着同一块数组,改 b 就是改 a,不用任何别的操作,赋值本身就是修改。这是切片最容易踩的地方,同时也是它省内存的原因,切割不复制,只是换个窗口看同一块。麻烦在于这个共享是静默的,b := a[1:3] 这一行长得像复制,看着就像一个全新的变量,你要是不知道它有指针,会一直以为改 b 跟 a 无关,等到某天 a 里的数据显示不对,回头找也很难找到这一行上来。

要想两块彻底分开,只有复制那一条路。

copy 用来断开这层共享

想让两个切片互不相干,用 copy,签名是 func copy(dst, src []T) int,返回实际复制了几个元素,这个数字经常被忽略。规则只有一条,复制多少个取决于谁短:dst 长了不会自动变长,dst 短了就只抄前面一段,多出来的原地不动,也不会被清空。所以真正想备份一个切片,正确写法是两行,bak := make([]int, len(s)) 加 copy(bak, s),你要是图省事写 bak := s,那只是多了一个头指着同一块数组,改哪个另一个都跟着变。返回值也值得用起来,n := copy(dst, src) 之后看一眼 n 是不是等于 len(src),不够就说明 dst 建小了,比事后数格子可靠。

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

import "fmt"

func main() {
s := []int{1, 2, 3}

d5 := make([]int, 5)
n := copy(d5, s)
fmt.Printf("dst 长度 5,复制了 %d 个: %v\n", n, d5)

d3 := make([]int, 3)
n = copy(d3, s)
fmt.Printf("dst 长度 3,复制了 %d 个: %v\n", n, d3)

d8 := make([]int, 8)
n = copy(d8, s)
fmt.Printf("dst 长度 8,复制了 %d 个: %v\n", n, d8)

back := d3
back[0] = 99
fmt.Printf("复制之后改 back[0]: s = %v back = %v\n", s, back)
}
1
2
3
4
5
$ go run .
dst 长度 5,复制了 3 个: [1 2 3 0 0]
dst 长度 3,复制了 3 个: [1 2 3]
dst 长度 8,复制了 3 个: [1 2 3 0 0 0 0 0]
复制之后改 back[0]: s = [1 2 3] back = [99 2 3]

三次都是 3,因为 src 只有 3 个。末尾那行是重点,改 back 的时候 s 一点没动。

map 的三种建法,nil 的只能读

map 也是三种建法,可它跟切片不一样,其中 var m map[string]int 这一种带刺。它建出来是 nil,能读,读出来是零值,能 len,能 range,就是不能写。m2 := map[string]int{} 和 m3 := make(map[string]int) 才是能写的,两种写法等价,后者还能带一个容量提示 make(map[string]int, 16),十几个键带不带没区别,几百个以上带上能少几轮扩容。

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

import "fmt"

func main() {
var m1 map[string]int
m2 := map[string]int{}
m3 := make(map[string]int)

fmt.Println("m1 == nil ?", m1 == nil, " len =", len(m1))
fmt.Println("m2 == nil ?", m2 == nil, " len =", len(m2))
fmt.Println("m3 == nil ?", m3 == nil, " len =", len(m3))

m2["a"] = 1
m3["a"] = 1
fmt.Println("写进去之后: m2 =", m2, " m3 =", m3)
}
1
2
3
4
5
$ go run .
m1 == nil ? true len = 0
m2 == nil ? false len = 0
m3 == nil ? false len = 0
写进去之后: m2 = map[a:1] m3 = map[a:1]

往 nil map 里写一次,就是这个下场,报错只有一句话,不告诉你是哪个变量,只告诉你哪一行。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
var m map[string]int
fmt.Println("这是个 nil map,len =", len(m))
m["a"] = 1
}
1
2
3
4
5
6
7
8
$ go run .
这是个 nil map,len = 0
panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
F:/Work/AI/Blog/_local/golab/h5/nilmap/main.go:8 +0x89
exit status 2

所以 map 一律建好再用,别指望零值能写。这一点跟切片刚好相反,切片零值能用,map 零值只能读。

增删改查,和被打乱的遍历

map 里没有下标这回事,全是键。

赋值 m["a"] = 1,同一个键再赋一次就是改。读 v := m["a"],键不存在不报错,直接给你零值。整套增删改查用一个从零开始的空 map 跑一遍最清楚。

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
package main

import "fmt"

func main() {
m := map[string]int{}

m["a"] = 1
fmt.Println("存一个 a:", m, " len =", len(m))

m["a"] = 100
fmt.Println("把 a 改成 100:", m)

v := m["a"]
fmt.Println("读 a:", v)

miss := m["nope"]
fmt.Println("读一个不存在的键 nope:", miss)

v, ok := m["a"]
fmt.Println(`v, ok := m["a"] ->`, v, ok)

v, ok = m["nope"]
fmt.Println(`v, ok := m["nope"] ->`, v, ok)

delete(m, "a")
fmt.Println("delete 之后:", m, " len =", len(m))

delete(m, "nope")
fmt.Println("删一个不存在的键,不报错:", m)
}
1
2
3
4
5
6
7
8
9
$ go run .
存一个 a: map[a:1] len = 1
把 a 改成 100: map[a:100]
读 a: 100
读一个不存在的键 nope: 0
v, ok := m["a"] -> 100 true
v, ok := m["nope"] -> 0 false
delete 之后: map[] len = 0
删一个不存在的键,不报错: map[]

v, ok := m["nope"] 得到的是 0 false,两个值都得看,光看 v 你分不出真假零。这是 map 比切片危险的地方,键名拼错一个字母,你拿到的是 0,不是错误,程序照常往下跑,等炸的时候已经隔了好几层。我见过一次最典型的,配置里有个键叫 timeout,代码里写的是 timeOut,读出来恒等于 0,于是每个请求超时时间都是 0,表现出来是接口偶尔秒回一个空结果,谁都觉得是网络抖动,查了半个下午才回到这一行。所以凡是键可能不存在的地方都写两个返回值,ok 那一半才是真正回答问题的那半,光有值没有 ok,等于把拼写错误当成数据读进去了。

删是 delete(m, "a"),删一个不存在的键什么也不发生,不报错,想确认删掉了没有只能再看一眼 len。

遍历用 range,三种写法:键和值都要、只要键、只要值。

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
package main

import "fmt"

func main() {
m := map[string]int{
"apple": 1, "banana": 2, "cherry": 3, "durian": 4,
"elder": 5, "fig": 6, "grape": 7, "honey": 8,
"kiwi": 9, "lemon": 10,
}

for i := 1; i <= 4; i++ {
fmt.Printf("第 %d 次: ", i)
for k := range m {
fmt.Print(k, " ")
}
fmt.Println()
}

fmt.Print("只要键: ")
for k := range m {
fmt.Print(k, " ")
}
fmt.Println()

fmt.Print("只要值: ")
for _, v := range m {
fmt.Print(v, " ")
}
fmt.Println()

fmt.Print("键和值都要: ")
for k, v := range m {
fmt.Printf("%s=%d ", k, v)
}
fmt.Println()

fmt.Println("len =", len(m))
}
1
2
3
4
5
6
7
8
9
$ go run .
第 1 次: apple cherry fig banana durian elder grape honey kiwi lemon
第 2 次: apple cherry fig banana durian elder grape honey kiwi lemon
第 3 次: banana durian elder grape honey kiwi lemon apple cherry fig
第 4 次: cherry fig banana durian elder grape honey kiwi lemon apple
只要键: banana durian elder grape honey kiwi lemon apple cherry fig
只要值: 1 3 6 2 4 5 7 8 9 10
键和值都要: banana=2 durian=4 elder=5 grape=7 honey=8 kiwi=9 lemon=10 apple=1 cherry=3 fig=6
len = 10

同一张 map 连走四遍,顺序每次都在转,隔一会儿再跑还会变。顺序是故意不给你的,要有序就自己排。

把键捞出来塞进切片,排一遍,再按排好的键去取值。这是日常唯一稳当的办法,多写四行,换来一个每次一样的输出。

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"
"sort"
)

func main() {
m := map[string]int{"b": 2, "a": 1, "c": 3}

keys := make([]string, 0, len(m))
for k := range m {
keys = append(keys, k)
}
sort.Strings(keys)

fmt.Print("排过序的键: ")
for _, k := range keys {
fmt.Print(k, " ")
}
fmt.Println()

nums := []int{3, 1, 4, 5, 2}
sort.Ints(nums)
fmt.Println("sort.Ints 之后:", nums)
fmt.Println("3 在下标", sort.SearchInts(nums, 3))
}
1
2
3
4
$ go run .
排过序的键: a b c
sort.Ints 之后: [1 2 3 4 5]
3 在下标 2

顺序稳定了,输出才能对得上。

还有两件事得提前知道,都是编译期就拦下来的。map 里的结构体字段不能直接改,m["a"].X = 1 报 cannot assign to struct field m["a"].X in map,得整个取出来改完再塞回去。map 之间也不能比,m1 == m2 报 invalid operation: m1 == m2 (map can only be compared to nil),只能跟 nil 比。至于 fmt.Println 打出来的 map 看着是有序的,那是格式化时替你排过序,跟 range 没关系,别拿打印结果当遍历顺序的证据。

记住这几件事就够了

这一篇一句底层都没讲,切片头为什么是三个数,append 什么时候另起一块,扩容的倍数怎么变,map 的桶怎么摆,那些在进阶线里各有专门一篇,等你写顺手了再回头看会顺很多。入门阶段只要把日常这几件做对:用字面量或者 make 把容器建出来,s = append(s, x) 一定接住返回值,判空一律写 len(s) == 0,map 先建再写,遍历要顺序就自己排一遍。这几条熟了,代码基本不会因为容器出问题,注意力可以全留给业务逻辑,下一件事是把这些散着的数据组织成有名字的结构,也就是结构体和方法,Go 说的对象从那儿开始。