1、Go语言支持闭包
2、Go语言能通过escape analyze识别出变量的作用域，自动将变量在堆上分配。将闭包环境变量在堆上分配是Go实现闭包的基础。
3、返回闭包时并不是单纯返回一个函数，而是返回了一个结构体，记录下函数返回地址和引用的环境中的变量地址。

用途

函数式编程，匿名函数。

示例一

  1. package main
  3. import "fmt"
  5. func adder() func(int) int {
  6.     sum := 0
  7.     return func(x int) int {
  8.         fmt.Printf("sum addr=%p, x addr=%p\n", &sum, &x)
  9.         sum += x
  10.         return sum
  11.     }
  12. }
  14. func main() {
  15.     pos, neg := adder(), adder()
  16.     fmt.Printf("pos addr=%p, neg addr=%p\n", &pos, &neg)
  17.     for i := 0; i < 10; i++ {
  18.         fmt.Println(
  19.             pos(i),
  20.             neg(-2*i),
  21.         )
  22.     }
  23. }

输出如下：

  1. pos addr=0xc000006028, neg addr=0xc000006030
  2. sum addr=0xc0000180d8, x addr=0xc0000180f8
  3. sum addr=0xc0000180f0, x addr=0xc000018120
  4. 0 0
  5. sum addr=0xc0000180d8, x addr=0xc000018130
  6. sum addr=0xc0000180f0, x addr=0xc000018138
  7. 1 -2
  8. sum addr=0xc0000180d8, x addr=0xc000018160
  9. sum addr=0xc0000180f0, x addr=0xc000018168
  10. 3 -6
  11. sum addr=0xc0000180d8, x addr=0xc000018190
  12. sum addr=0xc0000180f0, x addr=0xc000018198
  13. 6 -12
  14. sum addr=0xc0000180d8, x addr=0xc0000181c0
  15. sum addr=0xc0000180f0, x addr=0xc0000181c8
  16. 10 -20
  17. sum addr=0xc0000180d8, x addr=0xc0000181f0
  18. sum addr=0xc0000180f0, x addr=0xc0000181f8
  19. 15 -30
  20. sum addr=0xc0000180d8, x addr=0xc000018220
  21. sum addr=0xc0000180f0, x addr=0xc000018228
  22. 21 -42
  23. sum addr=0xc0000180d8, x addr=0xc000018250
  24. sum addr=0xc0000180f0, x addr=0xc000018258
  25. 28 -56
  26. sum addr=0xc0000180d8, x addr=0xc000018280
  27. sum addr=0xc0000180f0, x addr=0xc000018288
  28. 36 -72
  29. sum addr=0xc0000180d8, x addr=0xc0000182b0
  30. sum addr=0xc0000180f0, x addr=0xc0000182b8
  31. 45 -90

因为pos和neg都调用了adder()参数，返回了不同的闭包，所以sum在堆上分配的地址空间也不同；
所以针对pos(i)是求sum=sum+i，即0+0=0，0+1=1, 1+2=3，3+3=6…
neg是求sum=sum+(-2i)，即0+(-20)=0，0+(-21)=-2，-2+(-22)=-6….

示例二

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var flist []func()
  7.     for i := 0; i < 3; i++ {
  8.         fmt.Printf("A: addr=%p, value=%d\n", &i, i)
  9.         flist = append(flist, func() {
  10.             fmt.Printf("B: addr=%p, value=%d\n", &i, i)
  11.         })
  12.     }
  14.     for _, f := range flist {
  15.         f()
  16.     }
  17. }

输出如下：

  1. A: addr=0xc0000180d8, value=0
  2. A: addr=0xc0000180d8, value=1
  3. A: addr=0xc0000180d8, value=2
  4. B: addr=0xc0000180d8, value=3
  5. B: addr=0xc0000180d8, value=3
  6. B: addr=0xc0000180d8, value=3

这个比较好理解，三个匿名函数闭包中的i是同一个变量i，在堆上是同一个，最后i的值为3，所以三次都输出3。

示例三

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var flist []func()
  7.     for i := 0; i < 3; i++ {
  8.         //给i变量重新赋值
  9.         i := i
  10.         fmt.Printf("A: addr=%p, value=%d\n", &i, i)
  11.         flist = append(flist, func() {
  12.             fmt.Printf("B: addr=%p, value=%d\n", &i, i)
  13.         })
  14.     }
  15.     for _, f := range flist {
  16.         f()
  17.     }
  18. }

输出结果如下：

  1. A: addr=0xc0000180d8, value=0
  2. A: addr=0xc0000180f8, value=1
  3. A: addr=0xc000018118, value=2
  4. B: addr=0xc0000180d8, value=0
  5. B: addr=0xc0000180f8, value=1
  6. B: addr=0xc000018118, value=2

i被重新赋值，传入闭包函数的i为新的地址，所以三个闭包函数分别为1,2,3

参考

Go语言中的闭包
Golang中闭包的实现原理