javaScript设计模式-单例模式

发表于 更新于 阅读次数：

Singleton （单例）模式

它限制了类的实例化次数只能是一次，在该实例不存在的情况下，可以通过一个方法创建一个类来实现创建类的新实例；如果实例已经存在，它会简单返回该对象的引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
  var mySingleton = (function() {
    // 实例保持了 Singleton的一个引用
    var instance;
    function init() {
        // Singleton
        // 私有方法和变量
        function privateMethod() {
            console.log("I am private");
        }

        var privateVariable = "I am also private";
        var privateRandomNumber = Math.random();
        return {
            // 公有方法和变量
            publicMethod: function(){
                console.log("The public can see me!")
            },
            publicProperty: "I am also public",
            getRandomNumber: function(){
                return privateRandomNumber;
            }
        };
    };

    return {
        // 获取Singleton的实例，如果存在就返回，不存在就创建新实例
        getInstance: function() {
            if(!instance) {
                instance = init();
            }
            return instance;
        }
    };
})();


var myBadSingeton = (function() {
    //实例保持了Singleton的一个引用
    var instance;
    function init() {
        //Singleton
        var privateRandomNumber = Math.random();
        return {
            getRandomNumber: function(){
                return privateRandomNumber;
            }
        };
    };

    return {
        //每次都创建新实例
        getInstance: function(){
            instance = init();
            return instance;
        }
    };
})();

var singleA = mySingleton.getInstance();
var singleB = mySingleton.getInstance();
console.log(singleA.getRandomNumber() === singleB.getRandomNumber()); //true

var badSingleA = myBadSingeton.getInstance();
var badSingleB = myBadSingeton.getInstance();
console.log(badSingleA.getRandomNumber() === badSingleB.getRandomNumber());//false

有关Single模式适用性的描述如下。

  1. 当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
  2. 该唯一的实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

这些观点另外关联到一个场景，这里我们可能需要如下这样的代码：

1
2
3
4
5
6
7
8
9
10
mySingleton.getInstance = function(){
    if(this._instance == null){
        if(isFonn){
            this._instance = new FooSingleton();
        }else {
            this._instance = new BasicSingleton();
        }
    }
    return this._instance;
}

在这里，getInstance变得有点像Factory(工厂)方法，当访问它时，我们不需要更新代码中的每个访问点。FooSingleton(上面)将是一个BasicSingleton的子类，并将实现相同的接口。

在实践中，当在系统中确实需要一个对象来协调其他对象时，Singleton模式是很有用的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
   var SingletonTester = (function() {
		
		// options: 包含singleton所需配置信息的对象
		// e.g var options = {name: 'text', pointX: 5};
		function Singleton(options) {
			options = options || {};

			this.name = 'SingletonTester';
			this.pointX = options.pointX || 6;
			this.pointY = options.pointY || 10;
 		}
		var instance;
		var _static = {
			name: "SingletonTester",
			getInstance: function(options) {
				if(instance === undefined) {
					instance = new Singleton(options);
				}
				return instance;
			}
		};
		return _static; 
	})();
var singletonTest = SingletonTester.getInstance({
	pointX : 5,
})

console.log(singletonTest.pointX); //5