函数都有自己的执行环境，该环境定义了变量或者函数访问数据的权限，当离开执行环境后，该环境内的变量会被销毁。
function add() {
let a = 1;
console.log(a); // 1
}
console.log(a); // ReferenceError: a is not defined
上例a在 add() 函数的作用域内，能够访问，离开作用域后，就无法访问了。
那有没有办法在 add() 函数外访问a的值呢？
function add() {
const a = 1;
const addOne = function(b) { return b + a; }
return addOne;
}
const addOne = add();
console.log(addOne(1)); // 2
add() 函数执行完毕之后，会从函数调用栈中被推出，同时局部变量a应该被清理才对， 但我们调用 addOne(1) ，得到的结果却是2。说明a在 add() 执行结束后并没有被销毁，而是进入到了 addOne() 的作用域。
这里的 addOne() 函数被称为匿名函数（anonymous function）也叫做闭包（closure）。
那么 JS 的闭包是如何实现对外部变量的存储的呢？
作用域链
上面的例子中 addOne 函数获得a的值，我们需要先弄清楚，它是拷贝了a的值到其作用域中，还是a没有压根被销毁，而是给了 addOne 访问的权限。
function add() {
let a = 1;
const addOne = function(b) { return b + a; }
++a;
return addOne;
}
const addOne = add();
console.log(addOne(1)); // 3
我们可以发现在a被 addOne 捕获之后，再修改它的值， addOne() 的执行结果也随之变化，所以闭包不是拷贝变量的值，而是持有它的一个「引用」。
JS 在运行的时候，会为每一个执行函数分配内存空间，我们称这个空间为作用域对象（Scope Object）。当调用函数时，函数中分配的本地变量会被存储在这个作用域对象中。我们无法直接使用代码读取这个作用域对象，但是解析器在处理数据的时候会在后台使用它们。
JS 的函数是一等公民，声明时可能会有嵌套关系，因此会同时存在多个作用域对象，所有函数的作用域对象会被环境栈所管理。环境栈中的作用域对象是按顺序访问的，最先能够访问的是当前函数的作用域，如果访问的变量在当前作用域没有，会访问上一层作用域，直到找到全局作用域（Global）对象。如果访问到全局作用域也没有这个对象，会抛出ReferenceError的异常。这就是所谓的作用域链（scope chian)。
这跟原型继承的概念非常相似，只不过在原型链顶端找到不到某个属性时，返回是undefined。
闭包之所以能够访问到上一层函数中的局部变量，是因为当变量被捕获之后，即使上一层函数调用完毕出栈了，但是它的作用域对象没有被销毁，所以仍然能够被闭包访问。
验证
上面的理论是否正确，我们通过代码来验证一下。
function add(a) {
const addB = function(b) {
console.log(b);
const addC = function(c) {
return a + b + c;
}
return addC;
}
return addB;
}
const addOne = add(1);
const addTwo = addOne(1);
const addThree = addTwo(1);
这个例子中嵌套了两层闭包，我们分别在第 3 行和第 5 行打上断点。当断住第 3 行代码时，debuger 区域展示了 addB() 函数的作用域对象 Scope。
我们可以看到一个 Closure 属性，它持有了 add() 函数作用域中的 a，说明 Closure 对象存储了从外部捕获的变量。
当断住第 5 行进入下一层闭包，出现了两个 Closure 对象。
从中可以看出，闭包的作用域对象会根据外部函数的层级，生成对应的对象属性来存储变量。假如我们在 addB 函数中创建一个局部变量 a，覆盖从 add 函数的捕获的局部，对应的 Closure(add) 属性就不会生成了。
鬼畜的 var 关键字
JS 作用域对象的设计颠覆了我以往对程序语言的认知，比如说下面这段代码，a 明明是个局部变量，但是在 if 语句外面却能被访问到它。
function testVar() {
if (1) {
var a = 1;
let b = 2;
}
console.log(a); // 1
console.log(b); // ReferenceError
}
testVar();
var 声明的变量作用域会被提升到 Local，也就是当前函数的局部作用域中，而 let 声明的变量保存在 Block 属性中，当 if 语句执行结束，这个 Block 会被销毁，所以在 if 外就无法访问到 b 变量。
最后我们来看一段有趣的代码，思考一下输出结果会是什么。
function buildList(list) {
var result = [];
for (var i = 0; i < list.length; i++) {
var item = 'item' + i;
result.push( function() {
console.log(item + ' ' + list[i])
});
}
return result;
}
function testList() {
var fnlist = buildList([1,2,3]);
for (var j = 0; j < fnlist.length; j++) {
fnlist[j]();
}
}
testList()
输出结果为：
"item2 undefined"
"item2 undefined"
"item2 undefined"
我们使用循环将三个闭包存入数组，每次循环闭包都会捕获了数组的下标 i，照理说再取出闭包执行的时候，会顺序输出数组的元素，实际上却没有。
这是因为 var 关键字搞得鬼，被 var 关键字声明的 i 和 item 变量，作用域被提升到 buildList 函数的整个作用域（Local）中，每次循环它们的值都会被覆盖。对于同一层级的变量，闭包只会持有它的一个“引用”，所以在它执行时只能访问到的 i 和 item 的最新值 i = 3，item = item2。
如果将 i 和 item 都用 let 修饰，闭包捕获的变量会存入闭包作用域对象的 Block 属性，每次循环 Block 属性会被重新创建，并被数组持有。所以，遍历数组能输出预期的结果。
item0 1
item1 2
item2 3
总结
闭包能够访问外部函数的变量，即使变量已经离开它所创建的环境，是因为外部变量会被闭包的作用域对象所持有。闭包这种特性实现了嵌套函数之间数据的隐式传递。