Consejos Tecnológicos

¿Cuáles son los eventos en el nodo JS?

La mayor parte de Node.js se basa en el patrón de arquitectura asincrónica controlada por eventos. Esto significa que muchas de las API principales en Node funcionan de manera reactiva, donde el emisor (una especie de objeto) emitirá un evento con nombre que activará una función de devolución de llamada adjunta a través del objeto de escucha de ese evento con nombre en particular.

Consideremos el siguiente ejemplo de lectura de datos de un archivo de una manera que ahorra memoria usando Node.js y streams:

const fs = require('fs');
 
const dataStream = fs.createReadStream('data.txt', 'utf-8');
 
dataStream.on('readable', () => {
console.log(dataStream.read());
});

dataStream.on('end', () => console.log('File Read Completed'));

En el código anterior, el objeto dataStream creado por fs.createReadStream es un emisor, y cuando ocurren estos eventos específicos, emite varios eventos con nombre.

Por ejemplo, cuando el contenido de un archivo se serializa y está listo para ser leído, se emitirá un evento «legible». Usamos el método `on` para adjuntar un oyente a este evento particular emitido por el objeto dataStream.

Ahora, cuando se emite un evento «legible», se ejecutará la función de devolución de llamada adjunta a su oyente, que registra el contenido del archivo. Por lo tanto, toda la operación se completa de manera asincrónica y controlada por eventos.

Cuando la secuencia llega al final del archivo, se emite el evento final y se activa la devolución de llamada correspondiente adjunta a su oyente.

Lo que vimos anteriormente es un ejemplo típico de cómo la API central de Node.js se basa en eventos. En este artículo, analizaremos brevemente cómo crear eventos personalizados y varios métodos para escuchar los eventos emitidos.

Lanzador de eventos:

Como hemos visto en la sección anterior, para los objetos que emiten eventos, deben ser del tipo emisor. En resumen, un emisor es una instancia de objeto creada a partir de la clase EventEmitter u otra clase que hereda la clase EventEmiiter.

En Node.js, el módulo de eventos exporta la clase EventEmitter.

La clase EventEmitter encapsula un método llamado `emit`, que se puede usar para emitir eventos con nombre a partir de instancias de objetos creados.

Para adjuntar un oyente, podemos usar el método `on`, que estará disponible en el prototipo del objeto que activamos la emisión.

Echemos un vistazo rápido a un fragmento de código de muestra para demostrar los conceptos que discutimos anteriormente:

const EventEmitter = require('events');
const customEmitter = new EventEmitter();
customEmitter.on('exampleEvent', (data) => console.log(data));
customEmitter.emit('exampleEvent', 'A custom event was triggered!!');

¿Cuáles son los eventos en el nodo JS?En el ejemplo anterior, hemos creado una instancia de la clase emisor EventEmitter, y utilizamos el método `emit` en la instancia de objeto de desencadenar un evento con nombre llamado` exampleEvent`, que aprobó una cadena personalizada como datos.

También usamos el método `on` del objeto para escuchar este evento personalizado, y adjuntamos una función de devolución de llamada, que solo registra los datos transmitidos por el evento enviado desde la consola.

Por lo tanto, creamos nuestro propio evento personalizado. También debe tenerse en cuenta que, aunque todo el mecanismo de eventos es asíncrono, si adjuntamos varios oyentes al mismo evento en el mismo emisor, las devoluciones de llamada del oyente se ejecutarán sincrónicamente en el orden en que se declaran en el código.

Método de lanzamiento:

El método `emit` tiene la siguiente sintaxis:

emitter.emit(eventName,[,...args])

El primer parámetro es el nombre del evento que queremos emitir, seguido de cualquier número de parámetros.

Esto significa que podemos usar el método emit para realizar las siguientes operaciones:

customEmitter.emit("newLine", "A custom newLine event has been emitted", true);

Si se adjuntan uno o más oyentes, el método de lanzamiento devuelve verdadero. Si no se adjunta ningún oyente para un evento específico, el método de emisión devuelve falso.

método:

El método `on` se usa para adjuntar un oyente al evento nombrado del objeto emisor.

La sintaxis general es la siguiente:

emitter.on(eventName,listener)

eventName es una cadena que identifica el evento nombrado, y el oyente es una función de devolución de llamada.

El método `on` devuelve una instancia de EventEmitter para habilitar la cadena de métodos.

Por tanto, podemos escribir nuestro oyente de la siguiente forma:

customEmitter.on("newLine", (arg1,arg2)=>{ 
    console.log(arg1); 
    console.log(arg2); 
});

¿Cuáles son los eventos en el nodo JS?También es importante tener en cuenta que Node no realizará ninguna comprobación para ver si se ha conectado un oyente específico al transmisor. Esto significa que si adjuntamos el mismo oyente varias veces para un evento particular desde el emisor, la devolución de llamada del oyente se ejecutará tantas veces como los adjuntemos.

De forma predeterminada, el oyente se adjuntará a la matriz de oyentes para los eventos del emisor. Pero si queremos ejecutar la devolución de llamada del oyente antes que todos los demás oyentes adjuntos, entonces podemos usar `Monitor frontal`El método en el objeto transmisor.

Cada vez que se emite un evento específico, se llama al oyente adjunto mediante el método on. Para escenarios que solo necesitan llamar al oyente una vez, podemos usar diferentes métodos para adjuntar el oyente, que discutiremos en la siguiente sección.

Solo maneja el evento una vez:

Para procesar el evento solo una vez, podemos usar el método `once`. Tiene una firma similar al método `on`:

emitter.once(eventName, listener)

Veamos un fragmento de código de demostración:

const EventEmitter = require('events');
const customEmitter = new EventEmitter();
customEmitter.once('event1', (data) => console.log(data));
customEmitter.emit('event1', 'event 1 emitted'); 
customEmitter.emit('event1', 'event 1 emitted');

En el código anterior, el evento denominado `event1` se emite dos veces. Pero el oyente solo será llamado una vez.

¿Cuáles son los eventos en el nodo JS?Si usamos `on` en su lugar, el oyente será llamado dos veces, como se muestra a continuación:

¿Cuáles son los eventos en el nodo JS?

Manejo de errores:

En Node.js, la mayoría de las API principales siguen un patrón llamado «error en la primera devolución de llamada», lo que significa que si hay algún error, este debería ser el primer parámetro de la función de devolución de llamada.

Un fragmento general que represente esta idea podría verse así:

fs.readFile('data.csv', function(err, data) { 
if (err) { 
console.log('Error Found:' + err); 
throw err; 
} 
console.log(data); 
});

Pero para los emisores de eventos, usamos un método ligeramente diferente para manejar los errores. Dado que los emisores pueden emitir eventos personalizados, se pueden emitir eventos de error cuando encontramos eventos de error, y podemos adjuntar un oyente con una devolución de llamada que actuará como un controlador de errores.

El siguiente fragmento de código demuestra esta idea:

const EventEmitter = require('events');
const customEmitter = new EventEmitter(); 
  
const sporadicError = () => { 
const diceRoll = Math.random(); 
if (diceRoll >= 0.6) { 
   throw new Error('An error occurred in the application'); 
} 
}; 
  
customEmitter.on('data', (data) => console.log(data)); 
customEmitter.on('error', (error) => console.log(error)); 
  
try { 
sporadicError(); 
customEmitter.emit('data', 'That was successful'); 
} catch (err) { 
customEmitter.emit('error', err.message); 
}

El código anterior simula un escenario donde ocurren errores aleatorios, los errores son esporádicos y la probabilidad de ocurrencia es del 40%.

El resultado del fragmento de código anterior después de dos ejecuciones consecutivas es el siguiente:

¿Cuáles son los eventos en el nodo JS?A través de este código, mostramos cómo completar el manejo de errores en el emisor de eventos.

¿Son las actividades realmente importantes?

Los eventos son el mecanismo clave en el paradigma de Node.js. Una comprensión clara de los métodos controlados por eventos ayudará a escribir código de nodo idiomático y también evitará que escribamos lógica de sincronización de bloqueo en gran medida. Si este artículo despertó su curiosidad, también debería leer rápidamente un concepto llamado programación reactiva. Esto lo ayudará a obtener una comprensión más profunda de términos como flujos y observables, lo que a su vez lo ayudará a escribir una lógica de aplicación resistente, basada en eventos y con una buena arquitectura.

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba