Go 闭包

闭包是什么?

在正式认识闭包之前,我们先看一个很常见的小需求:如果要写一个计数器函数,每调用一次就让结果加 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. 使用闭包时,内存方面有什么需要注意的?

正因为闭包会延长外层变量的存活时间,在实际开发中,不要让一个长期存活的闭包无意间捕获体积很大的切片或数据块。

只要这个闭包没有被释放,它引用的那块大内存就会一直占着位置无法回收。平时写闭包时,只让它引用真正需要用到的那几个小变量即可。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号