15.观察者模式vs发布订阅模式

// 被观察者
var subject = {
  observers: [],
  notify() {
    this.observers.forEach((observer) => {
      observer.update();
    });
  },
  attach(observer) {
    this.observers.push(observer);
  },
};
// 观察者
var observer = {
  update() {
    alert("updated");
  },
};
// 绑定观察者
subject.attach(observer);
// 通知观察者
subject.notify();

//发布订阅对象
var pubsub = {
  subscribes: [],
  publish() {
    this.subscribes.forEach((subscribe) => {
      subscribe.update();
    });
  },
  subscribe(sub) {
    this.subscribes.push(sub);
  },
};

// 发布者
var publisher = {
  publish(pubsub) {
    pubsub.publish();
  },
};
// 订阅者
var subscriber = {
  update() {
    console.log("update");
  },
  subscribe(pubsub) {
    pubsub.subscribe(this);
  },
};
subscriber.subscribe(pubsub);
publisher.publish(pubsub);

//观察者模式
function ObserverList() {
  this.observerList = [];
}
ObserverList.prototype.add = function (obj) {
  return this.observerList.push(obj);
};
ObserverList.prototype.count = function () {
  return this.observerList.length;
};
ObserverList.prototype.get = function (index) {
  if (index > -1 && index < this.observerList.length) {
    return this.observerList[index];
  }
};
ObserverList.prototype.indexOf = function (obj, startIndex) {
  let i = startIndex;
  while (i < this.observerList.length) {
    if (this.observerList[i] == obj) {
      return i;
    }
    i++;
  }
  return -1;
};
ObserverList.prototype.removeAt = function (index) {
  this.observerList.splice(index, i);
};

function Subject() {
  this.observers = new ObserverList();
}
Subject.prototype.addObserver = function (observer) {
  this.observers.add(observer);
};
Subject.prototype.removeObserver = function (observer) {
  this.observer.removeAt(this.observers.indexOf(observer, 0));
};
Subject.prototype.notify = function (context) {
  let observerCount = this.observers.count();
  for (let index = 0; index < observerCount; index++) {
    this.observers.get(index).update(context);
  }
};

function Observer() {
  this.update = (context) => {
    console.log(context);
  };
}
let o = new Observer();
let subject = new Subject();
subject.addObserver(o);
subject.notify(55);

var pubsub = {};
(function (myObject) {
  // Storage for topics that can be broadcast
  // or listened to
  var topics = {};
  // An topic identifier
  var subUid = -1;
  // Publish or broadcast events of interest
  // with a specific topic name and arguments
  // such as the data to pass along
  myObject.publish = function (topic, args) {
    if (!topics[topic]) {
      return false;
    }
    var subscribers = topics[topic],
      len = subscribers ? subscribers.length : 0;
    while (len--) {
      subscribers[len].func(topic, args);
    }
    return this;
  };
  // Subscribe to events of interest
  // with a specific topic name and a
  // callback function, to be executed
  // when the topic/event is observed
  myObject.subscribe = function (topic, func) {
    if (!topics[topic]) {
      topics[topic] = [];
    }
    var token = (++subUid).toString();
    topics[topic].push({
      token: token,
      func: func,
    });
    return token;
  };
  // Unsubscribe from a specific
  // topic, based on a tokenized reference
  // to the subscription
  myObject.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 this;
  };
})(pubsub);

//订阅者1订阅了test
pubsub.subscribe("test", function () {
  console.log(arguments, 1);
});
//订阅者2订阅了test
pubsub.subscribe("test", function () {
  console.log(arguments, 2);
});
//订阅者3订阅了test
pubsub.subscribe("test", function () {
  console.log(arguments, 2);
});

//发布者发布事件
pubsub.publish("test", 666);