迎接移步我的博客浏览：《明白闭包》

闭包 是指能够包含自在（未绑定到特定对象）变量的代码块；这些变量不是在这个代码块内或许任何全局高低文中定义的，而是在定义代码块的环境中定义（局部变量）。“闭包” 一词来源于以下二者的连系：要实行的代码块（由于自在变量被包含在代码块中，这些自在变量以及它们援用的对象没有被开释）和为自在变量供应绑定的盘算环境（作用域）。

作用域

闭包的一个重点在于作用域，在 JavaScript 中变量的作用域分两种：全局变量与局部变量，起首让我们来相识一下：

var _global = 1;  // 全局变量

function print() {
  var _internal = 2;  // 局部变量

  console.log(_global); // 1
  console.log(_internal); // 2
  return _internal;
}

print();
console.log(_global); // 1
console.log(_internal); // ReferenceError: _internal is not defined

此时我们能够看到，在函数内部是能够直接读取全局变量的。但当我们在外部想接见内部变量时，就会报错，由于在函数体外部时没法接见函数内部的变量的。

须要注重的是，当在函数内部定义变量时没用运用 var 等声明变量，那末它现实上会成为一个全局变量：

function print() {
  _internal = 2;
}

console.log(_internal); // 2

从内存中诠释，变量的声明都存在栈中，而在 JavaScript 中存在渣滓接纳机制（garbage collection），当一个函数实行完返回以后，它的内存会被自动接纳，此时函数内部的变量都会被烧毁。

那末我们有什么要领能够保留这一内存，而且在外部接见函数内部的变量呢 —— 闭包。

闭包

在一般情况下，我们在外部时没法修正函数内部变量的值：

// 场景 1
function print(x) {
  var _internal = 1;

  console.log(_internal + 1);
}

print(1); // 2
// ...
print(1); // 2

我们能够看到，不管 print() 挪用多少次，打印的值都是 2，_internal 的值都是 1。

这是由于 JavaScript 中的渣滓接纳机制，在屡次挪用 print() 时，每一次都须要接纳前一次的内存，以后再次请求新内存，因而 _internal 没法在内存中继承保留。

换而言之，在每次挪用 print() 时都须要为其和内部的变量请求新的内存空间，第一次 _internal 的内存地点能够为 0x...1，在函数挪用完成以后，这块内存将被开释，再次挪用时 _internal 的内存地点能够就是 0x...2 了。因而它没法再内存中被保留下来。

那末我们须要在外部运用函数内部的变量时，就须要在函数内部再声明一个函数，并将其返回：

function print() {
  var _internal = 1;

  return function log() {
    console.log(_internal);
  }
}

var test = print();
test(); // 1

此时，我们已能够从外部接见 print() 函数内部的变量了。

当我们须要对 print() 函数内部的 _internal 的值举行修正时，我们能够给它别的一个函数：

// 场景 2
var add;
function print() {
  var _internal = 1;

  add = function(x) {
    _internal += x;
  }

  return function log() {
    console.log(_internal);
  }
}

var test = print();
test(); // 1
add(1);
test(); // 2

经由上述能够看出，函数 print() 在经由 add() 运转以后，_internal 的值分别为 1 和 2，这就说清楚明了 _internal 一直保留在内存中，并没有在 var test = print(); 挪用时被接纳。

这是由于 print() 内的 log() 作为返回值，被赋给 test 这个全局变量，因而 log() 一直在内存中。而 log() 依靠 print() 而且能够接见 _internal，所以 print() 也一直在内存中，而且在 var test = print(); 挪用时没有被接纳。

换而言之，当 _internal 在声明的时刻分配了内存，我们能够将其内存地点示意为 0x...1，在 print() 函数被挪用以后应当会被接纳，然则由于上述原因，没有被接纳，它的值将继承保留在地点为 0x...1 中。在外部能够运用指针去寻址，并获得其值。

其他例子

在轮回体中，我们能够碰到：

function loopA() {
  var arr = [];

  for(var i = 0; i < 10; i++) {
    arr[i] = function() {
      return i;
    }
  }

  return arr;
}

var test = loopA();
test[0]();  // 10
test[1]();  // 10
// ...
test[9]();  // 10

在上述例子中，我们须要他们实行差别的参数获得差别的值。然则一共建立了 10 次匿名函数，，他们都是同享同一个环境的。在匿名函数实行之前，轮回早已完成，此时的匿名函数一局指向轮回体中的末了一个值了。

• 解决方案 1：
  在 es6 中我们能够运用 let 声明：

  function loopA() {
    var arr = [];
  
    for(let i = 0; i < 10; i++) {
      arr[i] = function() {
        return i;
      }
    }
  
    return arr;
  }
  
  var test = loopA();
  test[0]();  // 0
  test[1]();  // 1
  // ...
  test[9]();  // 9

• 解决方案 2：
  将函数声明放在轮回体外部：

  function loopA() {
    var arr = [];
    var func = function(n) {
      return n;
    }
  
    for(var i = 0; i < 10; i++) {
      arr[i] = func(i)
    }
  
    return arr;
  }
  
  var test = loopA();
  test[0];  // 0
  test[1];  // 1
  test[9];  // 9

• 解决方案 3：

  function loopA() {
    var arr = [];
  
    for(var i = 0; i < 10; i++) {
      arr[i] = (function(i) {
        return i;
      })(i)
    }
  
    return arr;
  }
  
  var test = loopA();
  test[0];  // 0
  test[1];  // 1
  test[9];  // 9

• 其他解决方案请看参考

弊病

• 内存走漏：由于闭包会使得函数内部的变量都被保留在内存中，不会被烧毁，内存斲丧很大。因而须要在退出函数之前，将不运用的变量都删除。

• 会修正函数内部变量的值。

总结

闭包是一种特别的对象。它由两部分构成：函数，以及建立该函数的环境。环境由闭包建立时在作用域中的任何局部变量构成。
假如不是由于某些特别任务而须要闭包，在没有必要的情况下，在别的函数中建立函数是不明智的，由于闭包对剧本机能具有负面影响，包含处置惩罚速率和内存斲丧。

参考

百度百科 – 闭包
Wikipedia – Closure
进修 Javascript 闭包（Closure）
MDN – 闭包
深切明白闭包系列第二篇——从实行环境角度看闭包
深切明白闭包系列第四篇——罕见的一个轮回和闭包的毛病详解
深切明白javascript原型和闭包（15）——闭包