深入出不来nodejs源码-events模块
这一节内容超级简单，纯JS，就当给自己放个假了，V8引擎和node的C++代码看得有点脑阔疼。
学过DOM的应该都知道一个API，叫addeventlistener，即事件绑定。这个东西贯穿了整个JS的学习过程，无论是刚开始的自己获取DOM手动绑，还是后期vue的直接@click，所有的交互都离不开这个东西。
同样，在node中，事件绑定也贯穿了整个框架。基本上大多数的内置模块以events为原型，下面的代码随处可见：
EventEmitter.call(this);
不同的是，页面上DOM的事件绑定是由浏览器来实现，触发也是一些操作'间接'触发，并不需要去主动emit对应事件，并且有冒泡和捕获这两特殊的性质。
但是在node中，不存在dom，绑定的目标是一个对象(dom本质上也是对象)，在内部node自己用纯JS实现了一个事件绑定与事件触发类。
本文相关源码来源于https://github.com/nodejs/node/blob/master/lib/events.js。
首先看一下构造函数：
function EventEmitter() {
EventEmitter.init.call(this);
}
这里会调用一个init方法，this指向调用对象，初始化方法也很简单：
EventEmitter.init = function() {
// 事件属性
if (this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events) {
this._events = Object.create(null);
this._eventsCount = 0;
}
// 同类型事件最大监听数量
this._maxListeners = this._maxListeners || undefined;
};
涉及的三个属性分别是：
1、_events => 一个挂载属性，空对象，负责收集所有类型的事件
2、_eventsCount => 记录目前绑定事件类型的数量
3、_maxListeners => 同类型事件listener数量限制
事件相关的主要操作有3个，依次来看。
绑定事件/on
虽然一般用的AP都是event.on，但是其实用addListener是一样的：
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.addListener = function addListener(type, listener) { return _addListener(this, type, listener, false); };
这个addListener跟DOM的addEventListener稍微有点不一样，前两个参数一致，分别代表类型、回调函数。
但是最后一个参数，这里代表的是否优先插入该事件，有一个方法就是做这个的：
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
最终都指向这个_addListener，分步解释：
/**
* 事件绑定方法
* @param {Object} target 目标对象
* @param {String} type 事件名称
* @param {Function} listener 回调函数
* @param {Boolean} prepend 是否插入
*/
function _addListener(target, type, listener, prepend) {
// 指定事件类型的回调函数数量
var m;
// 事件属性对象
var events;
// 对应类型的回调函数
var existing;
if (typeof listener !== 'function') {
const errors = lazyErrors();
throw new errors.ERR_INVALID_ARG_TYPE('listener', 'Function', listener);
}
// 尝试获取对应类型的事件
events = target._events;
// 未找到对应的事件相关属性
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
}
// 当存在对象的事件属性对象时
else {}
// more...
return target;
}
这里首先会尝试获取指定对象的_events属性，即构造函数中初始化的挂载对象属性。
由于无论是任意构造函数中调用EventEmitter.call(this)或者new EventEmitter()都会在生成对象上挂载一个_events对象，所以这个判断暂时找不到反例。
当不存在就手动初始化一个，并添加一个记数属性重置为0。
当存在时，处理代码如下：
events = target._events;
if (events === undefined) {
// ...
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
// 尝试获取对应类型的回调函数集合
existing = events[type];
}
这个地方的注释主要讲的是，当绑定了type为newListener的事件时，每次都会触发一次这个事件，如果再次绑定该事件会出现递归问题。所以要判断是否存在newListener事件类型，如果有就先触发一次newListener事件。
先不管这个，最后会尝试获取指定类型的事件listener容器，下面就是对existing的处理。
// 首次添加该类型事件时
if (existing === undefined) {
// 直接把函数赋值给对应类型的key
existing = events[type] = listener;
// 记数+1
++target._eventsCount;
} else {
// 1.已有对应类型 但是只有一个
if (typeof existing === 'function') {
// 转换数组 根据prepend参数安排顺序
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
// If we've already got an array, just append.
}
// 2.已有多个 判断是否有优先的flag进行前插或后插
else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
// Check for listener leak
// ...
}
这里的处理就能很清楚的看到events模块对于事件绑定的处理，_events相当于一个总对象，属性的key就是对应的事件类型type，而key对应的value就是对应的listener。只有一个时，就直接用该listener做值。重复绑定同类型的事件，这时值会转换为数组保存所有的listener。这里prepend就是之前的最后一个参数，允许函数插入到队列的前面，优先触发。
最后还有一个绑定事件的数量判断：
// 获取_maxListeners参数 同类型事件listener最大绑定数量
m = $getMaxListeners(target);
// 如果超出就发出可能有内存泄漏的警告
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// 因为是warning所以不会有error code 可以不理这个东西
// eslint-disable-next-line no-restricted-syntax
const w = new Error('Possible EventEmitter memory leak detected. ' +
`${existing.length} ${String(type)} listeners ` +
'added. Use emitter.setMaxListeners() to ' +
'increase limit');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
process.emitWarning(w);
}
看看就好，程序员不用管warning，哈哈。
一次绑定事件/once
有些时候希望事件只触发一次，原生的API目前不存在该功能，当初jquery也是封装了一个once方法，对应的这个events模块也有。
EventEmitter.prototype.once = function once(type, listener) {
if (typeof listener !== 'function') {
const errors = lazyErrors();
throw new errors.ERR_INVALID_ARG_TYPE('listener', 'Function', listener);
}
this.on(type, _onceWrap(this, type, listener));
return this;
};
除去那个判断，其实绑定的方法还是同一个，只是对应的listener变成了一个包装函数，来看看。
function _onceWrap(target, type, listener) {
// this绑定对象
var state = { fired: false, wrapFn: undefined, target, type, listener };
var wrapped = onceWrapper.bind(state);
// 原生的listener挂载到这个包装函数上
wrapped.listener = listener;
// 处理完后更新state属性
state.wrapFn = wrapped;
// 返回的是一个包装的函数
return wrapped;
}
function onceWrapper(...args) {
// 这里所有的this指向上面的state对象
// args来源于触发时候给的参数
if (!this.fired) {
// 解绑该包装后的listener
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
// 触发listener
Reflect.apply(this.listener, this.target, args);
}
}
思路其实跟jquery的源码差不多，也是包装listener，当触发一次事件时，先解绑这个listener再触发事件。
需要注意的是，这里存在两个listener，一个是原生的，一个是包装后的。绑定的是包装的，所以解绑的第二个参数也要是包装的。其中原生的作为listener属性挂载到包装后的函数上，实际上触发包装listener后内部会隐式调用原生listener。
事件触发/emit
看完绑定，来看触发。
EventEmitter.prototype.emit = function emit(type, ...args) {
let doError = (type === 'error');
const events = this._events;
// 判断是否触发的error类型事件
if (events !== undefined)
doError = (doError && events.error === undefined);
else if (!doError)
return false;
// If there is no 'error' event listener then throw.
if (doError) {
// 错误处理 不看
}
// 跟之前的existing一个东西
const handler = events[type];
if (handler === undefined)
return false;
// 如果只有一个 直接调用
if (typeof handler === 'function') {
Reflect.apply(handler, this, args);
} else {
// 多个listener 依次触发
const len = handler.length;
const listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
Reflect.apply(listeners[i], this, args);
}
return true;
};
太简单了，懒得解释。
事件解绑/removeListener
同样分几步来看解绑的过程，首先是参数声明：
// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener = function removeListener(type, listener) {
// list => listener容器
// events => 事件根对象
// position => 记录删除listener位置
// i => 迭代参数
// originalListener => 原生listener 参考上面的once
var list, events, position, i, originalListener;
if (typeof listener !== 'function') {
const errors = lazyErrors();
throw new errors.ERR_INVALID_ARG_TYPE('listener', 'Function', listener);
}
events = this._events;
if (events === undefined)
return this;
list = events[type];
if (list === undefined)
return this;
// ...
}
比较简单，每个参数的用处都很明显，错误判断后，下面有两种不同的情况。
当对应type的listener只有一个时：
EventEmitter.prototype.removeListener = function removeListener(type, listener) {
// list => listener容器
// events => 事件根对象
// position => 记录删除listener位置
// i => 迭代参数
// originalListener => 原生listener 参考上面的once
var list, events, position, i, originalListener;
// ...
// listener只有一个的情况
if (list === listener || list.listener === listener) {
// 如果一个绑定事件都没了 直接重置_events对象
if (--this._eventsCount === 0)
this._events = Object.create(null);
else {
// 删除对应的事件类型
delete events[type];
// 尝试触发一次removeListener事件
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
// ...
}
return this;
};
这里还分了两种情况，如果_eventsCount为0，即所有的type都被清完，会重置_events对象。
理论上来说，按照else分支的逻辑，当listener剩一个的时候都是直接delete对应的key，最后剩下的还是一个空对象，那这里的重重置似乎变得没有意义了。
我猜测估计是为了V8层面的优化，因为对象的属性在破坏性变动(添加属性、重复绑定同type事件导致函数变成函数数组)的时候，所需的内存会进行扩充，这个过程是不可逆的，就算最后只剩一个空壳对象，其实际占用也是相当大的。所以为了省空间，这里进行重置，用很小的空间初始化_events对象，原来的空间被回收。
当对应type的listener为多个时，就要遍历了。
if (list === listener || list.listener === listener) {
// ...
} else if (typeof list !== 'function') {
position = -1;
// 倒序遍历
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
// once绑定的事件有listener属性
originalListener = list[i].listener;
// 记录位置
position = i;
break;
}
}
if (position < 0)
return this;
// 在第一个位置时
if (position === 0)
list.shift();
else {
// 删除数组对应索引的值
if (spliceOne === undefined)
spliceOne = require('internal/util').spliceOne;
spliceOne(list, position);
}
// 如果数组里只有一个值 转换为单个值
// 有点像HashMap的链表-红黑树转换……
if (list.length === 1)
events[type] = list[0];
// 尝试触发removeListener
if (events.removeListener !== undefined)
this.emit('removeListener', type, originalListener || listener);
}
太简单了，自己看吧。
其他还有诸如removeAllListeners、_listeners、eventNames等API，有兴趣的可以自行去看。