JS设计模式---单例(Singleton)模式

Posted 2021-04-25 程序员的修仙之路

前言

单例模式被熟知的原因是因为它限制了类的实例化次数只能一次。从经典意义上来讲，单例模式,在该例不存在的情况下，可以通过一个方法创建一个类来实现创建类的新实例。如果实例已经存在，它会简单返回该对象的引用。Singleton不同于静态类（或者对象），因为我们可以推迟它的初始化，这通常是由于它们需要一些在初始化阶段还获取不到的信息。

Singleton实现

在JS中，Singleton充当共享资源命名空间，从全局命名空间中隔离出代码实现，从而为函数提供单一访问点。我们可以像这样实现一个Singleton:

var mySingleton = (function(){
    //实例保持了单例的一个引用
    var instance;
    
    function init(){
        var privateNumber = Math.random();
        var privateFn = function(){
            console.log("I am a private function.")
        }
        
        return {
            publicFn: function(){
                console.log('public!')
            },
            getRandomNum: function(){
                return privateNumber;
            }
        }
    };
    
    return {
        //获取Singleton的实例，如果存在就返回，不存在就创建
        getInstance: function(){
            if(!instance){
                instance = init()
            }
            return instance;
        }
    }
})()

再展示一个错误写法：

var myErrorSingleton = (function(){
    //实例保持了单例的一个引用
    var instance;
    
    function init(){
        var privateNumber = Math.random();
        var privateFn = function(){
            console.log("I am a private function.")
        }
        
        return {
            publicFn: function(){
                console.log('public!')
            },
            getRandomNum: function(){
                return privateNumber;
            }
        }
    };
    
    return {
        // 每次都创建新实例
        getInstance: function(){
            instance = init()
            return instance;
        }
    }
})()

执行测试：

var singleA = mySingleton.getInstance();
var singleB = mySingleton.getInstance();

singleA.getRandomNum() === singleB.getRandomNum



var errorSingleC = myErrorSingleton.getInstance();
var errorSingleD = myErrorSingleton.getInstance();

errorSingleC.getRandomNum() !== errorSingleD.getRandomNum

单例模式的适用性

• 当类只能由一个实例而且客户可以从一个众所周知的访问点访问它时。

• 该唯一的实例应该是可以通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

延迟执行对于单例很重要

值得注意的是类的静态实例与单例之间的区别：当单例可以作为一个静态的实例实现时，它可以延迟构建，知道需要的时候，在此之前无需只用内存或者资源。

在实践中，当在系统中确实需要一个对象来协调其他对象时，单例模式是很有用的，如下eg.

var singletonDemo = (function(){
    // cfg:包含单例所需的配置信息
    function singleton(cfg){
        cfg = cfg || {}
        
        this.name = cfg.name
        this.age = cfg.age
    }
    
    var instance; // 实例持有者
    
    var _static = {
        name: 'summer',
        getInstance: function(cfg){
            if(instance === undefined) {
                instance = new singleton(cfg);
            }
            return instance
        }
    }
    
    return _static;
})()
var singletonTest = singletonDemo.getInstance({name:'zff'})
console.log(singletonTest.name)  // zff