下面我就详细讲解一下“JS实现单例模式的6种方案汇总”的完整攻略。

什么是单例模式

单例模式是一种常用的设计模式，它可以确保一个类只有一个实例，并提供了一个全局访问点。这对于管理共享的资源非常有用，比如线程池、数据库连接池等。

为什么要使用单例模式

使用单例模式可以避免不必要的资源浪费，提高程序性能，并且可以确保全局的一致性。

6种方案汇总

1. 普通模式

这种实现方式比较简单，只需要用一个变量来存储实例，然后在实例化时判断一下该变量是否已经保存了一个实例即可。
示例代码：

var Singleton = function(name){
    this.name = name;
    this.instance = null;
};
Singleton.prototype.getName = function(){
    console.log(this.name);
};
Singleton.getInstance = function(name){
    if(!this.instance){
        this.instance = new Singleton(name);
    }
    return this.instance;
};
var a = Singleton.getInstance('aa');
var b = Singleton.getInstance('bb');
console.log(a === b);// true

2. 透明的单例模式

透明的单例模式指的是，在调用getInstance方法时，直接返回单例类的实例对象。这种方式的优点是调用方便，但缺点是暴露了实现方式，不符合封装思想。
示例代码：

var Singleton = (function(){
    var instance;
    var Singleton = function(name){
        if(!instance){
            this.name = name;
            instance = this;
        }
        return instance;
    };
    Singleton.prototype.getName = function(){
        console.log(this.name);
    };
    return Singleton;
})();
var a = new Singleton('aa');
var b = new Singleton('bb');
console.log(a === b);// true

3. 代理模式的单例模式

在代理模式中，我们可以将一个模块的实例保存在代理模块中，这样在每次使用时，代理模块会返回这个实例。这种方式比较节省资源，且易于管理。
示例代码：

var Singleton = function(name){
    this.name = name;
};
Singleton.prototype.getName = function(){
    console.log(this.name);
};
var SingletonProxy = (function(){
    var instance;
    return function(name){
        if(!instance){
            instance = new Singleton(name);
        }
        return instance;
    }
})();
var a = new SingletonProxy('aa');
var b = new SingletonProxy('bb');
console.log(a === b);// true

4. 构造函数单例模式

构造函数单例模式，指的是在创建实例时，先判断是否存在该实例，如果存在，就直接返回该实例。
示例代码：

var Singleton = function(name){
    this.name = name;
    if(typeof Singleton.instance === 'object'){
        return Singleton.instance;
    }
    Singleton.instance = this;
    return this;
};
Singleton.prototype.getName = function(){
    console.log(this.name);
};
var a = new Singleton('aa');
var b = new Singleton('bb');
console.log(a === b);// true

5. 惰性单例模式

惰性单例模式指的是在需要使用实例时，才将实例化的过程执行一遍，这也是最常用到的单例模式。
示例代码：

var Singleton = function(name){
    this.name = name;
};
Singleton.prototype.getName = function(){
    console.log(this.name);
};
Singleton.getInstance = (function(){
    var instance;
    return function(name){
        if(!instance){
            instance = new Singleton(name);
        }
        return instance;
    }
})();
var a = Singleton.getInstance('aa');
var b = Singleton.getInstance('bb');
console.log(a === b);// true

6. ES6中的单例模式

在ES6中，可以利用静态属性来实现单例模式。代码如下：

class Singleton{
    constructor(name){
        this.name = name;
        if(typeof Singleton.instance === 'object'){
            return Singleton.instance;
        }
        Singleton.instance = this;
        return this;
    }
    getName(){
        console.log(this.name);
    }
    static getInstance(name){
        return new Singleton(name);
    }
}
let a = Singleton.getInstance('aa');
let b = Singleton.getInstance('bb');
console.log(a === b);// true

至此，关于JS实现单例模式的6种方案就讲解完毕了。

以下是两条示例说明：

第一条示例说明：

// 连接池类
class ConnectionPool{
    constructor(){
        // 假设初始化一些数据库连接等资源
    }
    // 假设还有其它方法来操作数据库
}
// 在连接池类中利用静态属性实现单例模式
ConnectionPool.instance = null;
ConnectionPool.getInstance = function(){
    if(!ConnectionPool.instance){
        ConnectionPool.instance = new ConnectionPool();
    }
    return ConnectionPool.instance;
}
// 其它使用者中可以这样使用
let pool = ConnectionPool.getInstance();

第二条示例说明：

// 弹出窗口类
class Popup{
    constructor(){
        // 假设初始化一些弹出窗口需要的资源
    }
    // 假设还有其它方法来操作弹出窗口
}
// 在弹出窗口类中利用惰性单例模式实现单例模式
Popup.instance = null;
Popup.getInstance = function(){
    if(!Popup.instance){
        Popup.instance = new Popup();
    }
    return Popup.instance;
}
// 其它使用者中可以这样使用
let popup = Popup.getInstance();

本文链接：http://task.lmcjl.com/news/9526.html