JS入门难点解析9-闭包的深入解析

（注1：如果有问题欢迎留言探讨，一起学习！转载请注明出处，喜欢可以点个赞哦！）

（注2：更多内容请查看我的目录。）

1. 简介

闭包，是让很多JS初学者闻之色变的一个概念。每次看过一些书籍或者网上的例子，会感觉自己懂了很多，但又是似懂非懂。这篇文章，我们会结合前面所学，深入探讨一下闭包的原理，让大家从根本上弄明白闭包产生的原因。

2. 定义

关于闭包的定义，是让大家迷惑的第一个点。因为不同书籍，不同的大神对闭包的解读和定义不尽相同。

2.1. 定义一

我们先来看一下《JavaScript高级程序设计》一书中对闭包的的定义：

闭包是指有权访问另一个函数作用域中的变量的函数。创建闭包的常见方式，就是在一个函数内部创建另一个函数。

再来看一下百度百科（百度百科-闭包）中对闭包的定义：

闭包就是能够读取其他函数内部变量的函数。由于在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。

可以看到，百度百科和《JavaScript高级程序设计》一书对闭包的定义基本相同，即“定义在一个函数内部的函数”。这是目前比较普遍被接受的一个定义。

2.2 定义二

看一下MDN对闭包的定义：

闭包是一个函数和声明该函数的词法环境的组合。从理论角度来说，所有函数都是闭包。

该说法认为“所有函数都是闭包”，是一个很宽泛的概念。

2.3 我对闭包的理解定义

其实，网上还有许多关于闭包的定义。说法各不相同，有从函数定义的角度出发，有从使用的角度出发，众说纷纭，让人无所适从。可是我在此只列举了以上两种定义，为什么呢？是对其余的定义不认同吗？并不是。是因为，对于闭包来讲，我们关注的并不是其定义或者概念，而是一种现象和产生这种现象的机制原理。那就是一个函数被嵌套时，不管在哪里被调用，为什么总能访问其外层嵌套函数作用域的变量？这么说，可能有人不理解，我们举一个简单的例子：

全局A定义函数B，函数B嵌套函数C，函数C嵌套函数D，函数D在C直接执行，或者通过赋值或者返回，在B，A任何一个作用域内被引用，当其执行时，都可以访问C，B，A作用域内定义的变量。(当然，A作为全局作用域，只要程序未销毁，其中定义的变量始终是可以被访问的，所以不做讨论。)

所以，非要让我对闭包下一个定义，我是倾向于定义一的。这其实是分了两个情况：

1. 被嵌套函数只在当前作用域。
2. 被嵌套函数在非当前作用域被引用。

对应了两个使用场景：

1. 被嵌套函数只在当前作用域执行。
2. 被嵌套函数在非当前作用域被执行。

下面，我们来分析一下这两种情况的深层原因。

3. 深入解析闭包

3.1 被嵌套函数只在当前作用域

对于这种情况，其实在前面文章中我们已经做了很详尽的解释。之所以被嵌套函数有权访问其外层嵌套函数作用域中的变量，是因为作用域链的原因。

看下面这段代码：

function foo() {
    var a = 2;

    function f() {
        console.log(a); // 2
    }

    f();
}

foo();

为什么在f的内部能访问foo作用域的变量a呢？我们讲过，在f执行时，创建f的执行上下文。此时：

fooContext = {
    AO = {
        arguments: {
            length: 0
        },
        a: 2
    },
    Scope: [AO, globalContext.VO],
    this: undefined
};

fContext = {
    AO = {
        arguments: {
            length: 0
        }
    },
    Scope: [AO, fooContext.AO, globalContext.VO],
    this: undefined
};

此时，执行

console.log(a)；

会对a进行RHS查找，查找过程是沿着作用域链向上，此时在fooContext.AO找到了a的值为2。

3.2 被嵌套函数在非当前作用域被引用。

发生这种情况，可能是被嵌套函数被当做返回值返回，也可能是直接赋值给了外部的变量。我们来看一下这两种情况。

3.2.1 被嵌套函数被当做返回值返回

看如下这段代码：

function foo() {
    var a = 2;

    function f() {
        console.log(a); // 2
    }

    return f;
}

foo()();

此处的关键节点在于foo的执行结果。我们在return f;处打一个断点，拍一张此时的快照：

ECStack = [
    fooContext,
    globalContext
];

fooContext = {
    AO = {
        arguments: {
            length: 0
        },
        a: 2
    },
    Scope: [AO, globalContext.VO],
    this: undefined
};

f.[[scope]] = fooContext.Scope = [fooContext.AO, globalContext.VO];

然后我们在foo()()处打一个断点，此时foo()已经执行完毕，返回了f，准备执行foo()()，即f()。

ECStack = [
    globalContext
];

f.[[scope]] = fooContext.Scope = [fooContext.AO, globalContext.VO];

此时，fooContext出栈并销毁。但是，关键的一点请注意，虽然foo的执行上下文fooContext销毁了，也不在对其活动对象fooContext.AO有引用了。但是，f.[scope]仍然保留有对fooContext.AO的引用，所以，fooContext.AO并没有被销毁，仍然存在于内存中。然后我们再往下走，执行f()

fContext = {
    AO = {
        arguments: {
            length: 0
        }
    },
    Scope: [AO, fooContext.AO, globalContext.VO],
    this: undefined
}

fContext利用f的[scope]信息生成了作用域链Scope: AO, fooContext.AO, globalContext.VO。此时执行

console.log(a)；

的过程与3.1示例相同。

3.2.2 直接赋值给了外部的变量

看下面代码：

var bar;
function foo(){
    var a = 2;
    function f(){
        console.log(a); // 2
    }
   bar = f;
}
foo();
bar();

其实这种情况，和3.2.1的执行原理是一样的。都是因为bar中保留有对foo的执行环境的活动对象的引用。具体的分析过程，大家可以自己尝试一下。

4. 总结

通过这篇文章的分析，我们可以清晰的看到闭包形成的原理，也可以看出闭包为什么可能造成内存被大量占用的原因。这里需要注意的是，只要被嵌套函数被返回或者赋值给了作用域以外的地方，那么在其所有引用执行完毕前，都会造成对其包含函数执行环境的活动对象的持续引用。

参考

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

深入理解闭包系列第二篇——从执行环境角度看闭包

JavaScript深入之闭包

百度百科-闭包

BOOK-《JavaScript高级程序设计（第3版）》第7章