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