什么是设计模式

设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。

设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

在合适的时机使用设计模式能够让我们的程序变得更加易用和安全。

在下面的代码中,将通过js来讲解一些常用的设计模式。

设计模式分类

通常情况下,设计模式可以分成三个种类,一共23种。

可以将设计模式分为创建型模式结构型模式行为型模式

创建型模式当中包含有以下的内容:

* 单例模式
* 抽象工厂模式
* 建造者模式
* 工厂模式
* 原型模式

结构型模式分为以下几种:

* 适配器模式
* 桥接模式
* 装饰模式
* 组合模式
* 外观模式
* 享元模式
* 代理模式

行为型模式分为以下几类:

* 模板方法模式
* 命令模式
* 迭代器模式
* 观察者模式
* 中介者模式
* 备忘录模式
* 解释器模式
* 状态模式
* 策略模式
* 职责链模式
* 访问者模式

下面聊聊几个常见的模式

单例模式

单例就是保证一个类只有一个实例,实现的方法一般是先判断实例存在与否,如果存在直接返回,如果不存在就创建了再返回,这就确保了一个类只有一个实例对象。

而在js当中,单例则是一个命名空间的创造者,通过单例模式来创造一个独立的命名空间,本质上是通过单例模式在全局命名空间当中创建一个唯一的访问点来访问该对象。

最简单的实现方式:

通过js当中的对象直接量来实现单例模式是最简单的实现方式:

例如:

var mySingleton = {
property1: "something",
property2: "something else",
method1: function () {
console.log('hello world');
}
};

通过对象直接量创建的对象里面可以存储很多的属性和方法。

当然,也可以采用下面的这种形式。

例如:

let single = function(){

    // 创建私有的属性和方法
let name = "zhangsan"; function sayHello(){
console.log(`hello,${name}`);
}
// 对外暴露的方法和属性
return {
sayGoodBye:()=>{
console.log("再见....");
},
like:"吃喝玩乐"
} }

如果想要在使用的时候进行初始化,而不是提前初始化好,并且更加的节约资源,可以使用构造函数的写法:

例如:

var Singleton = (function () {
var instantiated;
function init() {
/*这里定义单例代码*/
return {
publicMethod: function () {
console.log('hello world');
},
publicProperty: 'test'
};
} return {
getInstance: function () {
if (!instantiated) {
instantiated = init();
}
return instantiated;
}
};
})();

如果上面的代码难以理解,那么可以尝试着看看下面的代码,效果一致!

// 通过构造函数来模拟单例模式
function Construct(){
// 确保只有单例
if( Construct.unique !== undefined ){
return Construct.unique;
}
// 其他代码
this.name = "张三";
this.age="24";
Construct.unique = this;
} // 使用单例模式
let a = new Construct();
let b = new Construct(); console.log(a===b); // true

在上面的代码中,只不过是利用了数据缓存的原理存储了状态,然后再次进行判断操作即可,下面的写法也类似如此:

function Universe() {

    // 判断是否存在实例
if (typeof Universe.instance === 'object') {
return Universe.instance;
} // 其它内容
this.start_time = 0;
this.bang = "Big"; // 缓存
Universe.instance = this; // 隐式返回this
} // 测试
var uni = new Universe();
var uni2 = new Universe();
console.log(uni === uni2); // true

组合模式(Composite)

组合模式(Composite)将对象组合成树形结构以表示“部分-整体”的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。

这种组合模式的数据结构在js当中是属于非常少见的,不过我们常用的虚拟dom却是与其类似,一个DOM节点可以包含子节点,不管是父节点还是子节点都有添加、删除、遍历子节点的通用功能。所以说组合模式的关键是要有一个抽象类,它既可以表示子元素,又可以表示父元素,并且无论是什么层级都具备着相同的属性和方法。

例如:

var MenuComponent = function () {
};
MenuComponent.prototype.getName = function () {
throw new Error("该方法必须重写!");
};
MenuComponent.prototype.getDescription = function () {
throw new Error("该方法必须重写!");
};
MenuComponent.prototype.getPrice = function () {
throw new Error("该方法必须重写!");
};
MenuComponent.prototype.isVegetarian = function () {
throw new Error("该方法必须重写!");
};
MenuComponent.prototype.print = function () {
throw new Error("该方法必须重写!");
};
MenuComponent.prototype.add = function () {
throw new Error("该方法必须重写!");
};
MenuComponent.prototype.remove = function () {
throw new Error("该方法必须重写!");
};
MenuComponent.prototype.getChild = function () {
throw new Error("该方法必须重写!");
}; // 创建基本菜品
var MenuItem = function (sName, sDescription, bVegetarian, nPrice) {
MenuComponent.apply(this);
this.sName = sName;
this.sDescription = sDescription;
this.bVegetarian = bVegetarian;
this.nPrice = nPrice;
};
MenuItem.prototype = new MenuComponent();
MenuItem.prototype.getName = function () {
return this.sName;
};
MenuItem.prototype.getDescription = function () {
return this.sDescription;
};
MenuItem.prototype.getPrice = function () {
return this.nPrice;
};
MenuItem.prototype.isVegetarian = function () {
return this.bVegetarian;
};
MenuItem.prototype.print = function () {
console.log(this.getName() + ": " + this.getDescription() + ", " + this.getPrice() + "euros");
}; var Menu = function (sName, sDescription) {
MenuComponent.apply(this);
this.aMenuComponents = [];
this.sName = sName;
this.sDescription = sDescription;
this.createIterator = function () {
throw new Error("This method must be overwritten!");
};
};
Menu.prototype = new MenuComponent();
Menu.prototype.add = function (oMenuComponent) {
// 添加子菜品
this.aMenuComponents.push(oMenuComponent);
};
Menu.prototype.remove = function (oMenuComponent) {
// 删除子菜品
var aMenuItems = [];
var nMenuItem = 0;
var nLenMenuItems = this.aMenuComponents.length;
var oItem = null; for (; nMenuItem < nLenMenuItems; ) {
oItem = this.aMenuComponents[nMenuItem];
if (oItem !== oMenuComponent) {
aMenuItems.push(oItem);
}
nMenuItem = nMenuItem + 1;
}
this.aMenuComponents = aMenuItems;
};
Menu.prototype.getChild = function (nIndex) {
//获取指定的子菜品
return this.aMenuComponents[nIndex];
};
Menu.prototype.getName = function () {
return this.sName;
};
Menu.prototype.getDescription = function () {
return this.sDescription;
};
Menu.prototype.print = function () {
// 打印当前菜品以及所有的子菜品
console.log(this.getName() + ": " + this.getDescription());
console.log("--------------------------------------------"); var nMenuComponent = 0;
var nLenMenuComponents = this.aMenuComponents.length;
var oMenuComponent = null; for (; nMenuComponent < nLenMenuComponents; ) {
oMenuComponent = this.aMenuComponents[nMenuComponent];
oMenuComponent.print();
nMenuComponent = nMenuComponent + 1;
}
}; var DinnerMenu = function () {
Menu.apply(this);
};
DinnerMenu.prototype = new Menu(); var CafeMenu = function () {
Menu.apply(this);
};
CafeMenu.prototype = new Menu(); var PancakeHouseMenu = function () {
Menu.apply(this);
};
PancakeHouseMenu.prototype = new Menu(); var Mattress = function (aMenus) {
this.aMenus = aMenus;
};
Mattress.prototype.printMenu = function () {
this.aMenus.print();
}; var oPanCakeHouseMenu = new Menu("Pancake House Menu", "Breakfast");
var oDinnerMenu = new Menu("Dinner Menu", "Lunch");
var oCoffeeMenu = new Menu("Cafe Menu", "Dinner");
var oAllMenus = new Menu("ALL MENUS", "All menus combined"); oAllMenus.add(oPanCakeHouseMenu);
oAllMenus.add(oDinnerMenu); oDinnerMenu.add(new MenuItem("Pasta", "Spaghetti with Marinara Sauce, and a slice of sourdough bread", true, 3.89));
oDinnerMenu.add(oCoffeeMenu); oCoffeeMenu.add(new MenuItem("Express", "Coffee from machine", false, 0.99)); var oMattress = new Mattress(oAllMenus);
console.log("---------------------------------------------");
oMattress.printMenu();
console.log("---------------------------------------------");

观察者模式

观察者模式又叫发布订阅模式(Publish/Subscribe),它定义了一种一对多的关系,让多个观察者对象同时监听某一个主题对象,这个主题对象的状态发生变化时就会通知所有的观察者对象,使得它们能够自动更新自己。

使用观察者模式的好处:

  • 支持简单的广播通信,自动通知所有已经订阅过的对象。
  • 页面载入后目标对象很容易与观察者存在一种动态关联,增加了灵活性。
  • 目标对象与观察者之间的抽象耦合关系能够单独扩展以及重用。

在js当中,观察者模式主要是通过回调函数来实现的。

例如:

// 观察者模式

// 创建一个pubsub对象

var pubsub = {};

(function(q){
var topics = {}, // 回调函数存放的数组
subUid = -1; // 发布方法
q.publish = function (topic, args) { if (!topics[topic]) {
return false;
} setTimeout(function () {
var subscribers = topics[topic],
len = subscribers ? subscribers.length : 0; while (len--) {
subscribers[len].func(topic, args);
}
}, 0); return true; };
//订阅方法
q.subscribe = function (topic, func) { if (!topics[topic]) {
topics[topic] = [];
} var token = (++subUid).toString();
topics[topic].push({
token: token,
func: func
});
return token;
};
//退订方法
q.unsubscribe = function (token) {
for (var m in topics) {
if (topics[m]) {
for (var i = 0, j = topics[m].length; i < j; i++) {
if (topics[m][i].token === token) {
topics[m].splice(i, 1);
return token;
}
}
}
}
return false;
}; })(pubsub);

使用方式如下:

// 使用方式
//来,订阅一个
pubsub.subscribe('example1', function (topics, data) {
console.log(topics + ": " + data);
}); //发布通知
pubsub.publish('example1', 'hello world!');
pubsub.publish('example1', ['test', 'a', 'b', 'c']);
pubsub.publish('example1', [{ 'color': 'blue' }, { 'text': 'hello'}]);

使用场景:

观察者的使用场合就是:当一个对象的改变需要同时改变其它对象,并且它不知道具体有多少对象需要改变的时候,就应该考虑使用观察者模式。

假如我们想在网页面里插入一些元素,而这些元素类型不固定,可能是图片,也有可能是连接,甚至可能是文本,根据工厂模式的定义,我们需要定义工厂类和相应的子类,我们先来定义子类的具体实现(也就是子函数):

例如:

var page = page || {};
page.dom = page.dom || {};
//子函数1:处理文本
page.dom.Text = function () {
this.insert = function (where) {
var txt = document.createTextNode(this.url);
where.appendChild(txt);
};
}; //子函数2:处理链接
page.dom.Link = function () {
this.insert = function (where) {
var link = document.createElement('a');
link.href = this.url;
link.appendChild(document.createTextNode(this.url));
where.appendChild(link);
};
}; //子函数3:处理图片
page.dom.Image = function () {
this.insert = function (where) {
var im = document.createElement('img');
im.src = this.url;
where.appendChild(im);
};
};

那么如何定义工厂处理函数呢?

page.dom.factory = function (type) {
return new page.dom[type];
}

使用方式如下:

var o = page.dom.factory('Link');
o.url = 'http://www.cnblogs.com';
o.insert(document.body);

代理模式

代理,顾名思义就是帮助别人做事,GoF对代理模式的定义如下:

代理模式(Proxy),为其他对象提供一种代理以控制对这个对象的访问。

代理模式使得代理对象控制具体对象的引用。代理几乎可以是任何对象:文件,资源,内存中的对象,或者是一些难以复制的东西。

假如张三想要李四替它送花给小红,那么就可以通过如下的写法:

// 创建一个对象小红
var gril = function (name){
this.name = name;
} // 张三
var zhangsan = function (gril){
this.gril = gril;
this.sendGift = function(gift){
alert("Hi " + girl.name + ", zhangsan送你一个礼物:" + gift);
}
} // 李四就是代理
var lisi = function (girl) {
this.girl = girl;
this.sendGift = function (gift) {
(new zhangsan(girl)).sendGift(gift); // 替张三送花
}
} // 调用
var lisi = new proxyTom(new girl("小红"));
proxy.sendGift("999朵玫瑰");

javascript中的设计模式的更多相关文章

  1. JavaScript 中常见设计模式整理

    开发中,我们或多或少地接触了设计模式,但是很多时候不知道自己使用了哪种设计模式或者说该使用何种设计模式.本文意在梳理常见设计模式的特点,从而对它们有比较清晰的认知. JavaScript 中常见设计模 ...

  2. javascript中的设计模式之发布-订阅模式

    一.定义 又叫观察者模式,他定义对象间的依照那个一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都将的到通知.在javascript中,我们一般用时间模型来替代传统的发布-订阅模式 二 ...

  3. GOF提出的23种设计模式是哪些 设计模式有创建形、行为形、结构形三种类别 常用的Javascript中常用设计模式的其中17种 详解设计模式六大原则

    20151218mark 延伸扩展: -设计模式在很多语言PHP.JAVA.C#.C++.JS等都有各自的使用,但原理是相同的,比如JS常用的Javascript设计模式 -详解设计模式六大原则 设计 ...

  4. JavaScript中的设计模式:策略模式

    无论学习前端还是后端设计模式是作为一名程序员不可缺少的知识,就像下底传中对于一个边锋来说. 一.策略模式 策略模式给人的第一感觉就是在代码里面消除了很多if-else分支语句,比如一个求员工奖金的程序 ...

  5. JavaScript中的设计模式:状态模式

    前几天写了一个贪吃蛇小游戏,正好用到了状态模式. 定义 当一个对象内部状态发生改变时候,会导致其行为的改变,这看起来像是改变了对象. 简单的例子 如果一个函数要更具某一个对象的状态来判断该对象应该执行 ...

  6. JavaScript中的设计模式:单例模式

    定义 单例模式就是一个类只能实例化一个对象,并且提供了一个访问它的全局访问点. 一般在实现登陆框,或者一个全局的控制器都会用到单例模式.现实中有window对象,线程池,全局缓存等. 简单实现 var ...

  7. JS中常见设计模式总结

    github: https://github.com/14glwu/FEInterviewBox/tree/master/JS%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F ...

  8. Javascript 中创建自定义对象的方法(设计模式)

    Javascript 中创建对象,可以有很多种方法. Object构造函数/对象字面量: 抛开设计模式不谈,使用最基本的方法,就是先调用Object构造函数创建一个对象,然后给对象添加属性. var ...

  9. js架构设计模式——理解javascript中的MVVM开发模式

    理解javascript中的MVVM开发模式 http://blog.csdn.net/slalx/article/details/7856769 MVVM的全称是Model View ViewMod ...

随机推荐

  1. XCTF-wtf.sh-150

    wtf.sh-150 题目描述 没有描述 解题过程 打开之后是个论坛,有注册和登录功能点 抓包发现,登陆成功后会设置cookie <script>document.cookie = 'US ...

  2. shell中的引号和转义

    引号和转义 Bash 只有一种数据类型,就是字符串.不管用户输入什么数据,Bash 都视为字符串.因此,字符串相关的引号和转义,对 Bash 来说就非常重要. 转义 某些字符在 Bash 里面有特殊含 ...

  3. 『动善时』JMeter基础 — 8、JMeter主要元件介绍

    目录 1.测试计划(Test Plan) 2.线程组 3.取样器(sampler) 4.逻辑控制器(Logic Controller) 5.配置元件(Config Element) 6.定时器(Tim ...

  4. @Test无法运行

    使用@Test需要导入两个依赖 junit-4.12.jar hamcrest-core-1.3.jar 添加@Test注解,却没有运行的三角形.需要在该类和方法上都加一个public public ...

  5. Github + Picgo + Typora 让笔记远走高飞

    Github设置 登录 2.新建仓库 设置token 打开设置 然后点击,按钮生成Generate token Picgo设置 下载PicGo 参考视频 PicGo设置 设置Server 图床设置 上 ...

  6. liunx服务器安装jdk

    1.官网下载需要版本的jdk,官网地址 http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.h ...

  7. Linux下查看在线用户及用户进程

    #该服务器下的所有用户运行进程的情况 ps -ax -u #查看java程序下用户的进程情况 ps -ax -u |grep java   或  ps aux|grep java cat /etc/p ...

  8. C++逆向分析----虚函数与多层继承

    虚函数 C++通过关键字virtual来将函数声明为一个虚函数.当一个类包含虚函数后编译器就会给类的实例对象增加一个虚表指针,所谓的虚表指针就是指向虚表的指针.虚表就是一张地址表,它包含了这个类中所有 ...

  9. Django(21)migrate报错的解决方案

    前言 在讲解如何解决migrate报错原因前,我们先要了解migrate做了什么事情,migrate:将新生成的迁移脚本.映射到数据库中.创建新的表或者修改表的结构. 问题1:migrate怎么判断哪 ...

  10. OO课程仓库部署使用GitLab CI

    转自我的个人博客http://mistariano.com/blog/9 1. 服务器上安装 gitlab-runner 参考博客https://blog.csdn.net/qq_40699305/a ...