Introduction and information
http://nodejs.org/api/events.html
http://www.infoq.com/cn/articles/tyq-nodejs-event
events is the most important module of node.js. The events module only provides an object event.EventEmitter. The core of EventEmitter is event launch and event listener.
Most modules in Node.js are inherited from the Event module.
Unlike events on the DOM tree, there is no activity such as bubbling, layer-by-layer capture.
EventEmitter supports several event listeners. When an event is launched, the event listener registered to this event is called in sequence, and the event parameters are passed as callback function parameters.
How to access:
The code copy is as follows:
require('events');
emitter.on(event, listener)
The code copy is as follows:
/*
Call events module to get events.EventEmitter object
*/
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
/*
EventEmitter.on(event, listener) Register a listener for the event
Parameter 1: event string, event name
Parameter 2: Callback function
*/
ee.on('some_events', function(foo, bar) {
console.log("1st listening event, parameter foo=" + foo + ",bar="+bar);
});
console.log('First Round');
ee.emit('some_events', 'Wilson', 'Zhong');
console.log('Second Round');
ee.emit('some_events', 'Wilson', 'Z');
EventEmitter.on(event, listener) sample source code
emitter.emit(event, [arg1], [arg2], [...])
The code copy is as follows:
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
ee.on('some_events', function(foo, bar) {
console.log("1st listening event, parameter foo=" + foo + ",bar="+bar);
});
/*
EventEmitter.emit(event, [arg1], [arg2], [...]) Triggers the specified event
Parameter 1: event string, event name
Parameter 2: Optional parameters, pass the parameters of the callback function in order
Return value: Whether this event is listened
*/
var isSuccess = ee.emit('some_events', 'Wilson', 'Zhong');
ee.on('some_events', function(foo, bar) {
console.log("2nd listening event, parameter foo=" + foo + ",bar="+bar);
});
ee.emit('some_events', 'zhong', 'wei');
var isSuccess2 = ee.emit('other_events', 'Wilson', 'Zhong');
console.log(isSuccess);
console.log(isSuccess2);
emitter.emit(event, [arg1], [arg2], [...]) sample source code
The example has performed three triggering events operations, in which some_events registers the listening, and the emit function will return a true when called, while other_events does not register the listening, and the emit function will return a false, indicating that the event is not listened; of course, you can ignore the return value!
emitter.once(event, listener)
The code copy is as follows:
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
/*
EventEmitter.once(event, listener) Register one-time listening for events, remove listening after triggering once
Parameter 1: event string, event name
Parameter 2: Callback function
*/
ee.once('some_events', function(foo, bar) {
console.log("1st listening event, parameter foo=" + foo + ",bar="+bar);
});
console.log('First Round');
ee.emit('some_events', 'Wilson', 'Zhong');
console.log('Second Round');
var isSuccess = ee.emit('some_events', 'Wilson', 'Zhong');
console.log(isSuccess);
emitter.once(event, listener) sample source code
From the above example code execution results, we can see that after registering a listener for some_events with emitter.once, it will trigger in two rounds of call emitter.emit, and the second round will return false; this means that registering the listener with emitter.on is slightly different from registering the listener with emitter.on mentioned earlier.
emitter.once registration listening is a one-time listening. When triggered once, the listening will be removed! Of course, it is more obvious from the name ^_^!
emitter.removeListener(event, listener)
Let's take a look at a failed scene first~~~
The code copy is as follows:
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
ee.on('some_events', function(foo, bar) {
console.log("1st listening event, parameter foo=" + foo + ",bar="+bar);
});
/*
When I saw the removeListener removal method in the API, I thought it should be like this
But the result^_^!!!
*/
ee.removeListener('some_events', function(){
console.log('Successfully removed event some_events listening!');
});
console.log('First Round');
ee.emit('some_events', 'Wilson', 'Zhong');
emitter.removeListener(event, listener) sample failure scenario source code
When I registered a listener for some_events using emitter.on, I used emitter.removeListener to remove some_events' listener, and then called emitter.emit to trigger. Finally, I found that it was not proceeding as I imagined! Why?
I naturally think that the second parameter of emiiter.removeListener is a callback function, so the API should be carefully read! ! !
Let's see another successful scene~~~
The code copy is as follows:
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
var listener = function(foo,bar)
{
console.log("1st listening event, parameter foo=" + foo + ",bar="+bar);
}
var listener2= function(foo,bar)
{
console.log("2nd listening event, parameter foo=" + foo + ",bar="+bar);
}
var listener3= function(foo,bar)
{
console.log("3rd listening event, parameter foo=" + foo + ",bar="+bar);
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('some_events', listener3);
/*
EventEmitter.removeListener(event, listener) Removes the listener for the specified event
Note: The listener must be registered
PS: After the previous example, it will fail. The big reason is that the listener is ignored. It is natural to think that it is OK to pass the event name, so it is a tragedy!
*/
ee.removeListener('some_events', listener);
ee.removeListener('some_events', listener3);
ee.emit('some_events', 'Wilson', 'Zhong');
emitter.removeListener(event, listener) sample successful scenario source code
I used the example writing method, added three listeners to some_events, removed the first and third listeners, and finally triggered some_events with emitter.emit. The output result is not difficult to find that the first and third listeners removed with emitter.removeListener did not work anymore.
Of course, it is harmful to people. It turns out that the second parameter of emitter.removeListener is the listener to be removed, rather than the callback function after successful removal...^_^!
emitter.removeAllListeners([event])
emitter.removeListener has been used, but an event can have multiple listeners. When all need to be removed, it is obviously not a pleasant way to remove them one by one, and it does not conform to the nature of being lazy!
Let's experience the convenience brought by emitter.removeAllListeners!
The code copy is as follows:
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
var listener = function(foo,bar)
{
console.log("1st listening event, parameter foo=" + foo + ",bar="+bar);
}
var listener2= function(foo,bar)
{
console.log("2nd listening event, parameter foo=" + foo + ",bar="+bar);
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('other_events',function(foo,bar)
{
console.log("Other listening events, parameter foo=" + foo + ",bar="+bar);
});
/*
EventEmitter.removeAllListeners([event]) Removes (batch event) all listeners
Parameter 1: Optional parameter, event string, event name
*/
ee.removeAllListeners('some_events');
ee.emit('some_events', 'Wilson', 'Zhong');
ee.emit('other_events', 'Wilson', 'Zhong');
emitter.removeAllListeners Example source code for incoming event name parameter
Looking at the above execution results, you will find that two listeners were registered for some_events; one listener was registered for other_events; I called emitter.removeAllListeners to pass the some_events event name;
Finally, use emitter.on function to trigger two events: some_events and other_events. Finally, it is found that the two listeners registered by some_events do not exist, while the listeners registered by other_events still exist;
This means that when emitter.removeAllListeners passes with event name as a parameter, all listeners that passes in event name will be removed without affecting other event listeners!
emitter.removeAllListeners can be used without passing event name parameters; directly execute
The code copy is as follows:
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
var listener = function(foo,bar)
{
console.log("1st listening event, parameter foo=" + foo + ",bar="+bar);
}
var listener2= function(foo,bar)
{
console.log("2nd listening event, parameter foo=" + foo + ",bar="+bar);
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('other_events',function(foo,bar)
{
console.log("Other listening events, parameter foo=" + foo + ",bar="+bar);
});
/*
EventEmitter.removeAllListeners([event]) Removes (batch event) all listeners
Parameter 1: Optional parameter, event string, event name
*/
ee.removeAllListeners();
ee.emit('some_events', 'Wilson', 'Zhong');
ee.emit('other_events', 'Wilson', 'Zhong');
emitter.removeAllListeners sample source code without passing parameters
The sample code is almost the same as when passing in parameters, except that when calling emitter.removeAllListeners, no specified event name is passed in;
Running the results will find that some_events and other_events listeners no longer exist, and it will remove all listeners! (More violent methods should be used with caution~~)
emitter.listeners(event)
The code copy is as follows:
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
var listener = function(foo,bar)
{
console.log("1st listening event, parameter foo=" + foo + ",bar="+bar);
}
var listener2= function(foo,bar)
{
console.log("2nd listening event, parameter foo=" + foo + ",bar="+bar);
}
ee.on('some_events', listener);
ee.on('some_events', listener2);
ee.on('other_events',function(foo,bar)
{
console.log("Other listening events, parameter foo=" + foo + ",bar="+bar);
});
/*
EventEmitter.listeners(event) //Returns the listening array for the specified event
Parameter 1: event string, event name
*/
var listenerEventsArr = ee.listeners('some_events');
console.log(listenerEventsArr.length)
for (var i = listenerEventsArr.length - 1; i >= 0; i--) {
console.log(listenerEventsArr[i]);
};
emitter.listeners(event) sample source code
Register two listeners for some_events, call emitter.listeners function, pass in some_events event name, and receive the function return value;
From the results, we can see that the return value receives a collection of all registered listening for some_events!
emitter.setMaxListeners(n)
It is true that one event can add multiple listeners, but what is the default maximum value of Nodejs?
The code copy is as follows:
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
/*
Add 11 listeners to EventEmitter
*/
for (var i = 10; i >= 0; i--) {
ee.on('some_events',function()
{
console.log('th'+ (i +1) +'listener');
});
};
Add N listening sample source codes
In the above example, I used a loop to add 11 listening to some_events, executed the code, and found that the warning information appeared, and the prompt was more detailed, so I need to use emitter.setMaxListeners() to increase the limit.
The code copy is as follows:
var EventEmitter = require('events').EventEmitter;
var ee = new EventEmitter();
/*
EventEmitter.setMaxListeners (n) Set maximum listening for EventEmitter
Parameter 1: n Number type, maximum number of listeners
When there are more than 10 listeners, the maximum number of listeners for EventEmitter will be prompted:
(node) warning: possible EventEmitter memory leak detected. 11 listeners added.
Use emitter.setMaxListeners() to increase limit.
The designer believes that too many listeners may lead to memory leaks, so there is such a warning
*/
ee.setMaxListeners(15);
/*
Add 11 listeners to EventEmitter
*/
for (var i = 10; i >= 0; i--) {
ee.on('some_events',function()
{
console.log('th'+ (i +1) +'listener');
});
};
emitter.setMaxListeners sample source code
When I call emitter.setMaxListeners to pass in 15, the code is executed and the warning information no longer appears;
emitter.setMaxListeners' function is to set the maximum number of listeners for EventEmitter. It feels like you don't need to set this value. There should be fewer cases where 10 is not enough!
The designer thought that too many listeners would cause memory leaks, so he gave a warning!
other...
I won't go into details if I use less
EventEmitter.defaultMaxListeners
EventEmitter.defaultMaxListeners function is similar to setMaxListeners.
Set maximum listening for all EventEmitters
setMaxListeners priority is greater than defaultMaxListeners
EventEmitter.listenerCount(emitter, event)
Returns the number of listeners for the specified event
Special Event Error
Quote from Node.js Development Guide: EventEmitter defines a special event error, which contains the semantics of "error". We usually emit an error event when encountering exceptions. When an error is emitted, EventEmitter specifies that if there is no response listener, Node.js will treat it as an exception, exit the program and print the call stack. We generally need to set up listeners for objects that will emit error events to avoid the entire program crashing after encountering errors.
Inheritance of events
Let's talk about it later in Util. If you are interested, you can check it out by yourself http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor