一文彻底理解Golang闭包实现原理

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《一文彻底理解Golang闭包实现原理》很感兴趣。本篇文章就来给大家详细解析一下，主要介绍一下闭包，希望所有认真读完的童鞋们，都有实质性的提高。

函数一等公民

一门语言在实现闭包之前首先要具有的特性就是：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 
<p>这里体现了闭包的两个重要特性，第一个自然就是函数可以作为值返回，同时也能赋值给变量。</p>
<p>第二个就是在闭包函数 <code>f1()</code> 对闭包变量 <code>varInner</code> 的访问，每个闭包函数的引用都会在自己的函数内部保存一份闭包变量 <code>varInner</code>，这样在调用过程中就不会互相影响。</p>
<p>从打印的结果中也能看出这个特性。</p>
<h2>作用域</h2>
<p>闭包之所以不太好理解的主要原因是它不太符合自觉。</p>
<p style="text-align:center"><img alt="" src="/uploads/20221222/167170950863a443441eb95.jpg"></p>
<p>本质上就是作用域的关系，当我们调用 <code>f1()</code> 函数的时候，会在栈中分配变量 <code>varInner</code>，正常情况下调用完毕后 <code>f1</code> 的栈会弹出，里面的变量 <code>varInner</code> 自然也会销毁才对。</p>
<p>但在后续的 <code>f2()</code> 和 <code>f3()</code> 调用的时，却依然能访问到 <code>varInner</code>，就这点不符合我们对函数调用的直觉。</p>
<p>但其实换个角度来看，对 <code>innerFun</code> 来说，他能访问到 <code>varExternal</code> 和 <code>varInner</code> 变量，最外层的 <code>varExternal</code> 就不用说了，一定是可以访问的。</p>
<p>但对于 <code>varInner</code> 来说就不一定了，这里得分为两种情况；重点得看该语言是<strong>静态/动态</strong>作用域。</p>
<p>就静态作用域来说，每个符号在编译器就确定好了树状关系，运行时不会发生变化；也就是说 <code>varInner</code> 对于 <code>innerFun</code> 这个函数来说在编译期已经确定可以访问了，在运行时自然也是可以访问的。</p>
<p>但对于动态作用域来说，完全是在运行时才确定访问的变量是哪一个。</p>
<p>恰好 <code>Go</code> 就是一个静态作用域的语言，所以返回的 <code>innerFun</code> 函数可以一直访问到 <code>varInner</code> 变量。</p>
<h2>实现闭包</h2>
<p>但 Go 是如何做到在 <code>f1()</code> 函数退出之后依然能访问到 <code>f1()</code> 中的变量呢？</p>
<p>这里我们不妨大胆假设一下：</p>
<p>首先在编译期扫描出哪些是闭包变量，也就是这里的 <code>varInner</code>，需要将他保存到函数 <code>innerFun()</code> 中。</p>
<pre class="brush:go;">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
<p>可以看到运行结果和 Go 的一样，所以我们来看看 <code>GScript</code> 是如何实现的便也能理解 Go 的原理了。</p>
<p>先来看看第一步扫描闭包变量：</p>
<p style="text-align:center"><img alt="" src="/uploads/20221222/167170950863a44344a115a.jpg"></p>
<p><code>allVariable := c.allVariable(function)</code>查询所有的变量，包括父 <code>scope</code> 的变量。</p>
<p><code>scopeVariable := c.currentScopeVariable(function)</code>查询当前 <code>scope</code> 包含下级所有 <code>scope</code> 中的变量，这样一减之后就能知道闭包变量了，然后将所有的闭包变量存放进闭包函数中。</p>
<h3>闭包赋值</h3>
<p style="text-align:center"><img alt="" src="/uploads/20221222/167170950963a4434522f96.jpg"></p>
<p>之后在 <code>return innerFun</code> 处，将闭包变量的数据赋值到变量中。</p>
<p style="text-align:center"><img alt="" src="/uploads/20221222/167170950963a44345786a3.jpg"></p>
<h3>闭包函数调用</h3>
<pre class="brush:java;">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);

总结

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

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

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

今天带大家了解了闭包的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~