Come utilizzare gli emettitori di eventi in Node.js

Crea e gestisci i tuoi eventi personalizzati per organizzare il tuo codice JavaScript backend in modo efficiente.

Gli emettitori di eventi sono oggetti in NodeJS che attivano eventi inviando un messaggio per segnalare che si è verificata un'azione.

Node.js fornisce un modulo eventi integrato. Contiene una classe emettitore di eventi che consente di creare e gestire eventi personalizzati tramite funzioni di callback.

Qui imparerai come emettere eventi, ascoltare e gestire i dati degli eventi e gestire gli errori degli eventi in NodeJS.

Emissione di eventi

Il modulo eventi è una parte fondamentale dell'ambiente lato server Node.js. Pertanto, non è necessario installarlo, ma prima di utilizzare la classe EventEmitter, è necessario importarlo dal modulo eventi e istanziarlo.

Così:

const EventEmitter = require("events");
 
// Instantiatating the EventEmitter
const myEmitter = new EventEmitter();

Puoi emettere eventi utilizzando il metodo emit di EventEmitter. Il metodo emit accetta un eventName e un numero arbitrario di argomenti come parametri.

Una volta chiamato il metodo emit, viene emesso il eventName passato . Quindi chiama in modo sincrono ciascuno degli ascoltatori dell'evento nell'ordine in cui li hai registrati, passando a ciascuno gli argomenti forniti. Infine, restituisce true se l'evento ha avuto ascoltatori e false se non ha avuto ascoltatori.

Per esempio:

myEmitter.emit("TestEvent", "foo", "bar", 1, 2);

Nel blocco di codice sopra, hai superato TestEvent come EventName, e "foo", "bar", 1 e 2 come argomenti. Quando il blocco di codice sopra viene eseguito, avviserà tutti gli ascoltatori che ascoltano l'evento TestEvent. Chiamerà gli ascoltatori con gli argomenti forniti.

Ascolto di eventi

Puoi ascoltare gli eventi emessi utilizzando il metodo on di EventEmitter. Il metodo on accetta un EventName e una funzione di callback come parametri. Quando viene emesso l'evento con EventName passato al metodo on, richiama la sua funzione di callback. Questo metodo restituisce un riferimento a EventEmitter, consentendoti di concatenare più chiamate.

Per esempio:

// First Listener
myEmitter.on("TestEvent", () => {
  console.log("TestEvent Emitted!!!");
}); // TestEvent Emitted!!!
 
// Second Listener
myEmitter.on("TestEvent", (...args) => {
  args = args.join(", ");
  console.log(`Event emitted with the following arguments: ${args}`);
}); // Event emitted with the following arguments: foo, bar, 1, 2
 
myEmitter.emit("TestEvent", "foo", "bar", 1, 2);

Nel blocco di codice sopra, quando viene generato l'evento TestEvent, gli ascoltatori dell'evento invocheranno le loro funzioni di callback. Gli ascoltatori reagiranno nell'ordine in cui li hai registrati, il che significa che la richiamata del "primo ascoltatore" verrà eseguita prima del secondo e così via.

Puoi modificare questo comportamento utilizzando di EventEmitter prependListener metodo . Questo metodo accetta gli stessi parametri del metodo on. La differenza è che questo metodo reagisce prima all'evento, indipendentemente dal momento in cui lo registri.

Per esempio:

myEmitter.on("TestEvent", () => {
  console.log("TestEvent Emitted!!!");
});
 
myEmitter.prependListener("TestEvent", () => {
    console.log("Executes first")
})
 
// console.log(myEmitter.listeners("TestEvent"));
myEmitter.emit("TestEvent", "foo", "bar", 1, 2);

Quando viene eseguito il blocco di codice riportato sopra, sulla console verrà registrato per primo il messaggio "Esegui prima", seguito da "TestEvent Emesso!!!" indipendentemente dall'ordine in cui li hai registrati a causa di prependListener metodo.

Notare la disposizione dell'emettitore e degli ascoltatori. Gli ascoltatori vengono sempre prima di chi emette. Questa disposizione è dovuta al fatto che gli ascoltatori devono già ascoltare l'evento prima che l'emettitore lo emetta.

Per il contesto, considerare il blocco di codice seguente:

myEmitter.emit("TestEvent", "foo", "bar", 1, 2);
 
myEmitter.on("TestEvent", () => {
  console.log("TestEvent Emitted!!!");
}); 

Se esegui il blocco di codice sopra, non succede nulla perché, nel momento in cui l'emettitore ha emesso l'evento, nessun ascoltatore era in ascolto dell'evento.

Ascoltare gli eventi una volta

A seconda delle tue esigenze, potresti dover gestire alcuni eventi solo una volta nel ciclo di vita della tua applicazione. Puoi raggiungere questo obiettivo utilizzando il metodo once di EventEmitter.

Questo metodo accetta gli stessi argomenti del metodo on e funziona in modo simile. L'unica differenza è che gli ascoltatori registrati con il metodo una volta ascoltano solo l'evento una volta.

Per esempio:

myEmitter.once("SingleEvent", () => {
  console.log("Event handled once");
});
 
myEmitter.emit("SingleEvent"); // Event handled once
myEmitter.emit("SingleEvent"); // Ignored
myEmitter.emit("SingleEvent"); // Ignored

L'esecuzione del blocco di codice registrerà "Evento gestito una volta" sulla console solo una volta, indipendentemente dalla frequenza con cui l'emettitore emette l'evento.

Gli ascoltatori registrati con il metodo once reagiscono all'evento nell'ordine in cui li hai registrati. Puoi modificare questo comportamento utilizzando il metodo prependOnceListener, che funziona come prependListener. L'unica differenza è che gli ascoltatori registrati con il metodo una volta ascoltano solo l'evento una volta.

Gestione degli errori con gli emettitori di eventi

Dovresti fare attenzione a gestire gli errori JavaScript in modo appropriato e i listener di eventi non fanno eccezione. Errori non gestiti da parte loro causeranno la chiusura del processo Node.js e l'arresto anomalo dell'applicazione.

Per gestire un evento di errore, almeno uno degli ascoltatori dell'evento deve avere il suo EventName impostato su errore .

Per esempio:

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

Avere un ascoltatore in grado di gestire un potenziale errore, come nel blocco di codice sopra, impedirà all'applicazione di bloccarsi quando si verifica un errore.

Per esempio:

myEmitter.emit("error", new Error("This is an error"));

L'esecuzione del blocco di codice riportato sopra registrerà "Questo è un errore" sulla console perché un ascoltatore sta gestendo eventi di errore.

Gestione degli ascoltatori di eventi

La classe EventEmitter dispone di diversi metodi che consentono di manipolare e gestire i listener di eventi. Puoi ottenere gli ascoltatori di un evento, rimuoverli e impostare il numero massimo di ascoltatori per un evento.

Ecco una tabella contenente i metodi EventEmitter con cui puoi manipolare i listener di eventi:

Per esempio:

myEmitter.removeListener("TestEvent");

Il blocco di codice sopra rimuove un singolo ascoltatore per l'evento TestEvent.

L'importanza degli emettitori di eventi

Node.js adotta il paradigma di programmazione basata sugli eventi con il suo supporto per emettitori e ascoltatori di eventi. La programmazione basata sugli eventi è uno dei motivi per cui i programmi Node.js sono più veloci e più semplici di alcune alternative. Puoi sincronizzare facilmente più eventi, con conseguente maggiore efficienza.