一文彻底弄懂闭包，认真总结6千字

1. 什么是闭包？

通俗来讲，闭包就是使内层函数可以访问到其外层函数的作用域，即使该内层函数被调用过，该外层函数中变量仍会保存在内存中，不会被销毁。在JavaScript中，每当创建一个函数，闭包就会在函数创建的同时被创建出来。

官方说法，闭包指的是一个函数和对其周围状态（词法环境）的引用捆绑在一起形成的组合。

2. 什么是词法环境

词法一词指的是，词法作用域根据源代码中声明变量的位置来确定该变量在何处可用。

嵌套函数（闭包）可访问声明与它们外部作用域的变量。

个人认为，在JS中，当前作用域内的变量，在该变量所处的作用域内(包含当前作用域的所有子作用域内），都可以进行调用。这也是为什么闭包形成的环境可以调用外部作用域变量的原因。

例如在下列代码中：

function main(){
    let a = 'hello';
    for ( let i = 0; i < 5; i++){
        let b = a + 'world';
        console.log(b);
    }
}

变量a在for循环中仍然可以使用，但变量b却只能在for循环内进行使用。

因为变量b的作用域（词法环境）为for循环，而变量a的作用域（词法环境）是当前main函数内。

但闭包相比于上述解释之外，更重要的地方在于，当闭包所处的外部函数被调用后，该闭包所调用的外部变量仍然可用，并没有被销毁。因为闭包是由函数以及声明该函数的词法环境组合而成的。该环境包含了这个闭包创建时作用域内的任何局部变量。

3. 闭包示例1

我们通过一个简单的加法函数来解释一下闭包：

function makeAdder(x) {
  return function(y) {
    return x + y;
  };
}

var add5 = makeAdder(5);
var add10 = makeAdder(10);

console.log(add5(2));  // 7
console.log(add10(2)); // 12

在上述代码中，定义了 makeAdder(x) 函数，它接受一个参数 x ，并返回一个新的函数（这个新的函数就是闭包）。返回的函数接受一个参数 y，并返回x+y的值。

从本质上讲，makeAdder 是一个函数工厂 — 他创建了将指定的值和它的参数相加求和的函数。在上面的示例中，使用函数工厂创建了两个新函数 — 一个将其参数和 5 求和，另一个和 10 求和。

add5 和 add10 都是闭包（即makeAdder(x）函数返回的那个函数）。它们共享相同的函数定义，但是保存了不同的词法环境。在 add5 的环境中，x 为 5。而在 add10 中，x 则为 10。

4. 闭包示例2-实现一个闭包环境独立的计数器

var makeCounter = function() {
  var privateCounter = 0;
  function changeBy(val) {
    privateCounter += val;
  }
  return { // return的是一个对象，对象里每个键对应的值是一个函数，因此调用时要加()
    increment: function() {
      changeBy(1);
    },
    decrement: function() {
      changeBy(-1);
    },
    value: function() {
      return privateCounter;
    }
  }
};

var Counter1 = makeCounter();
var Counter2 = makeCounter();
console.log(Counter1.value()); /* 输出 0 */
Counter1.increment();
Counter1.increment();
console.log(Counter1.value()); /* 输出 2 */
Counter1.decrement();
console.log(Counter1.value()); /* 输出 1 */
console.log(Counter2.value()); /* 输出 0 */

上述代码实现了两个相互独立的计数器。

makeCounter是计时器工厂，return的闭包是一个对象，该对象里每个键对应的值都是一个函数。

该对象里的每一个函数都可以调用makeCounter工厂提供的privateCounter变量和changeBy()方法。同时private变量和changeBy()方法不会在调用结束后失效。

Counter1和Counter2都是由makeCounter生成的闭包。

因为该闭包是一个对象（前一个例子里闭包是一个函数），因此在调用闭包内的方法时，正确写法是Counter1.value()，而不是Counter.value,这是我自己实践时踩坑的一个点。

5. 在循环中使用闭包时容易踩坑的点

在 ECMAScript 2015 引入let关键字之前，在循环中有一个常见的闭包创建问题（推荐大家在平常写代码时使用let和const，var变量容易有变量提升等问题，不推荐使用）。参考下面的示例：

<p id="help">Helpful notes will appear here</p>
<p>E-mail: <input type="text" id="email" name="email"></p>
<p>Name: <input type="text" id="name" name="name"></p>
<p>Age: <input type="text" id="age" name="age"></p>

function showHelp(help) {
  document.getElementById('help').innerHTML = help;
}

function setupHelp() {
  var helpText = [
      {'id': 'email', 'help': 'Your e-mail address'},
      {'id': 'name', 'help': 'Your full name'},
      {'id': 'age', 'help': 'Your age (you must be over 16)'}
    ];

  for (var i = 0; i < helpText.length; i++) {
    var item = helpText[i];
    document.getElementById(item.id).onfocus = function() {
      showHelp(item.help);
    }
  }
}

setupHelp();

在上述代码中，执行setupHelp()方法后，并不会按照预期使得焦点落到三个input时，id为help的p标签显示该input对应的help语句。而是统一显示helpText最后一个数组元素的help。

这是因为变量item使用var进行声明，由于变量提升，所以具有函数作用域（详见我下一篇博客讲解什么是函数作用域）。

而赋值给 onfocus 的是闭包，这些闭包是由他们的函数定义和在 setupHelp 作用域中捕获的环境所组成的。这三个闭包在循环中被创建，但他们共享了同一个词法作用域，在这个作用域中存在一个变量item。

当onfocus的回调执行时，item.help的值被决定。由于循环在事件触发之前早已执行完毕，变量对象item（被三个闭包所共享）已经指向了helpText的最后一项。

因此导致最终被赋予同样的值。

针对该问题，有四种解决方法。最优的方式就是下列讲述的第一种，后面两种大家可以仅做了解

1. 用let来替换var

function showHelp(help) {
  document.getElementById('help').innerHTML = help;
}

function setupHelp() {
  var helpText = [
      {'id': 'email', 'help': 'Your e-mail address'},
      {'id': 'name', 'help': 'Your full name'},
      {'id': 'age', 'help': 'Your age (you must be over 16)'}
    ];

  for (var i = 0; i < helpText.length; i++) {
    let item = helpText[i];
    document.getElementById(item.id).onfocus = function() {
      showHelp(item.help);
    }
  }
}

setupHelp();

let的声明方式使得每个闭包都绑定了块作用域的变量，有效解决由于var变量提升带来的问题。

2. 使用匿名闭包

function showHelp(help) {
  document.getElementById('help').innerHTML = help;
}

function setupHelp() {
  var helpText = [
      {'id': 'email', 'help': 'Your e-mail address'},
      {'id': 'name', 'help': 'Your full name'},
      {'id': 'age', 'help': 'Your age (you must be over 16)'}
    ];

  for (var i = 0; i < helpText.length; i++) {
    (function() {
       var item = helpText[i];
       document.getElementById(item.id).onfocus = function() {
         showHelp(item.help);
       }
    })(); // 马上把当前循环项的item与事件回调相关联起来
  }
}

setupHelp();

匿名闭包使得每一个闭包和它所在的词法环境与其他闭包相互独立，从而解决变量提升导致的问题。

3. 使用 forEach()来遍历helpText数组并给每一个<p>添加一个监听器。

function showHelp(help) {
  document.getElementById('help').innerHTML = help;
}

function setupHelp() {
  var helpText = [
      {'id': 'email', 'help': 'Your e-mail address'},
      {'id': 'name', 'help': 'Your full name'},
      {'id': 'age', 'help': 'Your age (you must be over 16)'}
    ];

  helpText.forEach(function(text) {
    document.getElementById(text.id).onfocus = function() {
      showHelp(text.help);
    }
  });
}

setupHelp();

4. 使用更多的闭包来约束词法环境

function showHelp(help) {
  document.getElementById('help').innerHTML = help;
}

function makeHelpCallback(help) {
  return function() {
    showHelp(help);
  };
}

function setupHelp() {
  var helpText = [
      {'id': 'email', 'help': 'Your e-mail address'},
      {'id': 'name', 'help': 'Your full name'},
      {'id': 'age', 'help': 'Your age (you must be over 16)'}
    ];

  for (var i = 0; i < helpText.length; i++) {
    var item = helpText[i];
    document.getElementById(item.id).onfocus = makeHelpCallback(item.help);
  }
}

setupHelp();

这段代码可以所期望的那样工作。所有的回调不再共享同一个环境， makeHelpCallback 函数为每一个回调创建一个新的词法环境。在这些环境中，help 指向 helpText 数组中对应的字符串。

6. 使用闭包的好处和坏处

1. 好处

（1）闭包使得外部可以读取函数内的局部变量。

javascript语言的特别之处就在于：函数内部可以直接读取全局变量，但是在函数外部无法读取函数内部的局部变量。

为了使外部可以读取函数内变量，我们可以通过闭包，即在函数A内再返回一个函数B,从而使得外界可以读取函数A内的变量。

（2）闭包使得变量的安全性更高。

编程语言中，比如 Java，是支持将方法声明为私有的，即它们只能被同一个类中的其它方法所调用。

而 JavaScript 没有这种原生支持，但我们可以使用闭包来模拟私有方法。私有方法不仅仅有利于限制对代码的访问：还提供了管理全局命名空间的强大能力，避免非核心的方法弄乱了代码的公共接口部分。

例如我们前面4提出的实现一个闭包环境的计数器。

外界不需要关心这个makeCounter工厂是怎么工作的，只需要按要求调用响应的方法，即可实现相应的效果。感觉这又衍生出了工厂模式的知识点呢哈哈。

2. 坏处：

闭包在很多情况下确实很好用，但是因为闭包的调用最终是赋给了一个全局变量，所以导致它会一直存在于内存中，不会被js的垃圾回收机制回收，从而会影响计算机的性能，更严重点可能会导致内存泄露。因此在日常开发中，如果能不使用，还是减少使用吧~

刚在网上翻资料，又看到闭包相关的this指向问题。感兴趣的小伙伴可以运行看看效果：

　　var name = "The Window";

　　var object = {
　　　　name : "My Object",
　　　　getNameFunc : function(){
　　　　　　return function(){
　　　　　　　　return this.name;
　　　　　　};
　　　　}
　　};

　　alert(object.getNameFunc()());

　　var name = "The Window";

　　var object = {
　　　　name : "My Object",
　　　　getNameFunc : function(){
　　　　　　var that = this;
　　　　　　return function(){
　　　　　　　　return that.name;
　　　　　　};
　　　　}
　　};

　　alert(object.getNameFunc()());