Cómo usar emisores de eventos en Node.js

Los emisores de eventos son objetos en NodeJS que desencadenan eventos al enviar un mensaje para indicar que se ha producido una acción.

Node.js proporciona un módulo de eventos integrado. Contiene una clase de emisor de eventos que le permite crear y manejar eventos personalizados a través de funciones de devolución de llamada.

Aquí aprenderá cómo emitir eventos, escuchar y manejar datos de eventos y manejar errores de eventos en NodeJS.

Eventos de emisión

El módulo de eventos es una parte fundamental de el entorno del lado del servidor Node.js. Por lo tanto, no necesita instalarlo, pero antes de usar el EventEmitter clase, debe importar desde el módulo de eventos e instanciarlo.

Al igual que:

constante EventEmitter = requerir("eventos");
// Instanciando el EventEmitter
constante miEmisor = nuevo EventEmitter();

Puede emitir eventos usando el EventEmitter's emitir método. El emitir método toma un nombre del evento y un número arbitrario de argumentos como parámetros.

Una vez que llame al emitir

método, emite el pasado nombre del evento. Luego llama sincrónicamente a cada uno de los oyentes del evento en el orden en que los registró, pasando los argumentos proporcionados a cada uno. Finalmente, vuelve verdadero si el evento tuviera oyentes y FALSO si no tuviera oyentes.

Por ejemplo:

miEmisor.emit("Evento de prueba", "Foo", "bar", 1, 2);

En el bloque de código anterior, pasó Evento de prueba como el Nombre del evento, y "foo,” "bar,” 1, y 2 como los argumentos. Cuando se ejecuta el bloque de código anterior, notificará a todos los oyentes que escuchan el Evento de prueba evento. Llamará a esos oyentes con los argumentos dados.

Escuchar eventos

Puede escuchar los eventos emitidos usando el EventEmitter's en método. El en método toma un Nombre del evento y una función de devolución de llamada como parámetros. Cuando el evento con el Nombre del evento pasado en el en se emite el método, invoca su función de devolución de llamada. Este método devuelve una referencia a la EventEmitter, lo que le permite encadenar varias llamadas.

Por ejemplo:

// Primer oyente
miEmisor.on("Evento de prueba", () => {
 consola.log("TestEvent emitido!!!");
}); // TestEvent Emitido!!!
// segundo oyente
miEmisor.on("Evento de prueba", (... argumentos) => {
 argumentos = argumentos.join(", ");
consola.registro(`Evento emitido con los siguientes argumentos: ${argumentos}`);
}); // Evento emitido con los siguientes argumentos: foo, bar, 1, 2
miEmisor.emit("Evento de prueba", "Foo", "bar", 1, 2);

En el bloque de código anterior, cuando el Evento de prueba emite un evento, los oyentes del evento invocarán sus funciones de devolución de llamada. Los oyentes reaccionarán en el orden en que los registró, lo que significa que la devolución de llamada del "primer oyente" se ejecutará antes que la segunda, y así sucesivamente.

Puede cambiar este comportamiento usando el EventEmitter's prependListener método. Este método toma los mismos parámetros que el en método. La diferencia es que este método reacciona primero al evento, independientemente de la hora en que lo registres.

Por ejemplo:

miEmisor.on("Evento de prueba", () => {
 consola.log("TestEvent emitido!!!");
});
miEmisor.prependListener("Evento de prueba", () => {
 consola.log("se ejecuta primero")
})
// consola.log (miEmisor.oyentes("Evento de prueba"));
miEmisor.emit("Evento de prueba", "Foo", "bar", 1, 2);

Cuando se ejecuta el bloque de código anterior, "Se ejecuta primero" se registrará primero en la consola, seguido de "TestEvent Emitted!!!" independientemente del orden en que los registró debido a la prependListener método.

Si registra varios oyentes con el prependListener método, se ejecutarán en orden del último al primero.

Tenga en cuenta la disposición del emisor y los oyentes. Los oyentes siempre vienen antes que el emisor. Este arreglo se debe a que los oyentes ya deben estar escuchando el evento antes de que el emisor lo emita.

Para el contexto, considere el bloque de código a continuación:

miEmisor.emit("Evento de prueba", "Foo", "bar", 1, 2);
miEmisor.on("Evento de prueba", () => {
 consola.log("TestEvent emitido!!!");
}); 

Si ejecuta el bloque de código anterior, no sucede nada porque, en el momento en que el emisor emitió el evento, ningún oyente estaba escuchando el evento.

Escuchar eventos una vez

Según sus requisitos, es posible que deba manejar algunos eventos solo una vez en el ciclo de vida de su aplicación. Puedes lograr esto usando el EventEmitter's una vez método.

Este método toma los mismos argumentos que el en método y funciona de manera similar. La única diferencia es que los oyentes registrados en el una vez El método solo escucha el evento una vez.

Por ejemplo:

miEmisor.once("Evento único", () => {
 consola.log("Evento manejado una vez");
});
miEmisor.emit("Evento único"); // Evento manejado una vez
miEmisor.emit("Evento único"); // Ignorado
miEmisor.emit("Evento único"); // Ignorado

Ejecutar el bloque de código solo registrará "Evento manejado una vez" en la consola una vez, independientemente de la frecuencia con la que el emisor emita el evento.

Oyentes registrados en el una vez reacciona al evento en el orden en que los registra. Puede cambiar este comportamiento usando el anteponerOnceListener método, que funciona como prependListener. La única diferencia es que los oyentes registrados en el una vez El método solo escucha el evento una vez.

Manejo de errores con emisores de eventos

debes tener cuidado de manejar los errores de JavaScript apropiadamente y los detectores de eventos no son una excepción. Los errores no controlados de ellos harán que el proceso de Node.js se cierre y su aplicación se bloquee.

Para manejar un evento de error, al menos uno de los oyentes del evento debe tener su Nombre del evento ajustado a error.

Por ejemplo:

miEmisor.on("error", (error) => {
consola.error(`Error: ${error}`);
});

Hacer que un oyente maneje un error potencial, como en el bloque de código anterior, evitará que la aplicación se bloquee cuando ocurra un error.

Por ejemplo:

miEmisor.emit("error", nuevo error ("esto es un error"));

Ejecutar el bloque de código anterior registrará "Esto es un error" en la consola porque un oyente está manejando eventos de error.

Gestión de escuchas de eventos

El EventEmitter La clase tiene varios métodos que le permiten manipular y administrar los detectores de eventos. Puede obtener los oyentes de un evento, eliminarlos y establecer el número máximo de oyentes para un evento.

Aquí hay una tabla que contiene EventEmitter métodos con los que puede manipular los detectores de eventos:

Sólo puede llamar a estos métodos en un EventEmitter instancia.

Por ejemplo:

miEmisor.removeListener("Evento de prueba");

El bloque de código anterior elimina un solo oyente para el Evento de prueba evento.

La importancia de los emisores de eventos

Node.js adopta el paradigma de programación impulsada por eventos con su soporte para emisores y oyentes de eventos. La programación basada en eventos es una de las razones por las que los programas de Node.js son más rápidos y sencillos que algunas alternativas. Puede sincronizar fácilmente varios eventos, lo que mejora la eficiencia.