首页 > 编程语言 >Nodejs学习 2 -- events事件处理EventEmitter

Nodejs学习 2 -- events事件处理EventEmitter

时间：2022-12-14 15:40:50浏览次数：80  
标签：事件处理 bar Nodejs -- EventEmitter events ee foo 监听


EventEmitter类

  • 模块: events
  • 源码: events.js

EventEmitter类, 是node中事件的基础， 实现了事件模型需要的接口， 包括addListener，removeListener, emit及其ta工具方法. 同原生javascript事件类似， 采用了发布/订阅(观察者)的方式， 使用内部_events列表来记录注册的事件处理器.

描述
Stream、Socket套接字、HTTP请求及其ta需要事件的核心类, 都实现了事件接口(通过继承EventEmitter)

建立自己的事件类

实例默认值

[ new EventEmitter() ]

我们都知道new 构造器() , 会返回一个”object”

另外，EventEmitter.prototype生成的函数包括:

on = addListener ( type, callback )       // 注册函数，类似原生addListener的机制
once ( type, callback )                   // 通过fired（bool类型），注册函数只运行一次
removeListener ( type, callback )                    // 取消注册，类似原生removeListener
removeAllListeners ( type )                             // 遍历_events，循环调用removeListener
emit ( type )                                                     // 遍历_events,  循环调用_events注册的函数
setMaxListeners ( n )                                       // 设置每个_events属性最大注册函数上限
listeners ( type )                                              // 提取_events中注册的函数        
 EventEmitter.listenerCount ( emitter, type )  // 获取注册的函数最大数量

events是node.js 最重要的模块，events模块只提供了一个对象events.EventEmitter，EventEmitter 的核心是事件监听器on与事件发射emit。

简介及资料

　　​​http://nodejs.org/api/events.html​​

Node.js中大部分的模块，都继承自Event模块。与DOM树上事件不同，不存在事件冒泡、逐层捕获等行为。

EventEmitter 支持若干个事件监听器。当事件发射时，注册到这个事件的事件监听器被依次调用，事件参数作为回调函数参数传递。 　　

1. 如何访问

一般步骤：

  • EventEmitter.on(event, listener)
  • emitter.emit(event, [arg1], [arg2], […])
/*
    1. 调用events模块，获取events.EventEmitter对象
*/
/*
    2. EventEmitter.on(event, listener) 为事件注册一个监听
    参数1：event  字符串，事件名
    参数2：回调函数
*/
/*
    3. EventEmitter.emit(event, [arg1], [arg2], [...])   触发指定事件
    参数1：event  字符串，事件名
    参数2：可选参数，按顺序传入回调函数的参数
    返回值：该事件是否有监听
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

ee.on('some_events', function(foo, bar) {
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
});
console.log('第一轮');
ee.emit('some_events', 'Wilson', 'Zhong');
console.log('第二轮');
ee.emit('some_events', 'Wilson', 'Z');
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
ee.on('some_events', function(foo, bar) {         
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
});

var isSuccess = ee.emit('some_events', 'Wilson', 'Zhong');//有返回值
ee.on('some_events', function(foo, bar) {         
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
});
ee.emit('some_events', 'zhong', 'wei');//不带返回值
var isSuccess2 = ee.emit('other_events', 'Wilson', 'Zhong');
console.log(isSuccess);
console.log(isSuccess2);

示例进行了三次触发事件操作，其中​​some_events​​​注册了监听，调用时​​emit​​​函数会返回一个true,而​​other_events​​并没有注册监听，emit函数会返回一个false，表示该事件没有监听；当然也可以不用管这个返回值！

  • emitter.once(event, listener)
/*
    EventEmitter.once(event, listener)  为事件注册一次性监听，触发一次后移除监听
    参数1：event  字符串，事件名
    参数2：回调函数
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

ee.once('some_events', function(foo, bar) {
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
});
console.log('第一轮');
ee.emit('some_events', 'Wilson', 'Zhong');
console.log('第二轮');
var isSuccess =  ee.emit('some_events', 'Wilson', 'Zhong');
console.log(isSuccess);

从上面示例代码执行结果可以看出，用emitter.once给​​some_events​​注册一个监听后，分两轮调用emitter.emit触发，第二轮会返回false；这表示用emitter.once注册监听和用前面讲的emitter.on注册监听略有不同，

emitter.once注册监听是一次性监听，当触发一次后，会移除该监听！当然，从名字上就看就比较明显了^_^!

  • emitter.removeListener(event, listener)
    先来看一个失败的场景~~~注意这里的listener是回调函数名字。
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
ee.on('some_events', function(foo, bar) {
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
});
/*
    看到API中removeListener移除方法时，以为应该是这样
    但是结果^_^!!!!!
*/
ee.removeListener('some_events', function(){
    console.log('成功移除事件some_events监听!');        
});
console.log('第一轮');
ee.emit('some_events', 'Wilson', 'Zhong');

当我用emitter.on给some_events注册了一个监听后，我用​​emitter.removeListener​​移除some_events的监听，随后再调用emitter.emit去触发，最后发现不是按我想像的在进行！为什么呢？

我理所当然的认为emiiter.removeListener第二个参数是个回调函数，API还是要认真看清楚啊！！！

下面再看个成功的场景～～～

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
var listener = function(foo,bar)
{
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener2= function(foo,bar)
{
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener3= function(foo,bar)
{
    console.log("第3个监听事件,参数foo=" + foo + ",bar="+bar );
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('some_events', listener3);
/*
    EventEmitter.removeListener(event, listener)  移除指定事件的监听器
    注意：该监听器必须是注册过的
    PS：上一个例子之后以会失败，很大原因就是忽略了监听器，理所当然的认为传个事件名就OK了，所以就悲剧了!
*/
ee.removeListener('some_events', listener);
ee.removeListener('some_events', listener3);
ee.emit('some_events', 'Wilson', 'Zhong');

我用示例中写法，给some_events添加了三个监听，又移除了第一个和第三个监听，最后再用emitter.emit触发some_events，输出结果不难发现，用emitter.removeListener移除的第一个和第三个监听都没有再起作用，

想当然是害人地，原来emitter.removeListener的第二个参数是要移除的监听，而非移除成功后的回调函数……^_^!

  • emitter.removeAllListeners([event])

emitter.removeListener用过了，但一个事件可以有多个监听，需要全部移除时，一个个移除明显不是愉快的做法，不符合偷懒的天性！

让我们来体验一下emitter.removeAllListeners带来的便捷! 

/*
    EventEmitter.removeAllListeners([event])   移除（批定事件）所有监听器
    参数1：可选参数，event  字符串，事件名
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
var listener = function(foo,bar)
{
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener2= function(foo,bar)
{
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('other_events',function(foo,bar)
{
    console.log("其它监听事件,参数foo=" + foo + ",bar="+bar );
});

ee.removeAllListeners('some_events');
ee.emit('some_events', 'Wilson', 'Zhong');
ee.emit('other_events', 'Wilson', 'Zhong');

看看上面的执行结果，你会发现给​​some_events​​​注册了两个监听；给​​other_events​​注册了一个监听；我调用emitter.removeAllListeners传了some_events事件名；

最后使用emitter.on函数触发some_events和other_events两个事件，最后发现​​some_events​​注册的两个监听都不存在，而other_events注册的监听还存在；

这表示当 emitter.removeAllListeners传用事件名作为参数时，为移除传入事件名的所有监听，而不会影响其它事件监听！

emitter.removeAllListeners可以不传用事件名参数；直接执行

/*
    EventEmitter.removeAllListeners([event])   移除（批量事件）所有监听器
    参数1：可选参数，event  字符串，事件名
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
var listener = function(foo,bar)
{
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener2= function(foo,bar)
{
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('other_events',function(foo,bar)
{
    console.log("其它监听事件,参数foo=" + foo + ",bar="+bar );
});

ee.removeAllListeners();
ee.emit('some_events', 'Wilson', 'Zhong');
ee.emit('other_events', 'Wilson', 'Zhong');

示例代码和传入参数时几乎一样，只是在调用emitter.removeAllListeners并没有传入指定事件名；

运行结果会发现some_events和other_events所有监听都不存在了，它会移除所有监听！（比较暴力的方法一般要慎用~~）

  • emitter.listeners(event)
/*
    EventEmitter.listeners(event)   //返回指定事件的监听数组
    参数1：event  字符串，事件名    
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
var listener = function(foo,bar)
{
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener2= function(foo,bar)
{
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('other_events',function(foo,bar)
{
    console.log("其它监听事件,参数foo=" + foo + ",bar="+bar );
});

var listenerEventsArr = ee.listeners('some_events');
console.log(listenerEventsArr.length)
for (var i = listenerEventsArr.length - 1; i >= 0; i--) {
    console.log(listenerEventsArr[i]); 
};

给some_events注册两个监听，调用emitter.listeners函数，传入​​some_events​​事件名，接收函数返回值；

从结果可以看出，返回值接收到​​some_events​​所有注册监听的集合！

  • emitter.setMaxListeners(n)
    一个事件可以添加多个监听是没错，但Nodejs默认最大值是多少呢？
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
/*
     给EventEmitter 添加11个监听
*/
for (var i = 10; i >= 0; i--) {
    ee.on('some_events',function()
    {
        console.log('第'+ (i +1) +'个监听');
    });
};

添加N个监听示例源码
上面示例中我用个循环给some_events添加11个监听，执行代码，发现warning信息出现，并且提示的比较详细了，需要用emitter.setMaxListeners()去提升限值

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
/*
    EventEmitter.setMaxListeners (n)   给EventEmitter设置最大监听
    参数1： n 数字类型，最大监听数

    超过10个监听时，不设置EventEmitter的最大监听数会提示：
    (node) warning: possible EventEmitter memory leak detected. 11 listeners added.
     Use emitter.setMaxListeners() to increase limit.
    设计者认为侦听器太多，可能导致内存泄漏，所以存在这样一个警告
*/
ee.setMaxListeners(15);
/*
     给EventEmitter 添加11个监听
*/
for (var i = 10; i >= 0; i--) {
    ee.on('some_events',function()
    {
        console.log('第'+ (i +1) +'个监听');
    });
};

当我调用emitter.setMaxListeners传入15时，执行代码，warning信息不再出现；

emitter.setMaxListeners的作用是给EventEmitter设置最大监听数，感觉一般是不需要设置这个值，10个还不够用的情况应该是比较少了！

设计者认为侦听器太多会导致内存泄漏，所有就给出了一个警告！

其它…

用的比较少的就不详细说了

  • EventEmitter.defaultMaxListeners

EventEmitter.defaultMaxListeners功能与setMaxListeners类似，
给所有EventEmitter设置最大监听

setMaxListeners优先级大于defaultMaxListeners

  • EventEmitter.listenerCount(emitter, event)

返回指定事件的监听数

特殊的事件Error

引用自Node.js开发指南：EventEmitter 定义了一个特殊的事件 error，它包含了“错误”的语义，我们在遇到 异常的时候通常会发射 error 事件。当 error 被发射时，EventEmitter 规定如果没有响 应的监听器，Node.js 会把它当作异常，退出程序并打印调用栈。我们一般要为会发射 error 事件的对象设置监听器，避免遇到错误后整个程序崩溃。


EventEmitter类

  • 模块: events
  • 源码: events.js

EventEmitter类, 是node中事件的基础， 实现了事件模型需要的接口， 包括addListener，removeListener, emit及其ta工具方法. 同原生javascript事件类似， 采用了发布/订阅(观察者)的方式， 使用内部_events列表来记录注册的事件处理器.

描述
Stream、Socket套接字、HTTP请求及其ta需要事件的核心类, 都实现了事件接口(通过继承EventEmitter)

建立自己的事件类

实例默认值

[ new EventEmitter() ]

我们都知道new 构造器() , 会返回一个”object”

另外，EventEmitter.prototype生成的函数包括:

on = addListener ( type, callback )       // 注册函数，类似原生addListener的机制
once ( type, callback )                   // 通过fired（bool类型），注册函数只运行一次
removeListener ( type, callback )                    // 取消注册，类似原生removeListener
removeAllListeners ( type )                             // 遍历_events，循环调用removeListener
emit ( type )                                                     // 遍历_events,  循环调用_events注册的函数
setMaxListeners ( n )                                       // 设置每个_events属性最大注册函数上限
listeners ( type )                                              // 提取_events中注册的函数        
 EventEmitter.listenerCount ( emitter, type )  // 获取注册的函数最大数量

events是node.js 最重要的模块，events模块只提供了一个对象events.EventEmitter，EventEmitter 的核心是事件监听器on与事件发射emit。

简介及资料

　　​​http://nodejs.org/api/events.html​​

Node.js中大部分的模块，都继承自Event模块。与DOM树上事件不同，不存在事件冒泡、逐层捕获等行为。

EventEmitter 支持若干个事件监听器。当事件发射时，注册到这个事件的事件监听器被依次调用，事件参数作为回调函数参数传递。 　　

1. 如何访问

一般步骤：

  • EventEmitter.on(event, listener)
  • emitter.emit(event, [arg1], [arg2], […])
/*
    1. 调用events模块，获取events.EventEmitter对象
*/
/*
    2. EventEmitter.on(event, listener) 为事件注册一个监听
    参数1：event  字符串，事件名
    参数2：回调函数
*/
/*
    3. EventEmitter.emit(event, [arg1], [arg2], [...])   触发指定事件
    参数1：event  字符串，事件名
    参数2：可选参数，按顺序传入回调函数的参数
    返回值：该事件是否有监听
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

ee.on('some_events', function(foo, bar) {
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
});
console.log('第一轮');
ee.emit('some_events', 'Wilson', 'Zhong');
console.log('第二轮');
ee.emit('some_events', 'Wilson', 'Z');
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
ee.on('some_events', function(foo, bar) {         
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
});

var isSuccess = ee.emit('some_events', 'Wilson', 'Zhong');//有返回值
ee.on('some_events', function(foo, bar) {         
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
});
ee.emit('some_events', 'zhong', 'wei');//不带返回值
var isSuccess2 = ee.emit('other_events', 'Wilson', 'Zhong');
console.log(isSuccess);
console.log(isSuccess2);

示例进行了三次触发事件操作，其中​​some_events​​​注册了监听，调用时​​emit​​​函数会返回一个true,而​​other_events​​并没有注册监听，emit函数会返回一个false，表示该事件没有监听；当然也可以不用管这个返回值！

  • emitter.once(event, listener)
/*
    EventEmitter.once(event, listener)  为事件注册一次性监听，触发一次后移除监听
    参数1：event  字符串，事件名
    参数2：回调函数
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();

ee.once('some_events', function(foo, bar) {
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
});
console.log('第一轮');
ee.emit('some_events', 'Wilson', 'Zhong');
console.log('第二轮');
var isSuccess =  ee.emit('some_events', 'Wilson', 'Zhong');
console.log(isSuccess);

从上面示例代码执行结果可以看出，用emitter.once给​​some_events​​注册一个监听后，分两轮调用emitter.emit触发，第二轮会返回false；这表示用emitter.once注册监听和用前面讲的emitter.on注册监听略有不同，

emitter.once注册监听是一次性监听，当触发一次后，会移除该监听！当然，从名字上就看就比较明显了^_^!

  • emitter.removeListener(event, listener)
    先来看一个失败的场景~~~注意这里的listener是回调函数名字。
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
ee.on('some_events', function(foo, bar) {
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
});
/*
    看到API中removeListener移除方法时，以为应该是这样
    但是结果^_^!!!!!
*/
ee.removeListener('some_events', function(){
    console.log('成功移除事件some_events监听!');        
});
console.log('第一轮');
ee.emit('some_events', 'Wilson', 'Zhong');

当我用emitter.on给some_events注册了一个监听后，我用​​emitter.removeListener​​移除some_events的监听，随后再调用emitter.emit去触发，最后发现不是按我想像的在进行！为什么呢？

我理所当然的认为emiiter.removeListener第二个参数是个回调函数，API还是要认真看清楚啊！！！

下面再看个成功的场景～～～

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
var listener = function(foo,bar)
{
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener2= function(foo,bar)
{
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener3= function(foo,bar)
{
    console.log("第3个监听事件,参数foo=" + foo + ",bar="+bar );
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('some_events', listener3);
/*
    EventEmitter.removeListener(event, listener)  移除指定事件的监听器
    注意：该监听器必须是注册过的
    PS：上一个例子之后以会失败，很大原因就是忽略了监听器，理所当然的认为传个事件名就OK了，所以就悲剧了!
*/
ee.removeListener('some_events', listener);
ee.removeListener('some_events', listener3);
ee.emit('some_events', 'Wilson', 'Zhong');

我用示例中写法，给some_events添加了三个监听，又移除了第一个和第三个监听，最后再用emitter.emit触发some_events，输出结果不难发现，用emitter.removeListener移除的第一个和第三个监听都没有再起作用，

想当然是害人地，原来emitter.removeListener的第二个参数是要移除的监听，而非移除成功后的回调函数……^_^!

  • emitter.removeAllListeners([event])

emitter.removeListener用过了，但一个事件可以有多个监听，需要全部移除时，一个个移除明显不是愉快的做法，不符合偷懒的天性！

让我们来体验一下emitter.removeAllListeners带来的便捷! 

/*
    EventEmitter.removeAllListeners([event])   移除（批定事件）所有监听器
    参数1：可选参数，event  字符串，事件名
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
var listener = function(foo,bar)
{
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener2= function(foo,bar)
{
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('other_events',function(foo,bar)
{
    console.log("其它监听事件,参数foo=" + foo + ",bar="+bar );
});

ee.removeAllListeners('some_events');
ee.emit('some_events', 'Wilson', 'Zhong');
ee.emit('other_events', 'Wilson', 'Zhong');

看看上面的执行结果，你会发现给​​some_events​​​注册了两个监听；给​​other_events​​注册了一个监听；我调用emitter.removeAllListeners传了some_events事件名；

最后使用emitter.on函数触发some_events和other_events两个事件，最后发现​​some_events​​注册的两个监听都不存在，而other_events注册的监听还存在；

这表示当 emitter.removeAllListeners传用事件名作为参数时，为移除传入事件名的所有监听，而不会影响其它事件监听！

emitter.removeAllListeners可以不传用事件名参数；直接执行

/*
    EventEmitter.removeAllListeners([event])   移除（批量事件）所有监听器
    参数1：可选参数，event  字符串，事件名
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
var listener = function(foo,bar)
{
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener2= function(foo,bar)
{
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('other_events',function(foo,bar)
{
    console.log("其它监听事件,参数foo=" + foo + ",bar="+bar );
});

ee.removeAllListeners();
ee.emit('some_events', 'Wilson', 'Zhong');
ee.emit('other_events', 'Wilson', 'Zhong');

示例代码和传入参数时几乎一样，只是在调用emitter.removeAllListeners并没有传入指定事件名；

运行结果会发现some_events和other_events所有监听都不存在了，它会移除所有监听！（比较暴力的方法一般要慎用~~）

  • emitter.listeners(event)
/*
    EventEmitter.listeners(event)   //返回指定事件的监听数组
    参数1：event  字符串，事件名    
*/
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
var listener = function(foo,bar)
{
    console.log("第1个监听事件,参数foo=" + foo + ",bar="+bar );
}
var listener2= function(foo,bar)
{
    console.log("第2个监听事件,参数foo=" + foo + ",bar="+bar );
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('other_events',function(foo,bar)
{
    console.log("其它监听事件,参数foo=" + foo + ",bar="+bar );
});

var listenerEventsArr = ee.listeners('some_events');
console.log(listenerEventsArr.length)
for (var i = listenerEventsArr.length - 1; i >= 0; i--) {
    console.log(listenerEventsArr[i]); 
};

给some_events注册两个监听，调用emitter.listeners函数，传入​​some_events​​事件名，接收函数返回值；

从结果可以看出，返回值接收到​​some_events​​所有注册监听的集合！

  • emitter.setMaxListeners(n)
    一个事件可以添加多个监听是没错，但Nodejs默认最大值是多少呢？
var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
/*
     给EventEmitter 添加11个监听
*/
for (var i = 10; i >= 0; i--) {
    ee.on('some_events',function()
    {
        console.log('第'+ (i +1) +'个监听');
    });
};

添加N个监听示例源码
上面示例中我用个循环给some_events添加11个监听，执行代码，发现warning信息出现，并且提示的比较详细了，需要用emitter.setMaxListeners()去提升限值

var EventEmitter = require('events').EventEmitter;   
var ee = new EventEmitter();
/*
    EventEmitter.setMaxListeners (n)   给EventEmitter设置最大监听
    参数1： n 数字类型，最大监听数

    超过10个监听时，不设置EventEmitter的最大监听数会提示：
    (node) warning: possible EventEmitter memory leak detected. 11 listeners added.
     Use emitter.setMaxListeners() to increase limit.
    设计者认为侦听器太多，可能导致内存泄漏，所以存在这样一个警告
*/
ee.setMaxListeners(15);
/*
     给EventEmitter 添加11个监听
*/
for (var i = 10; i >= 0; i--) {
    ee.on('some_events',function()
    {
        console.log('第'+ (i +1) +'个监听');
    });
};

当我调用emitter.setMaxListeners传入15时，执行代码，warning信息不再出现；

emitter.setMaxListeners的作用是给EventEmitter设置最大监听数，感觉一般是不需要设置这个值，10个还不够用的情况应该是比较少了！

设计者认为侦听器太多会导致内存泄漏，所有就给出了一个警告！

其它…

用的比较少的就不详细说了

  • EventEmitter.defaultMaxListeners

EventEmitter.defaultMaxListeners功能与setMaxListeners类似，
给所有EventEmitter设置最大监听

setMaxListeners优先级大于defaultMaxListeners

  • EventEmitter.listenerCount(emitter, event)

返回指定事件的监听数

特殊的事件Error

引用自Node.js开发指南：EventEmitter 定义了一个特殊的事件 error，它包含了“错误”的语义，我们在遇到 异常的时候通常会发射 error 事件。当 error 被发射时，EventEmitter 规定如果没有响 应的监听器，Node.js 会把它当作异常，退出程序并打印调用栈。我们一般要为会发射 error 事件的对象设置监听器，避免遇到错误后整个程序崩溃。

标签：事件处理,bar,Nodejs,--,EventEmitter,events,ee,foo,监听
From： https://blog.51cto.com/u_15912341/5937174

相关文章

  • 第九章 JSP标签
    Shiro提供了JSTL标签用于在JSP/GSP页面进行权限控制，如根据登录用户显示相应的页面按钮。  导入标签库<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags"......
  • Java线程篇(九)：Condition-线程通信更高效的方式
      接近一周没更新《Java线程》专栏了，主要是这周工作上比较忙，生活上也比较忙，呵呵，进入正题，上一篇讲述了并发包下的Lock，Lock可以更好的解决线程同步问题，使之更面向对象，并......
  • Java线程篇(五)：Timer和TimerTask
      Timer和TimerTask可以做为实现线程的第三种方式，前两中方式分别是继承自Thread类和实现Runnable接口。    Timer是一种线程设施，用于安排以后在后台线程中执行......
  • 深入理解BootStrap -- 基础排版3
    前言本次主要来了解的是排版，这个大部分在HTML的基本标签中也是存在的，所以相对比较简单，为了保证系列的完整性，也顺带复习下，还是记录一下。主要内容如下：​​1.标题​​​​......
  • 单例模式的七种写法
    第一种（懒汉，线程不安全）： 1 public class Singleton {   2     private static Singleton instance;   3 private Singleton......
  • SpringMVC中HelloWorld实现（三）
    我机器的开发环境为：开发工具：EclipseForJavaEE；数据库：MySql5.5.35;运行环境：TomCatV7.0；JDK：JDK1.7.0_45；项目工程为：DynamicWebProject； 一、项目依赖的jar包：[ht......
  • JavaScript的数据类型详解
    数据类型JavaScript中有5种简单数据类型（也称为基本数据类型）：Undefined、Null、Boolean、Number和String。还有1种复杂数据类型——Object，Object本质上是由一组无序的名值对......
  • Mybatis学习之实现数据的增删改查（3）
    前面已经讲到用接口的方式编程。这种方式，要注意的一个地方就是。在User.xml 的配置文件中，mappernamespace="com.yihaomen.mybatis.inter.IUserOperation"，命名空间非常重......
  • Java8：Lambdas(一) 学习lambda表达式
    了解Java8中的lambda表达式对开发人员来说没有什么比自己选择的语言或平台发布新版本更令人激动了。Java开发者也不例外。实际上，我们更期待新版本的发布，有一部分原因是因......
  • Java8：Lambdas(二)学习怎样去使用lambda表达式
    JavaSE8的发布很快就到了。伴随着它来的不仅仅是新的语言lambda表达式（同样被称为闭包或匿名方法）——伴随着一些语言特性支持——更重要的是API和library的增强将会使传统......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99