Go语言学习匿名函数与闭包
Posted 清风学塾
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go语言学习匿名函数与闭包相关的知识，希望对你有一定的参考价值。
前言
入坑 Go 语言已经大半年了，却没有写过一篇像样的技术文章，每次写一半就搁笔，然后就烂尾了。
几经思考，痛定思痛，决定金盆洗手，重新做人，哦不，重新开始写技术博文。
这段时间在研究Go语言闭包的过程中，发现了很多有意思的东西，也学到了不少内容，于是便以次为契机，重新开始技术文章的输出。
什么是闭包
闭包 是 Go 语言中一个重要特性，也是 函数式编程 中必不可少的角色。那么什么是 闭包 呢？
A closure is a function value that references variables from outside its body.
这是 A Tour of Go 上的定义，闭包 是一种引用了外部变量的函数。但我觉得这个定义还不够准确，闭包 应该是引用了外部变量的 匿名函数 。
看了很多文章，大多把 闭包 跟匿名函数混淆在了一起，也有很多人说，闭包 其实就是匿名函数，但其实两者是不能直接划等号的。
闭包 是一种特殊的匿名函数，是匿名函数的子集。所以在说 闭包 之前，我们先来看看 匿名函数 吧。
匿名函数
匿名函数 顾名思义，就是没有名字的函数。在Go语言中，函数是一等公民，也就是说，函数可以被赋值或者当作返回值和参数进行传递，在很多时候我们并不需要一个有名字的函数（而且命名确实是一项相当费劲的事），所以我们在某些场景下可以选择使用 匿名函数 。
举个例子：
func main(){
hello := func(){
fmt.Println("Hello World")
}
hello()
}
这是一个简单的例子，我们声明了一个 匿名函数 ，然后把它赋值给一个叫 hello 的变量，然后我们就能像调用函数那样使用它了。
这跟下面的代码效果是一样的：
func main(){
hello()
}
func hello(){
fmt.Println("Hello World")
}
我们还可以把 匿名函数 当作函数参数进行传递：
func main(){
doPrint("Hello World", func(s string){
fmt.Println(s)
})
}
type Printer func(string)
func doPrint(s string, printer Printer){
printer(s)
}
或者当作函数返回值进行返回：
func main(){
getPrinter()("Hello World")
}
type Printer func(string)
func getPrinter()Printer{
return func(s string){
fmt.Println(s)
}
}
匿名函数 跟普通函数在绝大多数场景下没什么区别，普通函数的函数名可以当作是与该函数绑定的函数常量。
一个函数主要包含两个信息:函数签名和函数体，函数的签名包括参数类型，返回值的类型，函数签名可以看做是函数的类型，函数的函数体即函数的值。所以一个接收匿名函数的变量的类型便是由函数的签名决定的，一个匿名函数被赋值给一个变量后，这个变量便只能接收同样签名的函数。
func main(){
hello := func(){
fmt.Println("Hello World")
} // 给 hello 变量赋值一个匿名函数
hello()
hello = func(){
fmt.Println("Hello World2")
} // 重新赋值新的匿名函数
hello()
hello = hi // 将一个普通函数赋值给 hello
hello()
hello = func(int){
fmt.Println("Hello World3")
} // 这里编译器会报错
hello()
}
func hi(){
fmt.Println("Hi")
}
匿名函数 跟普通函数的微小区别在于 匿名函数 赋值的变量可以重新设置新的 匿名函数，但普通函数的函数名是与特定函数绑定的，无法再将其它函数赋值给它。这就类似于变量与常量之间的区别。
闭包的特性
说完了 匿名函数，我们再回过头来看看 闭包。
闭包是指由一个拥有许多变量和绑定了这些变量的环境的匿名函数闭包=函数+引用环境
听起来有点绕，什么是 引用环境呢？
引用环境是指在程序执行中的某个点所有处于活跃状态的变量所组成的集合。
由于闭包把函数和运行时的引用环境打包成为一个新的整体，所以就解决了函数编程中的嵌套所引发的问题。
当每次调用包含闭包的函数时都将返回一个新的闭包实例，这些实例之间是隔离的，分别包含调用时不同的引用环境现场。不同于函数，闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。
简单来说，闭包 就是引用了外部变量的匿名函数。不太明白？没关系，让我们先来看一个栗子：
func adder() func() int {
var i = 0
return func() int {
i++
return i
}
}
这是用闭包实现的简单累加器，这一部分便是闭包，它引用在其作用域范围之外的变量i。
func() int {
i++
return i
}
可以这样使用：
func main() {
a := adder()
fmt.Println(a())
fmt.Println(a())
fmt.Println(a())
fmt.Println(a())
b := adder()
fmt.Println(b())
fmt.Println(b())
}
输出如下：
1
2
3
4
1
2
上述例子中，adder 是一个函数，没有入参，返回值是一个返回 int 类型的无参函数，也就是说调用 adder 函数会返回一个函数，这个函数的返回值是 int 类型，且不接收参数。
在 main 方法中:
a := adder()
这里是将调用后得到的函数赋值给了变量 a ，随后进行了四次函数调用和输出：
fmt.Println(a())
fmt.Println(a())
fmt.Println(a())
fmt.Println(a())
也许你还是会感到困惑，i 是 adder 函数里的变量，调用完成之后变量的生命周期不久结束了吗？为什么还能不断累加？
这就涉及到闭包的另一个重要话题了：闭包 会让被引用的局部变量从栈逃逸到堆上，从而使其能在其作用域范围之外存活。闭包 “捕获”了和它在同一作用域的其它常量和变量。这就意味着当闭包被调用的时候，不管在程序什么地方调用，闭包能够使用这些常量或者变量。它不关心这些捕获了的变量和常量是否已经超出了作用域，只要闭包还在使用它们，这些变量就还会存在。
匿名函数和闭包的使用
可以利用匿名函数和闭包可以实现很多有意思的功能，比如上面的累加器，便是利用了 闭包 的作用域隔离特性，每调用一次 adder 函数，就会生成一个新的累加器，使用新的变量 i，所以在调用 b() 时，仍旧会从1开始输出。
再来看几个匿名函数和闭包应用的例子。
工厂函数
工厂函数即生产函数的函数，调用工厂函数可以得到其内嵌函数的引用，每次调用都可以得到一个新的函数引用。
func getFibGen() func() int {
f1 := 0
f2 := 1
return func() int {
f2, f1 = f1 + f2, f2
return f1
}
}
func main() {
gen := getFibGen()
for i := 0; i < 10; i++ {
fmt.Println(gen())
}
}
上面是利用闭包实现的函数工厂来求解斐波那契数列问题，调用 getFibGen 函数之后，gen 便获得了内嵌函数的引用，且该函数引用里一直持有 f1 和 f2 的引用，每执行一次 gen()，便会运算一次斐波那契的递推关系式：
func() int {
f2, f1 = f1 + f2, f2
return f1
}
输出如下：
1
1
2
3
5
8
13
21
34
55
由于闭包能构造出单独的变量环境，可以很好的实现环境隔离，所以很适合应用于函数工厂，在实现功能时保存某些状态变量。
装饰器/中间件
修饰器是指在不改变对象的内部结构情况下，动态地扩展对象的功能。通过创建一个装饰器，来包装真实的对象。使用闭包很容易实现装饰器模式。
在 gin 中的 Middleware 便是使用装饰器模式来实现的。比如我们可以这样实现一个自定义的 Logger：
func Logger() gin.HandlerFunc {
return func(context *gin.Context) {
host := context.Request.Host
url := context.Request.URL
method := context.Request.Method
fmt.Printf("%s::%s \t %s \t %s \n", time.Now().Format("2006-01-02 15:04:05"), host, url, method)
context.Next()
fmt.Println("response status: ", context.Writer.Status())
}
}
这是在 gin 中利用 匿名函数 实现的自定义日志中间件，在 gin 中，类似的用法十分常见。
defer
这是匿名函数和闭包最常用的地方，我们会经常在 defer 函数中使用匿名函数和闭包来做释放锁，关闭连接，处理 panic 等函数善后工作。
func main() {
defer func() {
if ok := recover(); ok != nil {
fmt.Println("recover from panic")
}
}()
panic("error")
}
gorutine
匿名函数和闭包还有一个十分常用的场景，那便是在启动 gorutine 时使用。
func main(){
go func(){
fmt.Println("Hello World")
}()
time.Sleep(1 * time.Second)
}
重新声明一下，在函数内部引用了外部变量便是闭包，否则就是匿名函数。
func main(){
hello := "Hello World"
go func(){
fmt.Println(hello)
}()
time.Sleep(1 * time.Second)
}
context
在cancelContext中也使用到了闭包：
// A CancelFunc tells an operation to abandon its work.
// A CancelFunc does not wait for the work to stop.
// A CancelFunc may be called by multiple goroutines simultaneously.
// After the first call, subsequent calls to a CancelFunc do nothing.
type CancelFunc func()
// WithCancel returns a copy of parent with a new Done channel. The returned
// context's Done channel is closed when the returned cancel function is called
// or when the parent context's Done channel is closed, whichever happens first.
//
// Canceling this context releases resources associated with it, so code should
// call cancel as soon as the operations running in this Context complete.
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
c := newCancelCtx(parent)
propagateCancel(parent, &c)
return &c, func() { c.cancel(true, Canceled) }
}
// newCancelCtx returns an initialized cancelCtx.
func newCancelCtx(parent Context) cancelCtx {
return cancelCtx{Context: parent}
}
闭包的陷阱
闭包很好用，但在某些场景下，也十分具有欺骗性，稍有不慎，就会掉入其陷阱里。
不如先来看一个例子：
for j := 0; j < 2; j++ {
defer func() {
fmt.Println(j)
}()
}
你猜会输出什么？
2
2
这是因为在 defer 中使用的闭包引用了外部变量 j 。
闭包中持有的是外部变量的引用
这是很容易犯的错误，在循环体中使用 defer，来关闭连接，释放资源，但由于闭包内持有的是外部变量的引用，在这里持有的是变量 j 的引用，defer 会在函数执行完成前调用闭包，在开始执行闭包时，j 的值已经是2了。
那么这个问题应该如何修复呢？有两种方式，一种是重新定义变量：
for j := 0; j < 2; j++ {
k := j
defer func() {
fmt.Println(k)
}()
}
在循环体里，每次循环都定义了一个新的变量 k 来获取原变量 j 的值，因此每次调用闭包时，引用的是不同的变量 k，从而达到变量隔离的效果。
另一种方式是把变量当成参数传入：
for j := 0; j < 2; j++ {
defer func(k int) {
fmt.Println(k)
}(j)
}
这里每次调用闭包时，传入的都是变量 j 的值，虽然 defer 仍会在函数执行完成前调用，但传入闭包的参数值却是先计算好的，因而能够正确输出。
为了更好的理解这一点，我们再来看一个例子：
package main
import "fmt"
func main() {
x, y := 1, 2
defer func(a int) {
fmt.Printf("x:%d,y:%d\n", a, y)
}(x)
x += 1
y += 1
fmt.Println(x, y)
}
输出如下：
2 3
x:1,y:3
另外，由于闭包会使得其持有的外部变量逃逸出原有的作用域，所以使用不当可能会造成内存泄漏，这一点由于相当具有隐蔽性，所以也需要谨慎对待。
总结
闭包是一种特殊的匿名函数，是由函数体和引用的外部变量一起组成，可以看成类似如下结构：
type FF struct {
F unitptr
A *int
B *int
X *int // 如果X是string/[]int，那么这里应该为*string，*[]int
}
在Go语言中，闭包的应用十分广泛，掌握了闭包的使用可以让你在写代码时能更加游刃有余，也可以避免很多不必要的麻烦。所以是必须要掌握的一个知识点。
至此，关于闭包的内容就完结了，希望能对你有帮助。
以上是关于Go语言学习匿名函数与闭包的主要内容，如果未能解决你的问题，请参考以下文章