彻底理解闭包实现原理

开发 前端
这篇文章的主要目的就是从编译器的角度来分析闭包,彻底搞懂闭包的实现原理。

前言

闭包对于一个长期写 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)= f1();
for(int i=0;i<2;i++){
println("varInner=" + f2(i) + ", varExternal=" + varExternal);
}
println("=======");
func int(int)= 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 处,将闭包变量的数据赋值到变量中。

图片

闭包函数调用

func int(int)= f1();
func int(int)= f1();

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

图片

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

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

函数式编程

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


class Test{
int value=0;
Test(int v){
value=v;
}
int map(func int(int){
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)= square;
func int(int)= add;
func int(int)= 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);

总结

总的来说闭包具有以下特性:

  • 函数需要作为一等公民。
  • 编译期扫描出所有的闭包变量。
  • 在返回闭包函数时,为闭包变量赋值。
  • 每次创建新的函数变量时,需要将闭包数据复制进去,这样闭包变量才不会互相影响。
  • 调用函数变量时,需要判断为函数,而不是变量。

图片

可以在 Playground 中体验闭包函数打印裴波那切数列的运用。

本文相关资源链接

  • GScript 源码:https://github.com/crossoverJie/gscript。
  • Playground 源码:https://github.com/crossoverJie/gscript-homepage。
责任编辑:姜华 来源: crossoverJie
相关推荐

2016-10-27 19:26:47

Javascript闭包

2016-09-18 20:53:16

JavaScript闭包前端

2017-05-22 16:08:30

前端开发javascript闭包

2010-07-26 11:27:58

Perl闭包

2011-03-02 12:33:00

JavaScript

2022-05-06 16:18:00

Block和 C++OC 类lambda

2021-10-26 13:18:52

Go底层函数

2011-08-05 09:33:30

Func局部变量作用域

2024-01-22 09:51:32

Swift闭包表达式尾随闭包

2022-05-04 10:38:58

React闭包组件

2021-09-04 07:29:57

Android

2022-05-05 08:31:48

useRefuseEffecthook

2020-02-12 16:58:15

JavaScript前端技术

2020-10-14 09:11:44

IO 多路复用实现机

2021-02-21 16:21:19

JavaScript闭包前端

2020-05-07 18:39:15

数据库闭源开源

2021-05-13 08:55:33

Android架构功能

2013-05-02 09:44:57

PHP闭包

2019-11-07 21:51:18

闭包前端函数

2020-08-10 15:24:05

Snowflake算法开源
点赞
收藏

51CTO技术栈公众号