javascript单体模式

单体模式的思想在于保证一个特定类仅有一个实例。这意味着当第二次使用同一个类创建的新对象的时候，应该得到与第一个所创建的对象完全相同。

javacript中并没有类，因此对单体咬文嚼字的定义严格来说并没有意义。但是javascript具有new语法可使用构造函数来创建对象，而且有时需要使用这种语法的单体实现。这种思想在于当使用同一个构造函数以new操作符来创建多个对象时，应该仅获得指向完全相同的对象的新指针。

下面的代码显示了其预期行为：

var nui = new Universe();
var nui2 = new Universe();
nui === nui2; //结果为true

上面例子中，uni对象仅在第一次调用构造函数时被创建。在第二次创建时会返回同一个对象。这就是为什么nui === nui2，我们可以写出2种做法。

静态属性中的实例

下面代码是一个在Universe构造函数静态属性中缓存单个实例的列子：

function Universe(){

    //如果有实例，返回出去
    if(typeof Universe.instance === 'object'){
        return Universe.instance;
    }
    this.start_time = 0;
    this.bang = 'Big';

    //缓存
    Universe.instance = this;
}
//测试
var nui = new Universe();
var nui2 = new Universe();
console.log( nui === nui2); //结果为true

正如你所看到的，这种做法的缺点在于instance是公开的。虽然其他代码不太可能会无意中修改该属性，但是仍有这种可能。

闭包中的实例

另外一种实现类似于类的单体方法是采用闭包来保护单个实例。

代码如下:

function Universe(){
    
    //缓存实例
    var instance = this;
    
    this.start_time = 0;
    this.bang = 'Big';

    Universe = function(){
        return instance;
    }
}
//测试：
var uni = new Universe();
var uni2 = new Universe();
console.log( uni == uni2 );  //结果为tur

这种做法会丢失所有在初始定义和重定义时刻时间添加到它里面的属性。这里的特定情况下，任何添加到Universe的原型中的对象都不会存在指向由原始实现所创建实例的活动连接。

通过下面一些测试，可以看到这个问题：

向原型添加属性

Universe.prototype.nothing = true;
var uni = new Universe();
Universe.prototype.everything = true;
var uni2 = new Universe();

开始测试：
仅有最初的原型
连接到对象上
console.log(uni.nothing); //结果为true
console.log(uni2.nothing); //结果为true

console.log(uni.everything); //结果为undefined
console.log(uni2.everything); //结果为undefined

结果看上去是正确的
console.log( uni.constructor.name ); //结果为Universe
console.log( uni.constructor === Universe); //结果为false

之所以uni.constructor不再与Universe()构造函数相同，是因为nui.constructor仍然指向了原始的构造函数，而不是重新定义的那个构造函数。

从需求上来说，如果需要使用原型和构造函数指针按照预期的那样运行，那么可以通过做一些调试来实现这个目标：

function Universe(){

    //缓存实例
    var instance;

    //重写构造函数
    Universe = function Universe(){
        return instance;
    }
    
    //保留原型属性
    Universe.prototype = this;
    
    //实例
    instance = new Universe();

    //重置构造函数指针
    instance.constructor =  Universe;

    //所有功能
    instance.start_time = 0;
    instance.bang = 'Big';

    return instance;
}

//更新原型并创建实例
Universe.prototype.nothing = true; //结果为true
var uni = new Universe();
Universe.prototype.everything = true; //结果为true
var uni2 = new Universe();

//相同的实例
console.log( uni === uni2 ); //结果为true

//所有原型属性
console.log( uni.nothing && uni.everything && uni2.nothing && uni2.everything ); //结果为true

//构造函数指针正确
console.log( uni.constructor === Universe); //结果为true

一个对象字面量创建一个简单的对象也是一个单体的例子：

var obj = {
     myprop : 'my value'      
};
var obj2 = {
     myprop : 'my value'  
};

console.log( obj === obj2 ); //false
console.log( obj == obj2 );   //false