深入学习 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);
  }
}