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

前言

JavaPythonGo

函数一等公民

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()varInnervarInner

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

作用域

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

f1()varInnerf1varInner

f2()f3()varInner

innerFunvarExternalvarInnervarExternal

varInner

varInnerinnerFun

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

GoinnerFunvarInner

实现闭包

f1()f1()

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

varInnerinnerFun()

f2 := f1()
f2()

f2innerFun()

statement

f3 := f1()f3f2varInnerf3f3f3

闭包扫描

GScript

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

GScript

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

allVariable := c.allVariable(function)scope

scopeVariable := c.currentScopeVariable(function)scopescope

闭包赋值

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 函数，将函数作为值传递进去，后续支持匿名函数后会更像是函数式编程，现在必须得先定义一个函数变量再进行传递。

GScripthttp

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

handlehandle

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 中体验闭包函数打印裴波那切数列的运用。