Node. js (2) --- event Module

Introduction and Materials

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 provides only one events. EventEmitter object. 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, events such as event bubbling and layer-by-layer capturing do not exist.

EventEmitter supports several event listeners. When an event is triggered, the event listener registered with the event is called in sequence, and the event parameters are passed as callback function parameters.

How to access:

Copy codeThe Code is as follows:
Require ('events ');

Emitter. on (event, listener)

Copy codeThe Code is as follows:
/*
Call the events module to obtain the events. EventEmitter object.
*/
Var EventEmitter = require ('events'). EventEmitter;
Var ee = new EventEmitter ();
/*
EventEmitter. on (event, listener) registers 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 listener events, parameter foo =" + foo + ", bar =" + bar );
});
Console. log ('first running ');
Ee. emit ('some _ events', 'wilson ', 'zhong ');
Console. log ('second running ');
Ee. emit ('some _ events', 'wilson ', 'z ');
EventEmitter. on (event, listener) sample source code

Emitter. emit (event, [arg1], [arg2], [...])

Copy codeThe Code is as follows:
Var EventEmitter = require ('events'). EventEmitter;
Var ee = new EventEmitter ();
Ee. on ('some _ events', function (foo, bar ){
Console. log ("1st listener events, parameter foo =" + foo + ", bar =" + bar );
});
/*
EventEmitter. emit (event, [arg1], [arg2], [...]) triggers a specified event
Parameter 1: event string, event name
Parameter 2: optional parameter. The callback function parameters are input in sequence.
Returned value: whether the event has a listener
*/
Var isSuccess = ee. emit ('some _ events', 'wilson ', 'zhong ');
Ee. on ('some _ events', function (foo, bar ){
Console. log ("2nd listener events, 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

In this example, three event triggering operations are performed. some_events registers the listener. The emit function returns a true value during the call, while other_events does not register the listener. The emit function returns a false value, it indicates that the event is not listened to. Of course, you can ignore this returned value!

Emitter. once (event, listener)

Copy codeThe Code is as follows:
Var EventEmitter = require ('events'). EventEmitter;
Var ee = new EventEmitter ();
/*
EventEmitter. once (event, listener) registers a one-time listener for the event. After the event is triggered, the listener is removed.
Parameter 1: event string, event name
Parameter 2: callback function
*/
Ee. once ('some _ events', function (foo, bar ){
Console. log ("1st listener events, parameter foo =" + foo + ", bar =" + bar );
});
Console. log ('first running ');
Ee. emit ('some _ events', 'wilson ', 'zhong ');
Console. log ('second running ');
Var isSuccess = ee. emit ('some _ events', 'wilson ', 'zhong ');
Console. log (isSuccess );
Emitter. once (event, listener) sample source code

The execution result of the sample code above shows that emitter is used. once a listener is registered for some_events, emitter is called in two rounds. emit is triggered, and false is returned in the second round. This indicates that emitter is used. register the listener once and use the emitter mentioned above. on registration listening is slightly different,

Emitter. once the registration listener is a one-time listener. When triggered once, the listener will be removed! Of course, the name is obvious!

Emitter. removeListener (event, listener)

First, let's look at a failed scenario ~~~

Copy codeThe Code is as follows:
Var EventEmitter = require ('events'). EventEmitter;
Var ee = new EventEmitter ();
Ee. on ('some _ events', function (foo, bar ){
Console. log ("1st listener events, parameter foo =" + foo + ", bar =" + bar );
});
/*
When I see the removeListener removal method in the API, I thought it should be like this.
But the result is pai_^ !!!!!
*/
Ee. removeListener ('some _ events', function (){
Console. log ('event some_events listener is removed successfully! ');
});
Console. log ('first running ');
Ee. emit ('some _ events', 'wilson ', 'zhong ');
Emitter. removeListener (event, listener) example failure scene source code

When I use emitter. after I register a listener for some_events, I use emiiter. removeListener removes the some_events listener and then calls emitter. emit triggers, and finally finds that it is not in progress as I imagined! Why?

I naturally think that the second parameter of emiiter. removeListener is a callback function. The API should be carefully understood !!!

Next, let's look at a successful scenario ~~~

Copy codeThe Code is as follows:
Var EventEmitter = require ('events'). EventEmitter;
Var ee = new EventEmitter ();
Var listener = function (foo, bar)
{
Console. log ("1st listener events, parameter foo =" + foo + ", bar =" + bar );
}
Var listener2 = function (foo, bar)
{
Console. log ("2nd listener events, parameter foo =" + foo + ", bar =" + bar );
}
Var listener3 = function (foo, bar)
{
Console. log ("3rd listener events, 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 of the specified event
Note: The listener must have been registered.
PS: after the previous example, it will fail. A major reason is that the listener is ignored. It is a matter of course that it is OK to pass an 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) Example success scene source code

In the example, I added three listeners to some_events, removed the first and third listeners, and then used emitter. emit triggers some_events, and output results are not difficult to find. emitter is used. the first and third listeners removed by removeListener no longer work,

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 one event can have multiple listeners. When you need to remove all of them, it is obviously not a pleasant practice to remove them one by one. It is not in line with the nature of laziness!

Let's try out the convenience of emitter. removeAllListeners!

Copy codeThe Code is as follows:
Var EventEmitter = require ('events'). EventEmitter;
Var ee = new EventEmitter ();
Var listener = function (foo, bar)
{
Console. log ("1st listener events, parameter foo =" + foo + ", bar =" + bar );
}
Var listener2 = function (foo, bar)
{
Console. log ("2nd listener events, 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]) Remove (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

Looking at the preceding execution results, you will find that two listeners are registered for some_events, One listener is registered for other_events, and some_events event name is passed by emitter. removeAllListeners;

Finally, the emitter. on function is used to trigger two events: some_events and other_events. Finally, we find that both the listening registered by some_events does not exist, while the listening registered by other_events still exists;

This indicates that when emitter. removeAllListeners uses the event name as the parameter, all the listeners that pass in the event name are removed without affecting other event listening!

Emitter. removeAllListeners can be directly executed without passing event name parameters.

Copy codeThe Code is as follows:
Var EventEmitter = require ('events'). EventEmitter;
Var ee = new EventEmitter ();
Var listener = function (foo, bar)
{
Console. log ("1st listener events, parameter foo =" + foo + ", bar =" + bar );
}
Var listener2 = function (foo, bar)
{
Console. log ("2nd listener events, 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]) Remove (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 example source code without passing Parameters

The sample code is almost the same as the input parameter, but the specified event name is not passed in when emitter. removeAllListeners is called;

The running result will find that all some_events and other_events listeners do not exist, and it will remove all listeners! (Generally, we should use this method with caution ~~)

Emitter. listeners (event)

Copy codeThe Code is as follows:
Var EventEmitter = require ('events'). EventEmitter;
Var ee = new EventEmitter ();
Var listener = function (foo, bar)
{
Console. log ("1st listener events, parameter foo =" + foo + ", bar =" + bar );
}
Var listener2 = function (foo, bar)
{
Console. log ("2nd listener events, 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 of 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 the emitter. listeners function, input the some_events event name, and receive the function return value;

From the results, we can see that the returned values receive a set of all some_events registered listening!

Emitter. setMaxListeners (n)

It is true that multiple listeners can be added to an event, but what is the default maximum value of Nodejs?

Copy codeThe Code 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 ('sub' + (I + 1) + 'listeners ');
});
};
Add N listening sample source code

In the above example, I use a loop to add 11 listeners to some_events, run the code, and find that the warning information appears, and the prompt is more detailed. We need to use emitter. setMaxListeners () to raise the limit.

Copy codeThe Code is as follows:
Var EventEmitter = require ('events'). EventEmitter;
Var ee = new EventEmitter ();
/*
EventEmitter. setMaxListeners (n) sets the maximum listener for EventEmitter.
Parameter 1: n numeric type, maximum number of listeners

If you do not set the maximum number of listeners for more than 10 listeners, the following message is displayed:
(Node) warning: possible EventEmitter memory leak detected. 11 listeners added.
Use emitter. setMaxListeners () to increase limit.
The designer believes that too many listeners may cause memory leakage, 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 ('sub' + (I + 1) + 'listeners ');
});
};
Emitter. setMaxListeners example source code

When I call emitter. setMaxListeners to pass in 15, the code is executed and the warning information is no longer displayed;

Emitter. setMaxListeners is used to set the maximum number of listeners for EventEmitter. It is generally not necessary to set this value. If 10 listeners are not enough, they should be fewer!

The designer thinks that too many listeners will cause memory leakage, so all of them will give a warning!

Other...

I will not describe it in detail for a few

EventEmitter. defaultMaxListeners

The EventEmitter. defaultMaxListeners function is similar to setMaxListeners,
Set the maximum listener for all EventEmitter
SetMaxListeners has a higher priority than defamaxmaxlisteners

EventEmitter. listenerCount (emitter, event)

Returns the number of listeners for a specified event.

Special event Error

Reference from Node. js Development Guide: EventEmitter defines a special event error, which contains the syntax of "error". When an exception occurs, an error event is usually triggered. When an error is triggered, EventEmitter specifies that if no listener is triggered, Node. js will treat it as an exception, exit the program, and print the call stack. We usually need to set a listener for the object that will launch an error event to avoid the entire program crash after an error occurs.

Event inheritance

I will go back to util and talk about it later. If you are interested, you can look at the http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor.