闭包总结（2018.03.19）

什么是闭包？

简单讲，闭包就是指有权访问另一个函数作用域中的变量的函数。

不好理解？看下面一个简单的例子：

function func() {
    var a = 1, b = 2;
    function closure() {
         return a + b
    }
    return closure
}

上述代码中的closure就是一个闭包，是不是有点感觉了？

接下来再看下下面这句话：

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

有点晕？我们一点点来看：

function addNum() {
    var a = 1, b = 2;
    console.log("addNum->a", a);
    console.log("addNum->b", b);
    return (a + b);
}

addNum();
console.log("handle->a", a);
console.log("handle->b", b);

执行结果如上图，在函数执行结束后，作用域和变量立即被销毁。

如果有闭包存在：

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

var handleAddNum = addNum(5); 
console.log(handleAddNum(2));  // 7
console.log(handleAddNum(3));  // 8

结果和上个例子是不是有所不同，按理说，addNum被执行结束后，x就应该别销毁，但是因为有闭包的存在，x的作用域被继续保留了，想要销毁x，就要销毁闭包。

handleAddNum = null;

下面在看下一个比较经典的闭包问题：

function test(){
  var arr = [];
  for(var i = 0;i < 10;i++){
    arr[i] = function(){
      return i;
    };
  }
  for(var a = 0;a < 10;a++){
    console.log(arr[a]());
  }
}
test(); //结果连打十个10

分析下执行过程：

首先，在这个作用域内，都是至上而下执行的，var i定义了一个整个作用域上的变量，第一个for语句执行结束后，i为10, 然后是第二个for语句，执行arr[i] = function(){ return i};，因为在函数中没有找到i，会往上一层作用域去找，而上一层的i已经为10，所以会连续输出十个十。

把var改动成let后，看下执行结果：

function test(){
  var arr = [];
  for(let i = 0;i < 10;i++){
    arr[i] = function(){
      return i;
    };
  }
  for(var a = 0;a < 10;a++){
    console.log(arr[a]());
  }
}
test(); //输出0,1,2,3,4,5,6,7,8,9

分析下执行过程：

let 在定义变量时会开辟新的块级作用域，即每次for循环都会开辟出一块的新的作用域，所以当执行arr[i] = function(){ return i};时，没有找到i时，向上找，在let开辟的新的块级作用域中找到了i，即对应的0,1,2,3,4,5,6,7,8,9

闭包中的this对象：

有如下代码：

var obj = {
    name: 'yy',
    getThis: function() {
        console.log('this', this);
    } 
}

obj.getThis();

执行结果：this Object {name: "yy"}...就是我们普遍认为的函数在哪里定义就在哪里执行。

那再看下面这个例子：

var obj = {
    name: 'yy',
    getThis: function() {
        //匿名函数
        return function() {
             console.log('this', this);
        }
    } 
}
obj.getThis()();

执行结果：

this Window {speechSynthesis: SpeechSynthesis, caches: CacheStorage, localStorage: Storage, sessionStorage: Storage, webkitStorageInfo: DeprecatedStorageInfo…}

全局作用域中调用了匿名函数，所以this指向了window。

不要认为函数在哪里，其内部的this就指向哪里。匿名函数的执行环境具有全局性，因此其 this 对象通常指向 window。

巩固下，想想下面的结果是啥：

var name = "The Window";

var obj = {
  name: "My Object",
  
  getName: function(){
    var that = this;
    console.log('getName:', this);
    return function(){
      return that.name;
    };
  }
};

console.log(obj.getName()());

闭包的应用：设计私有的方法和变量

任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数外部访问这些变量。私有变量包括函数的参数、局部变量和函数内定义的其他函数。
把有权访问私有变量的公有方法称为特权方法（privileged method）。

function Animal(){
  
  // 私有变量
  var series = "哺乳动物";
  function run(){
    console.log("Run!!!");
  }
  
  // 特权方法
  this.getSeries = function(){
    return series;
  };
}

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

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

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

var singleton = (function(){
  
  // 私有变量
  var age = 22;
  var speak = function(){
    console.log("speaking!!!");
  };
  
  // 特权（或公有）属性和方法
  return {
    name: "percy",
    getAge: function(){
      return age;
    }
  };
})();

闭包的缺陷：

闭包的缺点就是常驻内存会增大内存使用量，并且使用不当很容易造成内存泄露。
如果不是因为某些特殊任务而需要闭包，在没有必要的情况下，在其它函数中创建函数是不明智的，因为闭包对脚本性能具有负面影响，包括处理速度和内存消耗。