Aelous-Blog

养一猫一狗,猫叫夜宵,狗叫宵夜

0%

JS设计模式-单例模式

单例模式(Singleton)

保证一个类仅有一个实例,并提供一个访问它的全局访问点。

单例模式是一种常用的模式,有一些对象我们往往只需要一个,比如线程池、全局缓存、浏览器重的 window 对象等。在 javaScript 开发中,单例模式的用途同样非常广泛。试想一下,当我们单击登陆按钮的时候,页面中会出现一个登录浮窗,而这个登录浮窗是唯一的,无论单击多少次登录按钮,这个浮窗都只会被创建一次,那么这个登录浮窗就适合用单例模式来创建。

实现单例模式

简单说:单例就是保证一个类只有一个实例,实现方法一般是先判断实例存在与否,如果存在直接返回,如果不存在就创建了再返回,这就确保了一个类只有一个实例对象。在 JavaScript 里,单例作为一个命名空间提供者,从全局命名空间里提供一个唯一的访问点来访问该对象。

要实现一个标准的单例模式并不复杂,只需要用一个变量来标志当前是否已经为某个类创建了这个单例对象,如果是,则在下一次获取实例时,直接返回之前创建的对象。

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var Singleton = function(name) {
this.name = name;
this.instance = null;
};
Singleton.prototype.getName = function() {
alert(this.name);
};
Singleton.getInstance = function(name) {
if (!this.instance) {
this.instance = new Singleton(name);
}
return this.instance;
};

var a = Singleton.getInstance("sven1");
var b = Singleton.getInstance("sven2");

alert(a === b); //true

或者如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
var Singleton = function(name) {
this.name = name;
};
Singleton.prototype.getName = function() {
alert(this.name);
};
Singleton.getInstance = (function(name) {
var instance = null;
return function(name) {
if (!instance) {
instance = new Singleton(name);
}
return instance;
};
})();

var a = Singleton.getInstance("sven1");
var b = Singleton.getInstance("sven2");

alert(a === b); //true

通过 Singleton.getInstance 来获取 Singleton 类的唯一对象,这种方式理解起来很简单,但是增加了这个类的“不透明性”,Singleton 类的使用者必须知道这是一个单例类,跟以往通过 new XXX 的方式来获取对象不同,这里偏要使用 Singleton.getInstance 来获取对象。

虽然现在完成了一个单例模式的编写,但是这段代码的意义不大。

透明的单例模式

接下来实现一个“透明”的单例类,用户从这个类中创建对象的时候,可以像使用其他普通类一样,在下面的例子中,我们将使用 CreateDiv 单例类,它的作用是负责在页面中创建唯一的 div 节点,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var CreateDiv = (function() {
var instance;
var CreateDiv = function(html) {
if (instance) {
return instance;
}
this.html = html;
this.init();
return (instance = this);
};

CreateDiv.prototype.init = function() {
var div = document.createElement("div");
div.innerHTML = this.html;
document.body.appendChild(div);
};

return CreateDiv;
})();

var a = new CreateDiv("sven1");
var b = new CreateDiv("sven2");

alert(a === b); //true

现在我们完成了一个透明的单例类的编写,但是它同样有缺点。

为了吧 instance 封装起来,我们使用了自执行的匿名函数和闭包,并且让这个匿名函数返回真正的 Singleton 构造方法,这增加了一些程序的复杂度,阅读起来也不是很舒服。

观察我们现在的 Singleton 构造函数:

1
2
3
4
5
6
7
8
var CreateDiv = function(html) {
if (instance) {
return instance;
}
this.html = html;
this.init();
return (instance = this);
};

在这段代码中,CreateDiv 的构造函数实际上负责了两件事情,一是创建对象和执行初始化 init 方法,二是保证只有一个对象。按照“单一职责原则”的概念,这是一种不好的做法。

假设:我们某天需要利用这个类,在页面中创建千千万万个 div,即要让这个类从单例类变成一个普通的可产生多个实例的类,那我们必须得改写 CreateDiv 这个构造函数,把控制创建唯一对象的那一段去掉。很愁。

用代理实现单例模式

所以我们引入代理类的方式,来解决上面的问题。

在 CreateDiv 构造函数中,把负责管理单例的代码移除出去,使它成为一个普通的创建 div 的类。

1
2
3
4
5
6
7
8
9
10
var CreateDiv = function(html) {
this.html = html;
this.init();
};

CreateDiv.prototype.init = function() {
var div = document.createElement("div");
div.innerHTML = this.html;
document.body.appendChild(div);
};

接下来引入代理类:proxySingletonCreateDiv

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var ProxySingletonCreateDiv = (function() {
var instance;
return function(html) {
if (!instance) {
instance = new CreateDiv(html);
}
return instance;
};
})();

var a = new ProxySingletonCreateDiv("sven1");
var b = new ProxySingletonCreateDiv("sven2");

alert(a == b); //true

通过引入代理类的方式,我们同样完成了一个单例模式的编写,跟之前不同的是,现在我们把负责管理单例的逻辑移到了代理类 proxySingletonCreateDiv 中。这样一来,CreateDiv 就变成了一个普通的类,它跟 proxySingletonCreateDiv 组合起来可以实现单例模式的效果。

本例子是 缓存代理 的应用之一。

JavaScript 中的单例模式

前面提到的单例模式,更接近传统的面向对象语言的实现,单例对象从“类”中创建而来。在以类为中心的语言中,这是很自然的做法。比如 Java 中,如果需要某个对象,就必须先定义一个类,对象总是从类中创建出来的。

但是 JavaScript 其实是一门 无类(class-free) 语言,正因如此,生搬单例模式的概念并无意义。在 JS 中创建对象的方法其实非常简单,既然我们只需要一个“唯一”的对象,为什么要为它先创建一个类呢?传统单例模式的实现方式在 JS 中并不适用。

单例模式的核心:确保只有一个实例,并提供全局访问

全局变量不是单例模式,但是在 JS 中,我们经常把全局变量当成单例来使用,比如:

var a = {};

当使用这种方法创建对象 a 时,对象 a 确实是独一无二的,并且也可以通过全局来访问。但是!!!全局变量存在很多问题。很容易造成命名空间污染。容易不小心被覆盖。

作为开发者,我们有必要减少全局变量的使用,即使需要,也要把它的污染降到最低。以下几种方法可以相对降低全局变量带来的命名污染。

使用命名空间

适当的使用命名空间,并不会杜绝全局变量,但可以减少全局变量的数量。
最简单的方法依然是用对象字面量的方式:

1
2
3
4
5
6
7
8
var namespace1 = {
a: function() {
alert(1);
},
b: function() {
alert(2);
}
};

把 a 和 b 都定义为 namespace1 的属性,这样可以减少变量和全局作用域打交道的机会。另外我们还可以动态的创建命名空间,代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var MyApp = {};
MyApp.namespace = function(name) {
var parts = name.split(".");
var current = MyApp;
for (var i in parts) {
if (!current[parts[i]]) {
current[parts[i]] = {};
}
current = current[parts[i]];
}
};
MyApp.namespace("event");
MyApp.namespace("dom.style");
console.dir(MyApp);

//上述代码等价于

var MyApp = {
event: {},
dom: {
style: {}
}
};

使用闭包封装私有变量

这种方法把一些变量封装在闭包的内部,只暴露一些接口跟外界通信:

1
2
3
4
5
6
7
8
9
var user = (function() {
var __name = "sven",
__age = 29;
return {
getUserInfo: function() {
return __name + "-" + __age;
}
};
})();

我们用下划线来约定私有变量__name 和__age,它们被封装在闭包产生的作用域中,外部是访问不到这两个变量的,这就避免了对全局的命令污染。

惰性单例

惰性单例指的是在需要的时候才创建对象实例。惰性单例是单例模式的重点,这种技术在实际开发中非常有用,有用的程度可能超出我们想象。

假设我们是 WebQQ 的开发人员,当我们再点击头像时,会弹出登录浮窗,很明显这个浮窗在页面里总是唯一的,不可能同时出现两个登录窗口的情况。

第一种解决方案是在页面加载完之后便创建好了这个 div 浮窗,这个浮窗一开始肯定是隐藏状态的,当用户点击登录按钮,将它显示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<html>
<body>
<button id="loginBtn">登录</button>
</body>

<script>
var loginLayer = (function() {
var div = document.createElement("div");
div.innerHTML = "我是登录浮窗";
div.style.display = "none";
document.body.appendChild(div);
return div;
})();

document.getElementById("loginBtn").onclick = function() {
loginLayer.style.display = "block";
};
</script>
</html>

这种方法有一个问题,会浪费 DOM 节点,因为可能用户本身并不准备登录。

现在改写为,在用户点击按钮时才开始创建浮窗:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<html>
<body>
<button id="loginBtn">登录</button>
</body>

<script>
var createLoginLayer = function() {
var div = document.createElement("div");
div.innerHTML = "我是登录浮窗";
div.style.display = "none";
document.body.appendChild(div);
return div;
};

document.getElementById("loginBtn").onclick = function() {
var loginLayer = createLoginLayer();
loginLayer.style.display = "block";
};
</script>
</html>

现在实现了惰性的目的,但是失去了单例的效果。当我们再次点击登录按钮的时候,都会创建一个新的登录浮窗 div。虽然我们可以添加一些删除浮窗的功能,但是这样显然是不合理的,也是不必要的。

首相想到的就是通过一个变量来判断是否已经创建过登录浮窗,这也是文章最开始代码的做法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var createLoginLayer = (function() {
var div;
return function() {
if (!div) {
div = document.createElement("div");
div.innerHTML = "我是登录浮窗";
div.style.display = "none";
document.body.appendChild(div);
}
return div;
};

document.getElementById("loginBtn").onclick = function() {
var loginLayer = createLoginLayer();
loginLayer.style.display = "block";
};
})();

通用的惰性单例

同样上一段代码有如下问题:

  • 还是违反了“单一职能原则”,创建对象和管理单例的逻辑都放在了 createLoginLayer 对象内部
  • 如果我们下次需要创建页面唯一的 iframe,活着 script 标签,用来跨域请求数据,就要几乎把 createLoginLayer 函数再抄一遍。

所以我们需要把不变的部分隔离出来,先不考虑创建一个 div 和创建一个 iframe 有多少差异,管理单例的逻辑其实是完全可以抽象出来的,这个逻辑始终是一样的:用一个变量来标识是否创建过对象,如果是的话,下一次直接返回这个已经创建好的对象:

1
2
3
4
var obj;
if (!obj) {
obj = xxx;
}

现在我们就把如何管理单例的逻辑从原来的代码中抽离出来,这些逻辑被封装在 getSingle 函数内部,创建对象的方法 fn 被当成参数动态传入 getSingle 函数:

1
2
3
4
5
6
var getSingle = function(fn) {
var result;
return function() {
return result || (result = fn.apply(this, arguments));
};
};

接下来将用于创建登录浮窗的方法用参数 fn 的形式传入 getSingle,我们不仅可以传入 createLoginLayer,还能传入 createScript、createIframe、、createXhr 等。之后再让 getSingle 返回一个新的函数,并且用一个变量 result 来保存 fn 的计算结果。result 变量因为身在闭包中,它永远不会被销毁。在将来的请求中,如果 result 已经被赋值,那么它将返回这个值。代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var createLoginLayer = function() {
var div = document.createElement("div");
div.innerHTML = "我是登录浮窗";
div.style.display = "none";
document.body.appendChild(div);
return div;
};

var createSingleLoginLayer = getSingle(createLoginLayer);

document.getElementById("loginBtn").onclik = function() {
var loginLayer = createSingleLoginLayer();
loginLayer.style.display = "block";
};

接下来我们再尝试创建唯一的 iframe 用于动态加载第三方页面:

1
2
3
4
5
6
7
8
9
10
var createSingleIframe = getSingle(function() {
var iframe = document.createElement("iframe");
document.body.appendChild(iframe);
return iframe;
});

document.getElementById('loginBtn').onclick = funtion(){
var loginLayer = createSingleIframe();
loginLayer.src = 'http://baidu.com';
};

在这个例子中,我们把创建实例对象的职责和管理单例的职责分别放置在两个方法里,这两个方法可以独立变化而互不影响,当它们连接在一起的时候,就完成了创建唯一实例对象的功能。

这种单例模式的应用远不止创建对象,比如我们通常渲染完页面重的一个列表之后,接下来要给这个列表绑定 click 事件,如果是通过 ajax 动态往列表里面添加数据,在使用时间代理的前提下,click 事件实际上只需要在第一次渲染时被绑定一次,但是我们不想去判断当前是否是第一次渲染列表,如果借助于 jQuery,我们通常会选择给节点绑定 one 事件:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var bindEvent = function)(){
$('div').one('click',function(){
alert('click');
});
};

var render = function(){
console.log('开始渲染列表');
bindEvent();
};

render();
render();
render();

同样使用 getSingle 函数,也能达到一样的效果。代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var bindEvent = getSingle(function() {
document.getElementById("div").onclick = function() {
alert("click");
};
return true;
});
var render = function() {
console.log("开始渲染列表");
bindEvent();
};

render();
render();
render();

可以看到,render 函数和 bindEvent 函数都分别执行了 3 次,但 div 实际上只被绑定了一个事件。

小结

单例模式是我们学习的第一个模式,我们先学习了传统的单例模式实现,也了解到因为语言的差异性,在 JS 中有着更合适的方法去创建单例。单例模式是一种简单但非常实用的模式,特别是惰性单例技术,在合适的时候才创建对象,并且只创建唯一的一个。更奇妙的是,创建对象和管理单例的职责被分布在两个不同的方法中,这两个方法组合起来才具有单例模式的威力。

参考书籍:《JavaScript 设计模式与开发实战》

End~~ 撒花= ̄ω ̄=花撒
如果您读文章后有收获,可以打赏我喝咖啡哦~