陈翔刘美含吻戏,taylor swift壁纸,3dmax吊灯模型
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);
})
应用场景：
当需要通过一个单独的函数或方法来访问一系列的函数或方法调用，以简化代码库的其余内容，使得代码更容易跟踪管理或者更好的维护时，可以使用外观模式。其实我们平时代码中这种模式应该是用的比较多的。
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
[书籍精读]《响应式Web设计 HTML5和CSS3实战(第二版)》精读笔记分享
我要评论
网友评论