彻底理解闭包实现原理

技术分享 4年前 (2022-10-26) 0 999+

关注

前言

闭包对于一个长期写 Java 的开发者来说估计鲜有耳闻，我在写 Python 和 Go 之前也是没怎么了解，光这名字感觉就有点"神秘莫测"，这篇文章的主要目的就是从编译器的角度来分析闭包，彻底搞懂闭包的实现原理。

函数一等公民

一门语言在实现闭包之前首先要具有的特性就是：First class function 函数是第一公民。

简单来说就是函数可以像一个普通的值一样在函数中传递，也能对变量赋值。

先来看看在 Go 里是如何编写的：

package main  import "fmt"  var varExternal int  func f1() func(int) int { 	varInner := 20 	innerFun := func(a int) int { 		fmt.Println(a) 		varExternal++ 		varInner++ 		return varInner 	} 	return innerFun }  func main() { 	varExternal = 10 	f2 := f1() 	for i := 0; i < 2; i++ { 		fmt.Printf("varInner=%d, varExternal=%d n", f2(i), varExternal) 	} 	fmt.Println("======")  	f3 := f1() 	for i := 0; i < 2; i++ { 		fmt.Printf("varInner=%d, varExternal=%d n", f3(i), varExternal) 	} }  // Output: 0 varInner=21, varExternal=11  1 varInner=22, varExternal=12  ====== 0 varInner=21, varExternal=13  1 varInner=22, varExternal=14

这里体现了闭包的两个重要特性，第一个自然就是函数可以作为值返回，同时也能赋值给变量。

第二个就是在闭包函数 f1() 对闭包变量 varInner 的访问，每个闭包函数的引用都会在自己的函数内部保存一份闭包变量 varInner，这样在调用过程中就不会互相影响。

从打印的结果中也能看出这个特性。

作用域

闭包之所以不太好理解的主要原因是它不太符合自觉。

本质上就是作用域的关系，当我们调用 f1() 函数的时候，会在栈中分配变量 varInner，正常情况下调用完毕后 f1 的栈会弹出，里面的变量 varInner 自然也会销毁才对。

但在后续的 f2() 和 f3() 调用的时，却依然能访问到 varInner，就这点不符合我们对函数调用的直觉。

但其实换个角度来看，对 innerFun 来说，他能访问到 varExternal 和 varInner 变量，最外层的 varExternal 就不用说了，一定是可以访问的。

但对于 varInner 来说就不一定了，这里得分为两种情况；重点得看该语言是静态/动态作用域。

就静态作用域来说，每个符号在编译器就确定好了树状关系，运行时不会发生变化；也就是说 varInner 对于 innerFun 这个函数来说在编译期已经确定可以访问了，在运行时自然也是可以访问的。

但对于动态作用域来说，完全是在运行时才确定访问的变量是哪一个。

恰好 Go 就是一个静态作用域的语言，所以返回的 innerFun 函数可以一直访问到 varInner 变量。

实现闭包

但 Go 是如何做到在 f1() 函数退出之后依然能访问到 f1() 中的变量呢？

这里我们不妨大胆假设一下：

首先在编译期扫描出哪些是闭包变量，也就是这里的 varInner，需要将他保存到函数 innerFun() 中。

f2 := f1() f2()

运行时需要判断出 f2 是一个函数，而不是一个变量，同时得知道它所包含的函数体是 innerFun() 所定义的。

接着便是执行函数体的 statement 即可。

而当 f3 := f1() 重新赋值给 f3 时，在 f2 中累加的 varInner 变量将不会影响到 f3，这就得需要在给 f3 赋值的重新赋值一份闭包变量到 f3 中，这样便能达到互不影响的效果。

闭包扫描

GScript 本身也是支持闭包的，所以把 Go 的代码翻译过来便长这样：

int varExternal =10; func int(int) f1(){ 	int varInner = 20; 	int innerFun(int a){ 		println(a); 		int c=100; 		varExternal++; 		varInner++; 		return varInner; 	} 	return innerFun; }  func int(int) f2 = f1(); for(int i=0;i<2;i++){ 	println("varInner=" + f2(i) + ", varExternal=" + varExternal); } println("======="); func int(int) f3 = f1(); for(int i=0;i<2;i++){ 	println("varInner=" + f3(i) + ", varExternal=" + varExternal); }  // Output: 0 varInner=21, varExternal=11 1 varInner=22, varExternal=12 ======= 0 varInner=21, varExternal=13 1 varInner=22, varExternal=14

可以看到运行结果和 Go 的一样，所以我们来看看 GScript 是如何实现的便也能理解 Go 的原理了。

先来看看第一步扫描闭包变量：

allVariable := c.allVariable(function)
查询所有的变量，包括父 scope 的变量。

scopeVariable := c.currentScopeVariable(function)
查询当前 scope 包含下级所有 scope 中的变量，这样一减之后就能知道闭包变量了，然后将所有的闭包变量存放进闭包函数中。

闭包赋值

之后在 return innerFun 处，将闭包变量的数据赋值到变量中。

return innerFun

闭包函数调用

func int(int) f2 = f1();  func int(int) f3 = f1();

在这里每一次赋值时，都会把 f1() 返回函数复制到变量 f2/f3 中，这样两者所包含的闭包变量就不会互相影响。

在调用函数变量时，判断到该变量是一个函数，则直接返回函数。

之后直接调用该函数即可。

函数式编程

接下来便可以利用 First class function 来试试函数式编程：

 class Test{ 	int value=0; 	Test(int v){ 		value=v; 	}  	int map(func int(int) f){ 		return f(value); 	} } int square(int v){ 	return v*v;  } int add(int v){ 	return v++;  } int add2(int v){ 	v=v+2; 	return v;  } Test t =Test(100); func int(int) s= square; func int(int) a= add; func int(int) a2= add2; println(t.map(s)); assertEqual(t.map(s),10000);  println(t.map(a)); assertEqual(t.map(a),101);  println(t.map(a2)); assertEqual(t.map(a2),102);

这个有点类似于 Java 中流的 map 函数，将函数作为值传递进去，后续支持匿名函数后会更像是函数式编程，现在必须得先定义一个函数变量再进行传递。

除此之外在 GScript 中的 http 标准库也利用了函数是一等公民的特性：

// 标准库：Bind route httpHandle(string method, string path, func (HttpContext) handle){     HttpContext ctx = HttpContext();     handle(ctx); }

在绑定路由时，handle 便是一个函数，使用的时候直接传递业务逻辑的 handle 即可：

func (HttpContext) handle (HttpContext ctx){     Person p = Person();     p.name = "abc";     println("p.name=" + p.name);     println("ctx=" + ctx);     ctx.JSON(200, p); } httpHandle("get", "/p", handle);