观察者模式

目标和观察者是基类，目标提供维护观察者的一系列方法，观察者提供更新接口。具体观察者和具体目标继承各自的基类，然后具体观察者把自己注册到具体目标里，在具体目标发生变化时候，调度观察者的更新方法。

function Observer(){
  this.list = {};//保存所有观察者方法的引用
}
//添加观察者
Observer.prototype.addWatcher = function(type,func){
  if(!(this.list[type] instanceof Array)){
    this.list[type] = [];
  }
  this.list[type].push(func);
}
//发布
Observer.prototype.fire = function(type){
  var typeFunc = this.list[type];
  var len = typeFunc.length;
  for(var i = 0;i < len; i++){
    typeFunc[i](event);
  }
}
//移除观察者
Observer.prototype.removeWatcher = function(type,func){
  var typeFunc = this.list[type];
  if(!(typeFunc instanceof Array)){
    return;
  }
  var len = typeFunc.length;
  for(var i = 0;i < len; i++){
    if(typeFunc[i] == func){
      typeFunc.splice(i,1);
    }
  }
}   

发布/订阅模式

订阅者把自己想订阅的事件注册到调度中心，当该事件触发时候，发布者发布该事件到调度中心（顺带上下文），由调度中心统一调度订阅者注册到调度中心的处理代

    function Publisher(){
        this.subers = {};//存储各类订阅者
      }
      //添加发布者
      Publisher.prototype.addSub = function(type,func){
        if(!(subers[type] instanceof Array)){
          subers[type] = [];
        }
        subers[type].push(func);
      }
      //移除发布者
      Publisher.prototype.removeSub = function(type,func){
        var typeFunc = subers[type];
        if(!(typeFunc instanceof Array)){
          return;
        }
        var len = typeFunc.length;
        for(var i = ;i < len; i++){
          if(typeFunc[i] == func){
            typeFunc.splice(i,1);
          }
        }
      }
      //发布
      Publisher.prototype.fire = function(type){
        var typeFunc = subers[type];
        var len = typeFunc.length;
        for(var i = ;i < len; i++){
          typeFunc[i](event);
        }
      }
      function Subscriber(){
        this.Publisher = new Publisher();
      }
      Subscriber.prototype.fire = function(type){
        this.Publisher.fire(type);
      } 

上文可以看出发布/订阅模式相对观察者模式多了一个中间过度把发布和订阅分开，如果从这点代码量看来好像发布订阅完全多此一举，但是在大型项目中的团队合作来说，完全解耦是十分有必要的。