单例模式

单例模式

单例模式是一种保证一个类仅仅拥有一个实例的模式，使用这种模式，全局仅仅有一个该类的实例，它的实现思路是，构造一个类，这个类拥有instance属性，这个属性是一个flag，当它为null时才能创建一个类的实例，并且把实例赋值给它；创建实例使用的一个静态方法一般命名为getInstance

实现一个不透明度单例模式

不透明单例特点是就是不能通过new Single来创建单例，而是通过
Single.getInstance，意味着我们必须知道构造函数里面的getInstance方法，Single构造函数对我们来说不是透明的

// 方法一： 使用this.instance作flag
var Single = function(name){
    this.name = name;
    this.instance = null;// 用来判断是否已经实例化
}
Single.prototype.getName = function(){
    console.log(this.name);
}
Single.getInstance = function(name){
       if (!this.instance) {
        this.instance = new Single(name);
       }
       return this.instance;
   }
var a = Single.getInstance('jinghong');
var b = Single.getInstance('shao');
console.log(a === b);

// 方法一：使用闭包把参数当作flag
var Single = function(name){
    this.name = name;
}
Single.prototype.getName = function(){
    console.log(this.name);
}
// 自调用函数返回一个函数，这个函数的调用环境和instace构成了闭包，所以在这个函数内部可以修改instance变量
Single.getInstance = (function(name){
       var instance = null;// 用来判断是否已经实例化
          return function(name){
            if (!instance) instance = new Single(name);
            return instance;
          }
       })();
var a = Single.getInstance('jinghong');
var b = Single.getInstance('shao');
console.log(a === b);

实现透明的单例

透明单例特点是就是不能通过new Single来创建单例，构造函数里面的内容我们不需要关心，也不用知道，有两种方法来实现单例：

/ 方法一 
// 用代理实现单例模式
var Single = (function(){
    // instance和Single都在闭包里面
    var instance = null;
    function Single(name){
        this.name = name;
      }
    Single.prototype.getName = function(){
      console.log(this.name);
    }
    // 下面这个函数返回出去
    return function(name){
      if (!instance) {
        instance = new Single(name);
      }
      return instance;
    }
})();
var a = new Single('jinghong');
var b = new Single('shao');
console.log(a === b);

//方法二
//把控制单例的条件语句下载构造函数里面
var Single = (function(){
    var instance = null;
    var Single = function(name){
    if (instance) {
        return instance;
    }
    this.name = name;
    instance = this;
}
    Single.prototype.getName = function(){
      console.log(this.name);
    }
    return Single;
})();
var a = new Single('jinghong');
var b = new Single('shao');
console.log(a === b);

javascript中常用惰性单例

在合适的情况才创建对象，并且只创建一个对象
原理：让getSingle返回一个新的函数，并且用变量result来保存fn的计算结果，result本身在闭包中，永远不会被销毁，在将来的请求中，如果result已经被赋值，那么就会将这个数返回；
应用场景举例： 将createXhr传入里面，如果已经调用了createXhr，再将createXhr传入里面，返回的结果仍然是之前调用的结果；

//惰性单例
function getSingle(fn){
   var result;
   return function(){
     return result || (result = fn.apply(this, arguments));
   }
}