javascript常见设计模式
javascript常见设计模式
设计模式(design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于都是多赢的;设计模式使代码编制真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。
单例模式
单例模式定义了一个对象的创建过程,此对象只有一个单独的实例,并提供一个访问它的全局访问点。也可以说单例就是保证一个类只有一个实例,实现的方法一般是先判断实例存在与否,如果存在直接返回,如果不存在就创建了再返回,这就确保了一个类只有一个实例对象。
var single = (function(){
var unique;
function getinstance(){
// 如果该实例存在,则直接返回,否则就对其实例化
if( unique === undefined ){
unique = new construct();
}
return unique;
}
function construct(){
// ... 生成单例的构造函数的代码
}
return {
getinstance : getinstance
}
})();
上面的代码中,unique便是返回对象的引用,而 getinstance便是静态方法获得实例。construct 便是创建实例的构造函数。
可以通过 single.getinstance() 来获取到单例,并且每次调用均获取到同一个单例。这就是 单例模式 所实现的效果。
使用场景:
单例模式是一种常用的模式,有一些对象我们往往只需要一个,比如全局缓存、的window对象。在js开发中,单例模式的用途同样非常广泛。试想一下,当我们
单击登录按钮的时候,页面中会出现一个登录框,而这个浮窗是唯一的,无论单击多少次登录按钮,这个浮窗只会被创建一次。因此这个登录浮窗就适合用单例模式。
总结一下它的使用场景:
1、可以用它来划分命名空间
2、借助单例模式,可以把代码组织的更为一致,方便与维护
观察者模式(发布订阅模式)
定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新,也被称为是发布订阅模式。
它需要一种高级的抽象策略,以便订阅者能够彼此独立地发生改变,而发行方能够接受任何有消费意向的订阅者。
var pubsub = {}; // 定义发布者
(function (q) {
var list = [], //回调函数存放的数组,也就是记录有多少人订阅了我们东西
subuid = -1;
// 发布消息,遍历订阅者
q.publish = function (type, content) {
// type 为文章类型,content为文章内容
// 如果没有人订阅,直接返回
if (!list[type]) {
return false;
}
settimeout(function () {
var subscribers = list[type],
len = subscribers subscribers.length : 0;
while (len--) {
// 将内容注入到订阅者那里
subscribers[len].func(type, content);
}
}, 0);
return true;
};
//订阅方法,由订阅者来执行
q.subscribe = function (type, func) {
// 如果之前没有订阅过
if (!list[type]) {
list[type] = [];
}
// token相当于订阅者的id,这样的话如果退订,我们就可以针对它来知道是谁退订了。
var token = (++subuid).tostring();
// 每订阅一个,就把它存入到我们的数组中去
list[type].push({
token: token,
func: func
});
return token;
};
//退订方法
q.unsubscribe = function (token) {
for (var m in list) {
if (list[m]) {
for (var i = 0, j = list[m].length; i < j; i++) {
if (list[m][i].token === token) {
list[m].splice(i, 1);
return token;
}
}
}
}
return false;
};
} (pubsub));
//将订阅赋值给一个变量,以便退订
var girla = pubsub.subscribe('js类的文章', function (type, content) {
console.log('girla订阅的'+type + ": 内容内容为:" + content);
});
var girlb = pubsub.subscribe('js类的文章', function (type, content) {
console.log('girlb订阅的'+type + ": 内容内容为:" + content);
});
var girlc = pubsub.subscribe('js类的文章', function (type, content) {
console.log('girlc订阅的'+type + ": 内容内容为:" + content);
});
//发布通知
pubsub.publish('js类的文章', '关于js的内容');
// 输出:
// girlc订阅的js类的文章: 内容内容为:关于js的内容
// test3.html:78 girlb订阅的js类的文章: 内容内容为:关于js的内容
// test3.html:75 girla订阅的js类的文章: 内容内容为:关于js的内容
//girla退订了关于js类的文章
settimeout(function () {
pubsub.unsubscribe(girla);
}, 0);
//再发布一次,验证一下是否还能够输出信息
pubsub.publish('js类的文章', "关于js的第二篇文章");
// 输出:
// girlb订阅的js类的文章: 内容内容为:关于js的第二篇文章
// girlc订阅的js类的文章: 内容内容为:关于js的第二篇文章
应用场景:
这个模式要先说应用场景,比较好理解。
打一个离我们比较近的一个场景,博客园里面有一个订阅的按钮(貌似有bug),比如小a,小b,小c都订阅了我的博客,当我的博客一有更新时,就会统一发布邮件给他们这三个人,就会通知这些订阅者
发布订阅模式的流程如下:
1. 确定谁是发布者(比如我的博客)。
2.然后给发布者添加一个缓存列表,用于存放回调函数来通知订阅者。
3. 发布消息,发布者需要遍历这个缓存列表,依次触发里面存放的订阅者回调函数。
4、退订(比如不想再接收到这些订阅的信息了,就可以取消掉)
策略模式
策略模式指的是定义一系列的算法,把它们一个个封装起来,目的是将算法的使用和实现分离开。说白了就是以前要很多判断的写法,现在把判断里面的内容抽离开来,变成一个个小的个体。
例子:代码情景为超市促销,vip为5折,老客户3折,普通顾客没折,计算最后需要支付的金额。
没有使用策略模式:
function price(persontype, price) {
//vip 5 折
if (persontype == 'vip') {
return price * 0.5;
}
else if (persontype == 'old'){ //老客户 3 折
return price * 0.3;
} else {
return price; //其他都全价
}
}
使用策略模式:
// 对于vip客户
function vipprice() {
this.discount = 0.5;
}
vipprice.prototype.getprice = function(price) {
return price * this.discount;
}
// 对于老客户
function oldprice() {
this.discount = 0.3;
}
oldprice.prototype.getprice = function(price) {
return price * this.discount;
}
// 对于普通客户
function price() {
this.discount = 1;
}
price.prototype.getprice = function(price) {
return price ;
}
// 上下文,对于客户端的使用
function context() {
this.name = '';
this.strategy = null;
this.price = 0;
}
context.prototype.set = function(name, strategy, price) {
this.name = name;
this.strategy = strategy;
this.price = price;
}
context.prototype.getresult = function() {
console.log(this.name + ' 的结账价为: ' + this.strategy.getprice(this.price));
}
var context = new context();
var vip = new vipprice();
context.set ('vip客户', vip, 200);
context.getresult(); // vip客户 的结账价为: 100
var old = new oldprice();
context.set ('老客户', old, 200);
context.getresult(); // 老客户 的结账价为: 60
var price = new price();
context.set ('普通客户', price, 200);
context.getresult(); // 普通客户 的结账价为: 200
通过策略模式,使得客户的折扣与算法解藕,又使得修改跟扩展能独立的进行,不影到客户端或其他算法的使用;
应用场景:
策略模式最实用的场合就是某个“类”中包含有大量的条件性语句,比如if...else 或者 switch。每一个条件分支都会引起该“类”的特定行为以不同的方式作出改变。以其维
护一段庞大的条件性语句,不如将每一个行为划分为多个独立的对象。每一个对象被称为一个策略。设置多个这种策略对象,可以改进我们的代码质量,也更好的进行单元测试。
代理模式
代理模式的中文含义就是帮别人做事,javascript的解释为:把对一个对象的访问, 交给另一个代理对象来操作
比如我们公司的补打卡是最后是要交给大boss来审批的,但是公司那么多人,每天都那么多补打卡,那大boss岂不是被这些琐事累死。所以大boss下会有一个助理,来帮
忙做这个审批,最后再将每个月的补打卡统一交给大boss看看就行。
// 补打卡事件
var fillout = function (latedate) {
this.latedate = latedate;
};
// 这是bigboss
var bigboss = function (fillout) {
this.state = function (issuccess) {
console.log("忘记打卡的日期为:" + fillout.latedate + ", 补打卡状态:" + issuccess);
}
};
// 助理代理大boss 完成补打卡审批
var proxyassis = function (fillout) {
this.state = function (issuccess) {
(new bigboss(fillout)).state(issuccess); // 替bigboss审批
}
};
// 调用方法:
var proxyassis = new proxyassis(new fillout("2016-9-11"));
proxyassis.state("补打卡成功");
// 忘记打卡的日期为:2016-9-11, 补打卡状态:补打卡成功
应用场景:
比如图片的懒加载,我们就可以运用这种技术。在图片未加载完成之前,给个loading图片,加载完成后再替换成实体路径。
var myimage = (function(){
var imgnode = document.createelement("img");
document.body.appendchild(imgnode);
return function(src){
imgnode.src = src;
}
})();
// 代理模式
var proxyimage = (function(){
var img = new image();
img.onload = function(){
myimage(this.src);
};
return function(src) {
// 占位图片loading
myimage("http://img.lanrentuku.com/img/allimg/1212/5-121204193q9-50.gif");
img.src = src;
}
})();
// 调用方式
proxyimage("https://img.alicdn.com/tps/i4/tb1b_nelxxxxxcoxfxxc8pz9xxx-130-200.png"); // 真实要展示的图片
当然,这种懒加载方法不用代理模式也是可以实现的,只是用代理模式。我们可以让myimage 只做一件事,只负责将实际图片加入到页面中,而loading图片交给proxyimage去做。从而降低代码的耦合度。因为当我不想用loading的时候,可以直接调用myimage 方法。也即是说假如我门不需要代理对象的话,直接可以换成本体对象调用该方法即可。
外观模式
外观模式是很常见。其实它就是通过编写一个单独的函数,来简化对一个或多个更大型的,可能更为复杂的函数的访问。也就是说可以视外观模式为一种简化某些内容的手段。
说白了,外观模式就是一个函数,封装了复杂的操作。
比如一个跨浏览器的ajax调用
function ajaxcall(type,url,callback,data){
// 根据当前浏览器获取对ajax连接对象的引用
var xhr=(function(){
try {
// 所有现代浏览器所使用的标准方法
return new xmlhttprequest();
}catch(e){}
// 较老版本的internet explorer兼容
try{
return new activexobject("msxml2.xmlhttp.6.0");
}catch(e){}
try{
return new activexobject("msxml2.xmlhttp.3.0");
}catch(e){}
try{
return new activexobject("microsoft.xmlhttp");
}catch(e){}
// 如果没能找到相关的ajax连接对象,则跑出一个错误。
throw new error("ajax not support in this browser.")
}()),
state_loaded=4,
status_ok=200;
// 一但从服务器收到表示成功的相应消息,则执行所给定的回调方法
xhr.onreadystatechange=function{
if(xhr.readystate !==state_loaded){
return;
}
if(xhr.state==status_ok){
callback(xhr.responsetext);
}
}
// 使用浏览器的ajax连接对象来向所给定的url发出相关的调用
xhr.open(type.touppercase(),url);
xhr.send(data);
}
// 使用方法
ajaxcall("get","/user/12345",function(rs){
alert('收到的数据为:'+rs);
})
应用场景:
当需要通过一个单独的函数或方法来访问一系列的函数或方法调用,以简化代码库的其余内容,使得代码更容易跟踪管理或者更好的维护时,可以使用外观模式。其实我们平时代码中这种模式应该是用的比较多的。
上一篇: c中“>>”与“&”运算符
下一篇: goweb-http协议