函数是一等值,闭包只是它的一个用法

难度 ★★☆☆☆ · 前置:Go 只有值传递,切片也一样 | 一句话结论:函数在类型系统里就是一个普通的值,它有类型有零值能传递,唯独只能和 nil 比较。

学 Go 的头半年,我一直把函数当成代码块看。写 Python 那会儿就是这么理解的,def 定义一个动作,调用的时候跳过去执行,执行完回来,这个理解在大多数语言里够用,它唯独解释不了 Go 里一些很常见的东西(比如为什么可以把一个函数塞进 map),为什么 http.HandleFunc 只要传一个函数就能注册路由,为什么测试文件里那个匿名函数能记住外面循环到第几轮,为什么 recover 只有在 defer 里才管用。

这些现象背后是同一个事实,函数在 Go 的类型系统里是一等公民,它有类型、有零值、能赋值、能当参数、能当返回值,唯独不能比较。

把这一条吃透,后面那些用法都是推论,不需要死记,反过来看也成立,凡是让你觉得函数在 Go 里像个特殊构造的地方,基本都是因为忘了它首先是个值,其次才是一段可以执行的代码。用 type 给函数签名起个名字,这件事在标准库和框架里到处都是。net/http 的 HandlerFunc、database/sql 的 Scanner、sort 里的比较函数,本质都是把一个特定签名的函数变成有名有姓的类型。

起名字之后它就能挂方法,能写文档注释,能在 godoc 里被索引,还能在编译错误里显示成一个短名字而不是一长串括号。

不给名字也能用,var f func(int) int 就是声明,名字的价值在于可读性,接口方法参数里出现一长串函数括号,读的人得在脑子里数半天才数清楚哪一层是参数哪一层是返回值。

1
2
3
4
5
type Handler func(w io.Writer, r *Request) error

func apply(h Handler, w io.Writer, r *Request) error {
return h(w, r)
}

返回值命名只影响 godoc 那一页。

函数在 Go 里就是一个值

函数值可以被赋值、被传递、被返回,也可以在结构体字段里躺着。下面这段把三种用法放在一起,加法和乘法两个匿名函数放进同一张表,调用方按名字取。这种写法在配置驱动的代码里特别常见,比如把一组校验策略做成 map[string]func(any) error,新增规则只要往表里加一行,调用点一个字都不用改,它还有个副作用是让分支消失,本来要写一串 if 判断类型再调对应函数,现在变成一次查表加一次调用,代码短了,也更容易被测试覆盖。注意 map 的值类型写的是 op,字面量里那些匿名函数会被自动转成 op。这一步转换是隐式的,不需要写 op(func(...)) 显式包一层,Go 在赋值和传参时会对底层类型相同、其中一边是未命名类型的函数做这个转换,所以 type 起的名字不会在外面多包一层壳,调用起来跟裸函数一模一样。方法值也是函数值,但这两个写法差着一段:

写法 长什么样 接收者怎么进去
方法值 v.Method 绑定时就复制一份进去
方法表达式 T.Method 调用时显式当第一个参数传

v.Method 把一个方法绑到具体接收者上,得到一个可以到处传的函数。T.Method 拿到的是个普通函数,第一个参数专门留给接收者。

v.Method 拿到的那一刻接收者就被复制了,后面 v 再怎么改,函数值里存的那份不会跟着变(这一点和闭包抱变量正好相反),一个复制值,一个抱地址。

我第一次遇到这个差别是在做定时任务的时候,把 job.Run 直接塞进定时器,结果任务里读到的永远是注册那一刻的配置,配置热更新怎么都不生效,查了半天下才发现问题出在这个值上。后来我把这种写法统一改成传一个不带接收者的函数,让调用方自己决定用哪份配置,问题就没了。(顺带说一句,方法表达式 T.Method 拿到的是个普通函数,第一个参数专门留给接收者,写起来比方法值啰嗦,但它能塞进需要一个纯函数的位置(比如 sort.Slice 的比较函数就没法用方法值),得绕一下。)函数类型的零值是 nil,这点和指针、map、切片一样。

区别在于它没有 map 那么宽容,声明了不赋值就调用,程序直接崩在运行时,报的还是那句最容易误导人的 runtime error: invalid memory address or nil pointer dereference。

函数调用的空指针,读起来像指针问题,实际上是没赋值。崩得晚,查得久。

1
2
3
4
5
6
7
8
9
10
11
type op func(int, int) int

var table = map[string]op{
"add": func(a, b int) int { return a + b },
"mul": func(a, b int) int { return a * b },
}

func main() {
fmt.Println(table["add"](2, 3)) // 5
fmt.Println(table["mul"](2, 3)) // 6
}

闭包抱住的到底是什么

闭包这个词容易被神秘化。拆开看它就是两样东西,一个函数体,加上它引用的外部变量。Go 的实现很直接,被闭包引用的变量从栈上搬到堆上,函数值和这些变量一起构成一个可调用的对象,所以闭包能记住状态,代价是这个状态要活多久,编译器判断不了,只能交给 GC 管。

go run . 和 go run main.go 出来的数不一样。

差的就是那个点,它让模块生效。

很多从 Java 或 C# 过来的人对闭包的第一印象是语法糖,其实它更接近一个隐式构造出来的对象,字段就是那些被捕获的变量,方法就是那个函数体,只是编译器替你写了这些代码,这么一想,那些关于闭包的规则就都好解释了,字段要跟着对象活,所以变量上堆。每次调 counter 都得到一个新的 n。c := counter() 连调三次得到 1 2 3,c2 := counter() 从头开始又是 1,两个实例互不干扰,因为每次调用都重新分配了一份状态(这一点看着理所当然),实际上它已经把闭包和普通函数区分开了,普通函数的局部变量每次调用重新来过,闭包捕获的那些变量跟着函数值一起活着。

闭包的成本也值得说清楚。

验证时我踩了单文件模式的坑。

它至少要多分配一个对象来装那些捕获的变量,如果捕获的变量本身是指针或者切片,还得算上它们指向的东西。基准测试里这种分配经常是零点几个纳秒,看不出来,但放在每秒几百万次调用的热路径上就不是小数目了,我的习惯是,闭包里只捕获必须活的变量,能在外面算好再传进去的,就别让它被捕获,传值进函数,编译器看得清清楚楚,它会自动决定放哪,被闭包捕获反而逼着它上堆。

1
2
3
4
func counter() func() int {
n := 0
return func() int { n++; return n }
}

栽跟头最多的地方是循环。1.22 之前,for i := 0; i < 3; i++ 只声明一个 i,三轮循环共用同一个变量,三个闭包抱的都是它。等它们被调用的时候循环早结束了,i 已经变成 3,于是三个闭包全都打印 3,这不是 bug,语言规范当时就是这么写的。

1.22 改掉了这件事,同样的代码放在 go 1.27 的模块里跑,输出是 0 1 2,因为每一轮循环都拿到了新的 i。

行为由 go.mod 里那一行 go 决定,跟工具链版本无关,两次跑的是同一个 go1.27.2 的编译器。

我用 go run main.go 跑了两遍都是 0 1 2,一度以为 go 那行根本不起作用,单文件模式不看 go.mod,写成 go run . 才走模块。

命名返回值和 defer 的合谋

命名返回值不是装饰品,它参与了返回值这件事本身。写了 func f() (n int) 之后,n 在函数体开头就以零值存在,return 后面什么都不写就返回 n 的当前值。更微妙的是 defer,它在 return 算完返回值之后、函数返回之前执行,所以 defer 里的闭包能改掉 n,这两件事凑在一起,才有了那个很多人第一次看到会觉得奇怪的结论,写在 return 后面的表达式,不一定是最后返回出去的值。

1
2
3
4
5
6
7
8
9
10
func named() (n int) {
n = 7
defer func() { n = 8 }()
return n
}

func named2() (n int) {
defer func() { n++ }()
return 7
}

两个函数都返回 8。第一个把 7 赋给 n 再返回,defer 又改成 8,第二个 return 7 先把 7 写进 n,defer 再自增一次,这个特性是 recover 能工作的基础,panic 发生时 defer 里的代码可以改掉返回值,让函数正常返回一个错误值而不是把整个进程带走。注册时求值,返回时执行。defer 的参数是另一回事。

写 defer fmt.Println(x),x 的值在注册那一刻就算好并复制了,defer 执行时打印的是旧值。想让 defer 读到最新值,得传闭包而不是传参数。

三点省略号复制不复制

可变参数 ...int 在函数内部看起来就是一个 []int,这是它最好用的地方。传参时两种写法都行,f(1, 2, 3) 和 f(nums...),后者是把已有切片展开。很多人担心展开会复制一遍,实测下来不会,这背后没什么魔法,切片本身就是个头部的复制,展开时编译器直接把那个头部传进去,底层数组还是同一块,一个字节都没动。

真正需要留意的不是复制,而是别在函数里对展开进来的切片做 append,那才会动到底层数组。三种写法的基准摆在一起看最清楚:

写法 ns/op B/op allocs/op
传 1000 元素切片 f(s) 189.3 0 0
展开 f(s...) 189.8 0 0
传三个字面量 f(1,2,3) 5.117 0 0
1
2
3
BenchmarkSlice-32       6259179    189.3 ns/op    0 B/op    0 allocs/op
BenchmarkSpread-32 6235485 189.8 ns/op 0 B/op 0 allocs/op
BenchmarkLiteral3-32 1000000000 5.117 ns/op 0 B/op 0 allocs/op

(我原本以为展开会多一次分配,两行数字摆出来才知道想错了。)展开不是复制,是换个说法。真正有成本的是传字面量。sumVariadic(1, 2, 3) 这种调用,编译器要在栈上或者堆上拼一个临时切片,实测 5.117 ns/op,还是 0 allocs,三个 int 的临时切片在栈上就能放下。

还有一个边界值得记住。不传参数时,函数里的切片是 nil 而不是空切片,len 是 0,s == nil 是 true,如果代码里用 s != nil 做分支判断,这种情况会走进 false 那一支。

数量再多一点,就得挪到堆上,这一条跑 benchmark 看得见。

一个参数都不传,拿到的是 nil 不是空切片。展开一个切片传进去,到底复制了没有?

函数只能和 nil 比

Go 里函数值之间不能比较,编译期就拦下了。写 a == b 会得到 invalid operation: a == b (func can only be compared to nil)。原因不复杂,函数值背后可能是一段代码加一组捕获的变量,两者都没有确定的相等语义,语言选择不给答案(而不是给一个含糊的答案让人猜),同样的理由也解释了为什么结构体里只要有一个不可比较的字段,整个结构体就不能用 ==,判等的语义是从字段一层层推上来的,推不到底就不给。

名字撞了就是重复注册,好查得很。

a == nil 编得过,a == b 编不过。

和 nil 比是允许的。var f func() 之后 f == nil 是 true,这个检查在回调场景里很有用,注册进来的回调可能压根没设置,调用前判一下能避免直接崩。

函数名重复注册会 panic,这事好查。

切片、map、函数三个类型在这一点上是一致的,都不能比较,都只能和 nil 比。

想把函数值可比较化,得自己包一层(比如给它配一个 id 或者名字),比较 id 而不是函数本身,这个模式在插件注册表里很常见,注册表里存的是名字加函数的组合,查重靠名字,调用靠函数。

被带出去的都得上堆

逃逸分析决定一个变量住在栈上还是堆上。规则可以简化成一句话,变量的地址如果能活过函数返回,它就必须上堆。闭包是最典型的场景,被捕获的变量地址跟着函数值一起返回,只能搬走,没得商量。这条规则听起来宽松,实际执行得很死,哪怕编译器把整个函数都内联了,只要那个地址有可能跑出去,该搬的还得搬。所以看逃逸日志的时候,别指望内联能顺带把分配也消掉,它们是两件事。这四行放在一起看很有意思。编译器说它把 counter 内联了,同时也说 n 搬到了堆上。内联不等于免掉分配,内联只是把函数体摊平到调用点,闭包的生命周期该多长还是多长。看到 can inline 就以为没有分配,是很容易犯的一厢情愿。内联救不了逃逸。

变量被带出去,它就得搬到堆上。

看逃逸日志的命令是 go build -gcflags='-m' .,加一个 -m 还能看到内联的代价估算,-m=2 等价于写两遍。就地调用的字面量不逃逸,因为用完就没了。

日志是按包打的,包大了几百行,grep -i escape 筛一遍能省不少时间。这些日志里有两种说法,escapes to heap 说的是这个值跑到了堆上,moved to heap 说的是这个变量被搬家了,前者是结果,后者是动作。第一次读的时候我以为是同一件事的两种写法,后来才发现它们出现在不同的行上,一个是函数字面量,一个是被它捕获的变量。一个反直觉的地方,noCapture 里的闭包什么都没捕获,就因为被 return 出去,照样报 func literal escapes to heap。

逃逸看的不是捕获了什么,是这个值有没有跑出当前函数的栈帧。

1
2
3
4
./main.go:6:2: moved to heap: n
./main.go:7:9: func literal escapes to heap
./main.go:5:6: can inline counter
./main.go:15:14: inlining call to counter

收个尾

函数这一块的知识点看着散,其实都挂在函数是值这一条上。既然是值,就有类型、有零值、能被赋值和传递。既然是值,背后就可能带着捕获的变量,那些变量得搬到堆上。既然是值,两个值之间的相等就没有明确含义,语言干脆不给这个运算符。

从一条规则推出来的东西,比记住七条规则要稳。一条根,上面七个枝。写完这几段我回头翻了自己以前的代码,发现最常犯的错是把闭包当成语法上的方便,而不是一个带着状态的对象。前一种理解让人不自觉地在一个循环里塞闭包,还在心里默认它每次都独立。后一种理解会让人多问一句,这些闭包会活到循环结束之后吗。

如果会,它们现在抱的是谁。这个问题问出来,一半的坑就不用踩了。