闭包,最早最早接触到这个概念,是在学习JavaScript的回调函数,引出了闭包的概念,博主从Go语言的角度重新审视闭包,还是从JavaScript当初这个源头说起。

1.JavaScript中的闭包

function cal(a,b,callback){
    var res=(a+b)*100;
    return callback(res)
}

cal(1,2,function(res){
    console.log(res)
})

一个函数和对其周围状态(lexical environment,词法环境)的引用捆绑在一起(或者说函数被引用包围),这样的组合就是闭包**(**closure**)。也就是说,闭包让你可以在一个内层函数中访问到其外层函数的作用域。在 JavaScript 中,每当创建一个函数,闭包就会在函数创建的同时被创建出来。**

这是MDN上关于闭包的定义,您理解了吗?

2.C#中的闭包

闭包离不开函数,C#没有返回函数类型的概念,直愣愣的返回函数肯定是不行,但是C#创造性了引入了委托delegate类型

委托类型是一个重要概念,向下指代的是函数或者说方法,向上延伸至事件。

说白了,委托就是一个函数类型,杨中科老师把其称为函数占位符,博主喜欢这个说法。

利用委托,博主也写一个类似于JavaScript的回调函数。

static void Main(string[] args)
{
    var Res = Cal(1, 2);
    Console.WriteLine(Res());

    Cal(1, 2, (int res) =>
        {
            Console.WriteLine(res);
        });
}

static void Cal(int a, int b, Action<int> calAction)
{
    int weight = 100;
    calAction((a + b) * weight);
}

这种形式的回调函数,虽然C#中不爱这么称呼,在一些中间件中被大量使用,用于传递一些配置参数。

用到了Cal函数内部的乘法因子weight,并向调用者暴露了内部运算结果。

3.Go语言中的闭包

在Go语言中,我们将再次简练定义闭包:

闭包=函数+引用环境

函数:没什么说的,在Go语言中,就是一种类型,开发者可以把其视作int64 string等一样的类型。

引用环境:着重要理解一下引用环境,这里博主决定不再讲述概念。直接看一段代码(看完先猜一下输出结果):

package main

func test() []func()  {
    var funs []func()
    for i:=0;i<2 ;i++  {
        funs = append(funs, func() {
            println(&i,i)
        })
    }
    return funs
}

func main(){
    funs:=test()
    for _,f:=range funs{
        f()
    }
}
  • test()函数返回一个函数类型的切片
  • 这个函数功能:
    • 打印for循环中变量i的地址与i的值
  • main函数中遍历这个函数切片,并执行函数
#输出结果
0xc000014018 2
0xc000014018 2

可以看到地址不变,值也不变,而且值都是退出循环的值。

结论一

闭包=函数+引用环境,这里函数的引用环境就是for循环中i变量,但是i变量是在不断变化的,虽然地址没变,但是延迟到真正使用函数时。值已改变(循环完成)。

类似情况在C#中的Lambda表达式捕获了外部变量,然后延迟执行,一样会出现这种情况:

Action[] actions = new Action[3];
for (int i = 0; i < 3; i++)
{
    actions[i] = () =>
    {
        Console.Write(i);
    };
}
foreach (Action a in actions)
{
    a();
}

在另一篇博文【Node.js】匿名函数-闭包-Promise也有阐述。

上面Go语言代码的输出结果,肯定不是我们想要的,既然都循环了,肯定是想让其循环输出,办法来了:

package main

func test() []func() {
	var funs []func()
	for i := 0; i < 2; i++ {
		x := i
		funs = append(funs, func() {
			println(&x, x)
		})
	}
	return funs
}

func main() {
	funs := test()
	for _, f := range funs {
		f()
	}
}
0xc000014018 0
0xc000014020 1

结论二

闭包=函数+引用环境,这里函数的引用环境就是for循环内部x变量,但是x变量不同于i:每一次循环就是一次全新的分配空间,赋值。虽然循环已经退出,但是**引用环境(每次不同的x变量)**依然存在。

我们再来看一个有趣的代码,看完接着先猜一下输出结果

package main

func test(x int) (func(),func())  {
	return func() {
		println(x)
		x+=10
	}, func() {
		println(x)
	}
}

func main()  {
	a,b:=test(100)
	a()
	b()
}
#输出结果
100
110

答案有没有出乎你的意料,如果没有,恭喜您,下面的可以不看了。如果有,那我们将再一次理解一下:

闭包=函数+引用环境

我们从a,b:=test(100)说起:

  • 执行test函数,经过值拷贝,为x变量分配了空间,拷贝了值100
  • 此时第一个函数内部操作打印了x,并做x+=10,x为其引用环境
  • 第二个函数内部打印x,x也为其引用环境
  • a()时,对x进行打印输出:100,并作100+10,110
  • b()时,对x进行打印输出:110

所以综上,x是值拷贝后,开辟出的空间,这时返回的函数,虽然是不同函数,但是却是同一个引用环境

为了更清晰,再把x的地址输出:

package main

func test(x int) (func(), func()) {
	return func() {
			println(x)
			x += 10
			println(&x)
		}, func() {
			println(x)
			println(&x)
		}
}

func main() {
	a, b := test(100)
	a()
	b()
}
#输出结果
100
0xc000014018
110
0xc000014018

4.结论

闭包=函数+引用环境