模式（一）javascript设计模式

模式有三种：Architectural Pattern、Design Pattern、Coding Pattern，即：框架模式、设计模式、编程模式。本文主要讲解javascript中的设计模式，好的设计模式能够提高代码的重用性，可读性，使代码更容易的维护和扩展。本文适合有一点javascript基础，对javascript的概念有所了解。

一、单例模式：

单例模式是javascript中最常用的模式，它是将自己的代码放在一个命名空间下，这样的好处是可以减少使用全局变量，在多人协同开发时也能避免命名冲突等问题。这样的好处是维护起来非常方便，如下例：

 var m = {
     name: 'dog',
     action: function() {
         console.log(this.name);
     }
 };
 m.action();//调用

或者

 var dog = function() {
     this.name = 'dog';
     this.action = function() {
         return console.log(this.name);
     };
     action();
 };
 dog(); //调用

工厂模式：

工厂模式就是将对象的方法创建交给外部对象，这样的好处就是解决了对象之间的相互影响、即耦合，避免了使用new来实例化对象，有助于创建模块化的代码，维护起来也方便。 工厂模式分为简单工厂模式和抽象工厂模式，下面介绍简单工厂模式：

 var m = {};
 m.action = function() {
     console.log('dog');
 };
 var demo = function() {
     m.action();
 };
 demo()//调用

抽象工厂模式先设计一个抽象类，这个类不能被实例化，只能用来派生子类，最后通过对子类的扩展实现工厂方法。如下：

 var f = function() {};
 f.prototype = {
     c: function() {
         throw new Error('can\'t use this method');//如果调用此方法会报错，因为它是用来派生子类不能实例化
     }
 };
 var e = function() {
     f.call(this);
 }
 e.prototype = new f();
 e.prototype.constructor = e;
 e.prototype.c = function() {
     console.log('this method is redefine');
 }
 // 调用
 var demo = new e();
 demo.c();

桥接模式：

桥接模式是将抽象与实现隔离，一遍二者独立变化。在设计一个javascript API的时候，它可以用来弱化类和对象之间的耦合。它还可以用来把多个类联接在一起。例如：

 var class1 = function(a,b,c) {
     this.a = a;
     this.b = b;
     this.c = c;
 };
 var class2 = function(d) {
     this.d = d;
 };
 var demo = function(a,b,c,d) {
     this.one = new Class1(a,b,c);
     this.two = new Class2(d);
 };

组合模式：

组合模式可以用一条命令在多个对象上激发复杂的或递归的行为。好处是可以用同样的发放处理对象的集合与其中的特定子对象，也可以用来把一批子对象组织成树形结构，并且使整个树都可被遍历。如下：

 // DynamicGallery Class
 　　var DynamicGallery =function (id) { // 实现Composite，GalleryItem组合对象类
    　　this.children = [];
    　　this.element = document.createElement('div');
    　　this.element.id = id;
    　　this.element.className ='dynamic-gallery';
 　　}
 　　DynamicGallery.prototype = {
    　　// 实现Composite组合对象接口
    　　add: function (child) {
       　　this.children.push(child);
       　　this.element.appendChild(child.getElement());
    　　},
    　　remove: function (child) {
       　　for (var node, i =0; node =this.getChild(i); i++) {
          　　if (node == child) {
             　　this.children.splice(i, 1);
            　　 break;
          　　}
       　　}
       　　this.element.removeChild(child.getElement());
    　　},
    　　getChild: function (i) {
       　　returnthis.children[i];
    　　},
    　　// 实现DynamicGallery组合对象接口
    　　hide: function () {
       　　for (var node, i =0; node =this.getChild(i); i++) {
          　　node.hide();
       　　}
       　　this.element.style.display ='none';
    　　},
    　　show: function () {
       　　this.element.style.display ='block';
       　　for (var node, i =0; node = getChild(i); i++) {
          　　node.show();
       　　}
    　　},
    　　// 帮助方法
    　　getElement: function () {
       　　returnthis.element;
    　　}
 　　}

 var GalleryImage =function (src) { // 实现Composite和GalleryItem组合对象中所定义的方法
    　　this.element = document.createElement('img');
    　　this.element.className ='gallery-image';
    　　this.element.src = src;
 　　}
 　　GalleryImage.prototype = {
    　　// 实现Composite接口
    　　// 这些是叶结点，所以我们不用实现这些方法，我们只需要定义即可
    　　add: function () { },
    　　remove: function () { },
    　　getChild: function () { },
    　　// 实现GalleryItem接口
    　　hide: function () {
       　　this.element.style.display ='none';
    　　},
    　　show: function () {
       　　this.element.style.display ='';
    　　},
    　　// 帮助方法
    　　getElement: function () {
       　　returnthis.element;
    　　}
 　　}

 var topGallery =new DynamicGallery('top-gallery');
 　　topGallery.add(new GalleryImage('/img/image-1.jpg'));
 　　topGallery.add(new GalleryImage('/img/image-2.jpg'));
 　　topGallery.add(new GalleryImage('/img/image-3.jpg'));
 　　var vacationPhotos =new DyamicGallery('vacation-photos');
 　　for(var i =0, i <30; i++){
 　　　　vacationPhotos.add(new GalleryImage('/img/vac/image-'+ i +'.jpg'));
 　　}
 　　topGallery.add(vacationPhotos);
 　　topGallery.show();
 　　vacationPhotos.hide();

门面模式：

门面模式常常是开发人员最亲密的朋友，他几乎是所有javascript库的核心原则。门面模式有两个作用：一是简化类的接口；二是消除类与使用它的客户代码之间的耦合。示例如下：

 function a() {

 }
 function b() {

 }
 function ab() {
     a();
     b();
 }

适配器模式：

适配器模式可以用来在现有接口和不兼容的类之间进行适配。从表面上看，适配器模式很像门面模式，都对别的对象进行包装并改变其呈现的接口。二者的区别在与它们如何改变接口，门面元素展现的是一个简化的接口，它并不提供额外的选择，而且有时为了方便完成常见任务它还会做出一些假定。而适配器则要把一个接口转换为另一个接口，它并不会过滤某些能力，也不会简化接口。

 var str = {
     a: 'a',
     b: 'b',
     c: 'c'
 };
 function i(s1,s2,s3) {
     console.log(s1 + ',' + s2 + ',' + s3);
 }
 function demo(o) {
     i(o.a,o.b,o.c);
 }

装饰者模式：

装饰者模式可用来透明地把对象包装在具有同样接口的另一个对象之中，装饰者可以用于为对象添加功能，可以用来代替大量子类。装饰者模式和组合模式有很多共同点，它们都与所包装的对象实现统一的接口并且会把任何方法条用传递给这些对象。可是组合模式用于把众多子对象组织为一个整体，而装饰者模式用于在不修改现有对象或从派生子类的前提下为其添加方法。如下：

 var m = {};
 m.child = {};
 m.child.one = function() {};
 m.child.two = function() {};

享元模式：

享元模式最适合于解决因创建大量类似对象而累及性能的问题。通过把大量独立对象转化为少量共享对象，可以降低运行web应用程序所需的资源数量。

javascript设计模式中的示例：

 //汽车登记示例
 　　var Car =function(make,model,year,owner,tag,renewDate){
 　　　　this.make=make;
 　　　　this.model=model;
 　　　　this.year=year;
 　　　　this.owner=owner;
 　　　　this.tag=tag;
 　　　　this.renewDate=renewDate;
 　　}
 　　Car.prototype = {
 　　　　getMake:function(){
 　　　　　　returnthis.make;
 　　　　},
 　　　　getModel:function(){
 　　　　　　returnthis.model;
 　　　　},
 　　　　getYear:function(){
 　　　　　　returnthis.year;
 　　　　},
 　　　　transferOwner:function(owner,tag,renewDate){
 　　　　　　this.owner=owner;
 　　　　　　this.tag=tag;
 　　　　　　this.renewDate=renewDate;
 　　　　},
 　　　　renewRegistration:function(renewDate){
 　　　　　　this.renewDate=renewDate;
 　　　　}
 　　}
 　　//数据量小到没多大的影响，数据量大的时候对计算机内存会产生压力，下面介绍享元模式优化后
 　　//包含核心数据的Car类
 　　var Car=function(make,model,year){
 　　　　this.make=make;
 　　　　this.model=model;
 　　　　this.year=year;
 　　}
 　　Car.prototype={
 　　　　getMake:function(){
 　　　　　　returnthis.make;
 　　　　},
 　　　　getModel:function(){
 　　　　　　returnthis.model;
 　　　　},
 　　　　getYear:function(){
 　　　　　　returnthis.year;
 　　　　}
 　　}
 　　//中间对象，用来实例化Car类
 　　var CarFactory=(function(){
 　　　　var createdCars = {};
 　　　　return {
 　　　　　　createCar:function(make,model,year){
 　　　　　　　　var car=createdCars[make+"-"+model+"-"+year];
 　　　　　　　　return car ? car : createdCars[make +'-'+ model +'-'+ year] =(new Car(make,model,year));
 　　　　　　}
 　　　　}
 　　})();
 　　//数据工厂，用来处理Car的实例化和整合附加数据
 　　var CarRecordManager = (function() {
 　　　　var carRecordDatabase = {};
 　　　　return {
 　　　　　　addCarRecord:function(make,model,year,owner,tag,renewDate){
 　　　　　　　　var car = CarFactory.createCar(make, model, year);
 　　　　　　　　carRecordDatabase[tag]={
 　　　　　　　　　　owner:owner,
 　　　　　　　　　　tag:tag,
 　　　　　　　　　　renewDate:renewDate,
 　　　　　　　　　　car:car
 　　　　　　}
 　　　　},
 　　　　　　transferOwnership:function(tag, newOwner, newTag, newRenewDate){
 　　　　　　　　var record=carRecordDatabase[tag];
 　　　　　　　　record.owner = newOwner;
 　　　　　　　　record.tag = newTag;
 　　　　　　　　record.renewDate = newRenewDate;
 　　　　　　},
 　　　　　　renewRegistration:function(tag,newRenewDate){
 　　　　　　　　carRecordDatabase[tag].renewDate=newRenewDate;
 　　　　　　},
 　　　　　　getCarInfo:function(tag){
 　　　　　　　　return carRecordDatabase[tag];
 　　　　　　}
 　　　　}
 　　})();

代理模式：

代理是一个对象，它可以用来控制对另一个对象的访问。它与另外那个对象实现了同样的接口，并且会把任何方法调用传递给那个对象。代理模式适合处理实例化比较费时的本体，也适合处理那些需要较长时间才能把数据载入用户界面的类。

javascript设计模式中的示例：

 var Publication =new Interface('Publication', ['getIsbn', 'setIsbn', 'getTitle', 'setTitle', 'getAuthor', 'setAuthor', 'display']);
 　 var Book =function(isbn, title, author) {
    　　 //...
 　　}
 　　// implements Publication
 　　implements(Book,Publication);

 　　/* Library interface. */
 　　var Library =new Interface('Library', ['findBooks', 'checkoutBook', 'returnBook']);

 　　/* PublicLibrary class. */
 　　var PublicLibrary =function(books) {
    　　 //...
 　　};
 　　// implements Library
 　　implements(PublicLibrary,Library); 

 　　PublicLibrary.prototype = {
    　　 findBooks: function(searchString) {
       　　 //...
     　　},
     　　checkoutBook: function(book) {
      　　   //...
    　　 },
     　　returnBook: function(book) {
       　　  //...
    　　 }
 　　};

 　　/* PublicLibraryProxy class, a useless proxy. */
 　　var PublicLibraryProxy =function(catalog) {
   　　  this.library =new PublicLibrary(catalog);
 　　};
 　　// implements Library
 　　implements(PublicLibraryProxy,Library);

 　　PublicLibraryProxy.prototype = {
   　　  findBooks: function(searchString) {
     　　    returnthis.library.findBooks(searchString);
     　　},
     　　checkoutBook: function(book) {
      　　   returnthis.library.checkoutBook(book);
    　　 },
    　　 returnBook: function(book) {
     　　    returnthis.library.returnBook(book);
    　　 }
 　　};

观察者模式：

观察者模式是一种管理人与其任务之间的关系的得力工具。观察者模式中存在两个角色:观察者和被观察者。这种模式的好处是你可以对程序中某个对象的状态进行观察，并且在其发生改变时能够得到通知。

 　　var f1 =function(){
    　　//code
 　　}
 　　var f2 =function(){
    　　//code
 　　}
 　　addEvent(element,'click',f1)；
 　　addEvent(element,'click',f2)

 　　element.onclick = f1;
 　　element.onclick = f2;

命令模式：

命令模式可以用来对方法调用进行参数化处理和传送，经这样处理过的方法调用可以在任何需要的时候执行。好处是可以用来消除调用操作的对象和实现操作的对象之间的耦合，使对象间的互动方式更高的模块化。这为各种具体的类更换带来了极大的灵活性。

 car Calculator={
    　　add:function(x,y){
     　　  return x+y;
    　　},
    　　substract:function(x,y){
     　　  return x-y;
    　　},
    　　multiply:function(x,y){
     　　  return x*y;
    　　},
    　　divide:function(x,y){
     　　  return x/y;
    　　}
 　　}
 　　Calculator.calc =function(command){
    　　return Calculator[command.type](command.op1,command.opd2)
 　　};
 　　Calculator.calc({type:'add',op1:1,op2:1});
 　　Calculator.calc({type:'substract',op1:5,op2:2});
 　　Calculator.calc({type:'multiply',op1:5,op2:2});
 　　Calculator.calc({type:'divide',op1:8,op2:4});

职责链模式：

职责链模式是通过实现一个由隐式地请求进行处理对象组成的链而做到的。可以用来消除请求的发送者和接收者之间的耦合

javascript内部就使用了这种模式来处理事件捕获和冒泡的问题。

职责链由多个不同类型的对象组成：发送者是发出请求的对象，而接收者则是接收请求并且对其进行处理或传递的对象，请求本身有时也是一个对象，它封装着与操作有关的所有数据。其典型的流程大致是：

1. 发送者知道链中第一个接收者，它向这个接收者发出请求。
2. 每一个接收者都对请求进行分析，然后要么处理它，要么将其往下传。
3. 每一个接收者知道的其他对象只有一个，即它在链中的下家。
4. 如果没有任何接收者处理请求，那么请求将从链上离开，不同的实现对此也有不同的反应，一般会抛出一个错误。

小结：

　　每种模式都有自己的优点，选择一种适合自己业务的模式非常重要，能够提高代码的可读性、可维护性等等，希望本文能够对你有所帮助。

本文参考电子书《javascript设计模式》