Golang中的闭包怎么实现

这篇文章主要介绍了Golang中的闭包怎么实现的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇Golang中的闭包怎么实现文章都会有所收获，下面我们一起来看看吧。

1、什么是闭包？

在真正讲述闭包之前，我们先铺垫一点知识点：

• 函数式编程

• 函数作用域

• 作用域的继承关系

1.1 前提知识铺垫

1.2.1 函数式编程

函数式编程是一种编程范式，看待问题的一种方式，每一个函数都是为了用小函数组织成为更大的函数，函数的参数也是函数，函数返回的也是函数。我们常见的编程范式有：

• 命令式编程：

• 主要思想为：关注计算机执行的步骤，也就是一步一步告诉计算机先做什么再做什么。

• 先把解决问题步骤规范化，抽象为某种算法，然后编写具体的算法去实现，一般只要支持过程化编程范式的语言，我们都可以称为过程化编程语言，比如 BASIC，C 等。

• 声明式编程：

• 主要思想为：告诉计算机应该做什么，但是不指定具体要怎么做，比如 SQL，网页编程的 HTML，CSS。

• 函数式编程：

• 只关注做什么而不关注怎么做，有一丝丝声明式编程的影子，但是更加侧重于”函数是第一位“的原则，也就是函数可以出现在任何地方，参数、变量、返回值等等。

函数式编程可以认为是面向对象编程的对立面，一般只有一些编程语言会强调一种特定的编程方式，大多数的语言都是多范式语言，可以支持多种不同的编程方式，比如 JavaScript ，Go 等。

函数式编程是一种思维方式，将电脑运算视为函数的计算，是一种写代码的方法论，其实我应该聊函数式编程，然后再聊到闭包，因为闭包本身就是函数式编程里面的一个特点之一。

在函数式编程中，函数是头等对象，意思是说一个函数，既可以作为其它函数的输入参数值，也可以从函数中返回值，被修改或者被分配给一个变量。(维基百科)

一般纯函数编程语言是不允许直接使用程序状态以及可变对象的，函数式编程本身就是要避免使用 共享状态，可变状态，尽可能避免产生 副作用。

函数式编程一般具有以下特点：

• 函数是第一等公民：函数的地位放在第一位，可以作为参数，可以赋值，可以传递，可以当做返回值。

• 没有副作用：函数要保持纯粹独立，不能修改外部变量的值，不修改外部状态。

• 引用透明：函数运行不依赖外部变量或者状态，相同的输入参数，任何情况，所得到的返回值都应该是一样的。

1.2.2 函数作用域

作用域（scope），程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。

通俗易懂的说，函数作用域是指函数可以起作用的范围。函数有点像盒子，一层套一层，作用域我们可以理解为是个封闭的盒子，也就是函数的局部变量，只能在盒子内部使用，成为独立作用域。

函数内的局部变量，出了函数就跳出了作用域，找不到该变量。（里层函数可以使用外层函数的局部变量，因为外层函数的作用域包括了里层函数），比如下面的 innerTmep 出了函数作用域就找不到该变量，但是 outerTemp 在内层函数里面还是可以使用。

不管是任何语言，基本存在一定的内存回收机制，也就是回收用不到的内存空间，回收的机制一般和上面说的函数的作用域是相关的，局部变量出了其作用域，就有可能被回收，如果还被引用着，那么就不会被回收。

1.2.3 作用域的继承关系

所谓作用域继承，就是前面说的小盒子可以继承外层大盒子的作用域，在小盒子可以直接取出大盒子的东西，但是大盒子不能取出小盒子的东西，除非发生了逃逸（逃逸可以理解为小盒子的东西给出了引用，大盒子拿到就可以使用）。一般而言，变量的作用域有以下两种：

• 全局作用域：作用于任何地方

• 局部作用域：一般是代码块，函数、包内，函数内部声明/定义的变量叫局部变量，作用域仅限于函数内部

1.2 闭包的定义

“多数情况下我们并不是先理解后定义，而是先定义后理解“，先下定义，读不懂没关系：

闭包（closure）是一个函数以及其捆绑的周边环境状态（lexical environment，词法环境）的引用的组合。 换而言之，闭包让开发者可以从内部函数访问外部函数的作用域。 闭包会随着函数的创建而被同时创建。

一句话表述：

$$\text{闭包}=\text{函数}+\text{引用环境}$$

以上定义找不到 Go语言 这几个字眼，聪明的同学肯定知道，闭包是和语言无关的，不是 JavaScript 特有的，也不是 Go 特有的，而是函数式编程语言的特有的，是的，你没有看错，任何支持函数式编程的语言都支持闭包，Go 和 JavaScript 就是其中之二， 目前 Java 目前版本也是支持闭包的，但是有些人可能认为不是完美的闭包，详细情况文中讨论。

1.3 闭包的写法

1.3.1 初看闭包

下面是一段闭包的代码：

import "fmt"func main() {sumFunc := lazySum([]int{1, 2, 3, 4, 5})fmt.Println("等待一会")fmt.Println("结果：", sumFunc())}func lazySum(arr []int) func() int {fmt.Println("先获取函数，不求结果")var sum = func() int {fmt.Println("求结果...")result := 0for _, v := range arr {result = result + v}return result}return sum}

输出的结果：


先获取函数，不求结果等待一会求结果...结果： 15

上面的函数或许还可以更进一步，体现出捆绑函数和其周围的状态，我们加上一个次数 count：

import "fmt"func main() {sumFunc := lazySum([]int{1, 2, 3, 4, 5})fmt.Println("等待一会")fmt.Println("结果：", sumFunc())fmt.Println("结果：", sumFunc())fmt.Println("结果：", sumFunc())}func lazySum(arr []int) func() int {fmt.Println("先获取函数，不求结果")count := 0var sum = func() int {count++fmt.Println("第", count, "次求结果...")result := 0for _, v := range arr {result = result + v}return result}return sum}

上面代码输出什么呢？次数 count 会不会发生变化，count明显是外层函数的局部变量，但是在内存函数引用（捆绑），内层函数被暴露出去了，执行结果如下：


先获取函数，不求结果等待一会第 1 次求结果...结果： 15第 2 次求结果...结果： 15第 3 次求结果...结果： 15

• 函数体内嵌套了另外一个函数，并且返回值是一个函数。

• 内层函数被暴露出去，被外层函数以外的地方引用着，形成了闭包。

此时有人可能有疑问了，前面是lazySum（）被创建了 1 次，执行了 3 次，但是如果是 3 次执行都是不同的创建，会是怎么样呢？实验一下：

import "fmt"func main() {sumFunc := lazySum([]int{1, 2, 3, 4, 5})fmt.Println("等待一会")fmt.Println("结果：", sumFunc())sumFunc1 := lazySum([]int{1, 2, 3, 4, 5})fmt.Println("等待一会")fmt.Println("结果：", sumFunc1())sumFunc2 := lazySum([]int{1, 2, 3, 4, 5})fmt.Println("等待一会")fmt.Println("结果：", sumFunc2())}func lazySum(arr []int) func() int {fmt.Println("先获取函数，不求结果")count := 0var sum = func() int {count++fmt.Println("第", count, "次求结果...")result := 0for _, v := range arr {result = result + v}return result}return sum}

执行的结果如下，每次执行都是第 1 次：


先获取函数，不求结果等待一会第 1 次求结果...结果： 15先获取函数，不求结果等待一会第 1 次求结果...结果： 15先获取函数，不求结果等待一会第 1 次求结果...结果： 15

闭包被创建的时候，引用的外部变量count就已经被创建了 1 份，也就是各自调用是没有关系的。

继续抛出一个问题，**如果一个函数返回了两个函数，这是一个闭包还是两个闭包呢？**下面我们实践一下：

一次返回两个函数，一个用于计算加和的结果，一个计算乘积：

import "fmt"func main() {sumFunc, productSFunc := lazyCalculate([]int{1, 2, 3, 4, 5})fmt.Println("等待一会")fmt.Println("结果：", sumFunc())fmt.Println("结果：", productSFunc())}func lazyCalculate(arr []int) (func() int, func() int) {fmt.Println("先获取函数，不求结果")count := 0var sum = func() int {count++fmt.Println("第", count, "次求加和...")result := 0for _, v := range arr {result = result + v}return result}var product = func() int {count++fmt.Println("第", count, "次求乘积...")result := 0for _, v := range arr {result = result * v}return result}return sum, product}

运行结果如下：


先获取函数，不求结果等待一会第 1 次求加和...结果： 15第 2 次求乘积...结果： 0

闭包绑定了周围的状态，我理解此时的函数就拥有了状态，让函数具有了对象所有的能力，函数具有了状态。

1.3.2 闭包中的指针和值

上面的例子，我们闭包中用到的都是数值，如果我们传递指针，会是怎么样的呢？

import "fmt"func main() {i := 0testFunc := test(&i)testFunc()fmt.Printf("outer i = %d\n", i)}func test(i *int) func() {*i = *i + 1fmt.Printf("test inner i = %d\n", *i)return func() {*i = *i + 1fmt.Printf("func inner i = %d\n", *i)}}

运行结果如下：


test inner i = 1func inner i = 2outer i = 2

当我们函数的参数是指针的时候，参数会拷贝一份这个指针地址，当做参数进行传递，因为本质还是地址，所以内部修改的时候，仍然可以对外部产生影响。

闭包里面的数据其实地址也是一样的，下面的实验可以证明：

func main() {i := 0testFunc := test(&i)testFunc()fmt.Printf("outer i address %v\n", &i)}func test(i *int) func() {*i = *i + 1fmt.Printf("test inner i address %v\n", i)return func() {*i = *i + 1fmt.Printf("func inner i address %v\n", i)}}

输出如下, 因此可以推断出，闭包如果引用外部环境的指针数据，只是会拷贝一份指针地址数据，而不是拷贝一份真正的数据(==先留个问题：拷贝的时机是什么时候呢==)：


test inner i address 0xc0003fab98func inner i address 0xc0003fab98outer i address 0xc0003fab98

1.3.2 闭包延迟化

上面的例子仿佛都在告诉我们，闭包创建的时候，数据就已经拷贝了，但是真的是这样么？

下面是继续前面的实验：

func main() {i := 0testFunc := test(&i)i = i + 100fmt.Printf("outer i before testFunc  %d\n", i)testFunc()fmt.Printf("outer i after testFunc %d\n", i)}func test(i *int) func() {*i = *i + 1fmt.Printf("test inner i = %d\n", *i)return func() {*i = *i + 1fmt.Printf("func inner i = %d\n", *i)}}

我们在创建闭包之后，把数据改了，之后执行闭包，答案肯定是真实影响闭包的执行，因为它们都是指针，都是指向同一份数据：


test inner i = 1outer i before testFunc  101func inner i = 102outer i after testFunc 102

import "fmt"func main() {sumFunc := lazySum([]int{1, 2, 3, 4, 5})fmt.Println("等待一会")fmt.Println("结果：", sumFunc())}func lazySum(arr []int) func() int {fmt.Println("先获取函数，不求结果")count := 0var sum = func() int {fmt.Println("第", count, "次求结果...")result := 0for _, v := range arr {result = result + v}return result}count = count + 100return sum}

等待一会第 100 次求结果...结果： 15

如果还没看明白没关系，我们再来一个例子：

func main() {funcs := testFunc(100)for _, v := range funcs {v()}}func testFunc(x int) []func() {var funcs []func()values := []int{1, 2, 3}for _, val := range values {funcs = append(funcs, func() {fmt.Printf("testFunc val = %d\n", x+val)})}return funcs}

上面的例子，我们闭包返回的是函数数组，本意我们想入每一个 val 都不一样，但是实际上 val都是一个值，==也就是执行到return funcs 的时候（或者真正执行闭包函数的时候）才绑定的 val值==（关于这一点，后面还有个Demo可以证明），此时 val的值是最后一个 3,最终输出结果都是 103:


testFunc val = 103testFunc val = 103testFunc val = 103

下面的例子可以有效的解答：

import ("fmt""time")func main() {sumFunc := lazySum([]int{1, 2, 3, 4, 5})fmt.Println("等待一会")fmt.Println("结果：", sumFunc())time.Sleep(time.Duration(3) * time.Second)fmt.Println("结果：", sumFunc())}func lazySum(arr []int) func() int {fmt.Println("先获取函数，不求结果")count := 0var sum = func() int {count++fmt.Println("第", count, "次求结果...")result := 0for _, v := range arr {result = result + v}return result}go func() {time.Sleep(time.Duration(1) * time.Second)count = count + 100fmt.Println("go func 修改后的变量 count：", count)}()return sum}

输出结果如下：


先获取函数，不求结果等待一会第 1 次求结果...结果： 15go func 修改后的变量 count： 101第 102 次求结果...结果： 15

其实本质上，Go Routine的匿名函数的延迟绑定就是闭包的延迟绑定，上面的例子中，go func(){}获取到的就是最新的值，而不是原始值0。

总结一下上面的验证点：

• 闭包每次返回都是一个新的实例，每个实例都有一份自己的环境。

• 同一个实例多次执行，会使用相同的环境。

• 闭包如果逃逸的是指针，会相互影响，因为绑定的是指针，相同指针的内容修改会相互影响。

• 闭包并不是在声明时绑定的值，声明后只是预留了外部环境（逃逸分析），真正执行闭包函数时，会获取最新的外部环境的值（也称为延迟绑定）。

• Go Routine的匿名函数的延迟绑定本质上就是闭包的延迟绑定。

2、闭包的好处与坏处？

2.1 好处

纯函数没有状态，而闭包则是让函数轻松拥有了状态。但是凡事都有两面性，一旦拥有状态，多次调用，可能会出现不一样的结果，就像是前面测试的 case 中一样。那么问题来了：

Q：如果不支持闭包的话，我们想要函数拥有状态，需要怎么做呢？

A： 需要使用全局变量，让所有函数共享同一份变量。

但是我们都知道全局变量有以下的一些特点（在不同的场景，优点会变成缺点）：

• 常驻于内存之中，只要程序不停会一直在内存中。

• 污染全局，大家都可以访问，共享的同时不知道谁会改这个变量。

闭包可以一定程度优化这个问题：

• 不需要使用全局变量，外部函数局部变量在闭包的时候会创建一份，生命周期与函数生命周期一致，闭包函数不再被引用的时候，就可以回收了。

• 闭包暴露的局部变量，外界无法直接访问，只能通过函数操作，可以避免滥用。

除了以上的好处，像在 JavaScript 中，没有原生支持私有方法，可以靠闭包来模拟私有方法，因为闭包都有自己的词法环境。

2.2 坏处

函数拥有状态，如果处理不当，会导致闭包中的变量被误改，但这是编码者应该考虑的问题，是预期中的场景。

闭包中如果随意创建，引用被持有，则无法销毁，同时闭包内的局部变量也无法销毁，过度使用闭包会占有更多的内存，导致性能下降。一般而言，能共享一份闭包（共享闭包局部变量数据），不需要多次创建闭包函数，是比较优雅的方式。

3、闭包怎么实现的？

从上面的实验中，我们可以知道，闭包实际上就是外部环境的逃逸，跟随着闭包函数一起暴露出去。

我们用以下的程序进行分析：

import "fmt"func testFunc(i int) func() int {i = i * 2testFunc := func() int {i++return i}i = i * 2return testFunc}func main() {test := testFunc(1)fmt.Println(test())}

执行结果如下：


5

 go build --gcflags=-m main.go

可以看到 变量 i被移到堆中，也就是本来是局部变量，但是发生逃逸之后，从栈里面放到堆里面，同样的 test()函数由于是闭包函数，也逃逸到堆上。

下面我们用命令行来看看汇编代码：

go tool compile -N -l -S main.go

生成代码比较长，我截取一部分：

"".testFunc STEXT size=218 args=0x8 locals=0x38 funcid=0x0 align=0x0        0x0000 00000 (main.go:5)        TEXT    "".testFunc(SB), ABIInternal, $56-8        0x0000 00000 (main.go:5)        CMPQ    SP, 16(R14)        0x0004 00004 (main.go:5)        PCDATA  $0, $-2        0x0004 00004 (main.go:5)        JLS     198        0x000a 00010 (main.go:5)        PCDATA  $0, $-1        0x000a 00010 (main.go:5)        SUBQ    $56, SP        0x000e 00014 (main.go:5)        MOVQ    BP, 48(SP)        0x0013 00019 (main.go:5)        LEAQ    48(SP), BP        0x0018 00024 (main.go:5)        FUNCDATA        $0, gclocals·69c1753bd5f81501d95132d08af04464(SB)        0x0018 00024 (main.go:5)        FUNCDATA        $1, gclocals·d571c0f6cf0af59df28f76498f639cf2(SB)        0x0018 00024 (main.go:5)        FUNCDATA        $5, "".testFunc.arginfo1(SB)        0x0018 00024 (main.go:5)        MOVQ    AX, "".i+64(SP)        0x001d 00029 (main.go:5)        MOVQ    $0, "".~r0+16(SP)        0x0026 00038 (main.go:5)        LEAQ    type.int(SB), AX        0x002d 00045 (main.go:5)        PCDATA  $1, $0        0x002d 00045 (main.go:5)        CALL    runtime.newobject(SB)        0x0032 00050 (main.go:5)        MOVQ    AX, "".&i+40(SP)        0x0037 00055 (main.go:5)        MOVQ    "".i+64(SP), CX        0x003c 00060 (main.go:5)        MOVQ    CX, (AX)        0x003f 00063 (main.go:6)        MOVQ    "".&i+40(SP), CX        0x0044 00068 (main.go:6)        MOVQ    "".&i+40(SP), DX        0x0049 00073 (main.go:6)        MOVQ    (DX), DX        0x004c 00076 (main.go:6)        SHLQ    $1, DX        0x004f 00079 (main.go:6)        MOVQ    DX, (CX)        0x0052 00082 (main.go:7)        LEAQ    type.noalg.struct { F uintptr; "".i *int }(SB), AX        0x0059 00089 (main.go:7)        PCDATA  $1, $1        0x0059 00089 (main.go:7)        CALL    runtime.newobject(SB)        0x005e 00094 (main.go:7)        MOVQ    AX, ""..autotmp_3+32(SP)        0x0063 00099 (main.go:7)        LEAQ    "".testFunc.func1(SB), CX        0x006a 00106 (main.go:7)        MOVQ    CX, (AX)        0x006d 00109 (main.go:7)        MOVQ    ""..autotmp_3+32(SP), CX        0x0072 00114 (main.go:7)        TESTB   AL, (CX)        0x0074 00116 (main.go:7)        MOVQ    "".&i+40(SP), DX        0x0079 00121 (main.go:7)        LEAQ    8(CX), DI        0x007d 00125 (main.go:7)        PCDATA  $0, $-2        0x007d 00125 (main.go:7)        CMPL    runtime.writeBarrier(SB), $0        0x0084 00132 (main.go:7)        JEQ     136        0x0086 00134 (main.go:7)        JMP     142        0x0088 00136 (main.go:7)        MOVQ    DX, 8(CX)        0x008c 00140 (main.go:7)        JMP     149        0x008e 00142 (main.go:7)        CALL    runtime.gcWriteBarrierDX(SB)        0x0093 00147 (main.go:7)        JMP     149        0x0095 00149 (main.go:7)        PCDATA  $0, $-1        0x0095 00149 (main.go:7)        MOVQ    ""..autotmp_3+32(SP), CX        0x009a 00154 (main.go:7)        MOVQ    CX, "".testFunc+24(SP)        0x009f 00159 (main.go:11)       MOVQ    "".&i+40(SP), CX        0x00a4 00164 (main.go:11)       MOVQ    "".&i+40(SP), DX        0x00a9 00169 (main.go:11)       MOVQ    (DX), DX        0x00ac 00172 (main.go:11)       SHLQ    $1, DX        0x00af 00175 (main.go:11)       MOVQ    DX, (CX)        0x00b2 00178 (main.go:12)       MOVQ    "".testFunc+24(SP), AX        0x00b7 00183 (main.go:12)       MOVQ    AX, "".~r0+16(SP)        0x00bc 00188 (main.go:12)       MOVQ    48(SP), BP        0x00c1 00193 (main.go:12)       ADDQ    $56, SP        0x00c5 00197 (main.go:12)       RET        0x00c6 00198 (main.go:12)       NOP        0x00c6 00198 (main.go:5)        PCDATA  $1, $-1        0x00c6 00198 (main.go:5)        PCDATA  $0, $-2        0x00c6 00198 (main.go:5)        MOVQ    AX, 8(SP)        0x00cb 00203 (main.go:5)        CALL    runtime.morestack_noctxt(SB)        0x00d0 00208 (main.go:5)        MOVQ    8(SP), AX        0x00d5 00213 (main.go:5)        PCDATA  $0, $-1        0x00d5 00213 (main.go:5)        JMP     0

可以看到闭包函数实际上底层也是用结构体new创建出来的：

使用的就是堆上面的 i：

也就是返回函数的时候，实际上返回结构体，结构体里面记录了函数的引用环境。

4、浅聊一下

4.1 Java 支不支持闭包？

网上有很多种看法，实际上 Java 虽然暂时不支持返回函数作为返参，但是Java 本质上还是实现了闭包的概念的，所使用的的方式是内部类的形式，因为是内部类，所以相当于自带了一个引用环境，算是一种不完整的闭包。

目前有一定限制，比如是 final 声明的，或者是明确定义的值，才可以进行传递：

4.2 函数式编程的前景怎么样？

下面是Wiki的内容：

函数式编程长期以来在学术界流行，但几乎没有工业应用。造成这种局面的主因是函数式编程常被认为严重耗费CPU和存储器资源[18] ，这是由于在早期实现函数式编程语言时并没有考虑过效率问题，而且面向函数式编程特性，如保证参照透明性等，要求独特的数据结构和算法。[19]

然而，最近几种函数式编程语言已经在商业或工业系统中使用[20]，例如：

• Erlang，它由瑞典公司爱立信在20世纪80年代后期开发，最初用于实现容错电信系统。此后，它已在Nortel、Facebook、Électricité de France和WhatsApp等公司作为流行语言创建一系列应用程序。[21][22]

• Scheme，它被用作早期Apple Macintosh计算机上的几个应用程序的基础，并且最近已应用于诸如训练模拟软件和望远镜控制等方向。

• OCaml，它于20世纪90年代中期推出，已经在金融分析，驱动程序验证，工业机器人编程和嵌入式软件静态分析等领域得到了商业应用。

• Haskell，它虽然最初是作为一种研究语言，也已被一系列公司应用于航空航天系统，硬件设计和网络编程等领域。

其他在工业中使用的函数式编程语言包括多范型的Scala[23]、F#，还有Wolfram语言、Common Lisp、Standard ML和Clojure等。

关于“Golang中的闭包怎么实现”这篇文章的内容就介绍到这里，感谢各位的阅读！相信大家对“Golang中的闭包怎么实现”知识都有一定的了解，大家如果还想学习更多知识，欢迎关注编程网行业资讯频道。