闭包，其他很多开发语言也有，但是很多开发者对闭包感觉很难懂，也很难用，甚至干脆弃之不用。但既然很多语言包括 Go 语言也提供了闭包这种语法，就肯定有其必要性和某些适用场景。这一节，我们就实践一下 Go 语言的闭包，希望可以了解其特点，理解其原理，知道其适用场景，以便在编程开发中用好闭包，为编程扩展思路发挥作用。

闭包的概念定义

  有人说闭包是由函数及其相关应用环境组合而成的实体，也有人说闭包是引用了自由变量的函数，还有人说闭包是指有权访问另一个函数作用域中的变量的函数等等。但是大家听到这些是不是感觉还是很难一下子理解，不能有一个很直观的感性认识。

  个人总结 Go 语言闭包概念的通俗理解，是如果一个函数A的返回值是匿名函数B，且这个匿名函数B的函数体内使用了函数A的局部变量C（包括参数），（那么局部变量C在匿名函数体内的使用是引用关系，且会像公共变量一样常驻内存），局部变量C + 匿名函数B 就是闭包。

// test01 项目的 main 包，文件名 main.go
package main

import (
	"fmt"
)

func abc() func() int {
    
	x := 10              // 因下面匿名函数使用了 x，所以从这里开始
	return func() int {
    
		x += 1
		return x
	}                    // 到这里结束，称为闭包
}

// 主函数，程序入口
func main() {
    
	f := abc()
	a := f()
	b := f()

	fmt.Println(a)
	fmt.Println(b)
}

  上述代码编译执行结果如下：

11
12

  第9~14行称为闭包，在第10行开始定义的匿名函数体里，使用了 abc 函数的局部变量 x（第11、12行）。

  第18行，变量 f 就代表了上面的匿名函数。

  第19、20行，两次调用匿名函数，得到的结果却不一样，很明显第12行返回的 x 不是像其他局部变量那样执行完函数就被销毁了，再次执行会被重新初始化，而更像是对外部变量的引用关系，会保留每次的修改值。

  示例演示的就是闭包的最明显特征，接下来我们深入理解闭包的一些特性及原理。

闭包引用记忆变量的理解

  说闭包对其所在函数内的局部变量是引用关系，其实这不是闭包的特例，我们先看一下普通函数与公共变量的关系。

// test01 项目的 main 包，文件名 main.go
package main

import (
	"fmt"
)

var x = 10

func f() int {
    
	x += 1
	return x
}

// 主函数，程序入口
func main() {
    
	a := f()
	b := f()

	fmt.Println(a)
	fmt.Println(b)
}

  上述代码编译执行结果如下：

11
12

  在本示例中我们定义了一个普通命名函数 f，函数体内的代码与上一个示例中的匿名函数一样，但在这里 x 是公共变量，根据之前我们实践过的可以得知，公共变量是可以穿透函数的，所以在函数内修改公共变量是会成功并记忆结果的。

  那么比较上一个示例，可以看出两个示例中的 x，对于使用它的两个函数（一个是匿名函数、一个是命名函数）来说，x 都是函数的外部变量，都是与函数处在同一个作用域，所以第一个示例中匿名函数体内可以修改 x 就很好理解了，原理是一样的，并没有特殊化，只是第一个示例的匿名函数和 x 是嵌入在 abc 函数内而已。

  问题来了，既然第一个示例中 x 也是 abc 函数内的局部变量，那么第一个示例代码执行完第18行后，x 不是应该被销毁了吗，有怎么会记忆后面两行调用匿名函数是对 x 的修改呢？这是需要理解的重点，Go 语言在执行到第18行后，发现有闭包，就将闭包引用的外部变量（abc 的局部变量 x）进行了升级处理（放到堆里）。使它在 abc 函数执行完之后不被销毁，但又不能像其他公共变量那样被其他函数看到（使用），只限于 abc 返回的函数可以调用。等于将 x 保留并藏了起来，仅对 abc 返回的匿名函数可见。所以这是闭包中引用的外部变量具备独有特性的根本所在。

  ▲ 闭包特性1：闭包匿名函数内修改外部变量，外部变量的值也会变，与公共变量一样是引用关系。

  ▲ 闭包特性2：闭包匿名函数中引用的外部函数的局部变量是不会被销毁的，效果上相当于闭包有了记忆特征。

闭包所在的函数多次调用

// test01 项目的 main 包，文件名 main.go
package main

import (
	"fmt"
)

func abc() func() int {
    
	x := 10
	return func() int {
    
		x += 1
		return x
	}
}

// 主函数，程序入口
func main() {
    
	f1 := abc()   // 第一次调用 abc
	a1 := f1()
	b1 := f1()
	f2 := abc()   // 第二次调用 abc
	a2 := f2()
	b2 := f2()

	fmt.Println("第一次调用 abc 后")
	fmt.Println(a1)
	fmt.Println(b1)
	fmt.Println("第二次调用 abc 后")
	fmt.Println(a2)
	fmt.Println(b2)
}

  上述代码编译执行结果如下：

第一次调用 abc 后
11
12
第二次调用 abc 后
11
12

  abc 是闭包所在的函数，在第25、28行分别调用了两次，分别得到两个函数 f1 和 f2，而 f2 又是在 f1 被调用两次后才返回的。也就是 f2 是在变量 x 被修改两次后又调用 abc 函数返回的匿名函数，稍不注意我们可能认为这时返回的 f2 匿名函数内引用的变量 x 的值应该是从 12 开始了。但根据运行结果看以看出，并不是这样，还是从 10 开始计算的。说明第二次调用又产生了一个新的变量，为其分配了新内存。

  其实这个原理也是遵循正常函数的特点，就是每次被调用，都会重新初始化其局部变量的特点。

  ▲ 闭包特性3：闭包所在的函数被多次调用时，返回的闭包引用的变量每次都是全新的一个外部变量的副本，各次之间产生的变量互不影响。

  ▲ 闭包特性4：闭包可以使引用的变量像公共变量一样常驻内存，但又不是全局可见，仅对闭包可见。

同一个函数返回多个闭包

// test01 项目的 main 包，文件名 main.go
package main

import (
	"fmt"
)

func abc(x int) (func(int) int, func(int) int) {
    
	f1 := func(i int) int {
    
		x += i
		return x
	}
	f2 := func(i int) int {
    
		x -= i
		return x
	}

	return f1, f2
}

// 主函数，程序入口
func main() {
    
	ff1, ff2 := abc(10)
	a1 := ff1(5)
	b1 := ff2(5)
	a2 := ff1(10)
	b2 := ff2(10)

	fmt.Println("ff1 加5后：", a1)
	fmt.Println("ff2 减5后：", b1)
	fmt.Println("ff1 加10后：", a2)
	fmt.Println("ff2 减10后：", b2)
}

  上述代码编译执行结果如下：

ff1 加5后： 15
ff2 减5后： 10
ff1 加10后： 20
ff2 减10后： 10

  示例中 abc 函数返回两个匿名函数，但是两个匿名函数都引用了 abc 函数的参数 x。由于函数的参数也属于函数的局部变量，所以这两个匿名函数也是闭包，参数变量 x 也就同样具备闭包引用函数的特性了。

  但这里有个新情况就是两个闭包引用了同一个变量 x，那在调用两个返回的闭包函数时，对变量 x 的影响是怎样的呢？通过示例输出的结果可以看出，在同一个函数内定义的两个闭包，如果都引用同一个变量，那么它们将共享使用这个变量，无论哪个闭包修改这个变量值都会生效。

  ▲ 闭包特性5：定义闭包时，外部函数的参数与该函数的局部变量同样都属于闭包的外部变量，具有同样的闭包特性。

  ▲ 闭包特性6：同一个函数定义多个闭包时，若引用了同一个外部变量，那它们将共享使用这个变量，不会单独创造副本。
.
.
上一页：Go语言实践[回顾]教程25–详解Go语言函数的延迟执行调用 defer

下一页：Go语言实践[回顾]教程27–详解Go语言结构体 struct 定义与面向对象编程思想
.