事件是一种叫做观察者的设计模式，这是一种创建松散耦合代码的技术。对象可以发布事件，用来表示在该对象生命周期中有某个有趣的时刻到了。然后其他对象可以观察该对象，等待这些有趣的时刻到来，并通过运行代码来响应。
观察者模式由两类对象组成：主体和观察者。主体负责发布事件，同时观察者通过订阅这些事件来观察该主体。该模式的一个关键概念是主体不知道观察者的任何事情，也就是说它可以独自存在并正常运作即使观察者不存在。从另一方面来说，观察者知道主体并能注册时间的回调函数（事件处理程序）。
上面是红宝书（《JavaScript高级程序设计（第三版）》）对自定义事件的描述。并且，它认为自定义事件就是观察者模式。观察者模式有时候也叫发布/订阅模式。
但实际上，观察者模式和发布/订阅模式有一点小小的不同，即发布/订阅模式有一个调度中心，对事件进行统一处理。而观察者模式会将处理事件的代码分散在每个主体中。发布/订阅模式可以说是升级版观察者模式。
红宝书中实现自定义事件的代码实际上是发布/订阅模式。
什么时候用
个人认为，观察者模式主要解决的是模块之间的通信问题。你有两个类，当一个类中某个属性发生变化的时候，你要通知另一个类，让它执行对应的代码，这个时候就可以使用观察者模式。观察者模式也叫消息机制。
原理
不管是观察者模式还是发布/订阅模式，原理都是一样的。
看到这个名字，我一开始以为，当消息产生时，主体将消息内容通知给观察者，观察者执行对应的函数。但实际上，实现的思路刚好相反。
执行操作的是主体而不是观察者。观察者起到的作用只是为消息注册函数，当主体发布消息时，会执行注册在该消息上的所有函数。
回想一下浏览器中的事件（click，keydown），我们做的是给每个事件绑定响应的操作函数，我们写的js属于观察者。当事件发生时，浏览器就会执行我们绑定的函数，其实原理是一样的。
实现
发布/订阅模式
var Observer = (function() {
// 消息容器，用来存放消息和要对应的操作函数
var __messages = {}
return {
// 注册消息接口
regist: function(type, fn) {
// 当消息不存在时，创建一个该消息类型，将回调函数推入执行队列中
if (typeof __messages[type] === 'undefined') {
__messages[type] = [fn]
} else {
// 消息类型存在时，将回调函数推入执行队列中
__messages[type].push(fn)
}
},
// 发布消息接口
fire: function(type, args) {
// 当消息不存在时直接返回
if (!__messages[type])
return
args = args || {}
// 依次执行消息对应的动作队列
for (var i = 0, len = __messages[type].length; i < len; i++) {
__messages[type][i].call(this, args)
}
},
// 移除消息接口
remove: function(type, fn) {
if (__messages[type] instanceof Array) {
// 从后面开始遍历，如果存在该动作则将其移除
for (var i = __messages[type].length - 1; i >= 0; i--) {
__messages[type][i] === fn && __messages[type].splice(i, 1)
}
}
}
}
})()
// 在观察者中注册消息
Observer.regist('test', function(args){
console.log(args.msg) // 消息内容
})
// 主体发布消息
Observer.fire('test', { msg: '消息内容' })
通过单例模式创建的Observer对象，就是发布/订阅模式中的调度中心。私有变量__messages保存了消息类型及其对应的动作数组。观察者通过Observer.regist接口给消息注册动作，主体（发布者）通过Observer.fire发布消息，执行该消息的所有动作。通过Observer.remove方法可以移除对应动作。
可以说，这个一个简易的addEventListener的实现。
红宝书中的实现与上述代码的区别只是，它使用了构造函数-原型混合模式创建Observer对象，可以实例化多个调度中心。
观察者模式
// 观察者列表
function ObserverList() {
this.observerList = []
if (typeof this.add !== 'function') {
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.remove = function(observer) {
this.observerList.filter(function(item){
return item !== observer
})
}
}
}
// 主体（消息发布者）
function Subject() {
this.observers = new ObserverList()
if (typeof this.addObserver !== 'function') {
Subject.prototype.addObserver = function(observer) {
this.observers.add(observer)
}
Subject.prototype.removeObserver = function(observer) {
this.observers.remove(observer)
}
Subject.prototype.notify = function(args) {
var count = this.observers.count()
for (var i = 0; i < count; i++) {
this.observers.get(i).update(args)
}
}
}
}
// 观察者
function Observer() {
this.update = function(){
// ...
}
}
主体内部需要维护一个观察者列表，将需要观察主体变化的对象加入这个列表。当消息发生时，可以调用notify方法通知所有观察者（即调用观察者的update方法）。
可以看出，在每个主体中都要维护一个观察者列表，造成代码冗余。发布消息时，需要调用观察者的方法，主体和观察者耦合度高。上面的代码中，只有update一种消息类型，如果想要多种消息类型，主体需要定义多个函数，十分麻烦。
因此，发布/订阅模式更加常用。
