JavaScript：闭包

• 什么是闭包（what）

  简单讲，闭包由两部分构成：函数，以及创建该函数的环境。环境由闭包创建时在作用域中的任何局部变量组成。

  理解闭包的关键在于：无论什么时候在函数中访问一个变量时，就会从作用域链中搜索具有相应名字的变量。一般来讲，当函

  数执行完毕后，局部活动对象就会被销毁，内存中仅保存全局作用域（全局执行环境的变量对象）。但是，闭包的情况有所不

  同。

 调用closure()返回匿名函数，这个匿名函数仍然可以访问外部closure的局部变量a，所以closure执行完成后localVal不能被释放。

  closure()调用结束，b()再次调用的时候仍然能访问到外层的closure()这个外函数的局部变量。这种情况就是通常所说的闭包。

//普通函数
function closure() {
    var a = 1;
    return a;          // 1
}

//举个例子-->闭包：
function closure() {
    var a = 1;      //定义一个内部变量
    return function() {
        return a;   //返回a的变量值
    };
}
var b = closure();
console.log(b());  //   1

• 产生一个闭包（produce）

   创建闭包最常用的方式，就是在一个函数内部嵌套另外一个函数。 

// 创建闭包函数：
function func() {
    var a = 1,b = 2;      //定义变量
    function closure() {  //闭包函数
        return a + b;     //返回a + b的值
    };
    return closure;       //返回闭包函数
}

 闭包的作用域链包含着它自己的作用域，以及包含它的函数的作用域和全局作用域。

  通常，函数的作用域及其所有变量都会在函数执行结束后被销毁。但是，在创建了一个闭包以后，这个函数的作用域就会一直

  保存到闭包不存在为止。

• 闭包的注意事项（pay）

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

//释放对闭包
add5 = null;
add10 = null;

  可以看到add5 和 add10 都是闭包。它们共享相同的函数定义，但是保存了不同的环境。在 add5 的环境中，x 为 5。而在

  add10 中，x 则为 10。最后通过 null 释放了 add5 和 add10 对闭包的引用。

  在javascript中，如果一个对象不再被引用，那么这个对象就会被垃圾回收机制回收；

  如果两个对象互相引用，而不再被第3者所引用，那么这两个互相引用的对象也会被回收。 

  闭包只能取得包含函数中任何变量的最后一个值

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

  arr数组中包含了10个匿名函数，每个匿名函数都能访问外部函数的变量i，那么i是多少呢？

  当arrFunc执行完毕后，其作用域被销毁，但它的变量对象仍保存在内存中，得以被匿名访问，这时i的值为10。

  要想保存在循环过程中每一个i的值，需要在匿名函数外部再套用一个匿名函数，在这个匿名函数中定义另一个变量并且立即执

  行来保存i的值。 

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

console.log(aeeFunc()[1]());   // 1

  这时最内部的匿名函数访问的是num的值，所以数组中10个匿名函数的返回值就是1-10。 

  在闭包中使用this对象也可能会导致一些问题。

• 闭包中的this对象（object）

  this对象是在运行时基于函数的执行环境绑定的：

• 在全局函数中，this等于window
• 函数作为某个对象的方法调用时，this等于那个对象。
• 匿名函数的执行具有全局性，因此其this对象通常指向window。

   有的时候，由于编写闭包的方式不同，匿名函数的this指向window这一点可能不会那么明显。

var name="The Window";
var object={
    name:"My Object",
    gFunc:function(){
        'use strict';
        return function(){
            return this.name;
        }
    }
}
console.log(object.gFunc()());   //The Window （非严格模式）

  object包含一个name属性，还包含一个方法—gFunc()，返回一个匿名函数，而匿名函数又返回this.name。

  由于gFunc()返回一个函数，因此调用object.gFunc()()就会立即调用它返回的函数，结果就是返回一个字符串。

  这个例子返回的字符串是“The Window”，即全局name变量的值。为什么匿名函数没有取得其包含作用域（或者外部作用域）的

  this对象呢？

  每个函数在被调用时，其活动对象都会自动取得两个特殊变量：this和arguments。内部函数在搜索这两个变量时，只会搜索到

  内部函数自己的活动对象为止，可以看上面的原理图，因此永远不可能直接访问外部函数中的这两个变量。

  可以把外部作用域的this对象保存在一个闭包能够访问到的变量里，就可以让闭包访问该对象了。

var name="The Window";
var object={
    name:"My Object",
    gFunc:function(){
         var that=this;
        return function(){
                return that.name;
        }
    }
}
console.log(object.gFunc()());    //My Object

  在几种特殊情况下，this的值可能会意外地改变。下面是代码修改前不同调用方式下的结果。 

var name="The Window";
var object={
    name:"My Object",
    getName:function(){//getName()方法简单地返回this.name的值
        return this.name;
    }
}
//几种不同调用object.getName()的方式
console.log(object.getName());//My Object
console.log((object.getName)());//My Object
console.log((object.getName=object.getName)());//The Window

   闭包会引用包含函数的整个变量对象，如果闭包的作用域链中保存着一个HTML元素，那么就意味着该元素无法被销毁。所以

   我们有必要在对这个元素操作完之后主动销毁。

•  object.getName()普通调用

• (object.getName)()调用getName()方法前先给它加上了括号。虽然加上了括号之后，就好像只是在引用一个函数，但this的值得到了维持，因为object.getName和(object.getName)的定义是相同的。

• (object.getName=object.getName)()先执行一条赋值语句，然后再调用赋值后的结果。因为这个赋值表达式的值是函数本身，所以this的值不能得到维持，结果就返回了“The Window”。

• 内存泄漏（Memory leak）

function leakHandler() {
    var element = document.getElementBtId("someElemwnt");
    var id =element.id;
    element.onclick = function() {
        alert(id);
    };
    element = null;
}

   当函数内部的定时器引用了外部函数的变量对象时，该变量对象不会被销毁。

• 函数内部的定时器（timer）

(function leakHandler() {
    var a = 0;
    setInerval(function(){
        console.log(a++);
    },1000);
})();

   应用闭包的主要场合是：设计私有的方法和变量。

   任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数外部访问这些变量。私有变量包括函数的参数、局部变量

   和函数内定义的其他函数。

   把有权访问私有变量的公有方法称为特权方法（privileged method）。

• 闭包的应用（application）

var singleton ={
    name:"snco",
    speak: function(){
        console.log("speaking!!!");
    },
    getName: function(){
        return this.name;
    }
}

  在这里，我们需要理解两个概念：

  模块模式（The Module Pattern）：为单例创建私有变量和方法。

  单例（singleton）:指的是只有一个实力的对象。JavaScript 一般以对象字面量的方式来创建一个单例对象。

  普通模式创建的单例： 

var singleton ={
    name:"snco",
    speak: function(){
        console.log("speaking!!!");
    },
    getName: function(){
        return this.name;
    }
}

   模块模式创建单例：

var singleton = (function(){
    //私有变量
    var age = 25;
    var speak = function(){
        console.log("speaking!!!");
    };

    //特权（公有）属性和方法
    return {
        name:"percy",
        getAge: function(){
            return age;
        };
    };
})();

  匿名函数最大的用途是创建闭包，并且还可以构建命名空间，以减少全局变量的使用。从而使用闭包模块化代码，减少全局变

  量的污染。 

  在这段代码中函数 addEvent 和 removeEvent 都是局部变量，但我们可以通过全局变量 objEvent 使用它，这就大大减少了全局

  变量的使用，增强了网页的安全性。

var objEvent= objEvent || {};
(function(){
    var addEvent = function(){
        //some code
    };
    function removeEvent(){
        //some code
    }

    objEvent.addEvent = addEvent;
    objEvent.removeEvent = removeEvent;
})();

• 运用闭包的关键（crux）

  闭包引用外部函数变量对象中的值；

  在外部函数的外部调用闭包。

  闭包的缺陷

  闭包的缺点就是常驻内存会增大内存使用量，并且使用不当很容易造成内存泄露。

  如果不是因为某些特殊任务而需要闭包，在没有必要的情况下，在其它函数中创建函数是不明智的，因为闭包对脚本性能具有

  负面影响，包括处理速度和内存消耗。

function func(n,0){
    console.log(0);
    return {
        func: function(m){
            return func(m,n);
        }
    };
}

var a = func(0);a.func(1);a.func(2);a.func(3);
//undefined 0 0 0 

var b =func(0).func(1).func(2).func(3);
//undefined 0 1 2 

var c = func(0).func(1);c.func(2);c.func(3);
//undefined 0 1 1 

   具体分析分析过程，请阅读：经典例题（闭包） -- 分析思路