单例模式

一个类只能有一个实例化对象。

实现思想

经典的实现方式是，创建一个类，这个类包含一个方法，这个方法在没有对象存在的情况下，将会创建一个新的实例对象。如果对象存在，这个方法只是返回这个对象的引用。

var mySingleton = (function () {
    var instance
    function Init(params) {
        this.name = params.name
    }
    return {
        getInstance: function(params){
            if(!instance){
                instance = new Init(params)
            } 
            return instance
        }
    }
})()

var a = mySingleton.getInstance({name:'alen'})
var b = mySingleton.getInstance({name:'kate'})

a === b //true  a.name => 'alen' b.name => 'alen'

闭包实现

js 中并没有类的概念，作为一种非常灵活的语言，我们还可以用闭包的方式去实现：

var MySingleton = (function(){
    var instance
    var MySingleton = function(name){
        if ( instance ){
            return instance
        }
        this.name = name
        instance = this
    }
    return MySingleton
})()
var a = new MySingleton('alen')
var b = new MySingleton('bob')
a === b  //true

默认情况下函数的返回值为undefined（即没有显示地定义返回值的话）,但是构造函数比较例外，new构造函数在没有return的情况下默认返回新创建的对象。但是在有显示返回值的情况下，如果返回值为基本数据类型的话（string，number，boolean，undefined，null），返回值仍然为新创建的对象，这一点比较奇怪，需要注意。只有在显示返回一个非基本数据类型的对象的时候，函数的返回值才为指定的对象。在这种情况下，this值所引用的对象就被丢弃了。

es6实现

es6引进类的概念

class Singleton{
    constructor(name){//类构造器
        this.name=name;
        this.instance;
    }
    static getInstance(name){//静态方法
        //如果有实例则返回，没有则创建并返回 
        return this.instance || (this.instance=new Singleton(name))
    }
}

let a=Singleton.getInstance('alen')
let b=Singleton.getInstance('kate')
a === b //true