封面来源：由博主个人绘制，如需使用请联系博主。

参考链接：

闭包，看这一篇就够了——带你看透闭包的本质，百发百中

Lua的闭包详解（终于搞懂了）

「每日一题」JS 中的闭包是什么？

深入理解闭包系列第一篇——到底什么才是闭包

什么是闭包

这几天看 Lua 感觉进了个大坑，这个大坑就是闭包。闭包这玩意很玄学，它很重要，又难以掌握，难以下一个准确的定义，但在用的时候又那么自然。本文在互联网上参考了很多文章和回答，上方只列举出一些出处，如果发现本文的论述和互联网上某些文章或回答极其相似，不用怀疑，是我抄的 ta。在此向那些被“借鉴”的作者致以崇高的敬意与衷心感谢。

1. 基本概念

闭包这一概念最初是在 JavaScript 中听到的，但身为后端开发的我并没有对此进行深入了解，也仅仅是听过这个名词罢了。

最近在看 Lua 时发现 Lua 在实现多状态迭代器时使用了闭包，因此也打算对此深入了解一下。

先看几个概念：

1.1 词法定界

词法定界：Lua 中函数可以访问函数之外定义的值，该值可以定义在其他函数内，也可以直接定义在文件之内。比如：

1
2
3
4
5
6
7
8
9
local function fn1()
    local a = 5
    local function fn2()
        print(a)
    end
    fn2()
end

fn1() -- 5

1.2 一等公民

第一类值：我更喜欢叫它“一等公民”。在编程语言中，一等公民可以作为函数参数，可以作为函数返回值，也可以赋值给变量（比如可以认为 Java 8 及其之后函数是一等公民）。比如：

1
2
3
4
5
6
7
8
9
10
local function fn3()
    print("hello world")
end

local fn4 = function () -- 函数作为变量
    print("hello world")
end

fn3()
fn4()

1.3 闭包的定义

通过调用含有一个内部函数加上该外部函数持有的外部局部变量的外部函数产生的一个实例函数。比如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
local function outerFunc()
    local a = 0
    local function innerFun()
        a = a + 1
        print("a 的值为 " .. a)
    end
    return innerFun
end

-- 每次外部函数执行的时候，都会开辟一块内存空间，外部函数的地址不同，都会重新创建一个新的地址
local inner1 = outerFunc();
inner1() -- 1
inner1() -- 2
inner1() -- 3

local inner2 = outerFunc();
inner2() -- 1
inner2() -- 2
inner2() -- 3

正因为闭包这个机制，在实现 Lua 的多状态迭代器是需要保存上一次调用的状态和下一次成功的状态，因此恰好可以使用闭包的机制来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
local array = {"one", "two"}

local function elementIterator (collection)
   local index = 0
   local count = #collection
   -- 闭包函数
   return function ()
      index = index + 1
      if index <= count
      then
         --  返回迭代器的当前元素
         return collection[index]
      end
   end
end

for element in elementIterator(array)
do
   print(element)
    -- one 
    -- two
end

1.4 闭包的特点

1、让外部访问函数内部变量成为可能；

2、局部变量会常驻在内存中；

3、可以避免使用全局变量，防止全局变量污染；

4、有一块内存空间被长期占用，而不被释放。

注意第四点并 不一定会 内存泄漏，内存泄露是指用不到（或访问不到）的变量，依然占据着内存空间，不能被再次利用起来。闭包里的变量明显是我们需要的变量，因此这也就不是内存泄漏了。

如果闭包里面的变量是我们需要的变量，那这就不是内存泄漏了；但如果我就是闲得慌，整了一些无用的变量一直占着内存，这肯定是内存泄漏了。

依我看来，闭包和内存泄漏是没有内在联系的，只能说闭包 可能会 产生内存泄漏。

1.5 闭包的创建

闭包可以创建一个独立的环境，每个闭包里面的环境是独立的、互不干扰的。

每次外部函数执行时，外部函数的引用地址不同，都会重新创建一个新的地址。

凡是当前活动对象中有被内部子集引用的数据时，这个数据不会被删除，将会保留一根指针给内部活动对象。

2. 闭包的应用

先说概念：闭包找到的是同一地址中父级函数中对应变量最终的值。

请带着这个概念查看下面的每个例子：

例子一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
local function funA()
    local a = 10
    return function ()
        return a; -- 内部匿名函数访问外部函数的 a
    end
end

local b = funA();
-- 直接使用 b 会报错
print("b 的值为 ", b() ) -- 10

local function funB()
    return 100
end
b = funB()
print("b 的值为 " .. b) -- 100
print("---------------- ")

例子二

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
local function outerFunc()
    local a = 0
    local function innerFun()
        a = a + 1
        print("a 的值为 " .. a)
    end
    return innerFun
end

-- 每次外部函数执行的时候，都会开辟一块内存空间，外部函数的地址不同，都会重新创建一个新的地址
local inner1 = outerFunc();
inner1() -- 1
inner1() -- 2
inner1() -- 3

local inner2 = outerFunc();
inner2() -- 1
inner2() -- 2
inner2() -- 3

例子三

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
local i = 0
local function outerFun()
    local function innerFun()
        i = i + 1
        print("i 的值为 " .. i)
    end
    return innerFun;
end

local inner3 = outerFun();
local inner4 = outerFun();
inner3(); -- 1
inner4(); -- 2
inner3(); -- 3
inner4(); -- 4

例子四

1
2
3
4
5
6
7
8
local function fn()
    local a = 3
    return function ()
        return a + 1
    end
end
print(fn()()) -- 4
print(fn()()) -- 4

例子五

1
2
3
4
5
6
7
8
9
10
11
12
13
14
local function outerFun()
    local i = 0
    local function innerFun()
        i = i + 1
        print("i 的值为 " .. i)
    end
    return innerFun
end
local inner5 = outerFun()
local inner6 = outerFun()
inner5(); -- 1
inner6(); -- 1
inner5(); -- 2
inner6(); -- 2

例子六

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
WINDOW = {};

(function ()
    local m = 0
    local function getM()
        return m
    end
    local function setA(val)
        m = val
    end
    WINDOW.g = getM;
    WINDOW.f = setA;
end)() -- 定义并执行一个函数
WINDOW.f(100);
print("g() 的值为 " .. WINDOW.g()) -- 100

例子七

1
2
3
4
5
6
7
8
9
10
11
local function a()
    local n = 0
    local function b()
        n = n + 1
        print("n 的值为 " .. n)
    end
    return b
end
local c = a()
c() -- 1
c() -- 2

例子八

1
2
3
4
5
6
7
8
9
10
11
local function f()
    local count = 0
    return function ()
        count = count + 1
        print("count 的值为" .. count)
    end
end
local t1 = f()
t1() -- 1
t1() -- 2
t1() -- 3

例子九

1
2
3
4
5
6
7
8
9
10
11
12
13
14
local tmp
local add = function (x)
    local sum = 1
    tmp = function (x)
        sum = sum + x
        if x == 3 then
            return sum
        else
            return tmp
        end
    end
    return tmp
end
print(add(1)(2)(3)) -- 6

例子十

1
2
3
4
5
6
7
local table = {"apple", "pear", "orange"}

for index = 1, #table do
    (function (i)
        print("编列结果为 " .. table[i])
    end)(index)
end

例子十一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
local function m1()
    local x = 1
    return function ()
        x = x + 1
        print(x)
    end
end

m1()() -- 2
m1()() -- 2
m1()() -- 2

local m2 = m1()
m2() -- 2
m2() -- 3
m2() -- 4

例子十二

1
2
3
4
5
6
7
8
9
10
local fn12 = (function ()
    local i12 = 10
    local function fn12()
        i12 = i12 + 1
        print("i12 的值为 " .. i12)
    end
    return fn12
end)()
fn12() -- 11
fn12() -- 12

例子十三

1
2
3
4
5
6
7
8
9
10
local function love1()
    local num = 123
    local me1 = function ()
        print("num 的值为 " .. num)
    end
    num = num + 1
    return me1
end
local loveme1 = love1()
loveme1() -- 124

例子十四

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
local function fun14(n, o)
   print("o 的值为 " .. o)
   local tab14 = {}
   tab14.fun = function (m)
        return fun14(m, n)
   end
   return tab14
end
local a14 = fun14(0, 0) -- 0
a14.fun(1) -- 0
a14.fun(2) -- 0
a14.fun(3) -- 0
local b14 = fun14(0, 0).fun(1).fun(2).fun(3) -- 0 0 1 2
local c14 = fun14(0, 0).fun(1) -- 0 0
c14.fun(2) -- 1
c14.fun(3) -- 1

例子十五

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
local function fun15()
    local arr15 = {}
    I = 0 -- 全局变量
    while I < 5 do
        I = I + 1
        arr15[I] = function ()
            return I
        end
    end
    return arr15
end
local list15 = fun15()
for index, value in ipairs(list15) do
    print(value()) -- 5 5 5 5 5
end

例子十六

1
2
3
4
5
6
7
8
9
10
11
12
13
local function fun16()
    local arr16 = {}
    for i = 1, 5 do -- i 是局部变量
        arr16[i] = function ()
            return i
        end
    end
    return arr16
end
local list16 = fun16()
for index, value in ipairs(list16) do
    print(value()) -- 1 2 3 4 5
end

例子十七

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
local function fun17()
    local arr17 = {}
    J = 0 -- 全局变量
    while J < 5 do
        J = J + 1
        arr17[J] = (function (J)
            return function ()
                return J
            end
        end)(J)
    end
    return arr17
end
local list17 = fun17()
for index, value in ipairs(list17) do
    print(value()) -- 1 2 3 4 5
end

场景十八

1
2
3
4
5
6
7
8
9
10
V18 = {}
do
    local var18 = 2
    V18.fun18 = function ()
        var18 = var18 - 1
        print(var18)
    end
end
V18.fun18();
V18.fun18();

场景十九

1
2
3
4
5
6
7
8
9
10
11
local function fun19()
    local var19 = 3
    local tab19 = {
        ["A"] = function ()
            var19 = var19 - 1
            print("var19 = ", var19)
        end
    }
    return tab19
end
fun19().A() -- var19 = 2

怎么样，知道上面这些例子的最终结果是怎么来的吗？

不知道没关系，下面还有一节深入理解。

3. 深入理解闭包

3.1 给闭包下定义

《JavaScript高级程序设计》对闭包的解释

《JavaScript高级程序设计》对闭包的解释

如果按照这个定义，那么像这样嵌套在 foo() 中的 bar() 函数就是闭包：

1
2
3
4
5
6
7
8
function foo(){
    var a = 2;
    function bar(){
        console.log(a); // 2
    }
    bar();
}
foo();

《JavaScript权威指南》对闭包的解释

《JavaScript权威指南》对闭包的解释

那这样一个包含变量函数也是一个闭包：

1
2
3
4
function foo() {
    var a = 0
}
console.log(a); // a is not defined

还有这样的解释

闭包是指在函数声明时的作用域以外的地方被调用的函数，在这时需要通过将该函数作为返回值或作为参数进行传递。比如作为返回值：

1
2
3
4
5
6
7
function foo() {
    var a = 2;
    return function() {
        console.log(a); // 2
    }
}
foo()();

或者作为参数：

1
2
3
4
5
6
7
8
9
10
function foo() {
    var a = 2;
    function baz() {
        console.log(a); // 2
    }
    bar(baz);
}
function bar(fn) {
    fn();
}

也就是说，只要将内部函数传递到所在的 词法作用域 以外，它都会持有对原始作用域的引用，无论在何处执行这个函数都会使用闭包。

3.2 IIFE

IIFE 的全称是 Immediately Invoked Function Expression，译为：立即调用函数表达式。比如：

1
2
3
4
var a = "mofan"
(function () {
    console.log(a); // mofan
})();

那么它是闭包吗？

它在全局作用域中被定义，也在全局作用域中被调用，按照《JavaScript权威指南》对闭包的解释，它是闭包，但按照另外的解释似乎又不是。

除此之外，可以使用 IIFE 实现模块化编程，利用 window.fn = fn 来暴露接口，而这个 fn 就是闭包，IIFE 是一个包含闭包的函数调用：

1
2
3
4
5
6
7
8
(function() {
    var a = 0;
    function fn() {
        console.log(a); 
    }
    window.fn = fn;
})()
fn();

那 IIFE 究竟是不是呢？就看你的理解了。

3.3 作用域与作用域链

先以 JavaScript 为例，了解 全局作用域 的概念：

1、一对 <script> 标签里、或一个单独的 JS 文件里的 JS 代码，都是全局作用域；

2、全局作用域在页面打开时创建，页面关闭时销毁；

3、在全局作用域中有一个全局对象 window（代表的是一个浏览器的窗口，由浏览器创建），可以直接使用。

再了解 局部作用域 的概念：

1、一个函数内部就是一个局部作用域，其中定义的变量只在函数的内部起作用；

2、调用函数时创建函数作用域，函数执行完毕之后，函数作用域销毁；

3、每调用一次函数就会创建一个新的函数作用域，它们之间是相互独立的。

假设在 A 函数中创建 B 函数，在 B 函数中创建 C 函数，那么作用域链就是 C->B->A，沿着这个链找自由变量。

将一个变量定义在 JS 的全局作用域中，由于作用域链的存在，函数内部能访问到外部上级作用域的变量。

3.4 究竟什么是闭包

在知乎的 什么是闭包 的问答中进行了激烈的讨论：

寸志 - 知乎 (zhihu.com) 大佬是这样说的

JavaScript 闭包的本质源自 词法作用域 和 函数当作值传递。

词法作用域是在写代码或定义时确定的，简单就是内部函数可以访问到函数外的变量。引擎通过数据结构和算法表示一个函数，当某个函数执行并按照词法作用域访问了外围的变量时，这些变量会被添加到对应的数据结构中。

在 Lua 中，就是我们最开始说的 词法定界。那么还记得之后的 一等公民 吗？

当函数作为返回值时，相当于返回了一个通道，这个通道可以访问这个词法作用域中的变量，即函数所需要的数据结构被保存了下来，数据结构中的值在外层函数执行时创建，外层函数执行完毕时理因被销毁，但由于内部函数作为值返回出去，使得这些值能保存下来，而且无法直接访问，必须通过返回的函数（体现了私有性）。

也就是说：函数在执行完毕后，返回了函数，或者将函数得以保存下来，也就形成了闭包。

换言之，闭包是词法作用域的体现。

Saviio - 知乎 (zhihu.com) 又是这样说的

闭包，一言以蔽之：一个持有外部环境变量的函数就是闭包。 闭包的三个关键点：

1、函数

2、自由变量

3、环境（作用域）

如何理解自由变量呢？一个 🌰：

1
2
3
4
let a = "mofan"
let fun = function(){
    console.log(a)
}

函数 fun() 捕获了外部作用域的变量 a，由于 a 不属于函数 fun()，因此变量 a 也被成为 自由变量。 按照我们的定义，上述例子也形成了闭包。

Saviio 的其他解惑：

Q1：使用上述的例子在浏览器中进行断点调试时，Scope 下面并不会出现 Closure，这与定义矛盾了？

A1： 浏览器引擎针对全局对象做了特殊优化，是工程实现的一部分。闭包是一个跨语言的概念，浏览器只是一种语言的实现环境，以某一实现对比整体概念是不妥的。从定义角度出发，一旦引用自由变量，立刻成为闭包，但浏览器引擎可以选择用某种手段优化掉这个函数，不让它成为闭包，进而导致 Scope 下面没有出现 Closure。

Q2：MDN 上说【闭包是由函数以及创建该函数的词法环境组合而成。这个环境包含了这个闭包创建时所能访问的所有局部变量。】这里说的局部变量是包括了全局作用域中的全局变量吗？如果不是，是不是表示 JS 的闭包和广义的闭包定义不一样？

A2：这是把实现优化和定义混在一起了。全局变量可以视为一种特殊的自由变量。因此在函数里访问了全局变量，则成为闭包。但对于引擎来说，闭包有额外代价和开销，引擎默认通过把全局变量封装进执行环境来达到即使不形成闭包也保证函数可以访问全局变量的目的，可以理解为全局变量是具体实现的一种优化。这也是为什么 Q1 中 Scope 下面没有出现 Closure 的原因。

Q3：按照定义说的“持有外部环境变量的函数叫闭包”，由于作用域链本身就包含了外部环境变量，因此所有函数都会持有外部环境变量，那函数使用的外部变量不是自由变量，这是否矛盾？

A3：准确地说，函数是持有了访问外部环境的路径，但不代表持有了环境里的变量，也就是说，如果没有在 inner 函数里使用 outer 的变量，解释器是可以把这个函数优化掉。

Q4：闭包和作用域链有什么关系呢？函数访问外部作用域的变量是很正常的事，靠的是作用域链，怎么能形成闭包呢？

A4：作用域链是实现闭包的一种方式或机制。闭包这种特性能够通过作用域链实现，闭包是作用域链的实现对象，不能使用一种实现方式来否认实现对象。

我的看法

我更偏向：一个持有外部环境变量的函数就是闭包。

在我的理解下，这是更为广泛的定义，而其他的定义恰好只是它的某些特殊情况，因此我更偏向这种。

当然，也能有不同的理解，毕竟谁也不是一定对的。

3.5 必须有 return？

很明显，闭包中并不一定含有 return。

闭包与否，与函数是否持有外部环境变量有关。在使用闭包时经常 return 一个函数是为了能够更好得体现变量的私有性。

除此之外，从 2. 闭包的应用 - 例子十九 可以看出，对于函数嵌套，就算 return 了，也不一定非得 return 一个函数。

3.6 为什么要函数套函数

因为需要局部变量。

如果变量不放在函数里，那么这个变量可以在声明后在当前文件的任何位置被访问，这样就达不到闭包 隐藏变量 体现私有性的目的。

当然并不是说闭包一定是函数套函数。

3.7 闭包的作用

闭包常常用来间接访问一个变量，也就是说为了 隐藏一个变量 。

假设在设计一款游戏时，一个角色只有 3 条命，可以定义一个全局变量：

1
A = 3

然后变量 A 可以在当前文件任何地方被访问，甚至将 A 修改为 100，又或者将 A 减少至 -100，这显然都是不行的。

因此不能让别人 直接访问 到这个变量。

采用局部变量的话别人又访问不到，因此可以暴露一些函数，让别人 间接访问 ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
V = {}
(function ()
    local a = 3
    V.add = function ()
        assert(a < 3, "the most value is 3")
        a = a + 1
        print("a = ", a)
    end
    V.reduce = function ()
        assert(a > 0, "the min value is 0")
        a = a - 1
        print("a = ", a)
    end
end)()

V.reduce() -- 2
V.add() -- 3
V.add() -- error

这上面有两个地方出现了闭包。

如果以 Java 做比较，外层函数可以当做 Java 中的类，闭包就好像 Getter / Setter。或者说是，封装了一个私有变量，并向外暴露了一些方法。

当我们在写代码时并不知道所谓的闭包，只是按照自己的意图去编写，最终却编写出了闭包，这或许才是闭包真正的作用。