深入學習 Node.js EventEmitter

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
console.log('觸發了一個事件！');
});

myEmitter.emit('event');

function EventEmitter() {
EventEmitter.init.call(this);
}

EventEmitter.usingDomains = false;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._eventsCount = 0; // 事件數
EventEmitter.prototype._maxListeners = undefined; // 最大的監聽器數

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;
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};

/**
* 新增事件監聽器
* target：EventEmitter 例項
* type：事件型別
* listener：事件監聽器
* prepend：是否新增在前面
*/
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;

// 若監聽器不是函式物件，則丟擲異常
if (typeof listener !== 'function') {
const errors = lazyErrors();
throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'listener', 'Function');
}

events = target._events;
// 若target._events物件未定義，則使用Object.create建立一個新的物件
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} 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型別儲存的物件
}

if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
// 優化單個監聽器的場景，不需使用額外的陣列物件。
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') { // 新增type前已有繫結監聽器
// Adding the second element, need to change to array.
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
// If we've already got an array, just append.
} else if (prepend) { // 新增到前面
existing.unshift(listener);
} else { // 新增到後面
existing.push(listener);
}
}
return target;
}

EventEmitter.prototype.emit = function emit(type, ...args) {
let doError = (type === 'error'); 

const events = this._events;

const handler = events[type]; // 獲取type型別對應的處理器

if (handler === undefined)
return false;

// 若事件處理器為函式物件，則使用Reflect.apply進行呼叫
if (typeof handler === 'function') { 
Reflect.apply(handler, this, args);
} else {
const len = handler.length;
const listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
Reflect.apply(listeners[i], this, args);
}

return true;
};

// 陣列淺拷貝
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}

// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;

// 若監聽器不是函式物件，則丟擲異常
if (typeof listener !== 'function') {
const errors = lazyErrors();
throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'listener',
'Function');
}

events = this._events;
if (events === undefined)
return this;

list = events[type]; // 獲取type對應的繫結物件
if (list === undefined)
return this;

if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0) // 只繫結一個監聽器
this._events = Object.create(null);
else {
delete events[type];
// 若已設定removeListener監聽器，則觸發removeListener事件
if (events.removeListener) 
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') { // 包含多個監聽器
position = -1;

for (i = list.length - 1; i >= 0; i--) { // 獲取需移除listener對應的索引值
if (list[i] === listener || list[i].listener === 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移除position對應的值
spliceOne(list, position);
}

if (list.length === 1)
events[type] = list[0];

if (events.removeListener !== undefined)
this.emit('removeListener', type, originalListener || listener);
}

return this;
};

// About 1.5x faster than the two-arg version of Array#splice().
function spliceOne(list, index) {
for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
list[i] = list[k];
list.pop(); // 把最後面的空位移除
}

const myEmitter = new MyEmitter();
let m = 0;
myEmitter.once('event', () => {
console.log(++m);
});
myEmitter.emit('event'); // 列印: 1
myEmitter.emit('event'); // 無輸出

EventEmitter.prototype.once = function once(type, listener) {
if (typeof listener !== 'function') {
const errors = lazyErrors();
throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'listener', 'Function');
}
this.on(type, _onceWrap(this, type, listener));
return this;
};

function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target, type, listener };
var wrapped = onceWrapper.bind(state); // 繫結this上下文
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}

function onceWrapper(...args) {
if (!this.fired) { 
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
Reflect.apply(this.listener, this.target, args);
}
}