定义

MDN 对闭包的定义为：

闭包是指那些能够访问自由变量的函数。

那什么 是自由变量呢？

自由变量是指在函数中使用的，但既不是函数参数也不是函数的局部变量的变量。

由此，我们可以看出闭包共有两部分组成：

闭包 = 函数 + 函数能够访问的自由变量

举个例子：

1
2
3
4
5
6
7
var a = 1;

function foo() {
  console.log(a);
}

foo();

foo函数可以访问变量a,但是a既不是foo函数的局部变量，也不是foo函数的参数，所以a就是自由变量。

那么，函数foo+foo函数访问的自由变量a不就是构成了一个闭包嘛。

还真是这样的！

引用《JavaScript 权威指南》中就讲到：从技术的角度讲，所有的 JavaScript 函数都是闭包。

上述只是介绍的理论上的闭包，还有一个实践角度上的闭包，Tom 大叔翻译的关于闭包的文章中的定义：

ECMAScript 中，闭包指的是：

  1. 从理论角度：所有的函数。因为它们都在创建的时候就将上层上下文的数据保存起来了。哪怕是简单的全局变量也是如此，因为函数中访问全局变量就相当于是在访问自由变量，这个时候使用最外层的作用域。
  2. 从实践角度：以下函数才算是闭包：
    • 即使创建它的上下文已经销毁，它仍然存在(比如，内部函数从父函数中返回)
    • 在代码中引用了自由变量

接下来就来讲讲实践上的闭包。

分析

先写个例子：

1
2
3
4
5
6
7
8
9
10
11
var scope = "global scope";
function checkscope() {
  var scope = "local scope";
  function f() {
    return scope;
  }
  return f;
}

var foo = checkscope();
foo();

首先分析代码中执行上下文栈和执行上下文的变化情况。

这里直接给出简要的执行过程：

  1. 进入全局代码，创建全局执行上下文，全局执行上下文压入执行上下文栈
  2. 全局执行上下文初始化
  3. 执行checkscope函数，创建checkscope函数执行上下文，checkscope执行上下文被压入执行上下文栈
  4. checkscope执行上下文初始化，创建变量对象、作用域链、this 等
  5. checkscope函数执行完毕，checkscope执行上下文从执行上下文栈中弹出
  6. 执行f函数，创建f函数执行上下文，f执行上下文被压入执行上下文栈
  7. f执行上下文初始化，创建变量对象、作用域链、this 等
  8. f函数执行完毕，f函数上下文从执行上下文栈中弹出

了解到这个过程，我们需要思考一个问题，就是：

当F函数执行的时候，checkscope函数上下文已经被销毁了啊（即从执行上下文中被弹出），怎么还会读取到checkscope作用域下的scope值呢？

以上的代码，要是转换成 PHP，就会报错，因为到 PHP 中，f函数只能读取到自己作用域和全局作用域里的值，所以读不到checkscope下的scope值。

然而 JavaScript 确实可以的！

当我们了解了具体的执行过程后，我们知道f执行上下文维护了一个作用域链：

1
2
3
fContext = {
  Scope: [AO, checkscopeContext.AO, globalContext, VO],
};

就是因为这个作用域链，f函数仍然可以读取到checkscopeContext.AO的值，说明当f函数引用了checkscopeContext.AO中的值的时候，即使checkscopeContext被销毁了，但是 JavaScript 仍然会让checkscopeContext.AO活在内存中，f函数依然可以通过f函数的作用域链找到它，正是因为 JavaScript 做到了这一点，从而实现了闭包这个概念。

所以，让我们再看一遍实践角度上闭包的定义：

  1. 即使创建它的上下文已经销毁，它仍然存在（比如，内部函数从父函数中返回）
  2. 在代码中引用了自由变量

必刷题

接下来，看这道必刷题，面试必考的闭包题：

1
2
3
4
5
6
7
8
9
10
11
var data = [];

for (var i = 0; i < 3; i++) {
  data[i] = function () {
    console.log(i);
  };
}

data[0]();
data[1]();
data[2]();

答案是都是 3，让我们分析一下原因：

当执行到data[0]函数之前，此时全局上下文的 VO 为：

1
2
3
4
5
6
globalContext = {
    VO: {
        data: [...],
        i: 3
    }
}

当执行data[0]函数的时候，data[0] 函数的作用域链为：

1
2
3
data[0]Context = {
    Scope: [AO, globalContext.VO]
}

data[0]Context 的 AO 并没有 i 值，所以会从globalContext.VO中查找，i 为 3，所以打印的结果就是 3。

data[1] 和data[2]是一样的道理。

所以让我们改成闭包看看：

1
2
3
4
5
6
7
8
9
10
11
12
13
var data = [];

for (var i = 0; i < 3; i++) {
  data[i] = (function (i) {
    return function () {
      console.log(i);
    };
  })(i);
}

data[0]();
data[1]();
data[2]();

当执行到 data[0] 函数之前，此时全局上下文的 VO 为：

1
2
3
4
5
6
globalContext = {
    VO: {
        data: [...],
        i: 3
    }
}

跟没改之前一模一样。

当执行 data[0] 函数的时候，data[0] 函数的作用域链发生了改变：

1
2
3
data[0]Context = {
    Scope: [AO, 匿名函数Context.AO globalContext.VO]
}

匿名函数执行上下文的 AO 为：

1
2
3
4
5
6
7
8
9
匿名函数Context = {
  AO: {
    arguments: {
      0: 0,
      length: 1,
    },
    i: 0,
  },
};

data[0]Context 的 AO 并没有 i 值，所以会沿着作用域链从匿名函数 Context.AO 中查找，这时候就会找 i 为 0，找到了就不会往 globalContext.VO 中查找了，即使 globalContext.VO 也有 i 的值(值为 3)，所以打印的结果就是 0。

data[1] 和 data[2] 是一样的道理。