闭包
闭包是含有自由变量的函数。自由变量指的是不是函数局部变量，且不是函数参数的变量。比如
var a = 10;
function test(m){
alert(a + m);
}
test(10);
上面代码中，a就是函数test的自由变量，test也就是一个闭包。至于test能够访问到a，是因为在函数test被定义的时候，它的[[scope]]属性中就包含了全局变量a；之后在test被执行的时候，它的Execution context的Scope Chain中就可以找到a.
闭包原理
在javascript中，使用静态作用域。即函数的作用域在函数定义的时候被确定，函数运行时它内部用到的变量，就从该静态作用域中查找。
var x = 10;
function foo() {
alert(x);
}
/*
此时，foo的 [[scope]] =
{
x: 10,
this:window
...
}
*/
(function (funArg) {
var x = 20;
// 变量"x"在(lexical)上下文中静态保存的，在该函数创建的时候就保存了
funArg(); // 10, 而不是20
})(foo);
/*
匿名函数的[[scope]] 为 {x:20, this:window, ....}
匿名函数执行的时候，其Execution context的scope chain为
AO(匿名函数) + 匿名函数的[[scope]] = AO(匿名函数) -- > VO(global)，即为
{x:20, funArg: reference of function} --> {x:10, this:window, ....}
当foo在匿名函数内部被执行的时候，它的Execution context的scope chain为
AO(foo) + foo.[[scope]]
AO(foo) -- > VO(global)，即 {} -->{x:10, this:window}
*/
在一个函数被创建的时候，函数的内部属性[[scope]]中就保存了其父级上下文的所有参数信息。在上面的例子中，函数foo 在创建时，保存了其父级上下文的参数 x =10， 在foo作为参数传递给 匿名函数，并在匿名函数中被调用时，尽管匿名函数内部有变量x，但是函数 foo被调用时，它的作用域链是使用AO(foo) + foo.[[scope]]构成，索引x的时候，返回10（见上面注释）.
如果上面的程序中，没有在在全局位置处声明x，即:
function foo() {
alert(x);
}
(function (funArg) {
var x = 20;
// 变量"x"在(lexical)上下文中静态保存的，在该函数创建的时候就保存了
funArg(); // 10, 而不是20
})(foo);
/*
匿名函数的[[scope]] 为 {x:20, this:window, ....}
匿名函数执行的时候，其Execution context的scope chain为
AO(匿名函数) + 匿名函数的[[scope]] = AO(匿名函数) -- > VO(global)，即为
{x:20, funArg: reference of function} --> {this:window, ....}
当foo在匿名函数内部被执行的时候，它的Execution context的scope chain为
AO(foo) + foo.[[scope]]
AO(foo) -- > VO(global)，即 {} -->{this:window}
*/
则尽管在匿名函数中声明了变量x，但是执行foo的时候其作用域链不包含匿名函数的AO， 会报错x is undefined.
因此，闭包就是包含了父上下文中自由变量的函数，它能够引用定义在它外部的自由变量，是因为js的scope chain和VO/AO和[[scope]]的机制(见Javascript 运行上下文和作用域链)；且它的[[scope]]在它被定义的时候就确定了，而不是在运行的时候确定。
】
所有对象都引用同一个[[scope]]
在ECMAScript中，同一个父上下文中创建的闭包是共用同一个[[scope]]属性，即某个闭包对其中[[scope]]的变量做修改会影响到其他闭包对其变量的读取。
如:
var firstClosure;
var secondClosure;
function foo() {
var x = 1;
firstClosure = function () { return ++x; };
secondClosure = function () { return --x; };
x = 2; // 影响 AO["x"], 在2个闭包公有的[[Scope]]中
alert(firstClosure()); // 3, 通过第一个闭包的[[Scope]]
}
foo();
alert(firstClosure()); // 4
alert(secondClosure()); // 3
以及下面的：
var data = [];
for (var k = 0; k < 3; k++) {
data[k] = function () {
alert(k);
};
}
data[0](); // 3, 而不是0
data[1](); // 3, 而不是1
data[2](); // 3, 而不是2
data[k] 的 [[scope]] 都是 {k: xx, ...}， 这是共用的，当k变更的时候会影响到data[]的[[scope]].
那么，如何修改上面的代码使得data[k] = k呢？一种方法是封装一层函数，增加一层作用域，在该层作用域中保存k的值。
var data = [];
for (var k = 0; k < 3; k++) {
data[k] = (function _helper(x) {
return function () {
alert(x);
};
})(k); // 传入"k"值
}
// 现在结果是正确的了
data[0](); // 0
data[1](); // 1
data[2](); // 2
data[0].[[Scope]] === [
... // 其它变量对象
父级上下文中的活动对象AO: {data: [...], k: 3},
_helper上下文中的活动对象AO: {x: 0}
];
data[1].[[Scope]] === [
... // 其它变量对象
父级上下文中的活动对象AO: {data: [...], k: 3},
_helper上下文中的活动对象AO: {x: 1}
];
data[2].[[Scope]] === [
... // 其它变量对象
父级上下文中的活动对象AO: {data: [...], k: 3},
_helper上下文中的活动对象AO: {x: 2}
];
