深入出不来nodejs源码-events模块

EventEmitter.call(this);

function EventEmitter() {
  EventEmitter.init.call(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;
};

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

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

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

/**
 * 事件绑定方法
 * @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 = 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];
}

// 首次添加该类型事件时
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
  // ...
}

// 获取_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);
}

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

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

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

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

  // ...
}

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

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