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

函数是一等值,闭包只是它的一个用法
隔壁老康难度 ★★☆☆☆ · 前置: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 | type Handler func(w io.Writer, r *Request) error |
返回值命名只影响 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 | type op func(int, int) int |
闭包抱住的到底是什么
闭包这个词容易被神秘化。拆开看它就是两样东西,一个函数体,加上它引用的外部变量。Go 的实现很直接,被闭包引用的变量从栈上搬到堆上,函数值和这些变量一起构成一个可调用的对象,所以闭包能记住状态,代价是这个状态要活多久,编译器判断不了,只能交给 GC 管。
go run . 和 go run main.go 出来的数不一样。
差的就是那个点,它让模块生效。
很多从 Java 或 C# 过来的人对闭包的第一印象是语法糖,其实它更接近一个隐式构造出来的对象,字段就是那些被捕获的变量,方法就是那个函数体,只是编译器替你写了这些代码,这么一想,那些关于闭包的规则就都好解释了,字段要跟着对象活,所以变量上堆。每次调 counter 都得到一个新的 n。c := counter() 连调三次得到 1 2 3,c2 := counter() 从头开始又是 1,两个实例互不干扰,因为每次调用都重新分配了一份状态(这一点看着理所当然),实际上它已经把闭包和普通函数区分开了,普通函数的局部变量每次调用重新来过,闭包捕获的那些变量跟着函数值一起活着。
闭包的成本也值得说清楚。
验证时我踩了单文件模式的坑。
它至少要多分配一个对象来装那些捕获的变量,如果捕获的变量本身是指针或者切片,还得算上它们指向的东西。基准测试里这种分配经常是零点几个纳秒,看不出来,但放在每秒几百万次调用的热路径上就不是小数目了,我的习惯是,闭包里只捕获必须活的变量,能在外面算好再传进去的,就别让它被捕获,传值进函数,编译器看得清清楚楚,它会自动决定放哪,被闭包捕获反而逼着它上堆。
1 | func counter() func() int { |
栽跟头最多的地方是循环。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 | func named() (n int) { |
两个函数都返回 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 | BenchmarkSlice-32 6259179 189.3 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 | ./main.go:6:2: moved to heap: n |
收个尾
函数这一块的知识点看着散,其实都挂在函数是值这一条上。既然是值,就有类型、有零值、能被赋值和传递。既然是值,背后就可能带着捕获的变量,那些变量得搬到堆上。既然是值,两个值之间的相等就没有明确含义,语言干脆不给这个运算符。
从一条规则推出来的东西,比记住七条规则要稳。一条根,上面七个枝。写完这几段我回头翻了自己以前的代码,发现最常犯的错是把闭包当成语法上的方便,而不是一个带着状态的对象。前一种理解让人不自觉地在一个循环里塞闭包,还在心里默认它每次都独立。后一种理解会让人多问一句,这些闭包会活到循环结束之后吗。
如果会,它们现在抱的是谁。这个问题问出来,一半的坑就不用踩了。












