我理解的 js 的观察者模式 Observable

我第一次看 四人帮 写的《设计模式》时一头雾水，现在也是，或许其是针对专业的程序员学习使用的。

通过对Ext / Backbone 源码的学习，可总结如下：

模式 - 就是对解决某一类特定问题的有效总结，并在后续解决同样的问题可以持续使用。

设计模式 - 程序开发者认为自己是优雅的设计师。

观察者模式：主要应用于组件开发，以便组件使用者 可以自行定义某个性方法，在组件达到某种状态时调用。

 

一、观察者模式原理 

组件开发为了保证组件可以在不同的项目中都适用，其必须是对其常用功能 抽象出来 加以实现，绝不会包含具体的业务逻辑

而某一特定的项目使用者在其业务场景中使用组件时不可避免的要加入不同场景的业务逻辑，观察者模式很好的解决了这个的问题。

如下：

Js代码  收藏代码
  1. /* 
  2. * 组件开发者A 定义了通用方法 test 供 业务开发者B 使用 
  3. */  
  4. function test(){  
  5.     beforeTest && beforeTest()  
  6.     // do test something  
  7.     console.log( 'test ');  
  8.     // do test something  
  9.     afterTest && afterTest();  
  10. }  
  11.   
  12. /* 
  13. * 业务开发者B使用test，不修改test源码的情况下，执行test时，如B需要可以先执行B自定义的方法，test执行结束后还需再执行B自定义的另一方法 
  14. * 双方约定先执行的方法名为 beforeTest 
  15. */  
  16. function beforeTest(){  
  17.     console.log('beforeTest')  
  18.     /* 
  19.     * do beforeTest something 
  20.     */  
  21. }  
  22.   
  23. /* 
  24. * 双方约定后执行的方法名为 afterTest 
  25. */  
  26. function afterTest(){  
  27.     console.log('afterTest')  
  28.     /* 
  29.     * do afterTest something  
  30.     */  
  31. }  
  32.   
  33. /* 
  34. * 示例： 
  35. */  
  36. test();         //控制台会输出 开发者B自定义方法里的值  beforeTest ; afterTest   
  37. //这样每次执行test时，都会执行B自定义的方法  

 通过上面这种模式，可以降低代码之间的耦合，据实际使用和双方约定，组件使用方可以在组件使用过程中，不对组件进行修改，却可以自由的定义、执行其业务需要的个性化的方法。

 

上面的方法只是讲了原理，并不适用于实际的项目，且对于beforeTest只能定义一个，经过简单的抽象提取如下

Js代码  收藏代码
  1. /* 
  2. * 组件开发者A定义组件 Person 供开发者B使用 
  3. */  
  4. var events = {  
  5.       
  6.     /* 
  7.     * 添加 name 对应的 事件callback，保存在this._events里 
  8.     */  
  9.     on: function( name, callback ){  
  10.         this._events || (this._events = {});    //确保this._events存在  
  11.         this._events[name] = this._events[name] || [];//确保this._events[name]存在  
  12.         this._events[name].push({ callback: callback });//将callback 添加到 this._events[name] 内  
  13.     },  
  14.       
  15.     /* 
  16.     * 执行已经保存在this._events里的 name 对应的事件 
  17.     */  
  18.     trigger : function( name ){  
  19.         var args = Array.prototype.slice.call( arguments, 1 );        
  20.                  //将参数中除 name 外的其它参数取出来  
  21.         if( this._events && this._events[name] ){                                 //确保 this._events[name] 存在  
  22.             for( var i = 0; i < this._events[name].length; i++){   
  23.                                 //循环执行里面的callback  
  24.                 this._events[name][i].callback.apply( this, args );   
  25.                                 //将步骤一取出的值作用callback的参数  
  26.             }  
  27.         }  
  28.     },  
  29.       
  30.     /* 
  31.     * 删除this._events里 name 对应的事件 
  32.     */  
  33.     off: function( name ){  
  34.         if( this._events ){  
  35.             delete this._events[name];                          //删除  this._events[name]  
  36.         }  
  37.     }  
  38. }  
  39.   
  40. var Person = function( config ){  
  41.     this.name = config.name;  
  42.     this.age = config.age;  
  43. }  
  44.   
  45. for( var key in events ){  
  46.     Person.prototype[key] = events[key];          
  47.         //将events里的属性添加到Person的原型里  
  48. }  
  49.   
  50. Person.prototype.getName = function(){  
  51.     this.trigger('getName', this.name );  
  52.     return this.name;  
  53. }  
  54. /* 
  55. * 当设置Person里的名字里，执行一次 setName 监听 
  56. */  
  57. Person.prototype.setName = function( name ){  
  58.     this.trigger( 'setName', name );  
  59.     this.name = name;  
  60.     return this;  
  61. }  
  62.   
  63. /* 
  64. * 生成一个实例 
  65. */  
  66. var lulu = new Person({ name: 'lulu', age: '25'});  
  67.   
  68. /* 
  69. * 根据业务的个性化需要 添加一个监听事件，当执行到setName里，执行function， 
  70. */  
  71. lulu.on( 'setName', function( name ){  
  72.     console.log('您执行一次setName __ ' + name );  
  73.     /* 
  74.     * 上面一个无意义的场景 
  75.     * 实际的场景可以是setName后会通过 ajax 保存到数据库等操作 
  76.     */  
  77. });  
  78.   
  79. /* 
  80. * 对同一个监听行为可以添加多个 事件 
  81. */  
  82. lulu.on( 'setName', function( name ){  
  83.     console.log('您执行二次setName __ ' + name )  
  84. });  
  85.   
  86. /* 
  87. * 测试 
  88. */  
  89. lulu.setName('nana');       //控制台会输出    您执行一次setName __ nana;   您执行二次setName __ nana;  
  90. lulu.setName('aobama');     //您执行一次setName __ aobama;   您执行二次setName __ aobama;  
  91. lulu.off( 'setName' );  
  92. lulu.setName('lala');       //此时控制台将不会再输出信息  

 观察者模式 基础使用就是上面所讲，不过不同的框架又在此基础上丰富了功能

如backbone，可以一次添加多个监听事件 lulu.on({ 'setName': fun1, 'getName': fun2 }); 和只执行一次的监听  once。 具体参见 【backbone 源码分析】

Ext提供的功能更多，其中可以 据每次执行监听事件的结果是否为false来判定是否继续执行后面的操作， 除了这个功能较实用外，其它的功能个人认为不常用。

 

 

来源转载：http://jiangxiao-2000.iteye.com/blog/1893601

posted @ 2014-05-22 13:11  孙首富  阅读(525)  评论(0)  编辑  收藏  举报