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 degli eventi è una parte fondamentale di l'ambiente lato server Node.js. Pertanto, non è necessario installarlo, ma prima di utilizzare il file Emettitore di eventi class, devi importare dal modulo events e crearne un'istanza.

Così:

cost Emettitore di eventi = richiedere("eventi");
// Creazione di un'istanza di EventEmitter
cost mioEmettitore = nuovo EventEmitter();

Puoi emettere eventi usando il file Emettitore di eventi'S emettere metodo. IL emettere metodo richiede un nome dell'evento e un numero arbitrario di argomenti come parametri.

Una volta chiamato il

instagram viewer
emettere metodo, emette il passato nome dell'evento. Quindi chiama in modo sincrono ciascuno dei listener dell'evento nell'ordine in cui li hai registrati, passando a ciascuno gli argomenti forniti. Finalmente ritorna VERO se l'evento ha avuto ascoltatori e falso se non avesse ascoltatori.

Per esempio:

mioEmettitore.emit("Evento di prova", "pippo", "sbarra", 1, 2);

Nel blocco di codice sopra, hai passato Evento di prova come il Nome dell'evento, E "pippo,” "sbarra,” 1, E 2 come gli argomenti. Quando il blocco di codice sopra viene eseguito, avviserà tutti gli ascoltatori in ascolto per il file Evento di prova evento. Chiamerà quegli ascoltatori con gli argomenti dati.

Ascolto degli eventi

È possibile ascoltare gli eventi emessi utilizzando il file Emettitore di eventi'S SU metodo. IL SU metodo richiede un Nome dell'evento e una funzione di callback come parametri. Quando l'evento con il Nome dell'evento passato nel SU metodo viene emesso, richiama la sua funzione di callback. Questo metodo restituisce un riferimento al Emettitore di eventi, che consente di concatenare più chiamate.

Per esempio:

// Primo ascoltatore
mioEmettitore.on("Evento di prova", () => {
 console.log("TestEvent Emesso!!!");
}); // TestEvent Emesso!!!
// Secondo ascoltatore
mioEmettitore.on("Evento di prova", (...args) => {
 args = args.join(", ");
consolare.tronco d'albero(`Evento emesso con i seguenti argomenti: ${arg}`);
}); // Evento emesso con i seguenti argomenti: foo, bar, 1, 2
mioEmettitore.emit("Evento di prova", "pippo", "sbarra", 1, 2);

Nel blocco di codice sopra, quando il file Evento di prova evento emette, i listener per l'evento richiameranno 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.

È possibile modificare questo comportamento utilizzando il file Emettitore di eventi'S prependListener metodo. Questo metodo accetta gli stessi parametri del SU metodo. La differenza è che questo metodo reagisce prima all'evento, indipendentemente dall'ora in cui lo registri.

Per esempio:

mioEmettitore.on("Evento di prova", () => {
 console.log("TestEvent Emesso!!!");
});
myEmitter.prependListener("Evento di prova", () => {
 console.log("Esegue prima")
})
// console.log (myEmitter.listeners("Evento di prova"));
mioEmettitore.emit("Evento di prova", "pippo", "sbarra", 1, 2);

Quando il blocco di codice sopra viene eseguito, "Executes first" verrà registrato prima nella console, seguito da "TestEvent Emitted!!!" indipendentemente dall'ordine in cui li hai registrati a causa del prependListener metodo.

Se registri diversi ascoltatori con il prependListener metodo, verranno eseguiti in ordine dall'ultimo al primo.

Notare la disposizione dell'emettitore e degli ascoltatori. Gli ascoltatori vengono sempre prima dell'emittente. Questa disposizione è perché gli ascoltatori devono già ascoltare l'evento prima che l'emettitore lo emetta.

Per il contesto, considera il blocco di codice seguente:

mioEmettitore.emit("Evento di prova", "pippo", "sbarra", 1, 2);
mioEmettitore.on("Evento di prova", () => {
 console.log("TestEvent Emesso!!!");
});

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

Ascoltare gli eventi una volta

A seconda dei requisiti, potrebbe essere necessario gestire alcuni eventi solo una volta nel ciclo di vita dell'applicazione. È possibile ottenere questo utilizzando il Emettitore di eventi'S una volta metodo.

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

Per esempio:

mioEmettitore.once("Evento singolo", () => {
 console.log("Evento gestito una volta");
});
mioEmettitore.emit("Evento singolo"); // Evento gestito una volta
mioEmettitore.emit("Evento singolo"); // Ignorato
mioEmettitore.emit("Evento singolo"); // Ignorato

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

Gli ascoltatori registrati con il una volta metodo reagiscono all'evento nell'ordine in cui li registri. È possibile modificare questo comportamento utilizzando il file prependOnceListener metodo, che funziona come prependListener. L'unica differenza è che gli ascoltatori registrati con il una volta metodo ascolta l'evento solo una volta.

Gestione degli errori con emettitori di eventi

Dovresti prenderti cura di gestire gli errori JavaScript in modo appropriato e gli ascoltatori di eventi non fanno eccezione. Gli errori non gestiti causano l'uscita dal processo Node.js e l'arresto anomalo dell'applicazione.

Per gestire un evento di errore, almeno uno dei listener dell'evento deve avere il suo Nome dell'evento impostato errore.

Per esempio:

mioEmettitore.on("errore", (errore) => {
consolare.errore(`Errore: ${errore}`);
});

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

Per esempio:

mioEmettitore.emit("errore", nuovo errore("Questo è un errore"));

L'esecuzione del blocco di codice precedente registrerà "Questo è un errore" nella console perché un listener sta gestendo gli eventi di errore.

Gestione dei listener di eventi

IL Emettitore di eventi class 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 Emettitore di eventi metodi con cui puoi manipolare i listener di eventi con:

Metodo argomenti Valore di ritorno
listenerCount nome dell'evento Restituisce il numero di ascoltatori iscritti a un evento
ascoltatori nome dell'evento Restituisce una matrice di ascoltatori
removeListener nome dell'evento Rimuove almeno un listener da un eventName specificato.
removeAllListeners nome dell'evento Rimuove tutti i listener per un eventName specificato. Se non specifichi un nome evento, questa chiamata al metodo rimuoverà tutti i listener per EventEmitter.
setMaxListeners numero Modifica il numero massimo predefinito di ascoltatori per evento. Usa infinito o zero per indicare un numero illimitato di ascoltatori. Per impostazione predefinita, puoi iscrivere solo dieci ascoltatori a un evento.

Puoi chiamare questi metodi solo su un file Emettitore di eventi esempio.

Per esempio:

myEmitter.removeListener("Evento di prova");

Il blocco di codice precedente rimuove un singolo listener per il file Evento di prova evento.

L'importanza degli emettitori di eventi

Node.js adotta il paradigma di programmazione basato sugli eventi con il suo supporto per emettitori e ascoltatori di eventi. La programmazione guidata dagli eventi è uno dei motivi per cui i programmi Node.js sono più veloci e più semplici di alcune alternative. È possibile sincronizzare facilmente più eventi, con conseguente miglioramento dell'efficienza.