深入理解Lua的闭包一：概念、应用和实现原理

zoukankan html css js c++ java

深入理解Lua的闭包一：概念、应用和实现原理
本文首先通过具体的例子讲解了Lua中闭包的概念，然后总结了闭包的应用场合，最后探讨了Lua中闭包的实现原理。

闭包的概念

在Lua中，闭包（closure）是由一个函数和该函数会访问到的非局部变量（或者是upvalue）组成的，其中非局部变量（non-local variable）是指不是在局部作用范围内定义的一个变量，但同时又不是一个全局变量，主要应用在嵌套函数和匿名函数里，因此若一个闭包没有会访问的非局部变量，那么它就是通常说的函数。也就是说，在Lua中，函数是闭包一种特殊情况。另外在Lua的C API中，所有关于Lua中的函数的核心API都是以closure来命名的，也可视为这一观点的延续。在Lua中，函数是一种第一类型值（First-Class Value），它们具有特定的词法域（Lexical Scoping）。

第一类型值表示函数与其他传统类型的值（例如数字和字符串类型）具有相同的权利。即函数可以存储在变量或table中，可以作为实参传递给其他函数，还可以作为其他函数的返回值，可以在运行期间被创建。在Lua中，函数与所有其他的值是一样都是匿名的，即他们没有名称。当讨论一个函数时（例如print），实质上在讨论一个持有某个函数的变量。比如：
```
function foo(x) print(x) end
```
实质是等价于
```
foo = function (x) print(x) end
```
因此一个函数定义实质就是一条赋值语句，这条语句创建了一种类型为“函数”的值，并赋值给一个变量。可以将表达式function (x) <body> end 视为一种函数构造式，就像table的构造式{}一样。

值得一提的是，C语言里面函数不能在运行期被创建，因此不是第一类值，不过有时他们被称为第二类值，原因是他们可以通过函数指针实现某些特性，比如常常显现的回调函数的影子。

词法域是指一个函数可以嵌套在另一个函数中，内部的函数可以访问外部函数的变量。比如：
1. function f1(n)
2. --函数参数n也是局部变量
3. local function f2()
4. print(n) --引用外部函数的局部变量
5. end
6. return f2
7. end
9. g1 = f1(2015)
10. g1() -- 打印出2015
12. g2 = f1(2016)
13. g2() -- 打印出2016
注意这里的g1和g2的函数体相同(都是f1的内嵌函数f2的函数体)，但打印值不同。这是因为创建这两个闭包时，他们都拥有局部变量n的独立实例。事实上，Lua编译一个函数时，会为他生成一个原型(prototype)，其中包含了函数体对应的虚拟机指令、函数用到的常量值(数，文本字符串等等)和一些调试信息。在运行时，每当Lua执行一个形如function...end 这样的表达式时，他就会创建一个新的数据对象，其中包含了相应函数原型的引用及一个由所有upvalue引用组成的数组，而这个数据对象就称为闭包。由此可见，函数是编译期概念，是静态的，而闭包是运行期概念，是动态的。g1和g2的值严格来说不是函数而是闭包，并且是两个不相同的闭包，而每个闭包能保有自己的upvalue值，所以g1和g2打印出的结果当然就不相同了。

这里的函数f2可以访问参数n，而n是外部函数f1的局部变量。在f2中，变量n即不是全局变量也不是局部变量，将其称为一个非局部变量（non-local variable）或upvalue。upvalue实际指的是变量而不是值，这些变量可以在内部函数之间共享，即upvalue提供一种闭包之间共享数据的方法，比如：
1. function Create(n)
2. local function foo1()
3. print(n)
4. end
5. local function foo2()
6. n = n + 10
7. end
8. return foo1,foo2
9. end
11. f1,f2 = Create(2015)
12. f1() -- 打印2015
14. f2()
15. f1() -- 打印2025
17. f2()
18. f1() -- 打印2035
注意上面的例子中，闭包f1和f2共享同一个upvalue了，这是因为当Lua发现两个闭包的upvalue指向的是当前堆栈上的相同变量时，会聪明地只生成一个拷贝，然后让这两个闭包共享该拷贝，这样任一个闭包对该upvalue进行修改都会被另一个探知。

闭包在创建之时其upvalue就已不在堆栈上的情况也有可能发生，这是因为内嵌函数能引用更外层外包函数的局部变量：
1. function Test(n)
2. local function foo()
3. local function inner1()
4. print(n)
5. end
6. local function inner2()
7. n = n + 10
8. end
9. return inner1,inner2
10. end
11. return foo
12. end
13. t = Test(2015)
14. f1,f2 = t()
15. f1() -- 打印2015
17. f2()
18. f1() -- 打印2025
20. g1,g2 = t()
21. g1() -- 打印2025
23. g2()
24. g1() -- 打印2035
26. f1() -- 打印2035
注意上面的执行的结果表明了闭包f1、f2、g1和g2都共有同一个upvalue，这是因为在创建inner1,inner2这两个闭包被创建时堆栈上根本未找到n的踪影，而是直接使用闭包foo的upvalue。t = Test(2015)之后，t这个闭包一定已把n妥善保存好了，之后f1、f2如果在当前堆栈上未找到n就会自动到他们的外包闭包的upvalue引用数组中去找，并把找到的引用值拷贝到自己的upvalue引用数组中。所以f1、f2、g1和g2引用的upvalue实际也是同一个变量，而刚才描述的搜索机制则确保了最后他们的upvalue引用都会指向同一个地方。

闭包的应用
在许多场合中闭包都是一种很有价值的工具，主要有以下几个方面：

I）作为高阶函数的参数，比如像table.sort函数的参数。

II）创建其他的函数的函数，即函数返回一个闭包。

III）闭包对于回调函数也非常有用。典型的例子就是界面上按钮的回调函数，这些函数代码逻辑可能是一模一样，只是回调函数参数不一样而已，即upvalue的值不一样而已。

V）创建一个安全的运行环境，即所谓的沙盒（sandbox）。当执行一些未受信任的代码时就需要一个安全的运行环境。比如要限制一个程序访问文件的话，只需要使用闭包来重定义函数io.open就可以了：
1. do
2. local oldOpen = io.open
3. local accessOk = function(filename, mode)
4. <权限访问检查>
5. end
7. io.open = function (filename, mode)
8. if accessOk(filename, mode) then
9. return oldOpen(filename, mode)
10. else
11. return nil, "access denied"
12. end
13. end
14. end
经过重新定义后，原来不安全的版本保存到闭包的私有变量中，从而使得外部再也无法直接访问到原来的版本了。

V）实现迭代器。所谓迭代器就是一种可以遍历一种集合中所谓元素的机制。每个迭代器都需要在每次成功调用之间保持一些状态，这样才能知道它所在的位置及如何进到下一个位置。闭包刚好适合这种场景。比如：
1. function values(t)
2. local i = 0
3. return function () i = i + 1 return t[i] end
4. end
6. t = {10, 20, 30}
8. iter = values(t)
9. while true do
10. local element = iter()
11. if element == nil then break end
12. print(element)
13. end
闭包的实现原理

当Lua编译一个函数时，它会生成一个原型（prototype），原型中包括函数的虚拟机指令、函数中的常量（数值和字符串等）和一些调试信息。在任何时候只要Lua执行一个function .. end表达时，它都会创建一个新的闭包（closure）。每个闭包都有一个相应函数原型的引用以及一个数组，数组中每个元素都是一个对upvalue的引用，可以通过该数组来访问外部的局部变量（outer local variables）。值得注意的是，在Lua 5.2之前，闭包中还包括一个对环境（environment）的引用，环境实质就是一个table，函数可以在该表中索引全局变量，从Lua 5.2开始，取消了闭包中的环境，而引入一个变量_ENV来设置闭包环境。由此可见，函数是编译期概念，是静态的，而闭包是运行期概念，是动态的。

作用域（生成期）规则下的嵌套函数给如何实现内存函数存储外部函数的局部变量是一个众所周知的难题（The combination of lexical scoping with first-class functions creates a well-known difficulty for accessing outer local variables）。比如例子：
1. function add (x)
2. return function (y)
3. return x+y
4. end
5. end
7. add2 = add(2)
8. print(add2(5))
当add2被调用时，其函数体访问了外部的局部变量x（在Lua中，函数参数也是局部变量）。然而，当调用add2函数时，创建add2的add函数已经返回了，如果x在栈中创建，则当add返回时，x已经不存在了（即x的存储空间被回收了）。

为了解决上面的问题，不同语言有不同的方法，比如python通过限定作用域、Pascal限制函数嵌套以及C语言则两者都不允许。在Lua中，使用一种称为upvalue结构来实现闭包。任何外部的局部变量都是通过upvalue来间接访问。upvalue初始值是指向栈中，即变量在栈中的位置。如下图左边。当运行时，离开变量作用域时（即超过变量生命周期），则会把变量复制到upvalue结构中（注意也只是在此刻才执行这个操作），如下图右边。由于对变量的访问都是通过upvalue结构中指针间接进行的，因此复制操作对任何读或写变量的代码来说都是没有影响的。与内部函数（inner functions）不同的是，声明该局部变量的函数都是直接在栈中操作它的。

通过为每个变量最多创建一个upvalue并按需要重复利用这个upvalue，保证了未决状态（未超过生命周期）的局部变量（pending vars）能够在闭包之间正确地共享。为了保证这种唯一性，Lua维护这一条链表，该链表中每个节点对应一个打开的upvalue（opend upvalue）结构，打开的upvalue是指当前正指向栈局部变量的upvalue，如上图的未决状态的局部变量链表（the pending vars list）。当Lua创建一个新的闭包时，Lua会遍历当前函数所有的外部的局部变量，对于每一个外部的局部变量，若在上面的链表中能找到该变量，则重复使用该打开的upvalue，否则，Lua会创建一个新的打开的upvalue，并把它插入链表中。当局部变量离开作用域时（即超过变量生命周期），这个打开的upvalue就会变成关闭的upvalue（closed upvalue），并把它从链表中删除，如上图右图所示意。一旦某个关闭的upvalue不再被任何闭包所引用，那么它的存储空间就会被回收。

一个函数有可能存取其更外层函数而非直接外层函数的局部变量。在这种情况下，当创建闭包时，这个局部变量可能不在栈中。Lua使用flat 闭包(flat closures)来处理这种情况。使用flat闭包，无论何时一个函数访问一个外部的局部变量并且该变量不在直接外部函数中，该变量也会进入直接外部函数的闭包中。当一个函数被实例化时，其对应闭包的所有变量要么在直接外部函数的栈中要么在直接外部函数的闭包中。第一部分举的最后一个例子就是这种情况。下一篇文章将分析Lua中闭包对应的源码实现以及调用的过程。

参考资料

http://hi.baidu.com/wplzjtyldobrtyd/item/a293ac3c243e70ff97f88d07
http://blog.sina.com.cn/s/blog_547c04090100qfps.html
http://www.douban.com/note/183992679/
http://en.wikipedia.org/wiki/Scope_(programming)#Lexical_scoping
http://en.wikipedia.org/wiki/First-class_citizen
《Lua程序设计》
查看全文

相关阅读:
SpringMvc 大概流程分析
 HandlerMethodArgumentResolver 参数解析器
 linux 技巧：使用 screen 管理你的远程会话
 CentOS Linux解决Device eth0 does not seem to be present
php连接oracle oracle开启扩展
 关于linux一些备份、还原，压缩，归档的命令
 Sphinx学习之sphinx的安装篇
 linux wget 命令用法详解(附实例说明)
Linux的bg和fg命令
 linux中ctrl+z和ctrl+c的区别

原文地址：https://www.cnblogs.com/yanzi-meng/p/9264392.html