深入理解 Node.js 中 EventEmitter源码分析(3.0.0版本)
2019-02-25 00:28 龙恩0707 阅读(2083) 评论(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 可以自己看下源码了。