闭包

关于闭包，如今有以下说法：

• 闭包是函数和声明该函数的词法环境的组合(MDN)
• 函数对象可以经由过程作用域链互相关联起来，函数体内部的变量都可以保留在函数作用域内。这类特征在盘算机科学文献中被称为闭包(JavaScript威望指南)
• 闭包，指的是词法示意包括不被盘算的变量的函数，也就是说，函数可以运用函数之外定义的变量(W3school)
• 闭包是指有权接见另一个函数作用域中的变量的函数(JavaScript高等程序设计)

依据分列递次也可以看出，我个人对这些说法的认同水平。实在人人说的都是同一个东西，只是形貌是不是正确的题目。
为了充足明白以上的说法，要先明白一些术语：

词法作用域

简朴来说，词法作用域就是：依据变量定义时所处的位置，来肯定变量的作用局限。(词法剖析，经由过程浏览包括变量定义在内的数行源码就可以晓得变量的作用域)
举例而言，定义在全局的变量，它的作用局限是全局的，所以被称为全局变量；定义在函数内部的变量，它的作用局限是部分的，所以被称为部分变量。

作用域链

函数在建立时，会同时保留它的作用域链。——这个保留的作用域链包括了该函数所处的作用域对象的鸠合。因为一切函数都在全局作用域下声明，所以这个保留的作用域链肯定包括全局作用域对象（global）。别的，假如函数是在其他函数内部声明的，那它保留的作用域链中除了global之外，还包括它建立时所处的部分作用域对象。（在chrome中直接标识为closure，在firefox中则标识为块）。明显，这个作用域链实际上是一个指向作用域对象鸠合的指针列表。

函数在实行时，会建立一个实行环境、实行时作用域链以及运动对象。——运动对象(activation object)是指当前作用域对象(处于运动状况的，它包括arguments、this以及一切部分变量)。实行时作用域链实际上是函数建立时保留的作用域链的一个复制，但它更长，因为运动对象被推入了实行时作用域链的前端。每次函数在实行时都邑建立一个新的实行环境(execution context)，它对应着一个全新的实行时作用域链。

依据JavaScript的渣滓接纳机制：平常情况下，函数在实行终了后，实行环境（包括实行时作用域链）将自动被烧毁，占用的内存将被开释。

渣滓接纳机制

JavaScript 是一门具有自动渣滓接纳机制的言语。
这类机制的道理是找出那些不再继承运用的变量，然后开释其占用的内存。如今，找出不再继承运用的变量的战略有两种：标记消灭（主流浏览器）和援用计数（IE8及以下）。
标记消灭：渣滓收集器在运转的时刻会给存储在内存中的一切变量都加上标记；然后，它会去掉环境中的变量以及被环境中的变量援用的变量的标记；末了，渣滓收集器烧毁那些带标记的值并接纳它们所占用的内存空间。渣滓收集器会根据牢固的时候距离周期性地实行这一操纵。
援用计数：当声清楚明了一个变量并将一个援用范例值赋给该变量时，则这个值的援用次数就是 1。假如同一个值又被赋给另一个变量，则该值的援用次数加 1。相反，假如包括对这个值援用的变量又取得了别的一个值，则这个值的援用次数减 1。当这个值的援用次数变成 0 时，则申明没有办法再接见这个值了，因此就可以够将其占用的内存空间接纳返来。如许，当渣滓收集器下次再运转时，它就会开释那些援用次数为零的值所占用的内存。（援用计数的失利的地方在于它没法处置惩罚轮回援用）

如今，什么是闭包呢？
——“闭包是函数和声明该函数的词法环境的组合”(MDN)

function a(){
  console.log('1');
}
a();

以上例子：函数a，和它建立时地点的全局作用域，组成一个闭包。因而有人说每一个函数实际上都是一个闭包，但正确来说，应该是每一个函数和它建立时所处的作用域组成一个闭包。
但这个闭包叫什么名字呢？
在chrome和firefox调试中，将函数a地点作用域的名字，作为闭包的名字；在JavaScript高等程序设计中则将函数a的名字，作为闭包的名字。如许一来，每一个函数都是一个闭包的说法好像又“正确”了一些。
实在我们誊写的一切js代码，都处在全局作用域这个大大的闭包当中，只是我们认识不到它作为一个闭包存在着。

function a(){
  var b = 1;
  function c(){
    console.log(b);
  }
  return c
}
var d = a();
d(); // 1

以上例子：除了函数a和全局作用域组成一个闭包之外，函数c和部分作用域（函数a的作用域）也组成一个闭包。
先不关注这些函数内部的逻辑，我们只看构造：
函数a声清楚明了，然后在var d = a();这一句实行。经由过程以上对词法作用域、作用域链以及渣滓接纳机制的明白，我们可以得出以下结论：
函数a在声明时保留了一个作用域链，在它实行时又建立了一个实行环境（以及实行时作用域链）。平常情况下，当函数a实行终了，它的实行环境将被烧毁。但在这个例子里，函数a中的变量c，被return打破作用域的限定赋值给了变量d，而变量c是一个函数，它运用了它建立时所处的作用域（函数a的作用域）中的变量b，这意味着，在函数d实行终了之前，函数c以及它建立时所处的作用域中变量（变量b）不可以被烧毁。
这打断了函数a实行环境的烧毁历程，它被保留了下来，以备函数d调用时运用。看看被保留的是什么？一个函数c和它建立时地点的作用域。一个闭包。

function a(){
  var b = 1;
  function c(){
    b++; console.log(b);
  }
  return c
}
var d = a();
d(); // 2
d(); // 3
var e = a();
e(); // 2
e(); // 3

以上例子，函数a被实行了两次并离别赋值给了d、e，明显，函数a的两次实行建立了两个实行环境，它们本该被烧毁，但因为函数c的存在（有权接见另一个函数内部变量的函数），它们被保留下来。函数d的两次实行，运用同一个实行环境中的变量b，所以b递增了；因为函数e运用的是另一个实行环境中的变量b，所以它重新开始递增。

所以，什么是闭包呢？
闭包是一个函数和它建立时地点作用域的组合。在我们一样平常运用中，通常是将一个函数定义在另一个函数的内部并从中返回，以使它成为一个在函数外部仍有权限接见函数内部作用域的函数。
jQuery就是定义在一个匿名自实行函数内部的函数，当它被赋值给全局作用域变量$和jQuery时，在全局作用域运用$和jQuery要领，就可以够接见到谁人匿名自实行函数的内部作用域（个中包括的变量等）。在jQuery这个例子中，内部函数jQuery和其地点的匿名自实行函数作用域就组成一个闭包。

一个典范的例子：

// html <ul><li></li><li></li><li></li></ul>
var lis = document.querySelector('ul').children;
for (var i = 0; i < lis.length; i++) {
  lis[i].addEventListener('click', function(){
    console.log(i);
  })
}
var event = document.createEvent('MouseEvent');
event.initEvent('click', false, false);
for (var j = 0; j < lis.length; j++) {
  lis[j].dispatchEvent(event);
}

为页面上的一切li标签绑定点击函数，点击后输出本身的序号。在以上例子中，明显将输出 3, 3, 3；而非 0, 1, 2；
一个浅显的诠释是，当点击li标签时，for轮回已实行终了，i的值已肯定。所以三个li标签点击输出同一个i的值。
我们轻微修改一下代码：

// html <ul><li></li><li></li><li></li></ul>
var lis = document.querySelector('ul').children;
for (var i = 0; i < lis.length; i++) {
  (function(i){
    lis[i].addEventListener('click', function(){
      console.log(i);
    })
  })(i);
}
var event = document.createEvent('MouseEvent');
event.initEvent('click', false, false);
for (var j = 0; j < lis.length; j++) {
  lis[j].dispatchEvent(event);
}

以上例子，当点击li标签时，for轮回已实行终了，i的值已肯定，可为什么效果会输出 0, 1, 2 呢？
实际上，这是闭包在作祟：
　　click事宜的匿名函数 跟外层自实行匿名函数的作用域组成了一个闭包。在轮回中，外层匿名自实行函数本该在实行完毕后烧毁它的实行环境，开释其内存，但因为它的参数（变量）i 还被事宜监听函数援用着，所以这个实行环境没法被烧毁，它将被保留着。每一次的轮回，匿名自实行函数都将实行一次，并保留一个实行环境；当轮回完毕，相似的实行环境共有三个，每一个内里的变量i的值都是差别的。
　　回到第一个例子，匿名事宜函数实际上和声明它的全局作用域也组成了一个闭包，但在三次轮回中，i 都不曾脱离这个闭包，它一向递增直至3，三个点击事宜函数援用同一个实行环境中的变量i，它们的值必定是雷同的。

脱离闭包的泥塘，给这个例子一个较为合理的写法：

// html <ul><li></li><li></li><li></li></ul>
var lis = document.querySelector('ul').children;
var say = function(){
  console.log(this.index);
}
for (var i = 0; i < lis.length; i++) {
  lis[i].index = i;
  lis[i].addEventListener('click', say);
}

var event = document.createEvent('MouseEvent');
event.initEvent('click', false, false);
for (var j = 0; j < lis.length; j++) {
  lis[j].dispatchEvent(event);
}

总结：明白闭包的观点是主要的，但我们不该当过量的运用闭包，它有长处，也优缺点，是一把双刃剑。运用闭包可以建立一个关闭的环境，使得我们可以保留私有变量，防止全局作用域定名争执，加强了封装性；但它常驻内存的特征也对网页的机能形成了比较大的影响，在援用计数的渣滓接纳战略下更轻易形成内存走漏。