深入理解 Node.js 中 EventEmitter源码分析(3.0.0版本)

events模块对外提供了一个 EventEmitter 对象，即：events.EventEmitter. EventEmitter 是NodeJS的核心模块events中的类，用于对NodeJS中的事件进行统一管理，使用events可以对特定的API事件进行添加,触发和移除等。
我们可以通过 require('events')来访问该模块。

比如如下代码：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

我们先把如上代码放入 main.js 里面，然后在 项目中对应目录下 执行 node main.js 执行结果如下：

如上图可以看到，console.log(events); 打印后，有 EventEmitter 属性，defaultMaxListeners 属性(getter/setter) 方法，init函数属性，及 listenerCount 函数属性等。

1. defaultMaxListeners的含义是：默认事件最大监听个数，在源码中 默认是10个，设置最大监听个数为10个，因为如果监听的个数过多的话，会导致 内存泄露的问题产生。因此默认设置了十个。当然我们在源码中可以设置或者获取最大的监听个数，我们可以设置最大监听的个数 如下代码：

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
  }
  this._maxListeners = n;
  return this;
};

当然有设置监听的个数，我们也有获取最大的监听个数，如下源码：

function $getMaxListeners(that) {
  if (that._maxListeners === undefined)
    return EventEmitter.defaultMaxListeners;
  return that._maxListeners;
}

EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
  return $getMaxListeners(this);
};

当然源码中也使用了 Object.defineProperty方法监听该属性值是否发生改变，如下基本源码：

Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
  enumerable: true,
  get: function() {
    return defaultMaxListeners;
  },
  set: function(arg) {
    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
    }
    defaultMaxListeners = arg;
  }
});

如果defaultMaxListeners值发生改变的话，就会调用相对应的getter/setter方法。

2. events 中的init函数中基本源码如下：

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

如上基本代码：this._events 的含义是 保存所有的事件对象，事件的触发和事件的移除操作监听等都在
这个对象_events的基础上实现。

this._eventsCount 的含义是：用于统计事件的个数，也就是_events对象有多少个属性。

this._maxListeners 的含义是：保存最大的监听数的含义。

3. event中的listenerCount函数的作用是：返回指定事件的监听器数量。
如下基本代码：

EventEmitter.listenerCount = function(emitter, type) {
  if (typeof emitter.listenerCount === 'function') {
    return emitter.listenerCount(type);
  } else {
    return listenerCount.call(emitter, type);
  }
};

EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
  var events = this._events;

  if (events !== undefined) {
    var evlistener = events[type];

    if (typeof evlistener === 'function') {
      return 1;
    } else if (evlistener !== undefined) {
      return evlistener.length;
    }
  }

  return 0;
}

4. events中的EventEmitter属性

该属性就是events对外提供的一个对象类，使用 EventEmitter 类就是对事件的触发和监听进行封装。

现在我们看下创建 eventEmitter 对象，如下代码吧：

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

打印信息如下：

可以看到该实列有 _events属性及_maxListeners属性，及该实列上的原型有很多对应的方法，比如 addListener, emit,listenerCount, listeners, on, once, removeAllListeners, removeListener, setMaxListeners 等方法，及_events 及 _maxListeners 等属性。我们先来看下一些简单实列上的属性的基本源码如下：

// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._eventsCount = 0;
EventEmitter.prototype._maxListeners = undefined;

一：EventEmitter基本的API使用：

1. addListener(event, listener) 为指定的事件注册一个监听器。该方法是on的别名。该方法接收一个事件名和一个回调函数。
如下代码演示：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

// 注册 kongzhi 事件
eventEmitter.on('kongzhi', function() {
  console.log('dddd'); // 打印 dddd
});

// 触发kongzhi事件
eventEmitter.emit('kongzhi');

2. listenerCount(eventName)

该方法返回注册了指定事件的监听数量。基本语法如下：

EventEmitter.listenerCount(eventName);

eventName： 指监听的事件名

如下基本代码：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

// 注册 kongzhi 事件
eventEmitter.on('kongzhi', function() {
  console.log('dddd1111');
});

// 注册 kongzhi 事件
eventEmitter.on('kongzhi', function() {
  console.log('dddd22222');
});

// 触发kongzhi事件
eventEmitter.emit('kongzhi');

const num = eventEmitter.listenerCount('kongzhi');
console.log(num); // 返回2 说明注册了两个 kongzhi 这个事件

比如源码中如下代码所示：

EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
  var events = this._events;

  if (events !== undefined) {
    var evlistener = events[type];

    if (typeof evlistener === 'function') {
      return 1;
    } else if (evlistener !== undefined) {
      return evlistener.length;
    }
  }
  return 0;
}

如上代码，先判断 this._events 是否保存了事件，如果保存了事件的话，如果它是个函数的话，那么 return 1; 否则的话，如果不等于undefined，直接返回该监听事件名的长度。其他的情况下 返回 0；

因此上面我们通过如下代码，就可以获取到该监听的事件的长度了：如下代码：

const num = eventEmitter.listenerCount('kongzhi');
console.log(num); // 返回2 说明注册了两个 kongzhi 这个事件

3. listeners(event)

该方法返回指定事件的监听器数组。

如下代码演示：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

// 注册 kongzhi 事件
eventEmitter.on('kongzhi', function() {
  console.log('dddd1111');
});

// 注册 kongzhi 事件
eventEmitter.on('kongzhi', function() {
  console.log('dddd22222');
});

// 触发kongzhi事件
eventEmitter.emit('kongzhi');

const num = eventEmitter.listeners('kongzhi');
console.log(num); // 返回监听事件的数组

num.forEach((func) => {
  func(); // 我们可以这样指定任何一个事件调用，然后会分别打印 dddd1111, dddd2222
});

4. once(event, listener)
该函数的含义是：为指定事件注册一个单次监听器，也就是说监听器最多只会触发一次，触发后立刻解除该监听器。
如下代码：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

// 使用on注册监听器
eventEmitter.on('kongzhi', function() {
  console.log('我on事件触发了多少次呢？');
});

// 注册 kongzhi 事件
eventEmitter.once('kongzhi', function() {
  console.log('我once事件触发了多少次呢？');
});

// 触发kongzhi事件
eventEmitter.emit('kongzhi');
eventEmitter.emit('kongzhi');

如上代码所示：使用on 事件注册的话，如果使用emit触发的话，触发了多少次，就执行多少次，使用once注册事件的话，emit触发多次的话，最后也只能调用一次，如下执行结果如下：

5. removeListener(eventName, listener)

该方法的作用是：移除指定事件的某个监听器。监听器必须是该事件已经注册过的监听器。

eventName: 事件名称
listener： 回调函数的名称

如下代码演示：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

const callback = function() {
  console.log(11111);
};
// 使用on注册监听器
eventEmitter.on('kongzhi', callback);

// 触发事件 kongzhi
eventEmitter.emit('kongzhi');

eventEmitter.removeListener('kongzhi', callback);

/*
 我们继续触发事件 kongzhi 是不会触发的，因为上面已经使用
 removeListener 已经删除了 kongzhi 事件了
 */
eventEmitter.emit('kongzhi');

6. removeAllListeners([event])

移除所有事件的所有监听器，如果我们指定事件的话，则是移除指定事件的所有监听器。

参数event: 该参数的含义是事件名称，如果指定了该事件名称的话，则会删除该指定的事件名称对应的所有函数，如果没有指定任何事件名的话，则是删除所有的事件。如下代码所示：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

const callback = function() {
  console.log(11111);
};
// 使用on注册监听器
eventEmitter.on('kongzhi', callback);

// 注册kongzhi2事件
eventEmitter.on('kongzhi2', callback);

// 触发事件 kongzhi 是可以触发的
eventEmitter.emit('kongzhi');

// 删除所有的监听器

eventEmitter.removeAllListeners();

/*
 我们继续触发事件 kongzhi 和 kongzhi2 是不会触发的，因为上面已经使用
 removeAllListeners 已经删除了 所有的 事件了
 */
eventEmitter.emit('kongzhi');

eventEmitter.emit('kongzhi2');

7. setMaxListeners(n)

该方法的作用是 设置监听器的默认数量。因为EventEmitters默认的监听器为10个，如果超过10个就会输出警告信息，因此使用该方法，可以设置监听器的默认数量, 使之最大的数量不会报错。

如下代码所示：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

const callback = function() {
  console.log(11111);
};

// 设置默认监听数量最多为1个，如果超过该数量，控制台会发出警告
eventEmitter.setMaxListeners(1);

// 使用on注册监听器
eventEmitter.on('kongzhi', callback);

// 注册kongzhi事件
eventEmitter.on('kongzhi', callback);

// 触发事件 kongzhi
eventEmitter.emit('kongzhi');

执行结果如下所示：

当我们把上面的eventEmitter.setMaxListeners(2); 设置为大于1的时候，就不会报错了，比如最大设置的默认数量为2，监听器最大为2，就不会报错了。

如下图所示：

二：EventEmitter 源码分析

EventEmitter类它实质是一个观察者模式的实现，什么是观察者模式呢？观察者模式定义了对象间的一种一对多的关系，它可以让多个观察者对象同时监听一个主题对象，当一个主题对象发生改变时，所有依赖于它的对象都会得到一个通知。
那么在观察者模式中最典型的实列demo就是 EventEmitter类中on和emit方法，我们可以通过on注册多个事件进行监听，而我们可以通过emit方法来对on事件进行触发。比如如下demo代码：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

eventEmitter.on('kongzhi', function(name) {
  console.log('hello', name); // 输出：hello 我叫空智
});

eventEmitter.emit('kongzhi', '我叫空智');

如上代码，我们通过eventEmitter的emit方法，发出 kongzhi 事件，然后我们通过 eventEmitter 的on方法进行监听，从而执行相对应的函数，从而打印出信息出来。其中on方法属于多个观察者那个对象，它可以有多个on方法进行监听 emit中触发的那个主题对象，当那个emit触发的主体对象发生改变时，所有的on方法监听的对象都会触发。

上面我们知道了 EventEmitter模块的on和emit的用途后，我们首先来实现一个包含 emit和on方法的EventEmitter类。
如下代码：

class EventEmitter {
  constructor() {
    this._events = {}; // 保存所有的事件
  }
  on(eventName, callback) {
    if (!this._events[eventName]) {
      this._events[eventName] = [];
    }
    this._events[eventName].push(callback);
  }
  emit(eventName, ...arg) {
    // 如果on方法监听了多个事件的话，依次执行代码
    if (this._events[eventName]) {
      for (let i = 0; i < this._events[eventName].length; i++) {
        this._events[eventName][i](...arg);
      }
    }
  }
}

// 下面是实例化上面的类函数， 然后会依次执行

const eventEmitter = new EventEmitter();

eventEmitter.on('kongzhi', function(age) {
  console.log('我是空智,我今年' + age + '岁'); // 会打印：我是空智,我今年30岁
});

eventEmitter.on('kongzhi', function(age) {
  console.log('我是空智2,我今年' + age + '岁'); // 会打印：我是空智2,我今年30岁
});

eventEmitter.emit('kongzhi', 30);

如上代码就实现了一个类为 EventEmitter 中的on和emit方法了，on是注册事件，emit是触发该事件，然后执行的对应的回调函数，首先通过on去注册事件，然后我们会通过 this._event对象来保存该事件的回调函数，this._event中对象的key就是on注册的事件名，然后on注册的回调函数就是 this._event中使用数组保存起来，该this._event的值就是一个数组函数，然后在emit方法中，使用for循环进行依次执行该回调函数。就会依次触发对应的函数了。
emit(eventName, ...arg) 方法传入的参数，第一个为事件名，其他参数事件对应执行函数中的实参。该方法的作用是：从事件对象中，寻找对应的key为eventName的属性，执行该属性所对应的数组里面的每一个函数。

上面是一个简单的实现，下面我们再来看看 events.js 源码中是如何实现的呢？

events.js 源码分析：

function EventEmitter() {
  EventEmitter.init.call(this);
}
module.exports = EventEmitter;

EventEmitter.EventEmitter = EventEmitter;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._eventsCount = 0;
EventEmitter.prototype._maxListeners = undefined;

EventEmitter.init = function() {
  /*
   如果this._event为undefined，或 Object.getPrototypeOf 上面也没有 events的话(es5),
   则使用Object.create()创建一个空的对象. 并且设置_eventsCount事件个数为0，也就是初始化。
   并且初始化 _maxListeners，默认为10个，未初始化之前是undefined。
  */
  if (this._events === undefined ||
      this._events === Object.getPrototypeOf(this)._events) {
    this._events = Object.create(null);
    this._eventsCount = 0;
  }

  this._maxListeners = this._maxListeners || undefined;
};

如上代码，构造函数 EventEmitter 会调用 EventEmitter.init方法进行初始化，然后使用 this._events = Object.create(null)；创建一个对象保存到 this._events中，作用是用于存储和统一管理所有类型的事件，在创建构造函数的时候导出了 EventEmitter，后面所有的方法放在该对象中的原型中。_maxListeners的含义我们上面已经讲解过，是保存最大的监听数。默认为10个。

当然我们可以在源码中使用 getMaxListeners/setMaxListeners方法设置最大的监听数，比如如下的源码：

EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
  }
  this._maxListeners = n;
  return this;
};

function $getMaxListeners(that) {
  if (that._maxListeners === undefined)
    return EventEmitter.defaultMaxListeners;
  return that._maxListeners;
}

EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
  return $getMaxListeners(this);
};

在源码中，我们也对 最大的监听数使用了 Object.defineProperty方法进行监听，如下源码所示：

var defaultMaxListeners = 10;

Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
  enumerable: true,
  get: function() {
    return defaultMaxListeners;
  },
  set: function(arg) {
    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
    }
    defaultMaxListeners = arg;
  }
});

2. addEventListener 或 on 添加事件源码如下：

/*
 addListener函数的别名是on，该函数有两个参数，type是事件名称，listener是监听函数。
 之后会调用 _addListener函数进行初始化，从_addListener函数中返回的是this，这样的设计目的是可以进行链式
 调用。
*/
EventEmitter.prototype.addListener = function addListener(type, listener) {
  return _addListener(this, type, listener, false);
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;
/*
 该_addListener函数有四个参数，分别为 target指向了当前this对象。
 type为事件名称，listener为监听事件的函数名。
 prepend参数如果为true的话，是把监听函数插入到数组的头部，默认为false，插入到数组的尾部。
*/
function _addListener(target, type, listener, prepend) {
  var m;
  var events;
  var existing;
  /*
   如果使用on或addEventListener注册事件时，如果listener参数不是一个函数的话，会抛出错误。如下代码。
  */
  if (typeof listener !== 'function') {
    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
  }
  /*
   1. 拿到当前的所有的事件 _events， 即拿到一个事件对象，对象中存放了触发事件组或空对象。
      如果this._events是undefined的话，就使用 Object.create(null) 创建一个
      空对象给events保存起来。然后设置 this._eventsCount = 0;  用于统计事件的个数，也就是_events对象有多少个属性。
   2. 如果有this._event的话，如果使用了on或addEventListener注册了 newListener 事件的话，就直接触发执行它。
  */
  events = target._events;
  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，因为 newListener钩子可能导致this._event去重新注册个新对象。
      */
      events = target._events;
    }
    // 保存上一次触发的事件
    existing = events[type];
  }
  /*
   exiting变量是保存上一次触发的事件对象，比如：如下测试代码：
    // 引入 events 模块
    const events = require('events');
    console.log(events);
    // 创建 eventEmitter 对象
    const eventEmitter = new events.EventEmitter();
    console.log(eventEmitter);

    const callback = function() {
      console.log(11111);
    };
    // 使用on注册监听器
    eventEmitter.on('kongzhi', callback);

    // 注册kongzhi2事件
    eventEmitter.on('kongzhi', callback);

    // 触发事件 kongzhi 是可以触发的
    eventEmitter.emit('kongzhi');

    如上基本代码，当我们第一次监听eventEmitter.on('kongzhi'）的时候，existing并没有保存该事件对象函数，因此第一次
    的时候为undefined，所以会做如下判断 如果为undefined的话，就把 callback函数赋值给 events[type]了。
    然后 target._eventsCount 自增1，也就是说 _eventsCount 保存的事件个数加1.
    2. 如果 typeof existing 是个函数的话，说明之前注册过一次 'kongzhi' 这样的事件，然后继续判断 prepend 是否为
    true还是false，为true的话，说明把该函数插入到数组的最前面，否则的话，插入该数组的后面。如果为true，如下代码：
    events[type] = [listener, existing]，否则为false的话，events[type] = [existing, listener]， 其中existing
    是保存上一次触发的事件对象。然后所有的判断完成后，把最新值重新赋值给 existing 变量。
    3. 如果 existing 已经是个数组的话，并且prepend为true的话，直接插入到数组的最前面， 因此执行代码：
       existing.unshift(listener);
    4. 其他的情况就是 prepend 默认为false的情况下，且 existing 为数组的情况下，直接把 监听函数 listener 插入到existing该数组的后面去，如下代码： existing.push(listener);
  */
  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') {
      // 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);
    }
    /*
     下面是监听函数最大的数量。如果监听的数量 m > 0 && existing.length(监听数量的长度大于监听的数量的话) > m
      && !existing.warned 的话。existing.warned 设置为false，目的是打印一次错误即可，因此函数内部代码直接设置
      为 existing.warned = true；比如如下代码：
      // 引入 events 模块
      const events = require('events');

      console.log(events);

      // 创建 eventEmitter 对象
      const eventEmitter = new events.EventEmitter();

      console.log(eventEmitter);

      const callback = function() {
        console.log(11111);
      };

      // 设置默认监听数量最多为1个，如果超过该数量，控制台会发出警告
      eventEmitter.setMaxListeners(1);

      // 使用on注册监听器
      eventEmitter.on('kongzhi', callback);

      // 注册kongzhi事件
      eventEmitter.on('kongzhi', callback);

      // 触发事件 kongzhi
      eventEmitter.emit('kongzhi');

      设置监听最大个数为1个，但是实际监听的个数为2，因此在控制台中会输出错误，如下报错信息：
      (node) warning: possible EventEmitter memory leak detected. 2 listeners added. Use emitter.setMaxListeners() to increase limit.

      如上错误就是下面的代码的new Error抛出的。最后通过 执行如下函数抛出，如下代码：
      function ProcessEmitWarning(warning) {
        if (console && console.warn) console.warn(warning);
      }
    */
    // Check for listener leak
    m = $getMaxListeners(target);
    if (m > 0 && existing.length > m && !existing.warned) {
      existing.warned = true;
      // No error code for this since it is a Warning
      // eslint-disable-next-line no-restricted-syntax
      var 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;
      ProcessEmitWarning(w);
    }
  }

  return target;
}

3. emit 触发事件的源码如下：

/*
 1. 定义一个args数组，来保存所有的emit后面的参数。比如如下代码：
  // 引入 events 模块
  const events = require('events');

  console.log(events);

  // 创建 eventEmitter 对象
  const eventEmitter = new events.EventEmitter();

  console.log(eventEmitter);

  // 注册 kongzhi 事件
  eventEmitter.on('kongzhi', function(age) {
    console.log('dddd' + age); // 打印 dddd30
  });

  // 触发kongzhi事件
  eventEmitter.emit('kongzhi', 30);

  如上代码，emit上的第二个参数传递了30，因此在on监听该对象的时候，该函数会接收age这个参数值为30，因此会打印
  dddd30.
  如下代码：for (var i = 1; i < arguments.length; i++) args.push(arguments[i]); 就是从第一个参数开始
  ，使用 arguments.length 获取函数中所有的参数，依次循环保存到 args数组里面去。注意这边 i 是从1开始的，那么
  位置0就是type(类型)。除了触发类型之后所有的变量，也就是所有的参数保存到 args数组内部。
  2. 然后判断 type 是否等于 error， 如 var doError = (type === 'error'); 这句代码会返回一个布尔值。
  var events = this._events;保存所有的事件对象，如果 type === ‘error’的话，比如 doError 为true的话，
  如果args数组保存的第一个值是Error的实列的话，就抛出该error。否则的话，就抛出如下错误信息：
  events.js:62 Uncaught Error: Uncaught, unspecified "error" event. (undefined)
  如下代码使用 emit来监听 error事件会打印如上的error代码的。如下：
  // 引入 events 模块
  const events = require('events');

  console.log(events);

  // 创建 eventEmitter 对象
  const eventEmitter = new events.EventEmitter();

  console.log(eventEmitter);

  eventEmitter.emit('error');

  如果触发emit的事件不是error的话，那么获取该事件的对象，如下代码：var handler = events[type];
  如果该事件对象没有函数的话，直接返回，监听对象 on中会报错 listener 必须为一个函数的错误。
  如果该handler是一个函数的话，就会执行这个函数。如：ReflectApply(handler, this, args);代码；
  ReflectApply 封装的源码在events.js中的最上面代码：
  var R = typeof Reflect === 'object' ? Reflect : null
  var ReflectApply = R && typeof R.apply === 'function'
    ? R.apply
    : function ReflectApply(target, receiver, args) {
      return Function.prototype.apply.call(target, receiver, args);
    }
  想要了解 Reflect.apply的方法的话，可以看我这篇文章 (https://www.cnblogs.com/tugenhua0707/p/10291909.html#_labe2). 因此就能直接执行该回调函数。
  2. 如果handler不是一个函数的话，而是一个数组的话，那么就循环该数组，然后依次执行对应的函数。
*/
EventEmitter.prototype.emit = function emit(type) {
  var args = [];
  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
  var doError = (type === 'error');

  var events = this._events;
  if (events !== undefined)
    doError = (doError && events.error === undefined);
  else if (!doError)
    return false;

  // If there is no 'error' event listener then throw.
  if (doError) {
    var er;
    if (args.length > 0)
      er = args[0];
    if (er instanceof Error) {
      // Note: The comments on the `throw` lines are intentional, they show
      // up in Node's output if this results in an unhandled exception.
      throw er; // Unhandled 'error' event
    }
    // At least give some kind of context to the user
    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
    err.context = er;
    throw err; // Unhandled 'error' event
  }

  var handler = events[type];

  if (handler === undefined)
    return false;

  if (typeof handler === 'function') {
    ReflectApply(handler, this, args);
  } else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i)
      ReflectApply(listeners[i], this, args);
  }
  return true;
};

4. 删除指定的事件监听器removeListener源码如下：

// 如下基本代码：removeListener的别名是off。

EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
  var list, events, position, i, originalListener;

  /* 如果removeListener方法中第二个参数不是一个函数的话，抛出错误。必须为一个函数。*/
  if (typeof listener !== 'function') {
    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
  }
  /*
   获取所有的事件对象，保存到 events变量内。如果事件对象是undefined的话，直接返回。
   然后该事件对象 list = events[type]; type 是要被删除的事件名，因此 list 就是保存对应的函数了。
   1. 如果list对象函数等于 listener 要删除的对象函数的话，或者 list.listener === listener 的话；
      或者匹配的是监听事件key: Function
   如下代码：
   // 引入 events 模块
    const events = require('events');
    console.log(events);
    // 创建 eventEmitter 对象
    const eventEmitter = new events.EventEmitter();
    console.log(eventEmitter);
    const callback = function() {
      console.log(11111);
    };
    // 使用on注册监听器
    eventEmitter.on('kongzhi', callback);
    // 触发事件 kongzhi
    eventEmitter.emit('kongzhi');
    eventEmitter.removeListener('kongzhi', callback);
    /*
     我们继续触发事件 kongzhi 是不会触发的，因为上面已经使用
     removeListener 已经删除了 kongzhi 事件了
     */
    eventEmitter.emit('kongzhi');
  */
  events = this._events;
  if (events === undefined)
    return this;

  list = events[type];
  if (list === undefined)
    return this;

  if (list === listener || list.listener === listener) {
    /*
     如果删除的事件相等的话，--this._eventsCount 自减1. 同时判断 this._eventsCount 如果等于0的话，
     则移除所有监听，这里重置监听对象数组。即 this._events = Object.create(null);
    */
    if (--this._eventsCount === 0)
      this._events = Object.create(null);
    else {
      /*
       正常执行删除：delete events[type].
       在页面上我们可以来监听 removeListener 事件，比如使用 removeListener 删除事件，我们可以使用on
       来监听 removeListener 事件，比如如下代码：
       // 引入 events 模块
        const events = require('events');
        console.log(events);
        // 创建 eventEmitter 对象
        const eventEmitter = new events.EventEmitter();
        console.log(eventEmitter);
        const callback = function() {
          console.log(11111);
        };
        // 使用on注册监听器
        eventEmitter.on('kongzhi', callback);
        // 触发事件 kongzhi
        eventEmitter.emit('kongzhi');
        eventEmitter.on('removeListener', function(type, listener) {
          console.log('这里是来监听删除事件的'); // 会打印出来
          console.log(type);  // kongzhi
          console.log(listener); // callback对应的函数
        });
        eventEmitter.removeListener('kongzhi', callback);
        /*
         我们继续触发事件 kongzhi 是不会触发的，因为上面已经使用
         removeListener 已经删除了 kongzhi 事件了
         */
         eventEmitter.emit('kongzhi');
      */
      delete events[type];
      if (events.removeListener)
        this.emit('removeListener', type, list.listener || listener);
    }
  } else if (typeof list !== 'function') {
    /*
     这里是其他情况，如果list监听的不是一个函数的话，而是一个数组的话，比如on监听的多个相同的事件名的时候，则遍历该数组，同样判断，如果该数组的任何一项等于被删除掉的 listener函数的话，
     或者数组中的任何一项的key===listener 等于被删除掉的listener函数的话，使用 originalListener = list[i].listener; 保存起来，同样使用 position = i; 保存该对应的位置。跳出for循环。
     2. if (position < 0) 如果该 position 小于0的话，直接返回。说明没有要删除的事件。
     3. 如果position === 0的话，则删除数组中的第一个元素，使用 list.shift()，移除数组中的第一个元素。
     4. 否则的话调用 spliceOne 方法，删除数组list中的对应位置的元素，该spliceOne方法代码如下：
       function spliceOne(list, index) {
         for (; index + 1 < list.length; index++)
           list[index] = list[index + 1];
         list.pop();
       }
    */
    position = -1;

    for (i = list.length - 1; i >= 0; i--) {
      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 {
      spliceOne(list, position);
    }
    // 如果list.length === 1 的话，events[type] = list[0].
    if (list.length === 1)
      events[type] = list[0];

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

  return this;
};

EventEmitter.prototype.off = EventEmitter.prototype.removeListener;

5. 删除所有的监听器 removeAllListeners 源码如下：

/*
 removeAllListeners该函数接收一个参数type，事件名称。
*/
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
  var listeners, events, i;

  events = this._events;
  // 如果 保存的事件对象 events 为undefined的话，直接返回
  if (events === undefined)
    return this;

  // not listening for removeListener, no need to emit
  /*
   1. 如果 this._events保存的事件对象的removeListener为undefined的话。说明没有使用 removeListener来进行
   删除事件。
   2. 如果  arguments.length === 0 则是删除所有的事件。因为如果removeAllListeners没有指定事件名称的话，
   则是删除所有的事件的。因此直接设置 this._events = Object.create(null); 为空对象，并且 this._eventsCount = 0; 监听的事件数量为0.
   3. 如果 events[type] !== undefined 不等于undefined，说明type有的话，则是删除该事件名的所有事件。
   --this._eventsCount 自减1. 并且如果 this._eventsCount === 0 等于0 的话，则：
   this._events = Object.create(null); 设置空对象。
   4. 如果 this._eventsCount 不等于0 的话，则删除该指定的事件的所有事件名称。最后返回该this对象。
  */
  if (events.removeListener === undefined) {
    if (arguments.length === 0) {
      this._events = Object.create(null);
      this._eventsCount = 0;
    } else if (events[type] !== undefined) {
      if (--this._eventsCount === 0)
        this._events = Object.create(null);
      else
        delete events[type];
    }
    return this;
  }

  // emit removeListener for all listeners on all events
  /*
   1. 如果 arguments.length === 0 等于0的话，则是删除所有的事件。先使用 var keys = Object.keys(events);
   获取所有的keys。然后使用for循环依次遍历，得到某一个事件key。然后依次使用 this.removeAllListeners(key);
   方法递归调用删除对应的key。
   2. 最后执行 this._events = Object.create(null); 设置为空对象。置空。
   3. this._eventsCount = 0; 事件的个数设置为0. 最后返回该this对象。
  */
  if (arguments.length === 0) {
    var keys = Object.keys(events);
    var key;
    for (i = 0; i < keys.length; ++i) {
      key = keys[i];
      if (key === 'removeListener') continue;
      this.removeAllListeners(key);
    }
    this.removeAllListeners('removeListener');
    this._events = Object.create(null);
    this._eventsCount = 0;
    return this;
  }
  /*
   1. 如果该 events[type] 是一个函数的话，则调用 this.removeListener(type, listeners); 删除该事件对应
   的函数。
   2. 其他的情况就是 listeners 不等于 undefined的话。说明是一个数组的话，那么依次循环该数组，然后依次使用
   removeListener方法删除该事件对应的函数。最后返回this对象。使可以链式调用。
  */
  listeners = events[type];

  if (typeof listeners === 'function') {
    this.removeListener(type, listeners);
  } else if (listeners !== undefined) {
    // LIFO order
    for (i = listeners.length - 1; i >= 0; i--) {
      this.removeListener(type, listeners[i]);
    }
  }
  return this;
};

6. 返回指定事件的监听器数组--listeners源码如下：

function _listeners(target, type, unwrap) {
  var events = target._events;

  if (events === undefined)
    return [];

  var evlistener = events[type];
  if (evlistener === undefined)
    return [];
  /*
   1. 如果events[type]是一个函数的话，就返回 [evlistener.listener || evlistener], 则返回该数组函数。
   2. 否则的话，则返回 该数组函数。
  */
  if (typeof evlistener === 'function')
    return unwrap ? [evlistener.listener || evlistener] : [evlistener];

  return unwrap ?
    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
function unwrapListeners(arr) {
  var ret = new Array(arr.length);
  for (var i = 0; i < ret.length; ++i) {
    ret[i] = arr[i].listener || arr[i];
  }
  return ret;
}
function arrayClone(arr, n) {
  var copy = new Array(n);
  for (var i = 0; i < n; ++i)
    copy[i] = arr[i];
  return copy;
}
EventEmitter.prototype.listeners = function listeners(type) {
  return _listeners(this, type, true);
};

如下代码演示：

// 引入 events 模块
const events = require('events');

console.log(events);

// 创建 eventEmitter 对象
const eventEmitter = new events.EventEmitter();

console.log(eventEmitter);

// 注册 kongzhi 事件
eventEmitter.on('kongzhi', function() {
  console.log('dddd1111');
});

// 注册 kongzhi 事件
eventEmitter.on('kongzhi', function() {
  console.log('dddd22222');
});

// 触发kongzhi事件
eventEmitter.emit('kongzhi');

const num = eventEmitter.listeners('kongzhi');
console.log(num); // 返回监听事件的数组

num.forEach((func) => {
  func(); // 我们可以这样指定任何一个事件调用，然后会分别打印 dddd1111, dddd2222
});

7. listenerCount返回注册了指定事件的监听数量，源码如下：

EventEmitter.listenerCount = function(emitter, type) {
  if (typeof emitter.listenerCount === 'function') {
    return emitter.listenerCount(type);
  } else {
    return listenerCount.call(emitter, type);
  }
};

EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
  var events = this._events;

  if (events !== undefined) {
    var evlistener = events[type];

    if (typeof evlistener === 'function') {
      return 1;
    } else if (evlistener !== undefined) {
      return evlistener.length;
    }
  }

  return 0;
}

还有其他几个简单的方法 once, eventNames 可以自己看下源码了。