Introducción e información
http://nodejs.org/api/events.html
http://www.infoq.com/cn/articles/tyq-nodejs-event
Los eventos son el módulo más importante de Node.js. El módulo de eventos solo proporciona un evento de objeto. El núcleo de EventEmitter es el oyente de eventos de lanzamiento y eventos.
La mayoría de los módulos en Node.js se heredan del módulo de evento.
A diferencia de los eventos en el árbol DOM, no hay actividad, como burbujear, captura de capa por capa.
EventEmitter admite varios oyentes de eventos. Cuando se lanza un evento, el oyente del evento registrado en este evento se llama en secuencia, y los parámetros del evento se pasan como parámetros de la función de devolución de llamada.
Cómo acceder:
La copia del código es la siguiente:
requiere ('eventos');
emitor.on (evento, oyente)
La copia del código es la siguiente:
/*
Llame al módulo de eventos para obtener eventos.
*/
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
/*
EventEmitter.on (evento, oyente) Registre un oyente para el evento
Parámetro 1: cadena de evento, nombre del evento
Parámetro 2: función de devolución de llamada
*/
ee.on ('some_events', function (foo, bar) {
console.log ("primer evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
});
console.log ('primera ronda');
ee.emit ('Some_events', 'Wilson', 'Zhong');
console.log ('segunda ronda');
ee.emit ('some_events', 'wilson', 'z');
EventEmitter.on (Evento, oyente) Código fuente de muestra
emitter.emit (evento, [arg1], [arg2], [...])
La copia del código es la siguiente:
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
ee.on ('some_events', function (foo, bar) {
console.log ("primer evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
});
/*
EventEmitter.emit (evento, [arg1], [arg2], [...]) desencadena el evento especificado
Parámetro 1: cadena de evento, nombre del evento
Parámetro 2: parámetros opcionales, pase los parámetros de la función de devolución de llamada en orden
Valor de retorno: si se escucha este evento
*/
var issuccess = ee.emit ('some_events', 'wilson', 'zhong');
ee.on ('some_events', function (foo, bar) {
console.log ("2do evento de escucha, parámetro 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 (evento, [arg1], [arg2], [...]) Código fuente de muestra
El ejemplo ha realizado tres operaciones de eventos desencadenantes, en las que algunos_events registran la escucha, y la función de emisión devolverá una verdadera cuando se llama, mientras que otros no registran la escucha, y la función de emits devolverá un falso, lo que indica que el evento no se escucha; ¡Por supuesto, puede ignorar el valor de retorno!
emitter.once (evento, oyente)
La copia del código es la siguiente:
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
/*
EventEmitter.once (evento, oyente) Registre una vez escuchando eventos, elimine la escucha después de activar una vez
Parámetro 1: cadena de evento, nombre del evento
Parámetro 2: función de devolución de llamada
*/
ee.once ('some_events', function (foo, bar) {
console.log ("primer evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
});
console.log ('primera ronda');
ee.emit ('Some_events', 'Wilson', 'Zhong');
console.log ('segunda ronda');
var issuccess = ee.emit ('some_events', 'wilson', 'zhong');
console.log (issuccess);
emitter.once (evento, oyente) Código fuente de muestra
De los resultados de ejecución del código de ejemplo anterior, podemos ver que después de registrar un oyente para algunos_events con emitter. Una vez, se activará en dos rondas de llamadas emitter.emit, y la segunda ronda devolverá falso; Esto significa que registrar al oyente con emitter.on es ligeramente diferente de registrar el oyente con emitter.on mencionado anteriormente.
EMITER. La escucha de registro de una vez es una escucha única. Cuando se active una vez, ¡la escucha se eliminará! Por supuesto, es más obvio por el nombre ^_ ^!
emitter.removelistener (evento, oyente)
Echemos un vistazo a una escena fallida primero ~~~
La copia del código es la siguiente:
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
ee.on ('some_events', function (foo, bar) {
console.log ("primer evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
});
/*
Cuando vi el método de eliminación de removelistener en la API, pensé que debería ser así
Pero el resultado^_^!!!
*/
ee.removelistener ('some_events', function () {
console.log ('El evento eliminado con éxito algunos_events escucha!');
});
console.log ('primera ronda');
ee.emit ('Some_events', 'Wilson', 'Zhong');
emitter.removelistener (evento, oyente) Código fuente del escenario de falla de muestra
Cuando registré un oyente para algunos_events usando emitter.on, utilicé emitter.removelistener para eliminar el oyente de algunos_events, y luego llamé emitter.emit para activar. ¡Finalmente, descubrí que no estaba procediendo como imaginaba! ¿Por qué?
Naturalmente, creo que el segundo parámetro de emiiter.removelistener es una función de devolución de llamada, ¡por lo que la API debe leerse cuidadosamente! ! !
Veamos otra escena exitosa ~~~
La copia del código es la siguiente:
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
VAR LOYER = FUNTIL (FOO, BAR)
{
console.log ("primer evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
}
var oyente2 = function (foo, bar)
{
console.log ("2do evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
}
VAR LOYER3 = function (foo, bar)
{
console.log ("3er evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
}
ee.on ('some_events', oyente);
ee.on ('some_events', oyente2);
ee.on ('some_events', oyente3);
/*
EventEmitter.RemoVelistener (evento, oyente) Elimina al oyente para el evento especificado
Nota: el oyente debe estar registrado
PD: Después del ejemplo anterior, fallará. La gran razón es que el oyente es ignorado. Es natural pensar que está bien pasar el nombre del evento, ¡así que es una tragedia!
*/
ee.removelistener ('Some_events', oyente);
ee.removelistener ('Some_events', oyente3);
ee.emit ('Some_events', 'Wilson', 'Zhong');
emitter.removelistener (evento, oyente) Muestra de código fuente de escenario exitoso
Utilicé el método de escritura de ejemplo, agregué tres oyentes a algunos_events, eliminé el primer y tercer oyente, y finalmente activé algunos_events con emitter.emit. El resultado de la salida no es difícil encontrar que el primer y el tercer oyentes eliminaron con emisor. Removelistener ya no funcionó.
Por supuesto, es perjudicial para las personas. Resulta que el segundo parámetro de emitter.
emitter.removealllisteners ([evento])
se ha utilizado emitter.removelistener, pero un evento puede tener múltiples oyentes. Cuando todos necesitan ser eliminados, obviamente no es una forma agradable de eliminarlos uno por uno, ¡y no se ajusta a la naturaleza de ser perezoso!
Experimentemos la conveniencia traída por el emisor.
La copia del código es la siguiente:
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
VAR LOYER = FUNTIL (FOO, BAR)
{
console.log ("primer evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
}
var oyente2 = function (foo, bar)
{
console.log ("2do evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
}
ee.on ('some_events', oyente);
ee.on ('some_events', oyente2);
ee.on ('Other_events', function (foo, bar)
{
console.log ("Otros eventos de escucha, parámetro foo =" + foo + ", bar =" + bar);
});
/*
EventEmitter.removealllisteners ([evento]) elimina (evento por lotes) Todos los oyentes
Parámetro 1: parámetro opcional, cadena de eventos, nombre del evento
*/
ee.removealllisteners ('some_events');
ee.emit ('Some_events', 'Wilson', 'Zhong');
ee.emit ('Other_events', 'Wilson', 'Zhong');
emitter.removealllisteners Ejemplo Código fuente para el parámetro de nombre de evento entrante
Mirando los resultados de ejecución anteriores, encontrará que dos oyentes estaban registrados para algunos_events; Un oyente fue registrado para otros_events; Llamé a emitter.
Finalmente, use la función emitor.on para activar dos eventos: algunos_events y otros_events. Finalmente, se encuentra que los dos oyentes registrados por algunos_events no existen, mientras que los oyentes registrados por otros_events todavía existen;
Esto significa que cuando emitter.
emitter.removealllistener se pueden usar sin pasar los parámetros del nombre del evento; ejecutar directamente
La copia del código es la siguiente:
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
VAR LOYER = FUNTIL (FOO, BAR)
{
console.log ("primer evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
}
var oyente2 = function (foo, bar)
{
console.log ("2do evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
}
ee.on ('some_events', oyente);
ee.on ('some_events', oyente2);
ee.on ('Other_events', function (foo, bar)
{
console.log ("Otros eventos de escucha, parámetro foo =" + foo + ", bar =" + bar);
});
/*
EventEmitter.removealllisteners ([evento]) elimina (evento por lotes) Todos los oyentes
Parámetro 1: parámetro opcional, cadena de eventos, nombre del evento
*/
ee.removealllisteners ();
ee.emit ('Some_events', 'Wilson', 'Zhong');
ee.emit ('Other_events', 'Wilson', 'Zhong');
emitter.removealllisteners Código fuente de muestra sin pasar parámetros
El código de muestra es casi el mismo que cuando se pasa en los parámetros, excepto que al llamar a emitter.removealllisteners, no se pasa el nombre del evento especificado;
Ejecución de los resultados encontrará que algunos oyentes de EVENTS y OTROS ya no existen, ¡y eliminará a todos los oyentes! (Se deben usar métodos más violentos con precaución ~~)
emitor.listeners (evento)
La copia del código es la siguiente:
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
VAR LOYER = FUNTIL (FOO, BAR)
{
console.log ("primer evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
}
var oyente2 = function (foo, bar)
{
console.log ("2do evento de escucha, parámetro foo =" + foo + ", bar =" + bar);
}
ee.on ('some_events', oyente);
ee.on ('some_events', oyente2);
ee.on ('Other_events', function (foo, bar)
{
console.log ("Otros eventos de escucha, parámetro foo =" + foo + ", bar =" + bar);
});
/*
EventEmitter.listeners (evento) // Devuelve la matriz de escucha para el evento especificado
Parámetro 1: cadena de evento, nombre del evento
*/
var oyearerEventSarr = ee.listeners ('some_events');
console.log (ListenSarr.length Length)
para (var i = Learchereventsarr.length-1; i> = 0; i--) {
console.log (Learchereventsarr [i]);
};
emitter.listeners (evento) Código fuente de muestra
Registre a dos oyentes para algunos_events, llame a la función de emisores.
¡De los resultados, podemos ver que el valor de retorno recibe una colección de todos los registros de escucha para algunos_events!
emitor.setMaxListeners (N)
Es cierto que un evento puede agregar múltiples oyentes, pero ¿cuál es el valor máximo predeterminado de NodeJS?
La copia del código es la siguiente:
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
/*
Agregue 11 oyentes a EventEmitter
*/
para (var i = 10; i> = 0; i--) {
ee.on ('some_events', function ()
{
console.log ('th' +(i +1) +'oyente');
});
};
Agregar n Códigos fuente de muestra de escucha
En el ejemplo anterior, utilicé un bucle para agregar 11 escuchando algunos_events, ejecuté el código y descubrí que apareció la información de advertencia, y el aviso era más detallado, por lo que necesito usar emitter.setMaxListeners () para aumentar el límite.
La copia del código es la siguiente:
var eventEmitter = request ('events'). EventEmitter;
var ee = new EventEmitter ();
/*
EventEmitter.SetMaxListeners (N) Establezca la máxima escucha para EventEmitter
Parámetro 1: n tipo de número, número máximo de oyentes
Cuando hay más de 10 oyentes, se solicitará el número máximo de oyentes para EventEmitter:
(nodo) ADVERTENCIA: Posible fuga de memoria de EventEmitter detectada. 11 oyentes agregados.
Use emitter.setMaxListeners () para aumentar el límite.
El diseñador cree que demasiados oyentes pueden conducir a fugas de memoria, por lo que hay tal advertencia.
*/
ee.setMaxListeners (15);
/*
Agregue 11 oyentes a EventEmitter
*/
para (var i = 10; i> = 0; i--) {
ee.on ('some_events', function ()
{
console.log ('th' +(i +1) +'oyente');
});
};
emitter.setMaxListeners Código fuente de muestra
Cuando llamo a emitter.setMaxListeners para pasar en 15, el código se ejecuta y la información de advertencia ya no aparece;
La función de emitter.setMaxListeners es establecer el número máximo de oyentes para EventEmitter. Parece que no necesitas establecer este valor. ¡Debe haber menos casos en los que 10 no sea suficiente!
El diseñador pensó que demasiados oyentes causarían fugas de memoria, ¡así que dio una advertencia!
otro...
No entraré en detalles si uso menos
EventEmitter.defaultMaxListeners
EventEmitter.DefaultMaxListeners La función es similar a SetMaxListeners.
Establezca la escucha máxima para todos los empleados de eventos
setMaxListeners La prioridad es mayor que el defaultMaxListeners
EventEmitter.listenerCount (emisor, evento)
Devuelve el número de oyentes para el evento especificado
Error de evento especial
Cita de la Guía de desarrollo de Node.js: EventEmister define un error de evento especial, que contiene la semántica de "error". Por lo general, emitimos un evento de error al encontrar excepciones. Cuando se emite un error, EventEmitter especifica que si no hay un oyente de respuesta, Node.js lo tratará como una excepción, salga del programa e imprima la pila de llamadas. En general, necesitamos configurar los oyentes para objetos que emitan eventos de error para evitar que todo el programa se bloquee después de encontrar errores.
Herencia de eventos
Hablemos de ello más tarde en Util. Si está interesado, puede verlo por usted mismo http://nodejs.org/api/util.html#util_util_inherits_constructor_superperconstructor