一. 闭包的定义
闭包是指那些能够访问自由变量的函数。
自由变量 是指在函数中使用的，既不是函数参数也不是函数内部声明的局部变量的变量！！！
-
从理论角度
- JS 中所有的函数都是闭包，因为都能访问外部的自由变量 -
从实践角度，以下函数才算是闭包：
- 即使创建它的上下文已经被销毁，但它仍然存在（eg：函数内部又返回了的函数，）。 - 【此时外部的函数执行完毕后，其上下文会从执行上下文栈中弹出，但是其返回的函数的上下文依旧存在！！！】 - 在代码中使用了自由变量！！
举栗分析：
var scope = "global scope";
function checkscope(){
var scope = "local scope";
function f(){
return scope;
}
return f;
}
var foo = checkscope();
foo();
执行过程：
-
创建全局上下文，全局上下文压入执行上下文栈
-
初始化全局上下文（创建全局对象，将var声明的变量作为属性添加到全局对象中，并初始化为undefined...）
-
执行 checkscope 函数：
- 执行前：创建 checkscope 函数的执行上下文，并压入栈 - 创建变量对象、作用域链... - 执行，执行完毕后，其执行上下文从上下文栈中弹出 -
执行 f 函数
- 执行前：创建 f 函数的执行上下文，并压入栈 - 创建变量对象、作用域链... - 执行，执行完毕后，其执行上下文从上下文栈中弹出
当 f 函数执行的时候，checkscope 函数上下文已经被销毁了啊(即从执行上下文栈中被弹出)，怎么还会读取到 checkscope 作用域下的 scope 值呢？
因为 f 执行上下文维护了一条作用域链：
fContext = {
Scope: [AO, checkscopeContext.AO, globalContext.VO],
}
闭包实现的基础：
就是因为这个作用域链，即使 checkscopeContext 被销毁了，但是 JavaScript 依然会让 checkscopeContext.AO 活在内存中，f 函数依然可以通过 f 函数的作用域链找到它，正是因为 JavaScript 做到了这一点，从而实现了闭包这个概念。
经典面试题：
普通函数调用：
var data = [];
for (var i = 0; i < 3; i++) {
data[i] = function () {
console.log(i);
};
}
data[0]();
data[1]();
data[2]();
// 3 3 3
当执行 data[0] 函数的时候，data[0] 函数的作用域链为：
data[0]Context = {
Scope: [AO, globalContext.VO]
}
data[0]Context 的 AO 并没有 i 值，所以会从 globalContext.VO 中查找，而此时的 全局上下文中的 i 的值为 3 ，因为此时 for 循环已经执行完毕了！！！
使用了闭包的函数调用：
var data = [];
for (var i = 0; i < 3; i++) {
data[i] = (function (i) {
// 定义返回函数
return function(){
console.log(i);
}
})(i); // IIFE ，后面的小括号，会立马去调用前面括号里的数，并把自己括号里的参数作为参数传进去前面括号中的函数
}
data[0]();
data[1]();
data[2]();
// 0 1 2
每次 for 循环都会执行一次 IIFE ，而每次执行，自己内部的活动对象中都有参数属性 i ，且每次的值都不一样，第一次是 0 ...，而当执行完IIFE函数后，到定义返回函数时，会保存父级的作用域链，即会把第一次的IIFE的活动对象，保存下来，后面执行时，形成自己的作用域链，即执行 data0 时，data[0] 函数的作用域链为：
data[0]Context = {
Scope: [AO, 匿名函数Context.AO globalContext.VO]
}
而其保存的第一次的 IIFE 的活动对象为：
AO: {
arguments: {
0: 0,
length: 1
},
i: 0
}
