提要
本文将引见一个在JavaScript常常会拿来议论的话题 —— 闭包（closure）。闭包实在已是个陈词滥调的话题了； 有大批文章都引见过闭包的内容（个中不失一些很好的文章，比方，扩大浏览中Richard Cornford的文章就非常好）， 尽管云云，这里照样要试着从理论角度来议论下闭包，看看ECMAScript中的闭包内部究竟是怎样事情的。
正如在此前文章中提到的，这些文章都是系列文章，相互之间都是有关联的。因而，为了更好的明白本文要引见的内容， 发起先去浏览下第四章 – 作用域链和 第二章 – 变量对象。
概论
在议论ECMAScript闭包之前，先来引见下函数式编程（与ECMA-262-3 规范无关）中一些基本定义。 但是，为了更好的诠释这些定义，这里照样拿ECMAScript来举例。
尽人皆知，在函数式言语中（ECMAScript也支撑这类作风），函数等于数据。就比方说，函数可以保留在变量中，可以当参数通报给其他函数，还可以当返回值返回等等。 这类函数有特别的名字和组织。
定义
函数式参数（“Funarg”） —— 是指值为函数的参数。
以下例子：
function exampleFunc(funArg) {
funArg();
}
exampleFunc(function () {
alert('funArg');
});
上述例子中funarg的实参是一个通报给exampleFunc的匿名函数。
反过来，接收函数式参数的函数称为 高阶函数（high-order function 简称：HOF）。还可以称作：函数式函数 或许 偏数理的叫法：操纵符函数。 上述例子中，exampleFunc 就是如许的函数。
此前提到的，函数不仅可以作为参数，还可以作为返回值。这类以函数为返回值的函数称为 _带函数值的函数（functions with functional value or function valued functions）。
(function functionValued() {
return function () {
alert('returned function is called');
};
})()();
可以以平常数据情势存在的函数（比方说：当参数通报，接收函数式参数或许以函数值返回）都称作 第一类函数（平常说第一类对象）。 在ECMAScript中，一切的函数都是第一类对象。
接收本身作为参数的函数，称为 自运用函数（auto-applicative function 或许 self-applicative function）：
(function selfApplicative(funArg) {
if (funArg && funArg === selfApplicative) {
alert('self-applicative');
return;
}
selfApplicative(selfApplicative);
})();
以本身为返回值的函数称为 自复制函数（auto-replicative function 或许 self-replicative function）。 一般，“自复制”这个词用在文学作品中：
(function selfReplicative() {
return selfReplicative;
})();
在函数式参数中定义的变量，在“funarg”激活时就可以接见了（由于存储高低文数据的变量对象每次在进入高低文的时刻就建立出来了）：
function testFn(funArg) {
// 激活funarg, 当地变量localVar可接见
funArg(10); // 20
funArg(20); // 30
}
testFn(function (arg) {
var localVar = 10;
alert(arg + localVar);
});
但是，我们晓得（特别在第四章中提到的），在ECMAScript中，函数是可以封装在父函数中的，并可以运用父函数高低文的变量。 这个特征会激发 funarg题目。
Funarg题目
在面向客栈的编程言语中，函数的当地变量都是保留在 客栈上的， 每当函数激活的时刻，这些变量和函数参数都邑压栈到该客栈上。
当函数返回的时刻，这些参数又会从客栈中移除。这类模子对将函数作为函数式值运用的时刻有很大的限定（比方说，作为返回值从父函数中返回）。 绝大部份状况下，题目会出如今当函数有 自在变量的时刻。
自在变量是指在函数中运用的，但既不是函数参数也不是函数的局部变量的变量
以下所示：
function testFn() {
var localVar = 10;
function innerFn(innerParam) {
alert(innerParam + localVar);
}
return innerFn;
}
var someFn = testFn();
someFn(20); // 30
上述例子中，关于innerFn函数来讲，localVar就属于自在变量。
关于采纳 面向客栈模子来存储局部变量的体系而言，就意味着当testFn函数挪用完毕后，其局部变量都邑从客栈中移除。 如许一来，当从外部对innerFn举行函数挪用的时刻，就会发作毛病（由于localVar变量已不存在了）。
而且，上述例子在 面向客栈完成模子中，要想将innerFn以返回值返回根本是不能够的。 由于它也是testFn函数的局部变量，也会跟着testFn的返回而移除。
另有一个函数对象题目和当体系采纳动态作用域，函数作为函数参数运用的时刻有关。
看以下例子（伪代码）：
var z = 10;
function foo() {
alert(z);
}
foo(); // 10 – 静态作用域和动态作用域状况下都是
(function () {
var z = 20;
foo(); // 10 – 静态作用域状况下, 20 – 动态作用域状况下
})();
// 将foo函数以参数通报状况也是一样的
(function (funArg) {
var z = 30;
funArg(); // 10 – 静态作用域状况下, 30 – 动态作用域状况下
})(foo);
我们看到，采纳动态作用域，变量（标识符）处置惩罚是经由过程动态客栈来治理的。 因而，自在变量是在当前活泼的动态链中查询的，而不是在函数建立的时刻保留起来的静态作用域链中查询的。
如许就会发生争执。比方说，纵然Z依然存在（与之前从客栈中移除变量的例子相反），照样会有如许一个题目： 在差别的函数挪用中，Z的值究竟取哪一个呢（从哪一个高低文，哪一个作用域中查询）？
上述形貌的就是两类 funarg题目 —— 取决因而不是将函数以返回值返回（第一类题目）以及是不是将函数当函数参数运用（第二类题目）。
为了处理上述题目，就引入了 闭包的观点。
闭包
闭包是代码块和建立该代码块的高低文中数据的连系。
让我们来看下面这个例子（伪代码）：
var x = 20;
function foo() {
alert(x); // 自在变量 "x" == 20
}
// foo的闭包
fooClosure = {
call: foo // 对函数的援用
lexicalEnvironment: {x: 20} // 查询自在变量的高低文
};
上述例子中，“fooClosure”部份是伪代码。对应的，在ECMAScript中，“foo”函数已有了一个内部属性——建立该函数高低文的作用域链。
这里“lexical”是显而易见的，一般是省略的。上述例子中是为了强调在闭包建立的同时，高低文的数据就会保留起来。 当下次挪用该函数的时刻，自在变量就可以在保留的（闭包）高低文中找到了，正如上述代码所示，变量“z”的值老是10。
定义中我们运用的比较广义的词 —— “代码块”，但是，一般（在ECMAScript中）会运用我们常常用到的函数。 固然了，并不是一切对闭包的完成都邑将闭包和函数绑在一同，比方说，在Ruby言语中，闭包就有多是： 一个顺序对象（procedure object）, 一个lambda表达式或许是代码块。
关于要完成将局部变量在高低文烧毁后依然保留下来，基于客栈的完成显然是不实用的（由于与基于客栈的组织相抵牾）。 因而在这类状况下，上层作用域的闭包数据是经由过程 动态分配内存的体式格局来完成的（基于“堆”的完成），合营运用渣滓接纳器（garbage collector简称GC）和 援用计数（reference counting）。 这类完成体式格局比基于客栈的完成机能要低，但是，任何一种完成老是可以优化的： 可以剖析函数是不是运用了自在变量，函数式参数或许函数式值，然后依据状况来决议 —— 是将数据存放在客栈中照样堆中。
ECMAScript闭包的完成
议论完理论部份，接下来让我们来引见下ECMAScript中闭包究竟是怎样完成的。 这里照样有必要再次强调下：ECMAScript只运用静态（词法）作用域（而诸如Perl如许的言语，既可以运用静态作用域也可以运用动态作用域举行变量声明）。
var x = 10;
function foo() {
alert(x);
}
(function (funArg) {
var x = 20;
// funArg的变量 "x" 是静态保留的，在该函数建立的时刻就保留了
funArg(); // 10, 而不是 20
})(foo);
从手艺角度来讲，建立该函数的上层高低文的数据是保留在函数的内部属性 [[Scope]]中的。 假如你还不相识什么是[[Scope]]，发起你先浏览第四章, 该章节对[[Scope]]作了非常细致的引见。假如你对[[Scope]]和作用域链的学问完整明白了的话，那对闭包也就完整明白了。
依据函数建立的算法，我们看到 在ECMAScript中，一切的函数都是闭包，由于它们都是在建立的时刻就保留了上层高低文的作用域链（除开非常的状况） （不论这个函数后续是不是会激活 —— [[Scope]]在函数建立的时刻就有了）：
var x = 10;
function foo() {
alert(x);
}
// foo is a closure
foo: <FunctionObject> = {
[[Call]]: <code block of foo>,
[[Scope]]: [
global: {
x: 10
}
],
... // other properties
};
正云云前提到过的，出于优化的目标，当函数不运用自在变量的时刻，完成层能够就不会保留上层作用域链。 但是，ECMAScript-262-3规范中并未对此作任何申明；因而，严格来讲 —— 一切函数都邑在建立的时刻将上层作用域链保留在[[Scope]]中。
有些完成中，许可对闭包作用域直接举行接见。比方Rhino，针对函数的[[Scope]]属性，对应有一个非规范的 parent属性，在第二章中作过引见：
var global = this;
var x = 10;
var foo = (function () {
var y = 20;
return function () {
alert(y);
};
})();
foo(); // 20
alert(foo.__parent__.y); // 20
foo.__parent__.y = 30;
foo(); // 30
// 还可以操纵作用域链
alert(foo.__parent__.__parent__ === global); // true
alert(foo.__parent__.__parent__.x); // 10
“全能”的[[Scope]]
这里还要注重的是：在ECMAScript中，同一个高低文中建立的闭包是共用一个[[Scope]]属性的。 也就是说，某个闭包对个中的变量做修正会影响到其他闭包对其变量的读取：
var firstClosure;
var secondClosure;
function foo() {
var x = 1;
firstClosure = function () { return ++x; };
secondClosure = function () { return --x; };
x = 2; // 对AO["x"]发生了影响, 其值在两个闭包的[[Scope]]中
alert(firstClosure()); // 3, 经由过程 firstClosure.[[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
上述例子就证明了 —— 同一个高低文中建立的闭包是共用一个[[Scope]]属性的。因而上层高低文中的变量“k”是可以很轻易就被转变的。
以下所示：
activeContext.Scope = [
... // higher variable objects
{data: [...], k: 3} // activation object
];
data[0].[[Scope]] === Scope;
data[1].[[Scope]] === Scope;
data[2].[[Scope]] === Scope;
如许一来，在函数激活的时刻，终究运用到的k就已变成了3了。
以下所示，建立一个分外的闭包就可以处理这个题目了：
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
上述例子中，函数“_helper”建立出来以后，经由过程参数“k”激活。其返回值也是个函数，该函数保留在对应的数组元素中。 这类手艺发生了以下结果： 在函数激活时，每次“_helper”都邑建立一个新的变量对象，个中含有参数“x”，“x”的值就是通报进来的“k”的值。 如许一来，返回的函数的[[Scope]]就成了以下所示：
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}
];
我们看到，这个时刻函数的[[Scope]]属性就有了真正想要的值了，为了到达如许的目标，我们不得不在[[Scope]]中建立分外的变量对象。 要注重的是，在返回的函数中，假如要猎取“k”的值，那末该值照样会是3。
趁便提下，大批引见JavaScript的文章都以为只要分外建立的函数才是闭包，这类说法是毛病的。 实践得出，这类体式格局是最有用的，但是，从理论角度来讲，在ECMAScript中一切的函数都是闭包。
但是，上述提到的要领并不是唯一的要领。经由过程其他体式格局也可以获得准确的“k”的值，以下所示：
var data = [];
for (var k = 0; k < 3; k++) {
(data[k] = function () {
alert(arguments.callee.x);
}).x = k; // 将“k”存储为函数的一个属性
}
// 一样也是可行的
data[0](); // 0
data[1](); // 1
data[2](); // 2
Funarg和return
别的一个特征是从闭包中返回。在ECMAScript中，闭包中的返回语句会将掌握流返回给挪用高低文（挪用者）。 而在其他言语中，比方，Ruby，有许多中情势的闭包，响应的处置惩罚闭包返回也都差别，下面几种体式格局都是能够的：能够直接返回给挪用者，或许在某些状况下——直接从高低文退出。
ECMAScript规范的退出行动以下：
function getElement() {
[1, 2, 3].forEach(function (element) {
if (element % 2 == 0) {
// 返回给函数"forEach"，
// 而不会从getElement函数返回
alert('found: ' + element); // found: 2
return element;
}
});
return null;
}
alert(getElement()); // null, 而不是 2
但是，在ECMAScript中经由过程try catch可以完成以下结果：
var $break = {};
function getElement() {
try {
[1, 2, 3].forEach(function (element) {
if (element % 2 == 0) {
// 直接从getElement"返回"
alert('found: ' + element); // found: 2
$break.data = element;
throw $break;
}
});
} catch (e) {
if (e == $break) {
return $break.data;
}
}
return null;
}
alert(getElement()); // 2
理论版本
一般，顺序员会毛病的以为，只要匿名函数才是闭包。实在并不是云云，正如我们所看到的 —— 恰是由于作用域链，使得一切的函数都是闭包（与函数范例无关： 匿名函数，FE，NFE，FD都是闭包）， 这里只要一类函数除外，那就是经由过程Function组织器建立的函数，由于其[[Scope]]只包括全局对象。 为了更好的廓清该题目，我们对ECMAScript中的闭包作两个定义（即两种闭包）：
ECMAScript中，闭包指的是：
- 从理论角度：一切的函数。由于它们都在建立的时刻就将上层高低文的数据保留起来了。哪怕是简朴的全局变量也是云云，由于函数中接见全局变量就相称因而在接见自在变量，这个时刻运用最外层的作用域。
- 从实践角度：以下函数才算是闭包：
- 纵然建立它的高低文已烧毁，它依然存在（比方，内部函数从父函数中返回）
- 在代码中援用了自在变量
闭包实践
实际运用的时刻，闭包可以建立出非常文雅的设想，许可对funarg上定义的多种盘算体式格局举行定制。 以下就是数组排序的例子，它接收一个排序前提函数作为参数：
[1, 2, 3].sort(function (a, b) {
... // 排序前提
});
一样的例子另有，数组的map要领（并不是一切的完成都支撑数组map要领，SpiderMonkey从1.6版本最先有支撑），该要领依据函数中定义的前提将原数组映射到一个新的数组中：
[1, 2, 3].map(function (element) {
return element * 2;
}); // [2, 4, 6]
运用函数式参数，可以很轻易的完成一个搜刮要领，而且可以支撑无限多的搜刮前提：
someCollection.find(function (element) {
return element.someProperty == 'searchCondition';
});
另有运用函数，比方罕见的forEach要领，将funarg运用到每一个数组元素：
[1, 2, 3].forEach(function (element) {
if (element % 2 != 0) {
alert(element);
}
}); // 1, 3
趁便提下，函数对象的 apply 和 call要领，在函数式编程中也可以用作运用函数。 apply和call已在议论“this”的时刻引见过了；这里，我们将它们看做是运用函数 —— 运用到参数中的函数（在apply中是参数列表，在call中是自力的参数）：
(function () {
alert([].join.call(arguments, ';')); // 1;2;3
}).apply(this, [1, 2, 3]);
闭包另有别的一个非常重要的运用 —— 耽误挪用：
var a = 10;
setTimeout(function () {
alert(a); // 10, 一秒钟后
}, 1000);
也可以用于回调函数：
...
var x = 10;
// only for example
xmlHttpRequestObject.onreadystatechange = function () {
// 当数据停当的时刻，才会挪用;
// 这里，不论是在哪一个高低文中建立，变量“x”的值已存在了
alert(x); // 10
};
..
还可以用于封装作用域来隐蔽辅佐对象：
var foo = {};
// initialization
(function (object) {
var x = 10;
object.getX = function _getX() {
return x;
};
})(foo);
alert(foo.getX()); // get closured "x" – 10
总结
本文引见了更多关于ECMAScript-262-3的理论学问，而我以为，这些基本的理论有助于明白ECMAScript中闭包的观点。
