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

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

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

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

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

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

一、观察者模式原理

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

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

如下：

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. * 业务开发者B使用test，不修改test源码的情况下，执行test时，如B需要可以先执行B自定义的方法，test执行结束后还需再执行B自定义的另一方法
13. * 双方约定先执行的方法名为 beforeTest
14. */
15. function beforeTest(){
16. console.log('beforeTest')
17. /*
18. * do beforeTest something
19. */
20. }
21. /*
22. * 双方约定后执行的方法名为 afterTest
23. */
24. function afterTest(){
25. console.log('afterTest')
26. /*
27. * do afterTest something
28. */
29. }
30. /*
31. * 示例：
32. */
33. test();         //控制台会输出 开发者B自定义方法里的值  beforeTest ; afterTest
34. //这样每次执行test时，都会执行B自定义的方法

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

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

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

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

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

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

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