javascript闭包详解

概念：闭包是指在JavaScript中，内部函数总是可以访问其所在的外部函数中声明的参数和变量，即使在其外部函数被返回了之后，这意味着当前作用域总是能够访问外部作用域中的变量。因为函数是javascript中唯一拥有自身作用域的结构，因此闭包的创建依赖于函数。

接下来我们开始进行分析，上代码：

function init() {

     var name = "Hello World";

     function displayName() {

          alert(name);

     }

     displayName();

}

init();

函数init()创建了一个局部变量name，然后定义了名为displayName()的函数。

displayName()是一个内部函数(inner function)定义于init()之内且仅在该函数体内可用。displayName()没有任何自己的局部变量，而是重用了声明在外围函数中的name变量。

这种方式没有什么问题-可以试试运行这段代码看看会发生什么。这就是所谓函数作用域（functional scoping）的一个例子：在JavaScript中，变量的作用域是由它在源代码中所处的位置定义的，且嵌套的函数可以访问在其外层作用域中声明的变量。

现在来考虑如下的例子：

function makeFunc() {

     var name = "Hello World";

     function displayName() {

          alert(name);

     }

     return displayName;

}

var myFunc = makeFunc();

myFunc();

运行这段代码的效果和之前的init()示例完全一样：字符串"hello world"将被显示在一个JavaScript警告框中。其中的不同也是有意思的地方：在于displayName()内部函数在执行前被从其外围函数中返回了。

这段代码看起来别扭却能正常运行。通常，函数中的局部变量仅在函数的执行期间可用。一旦makeFunc()执行过后，我们会很合理的认为name变量将不再可用。不过，既然代码运行的没问题，显然不是我们想象的那样。

这个答案是myFunc变成一个闭包了。闭包是一种特殊的对象。它由两部分构成：函数，以及创建该函数的环境。环境由闭包创建时在作用域中的任何局部变量组成。在我们的例子中，myFunc是一个闭包，由displayName函数和闭包创建时存在的"hello world"字符串形成。

下面是一个更有意思的示例：makeAdder函数：

function makeAdder(x) {

     return function(y) {

          return x + y;

     };

}

var add5 = makeAdder(5);

var add10 = makeAdder(10);

alert(add5(2)); // 7

alert(add10(2)); // 12

在这个示例中，我们定义了makeAdder(x)函数：带有一个参数x并返回一个新的函数。返回的函数带有一个参数y，并返回x和y的和。

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

add5和add10都是闭包。他们共享相同的函数定义，但是保存了不同的环境。在add5的环境中，x为5.而在add10中，x则为10。

闭包的应用场景：缓存变量

代码示例：

error: (function(){

    var called = false;

    return function(e) {

        if (called) {

            return;

        }

         //code执行行

        called = true;

    }

})();

特定：error重复引用return回来的function时，called的值赋值过一次为true，会一直保留为true这种状态，不会被销毁

实用的闭包

接下来看看闭包的实践意义。闭包允许将函数与其所操作的某些数据（环境）关联起来。这显然类似于面向对象编程。在面向对象编程中，对象允许我们将某些数据（对象的属性）与一个或者多个方法相关联。

因而，一般说来，可以使用只有一个方法的对象的地方，都可以使用闭包。

在web中，您可能想这样做的情形非常普遍。大部分我们所写的web javascript代码都是事件驱动的：定义某种行为，然后将其添加到用户触发的事件之上（比如点击或者按键）。我们的代码通常添加为回调：响应事件而执行的函数。

以下是一个实际的示例：假设我们想在页面上添加一些可以调整字号的按钮。一种方法是以像素为单位指定body元素的font-size，然后通过相对的em单位设置页面中其它元素（例如页眉）的字号：

body {

     font-family: Helvetica, Arial, sans-serif;

     font-size: 12px;

}

h1 {

     font-size: 1.5em;

}

h2 {

     font-size: 1.2em;

}

我们的交互式的文本尺寸按钮可以修改body元素的font-size属性，而由于我们使用相对的单位，页面中的其它元素也会相应地调整。

以下是JavaScript：

function makeSizer(size) {

     return function() {

          document.body.style.fontSize = size + 'px';

     };

}

var size12 = makeSizer(12);

var size14 = makeSizer(14);

var size16 = makeSizer(16);

size12，size14和size16为将body文本相应地调整为12，14，16像素的函数。我们可以将它们分别添加到按钮上（这里是链接）。如下所示：

document.getElementById('size-12').onclick = size12;

document.getElementById('size-14').onclick = size14;

document.getElementById('size-16').onclick = size16;

<a href="#" id="size-12">12</a>

<a href="#" id="size-14">14</a>

<a href="#" id="size-16">16</a>

用闭包模拟私有方法

诸如Java在内的一些语言支持将方法声明为私有的，既它们只能被同一个类中的其它方法所调用。

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

下面的示例展现了如何使用闭包来定义公共函数，且其可以访问私有函数和变量。这个方式也成为模块模式（module pattern）：

var Counter = (function(){

     var privateCounter = 0;

     function changeBy(val) {

          privateCounter += val;

     }

     return {

          increment: function() {

               changeBy(1);

          },

          decrement: function() {

               changeBy(-1);

          },

          value: function() {

               return privateCounter;

          }

     };

})();

alert(Counter.value()); /*提示0*/

Counter.increment();

Counter.increment();

alert(Counter.value()); /*提示2*/

Counter.decrement();

alert(Counter.value()); /*提示1*/

这里有好多细节。在以往的示例中，每个闭包都有它自己的环境；而这次我们只创建了一个环境，为三个函数所共享：Counter.increment，Counter.decrement和Counter.value。

该共享环境创建于一个匿名函数体内，该函数一经定义立刻执行。环境中包含两个私有项：名为privateCounter的变量和名为changeBy的函数。这两项都无法在匿名函数外部直接访问。必须通过匿名包装器返回的三个公共函数访问。

这三个公共函数是共享同一个环境的闭包。多亏JavaScript的词法范围的作用域，它们都可以访问privateCounter变量和changeBy函数。

您应该注意到了，我们定义了一个匿名函数用于创建计数器，然后直接调用该函数，并将返回值赋给Counter变量。也可以将这个函数保存到另一个变量中，以便创建多个计数器。

var makeCounter = function() {

     var privateCounter = 0;

     function changeBy(val) {

          privateCounter += val;

     }

     return {

          increment: function() {

               changeBy(1);

          },

          decrement: function() {

               changeBy(-1);

          },

          value: function() {

               return privateCounter;

          }

     };

};

var Counter1 = makeCounter();

var Counter2 = makeCounter();

alert(Counter1.value()); /*提示 0*/

Counter1.increment();

Counter1.increment();

alert(Counter1.value()); /*提示 2*/

Counter1.decrement();

alert(Counter1.value()); /*提示 1*/

alert(Counter2.value()); /*提示 0*/

请注意两个计数器是如何维护它们各自的独立性的。每次调用makeCounter()函数期间，其环境是不同的。每次调用中，privateCounter中含有不同的实例。

这种形式的闭包提供了许多通常由面向对象编程所享有的益处，尤其是数据隐藏和封装。

在循环中创建闭包：一个常见错误

在JavaScript 1.7 引入 let关键字之前，闭包的一个常见的问题发生于在循环中创建闭包。参考下面的示例：

<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>

<script type="text/javascript">

     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();

</script>

数组helpText中定义了三个有用的提示信息，每一个都关联于对应的文档中的输入域的ID。通过循环这三项定义，依次为每一个输入域添加了一个onfocus事件处理函数，以便显示帮助信息。

运行这段代码后，您会发现它没有达到想要的效果。无论焦点在哪个输入域上，显示的都是关于年龄的消息。

该问题的原因在于赋给onfocus的函数是闭包；它们由函数定义和记录自setupHelp函数作用域的环境构成。一共创建了三个闭包，但是它们都共享同一个环境。在onfocus的回调被执行时，循环早已经完成，且此时item变量（由所有三个闭包所共享）已经指向了helpText列表中的最后一项。

解决这个问题的一种方案是使用更多的闭包：特别是使用前文所述的函数工厂。

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数组中对应的字符串。

性能考量

如果不是因为某些特殊任务而需要闭包，在没有必要的情况下，在其它函数中创建函数是不明智的，因为闭包对脚本性能具有负面影响，包括处理速度和内存消耗。

例如，在创建新的对象或者类时，方法通常应该关联于对象的原型，而不是定义到对象的构造器中。原因是这将导致每次构造器被调用，方法都会被重新赋值一次（也就是说，为每一个对象的创建）。

考虑以下虽然不切实际但却说明问题的示例：

function MyObject(name, message) {

     this.name = name.toString();

     this.message = message.toString();

     this.getName = function() {

          return this.name;

     };

     this.getMessage = function() {

          return this.message;

     };

}

上面的代码并未利用到闭包的益处，因此，应该修改为如下常规形式：

function MyObject(name, message) {

     this.name = name.toString();

     this.message = message.toString();

}

MyObject.prototype = {

     getName: function() {

          return this.name;

     },

     getMessage: function() {

          return this.message;

     }

};

或者改成：

function MyObject(name, message) {

     this.name = name.toString();

     this.message = message.toString();

}

MyObject.prototype.getName =  function() {

          return this.name;

};

MyObject.prototype.getMessage = function() {

          return this.message;

};

在前面的两个示例中，继承的原型可以为所有对象共享，且不必在每一次创建对象时定义方法。