闭包是什么?
在正式认识闭包之前,我们先看一个很常见的小需求:如果要写一个计数器函数,每调用一次就让结果加 1,依次得到 1、2、3……应该怎么实现呢?
如果把计数变量定义成函数内部的普通局部变量,每次函数执行完这个变量就会失效。比如下面这样写,无论调用多少次,返回的结果永远都是 1:
func badCounter() int {
count := 0 // 每次调用都会重置为 0
count++
return count
}如果把 count 改成全局变量,虽然能记住数值,但程序里的其他函数也能随意修改它,既不安全也容易互相干扰。为了既让变量记住状态,又保证它只归当前函数专用,Go 语言提供了 “闭包(closure)”。
简单来说,当外层函数把一个内层匿名函数返回出去,并且这个内层函数用到了外层函数里的局部变量时,两者就会绑定在一起。这个 “内层匿名函数” 加上它引用的 “外层局部变量”,合起来就叫做一个闭包。
你可以把闭包看成给函数配了一本 “专属记事本”。哪怕外层函数已经执行结束,只要返回出来的匿名函数还在使用,这本记事本就会一直留着,每次调用都会在原来的记录上接着往下写。
在 Go 语言中,构成闭包需要同时满足以下 2 个条件:
- 返回内层匿名函数:外层函数内部定义了一个匿名函数,并通过
return语句将它返回出去。 - 引用外层局部变量:内层匿名函数中使用了外层函数定义的局部变量或形参。
闭包的使用
下面我们来看看编写闭包的具体语法,并用它实现开头提到的自增计数器。
语法:
func 外层函数名() func() 返回值类型 {
// 外层局部变量
return func() 返回值类型 {
// 使用外层局部变量
}
}说明:
初次看到函数头部连写两个 func 时,小伙伴们不用觉得陌生。我们从中间拆开看就非常清晰了:前面的 func 外层函数名() 是外层函数本身,后面的 func() 返回值类型 整体是它的返回值类型,表示外层函数执行完后会返回 “另一个函数”。
示例 1:实现自增计数器
package main
import "fmt"
// 返回闭包函数
func makeCounter() func() int {
count := 0
return func() int {
count++
return count
}
}
func main() {
// 1. 获取闭包函数
next := makeCounter()
// 2. 连续调用闭包
fmt.Println(next())
fmt.Println(next())
fmt.Println(next())
}运行结果如下。
1
2
3分析:
在 func makeCounter() func() int 中,后面的 func() int 表示返回一个无参、结果为 int 的函数。执行 next := makeCounter() 时,外层函数只运行了一次,它会把局部变量 count 初始化为 0,并把内层匿名函数赋给 next。
这里有一个非常关键的底层规律,小伙伴们一定要记住:闭包捕获的是外层变量 count 本身,而不是在创建那一刻把数值 0 复制一份带走。
正因为 next 一直抓着同一个 count 变量不放,到了第 2 步每次调用 next() 时,count++ 都会真正在原来的数值上累加 1,因此依次输出了 1、2、3。
需要注意的是,使用闭包时我们要先把外层函数返回的闭包保存在变量(如 next)中,再通过该变量重复调用。如果省掉变量、每次都直接写成 makeCounter()(),语法上虽然不会报错,但就达不到累加的效果了。
// 正确方式
next := makeCounter()
fmt.Println(next()) // 输出 1
fmt.Println(next()) // 输出 2
// 错误方式
fmt.Println(makeCounter()()) // 输出 1
fmt.Println(makeCounter()()) // 输出 1在上面的错误方式中,makeCounter()() 的第 1 对小括号先调用外层函数拿到闭包,第 2 对小括号紧接着执行该闭包。由于每次这样写都会重新调用一次外层函数,每次都会新建一个初始值为 0 的 count 变量,所以打印出来的结果永远是 1。
如果我们调用两次 makeCounter(),分别赋给两个不同的变量 c1 和 c2,它们会共用同一个 count 吗?下面我们来看一个例子。
示例 2:多个独立的闭包实例
package main
import "fmt"
func makeCounter() func() int {
count := 0
return func() int {
count++
return count
}
}
func main() {
c1 := makeCounter()
c2 := makeCounter()
fmt.Printf("c1 第 1 次:%d\n", c1())
fmt.Printf("c1 第 2 次:%d\n", c1())
fmt.Printf("c2 第 1 次:%d\n", c2())
}运行结果如下。
c1 第 1 次:1
c1 第 2 次:2
c2 第 1 次:1分析:
从运行结果可以看出,c1 已经累加到了 2,但当我们调用 c2() 时,它依然是从 1 开始计算的。
这是因为每调用一次外层函数 makeCounter(),Go 语言都会重新创建一个新的局部变量 count。c1 和 c2 各自绑定着独立的 count 变量,修改 c1 内部的状态完全不会影响 c2,两者的对应关系如下图所示。

很多初学的小伙伴看完前两个例子,容易以为闭包只能用来写计数器。实际上,外层函数和内层匿名函数都可以接收参数。因为外层函数的形参本身也属于外层局部变量,所以我们经常用闭包来批量生成 “自带固定配置” 的专属函数(常叫做 “函数工厂”)。
示例 3:生成后缀处理函数
package main
import "fmt"
// suffix 是外层函数的形参
func makeSuffix(suffix string) func(string) string {
return func(name string) string {
return name + suffix
}
}
func main() {
addGo := makeSuffix(".go")
addTxt := makeSuffix(".txt")
fmt.Println(addGo("main"))
fmt.Println(addGo("utils"))
fmt.Println(addTxt("notes"))
}运行结果如下。
main.go
utils.go
notes.txt分析:
在这个例子中,外层函数 makeSuffix(suffix string) 负责把固定的文件后缀存进闭包里,返回一个类型为 func(string) string 的新函数。
当我们执行 addGo := makeSuffix(".go") 后,addGo 就记住了 ".go" 这个后缀,后面每次调用只需传入文件名 "main" 或 "utils",就能直接拼出完整文件名。同理,addTxt 也记住了 ".txt" 后缀。
这样一来,我们既不用每次调用都重复传同一个后缀参数,又能灵活定制出多个不同功能的专属函数。
常见问题
1. 为什么外层函数执行结束后,闭包里的局部变量没有跟着消失?
在正常情况下,普通函数的局部变量只在函数运行期间存在,一旦函数执行完毕就会自动销毁释放。
但在闭包中,Go 编译器在编译时会自动识别出:这个局部变量(如 count)还要留给返回出去的匿名函数继续使用,因此不会在函数结束时销毁它,而是将它单独保留在内存中。
只要外部还有变量持有这个闭包,该变量就会一直存在,直到没有任何地方再使用它时,才会被系统自动回收。
2. 使用闭包时,内存方面有什么需要注意的?
正因为闭包会延长外层变量的存活时间,在实际开发中,不要让一个长期存活的闭包无意间捕获体积很大的切片或数据块。
只要这个闭包没有被释放,它引用的那块大内存就会一直占着位置无法回收。平时写闭包时,只让它引用真正需要用到的那几个小变量即可。
