Nel Nodo.js molti degli oggetti presenti nell'ambiente emettono eventi, ad esempio un server TCP emette un evento di tipo Collegare ogni volta che un nuovo client si connette o un flusso di file emette informazioni ogni volta che viene letta un'informazione.
Questo in Nodo.js sono i cosiddetti emettitori di eventi, che consentono agli sviluppatori la possibilità di sottoscrivere eventi, dove si sottoscrive una funzione richiama che verrà invocato ogni volta che si verifica un evento nell'emettitore di eventi. Possiamo persino creare i nostri emettitori di eventi grazie alla pseudo-classe EventEmitter.
Tuttavia, per entrare con gli emettitori di eventi, dobbiamo prima essere chiari su alcuni concetti, come alcuni modelli di queste funzioni, i tipi di eventi e persino gli ascoltatori.
RequisitiPer svolgere gli esercizi proposti in questo tutorial dobbiamo avere un'installazione funzionale di Nodo.js nel nostro sistema, possiamo dare un'occhiata a questo tutorial prima di continuare ad approfondire. È anche importante poter avere accesso a un editor di testo ricco per codificare gli esempi, possiamo usare qualunque cosa ci sentiamo a nostro agio, tuttavia, per la sua facilità d'uso, consigliamo Testo sublime o NotePad ++ che ha anche plugin per la sintassi JavaScript sì HTML.
Modello per i callback
La programmazione asincrona non utilizza il ritorno di valori nelle funzioni per indicare che quella funzione è appena terminata, ma invoca il famoso callback dopo che l'operazione è stata completata in modo che il nostro programma possa continuare, dove JavaScript Conduco a questo tipo di programmazione, vediamo un esempio in Non dare che legge un file e ne carica il contenuto in memoria:
var fs = richiede ('fs'); fs.readFile ('file.txt', function (err, fileContent) {if (err) {throw err;} console.log ('Contenuto del file:', fileContent.toString ());});Quello che facciamo qui è inviare una funzione anonima come secondo argomento della funzione fs.readFilee come possiamo vedere che il primo argomento della funzione di callback è un oggetto errore, che avrà un'istanza della classe Error se si verifica un errore.
Modello per l'emettitore di eventi
Lo stile precedente funziona perfettamente quando vogliamo notificare che una funzione che stiamo eseguendo termina il suo lavoro, ma nel caso in cui si verifichino più eventi durante questa esecuzione o molte volte, questo stile non funzionerà come vogliamo. Ad esempio, se vogliamo essere avvisati ogni volta che l'informazione è disponibile nel socket, una funzione di tipo richiama standard non ci aiuterà molto, ma è qui che l'emettitore di eventi può aiutarci.
L'emettitore di eventi non è altro che un oggetto che, come indica il nome, emette un evento, dove a ascoltatore fa parte del codice che si lega a questo emettitore e ascolta alcuni tipi di eventi, come:
var req = http.request (options, function (response) {response.on ("data", function (data) {console.log ("Alcuni dati di risposta", data);}); response.on (" end " , function() {console.log ("risposta completata");});}); req.end();Questo è un codice puramente esplicativo, dove possiamo vedere alcuni passaggi per effettuare una richiesta HTTP a un server remoto ma ci permette di vedere come l'oggetto risposta è un emettitore di eventi, che può emettere non solo dati sì fine ma anche altri tipi di eventi.
Tipi di eventi
Secondo l'esempio precedente abbiamo potuto vedere che gli eventi emessi hanno sempre un tipo, che è rappresentato da una stringa, in questo caso "dati"Y"fine”, che saranno stringhe arbitrarie designate dall'emittente dell'evento.
L'emettitore di eventi è un'interfaccia generica che serve qualsiasi tipo di evento, ma c'è un caso speciale nell'implementazione di Non dare ed è l'evento errore, dove ogni evento nell'ambiente emetterà un evento di questo tipo ogni volta che si verifica un errore e se lo sviluppatore sceglie di non ascoltare questo tipo di evento e si verifica un errore, l'emettitore di eventi lo noterà e solleverà un'eccezione in questo caso . Vediamo nel codice seguente come possiamo simulare questo comportamento:
var em = new (require ('events'). EventEmitter) (); em.emit ('evento1'); em.emit ("errore", nuovo errore ("errore mio"));Se lo eseguiamo attraverso la console possiamo vedere come Non dare ci dice che non stiamo gestendo l'errore, generando così un'eccezione non rilevata:
Poiché abbiamo visto come si comportano gli eventi in modo generale, vediamo come utilizziamo l'API dell'emettitore di eventi.
Utilizzo dell'API dell'emettitore di eventi
Qualsiasi oggetto che implementa il modello di emettitore di eventi implementa una serie di eventi come possiamo vedere di seguito:
.addListener - .onQuesto metodo ci consente di aggiungere un listener a un tipo di evento.
.undiciCon questo metodo possiamo associare un listener a un tipo di evento dato che verrà chiamato almeno una volta.
.removeEventListenerQuesto metodo ci consentirà di rimuovere un ascoltatore da un determinato evento.
.removeAllEventListenersInfine, questo metodo ci aiuta a rimuovere tutti i listener per un determinato tipo di evento.
Avendo già visto qual è la funzione di ciascuno di questi, vediamo come li utilizziamo all'interno dei nostri programmi.
Utilizzo di .addListener () o .on () nei callback
Specificando un tipo di evento e una funzione richiama, possiamo registrare l'azione da intraprendere quando si verifica un evento specifico. Ad esempio, se vogliamo essere informati che una porzione di dati è disponibile ed emettere un evento di tipo dati, possiamo fare quanto segue:
funzione riceviData (dati) {console.log ("I dati sono stati ottenuti:% j", dati); } readFlow.addListener ("dati", riceviData);Possiamo anche usare il metodo .sopra () che è solo una scorciatoia, vediamo l'equivalente del codice precedente:
funzione riceviData (dati) {console.log ("I dati sono stati ottenuti:% j", dati); } readFlow.on ("dati", ricezioneDati);Possiamo anche aggiungere più ascoltatori per i nostri eventi per ascoltare lo stesso tipo di evento sullo stesso trasmettitore, ad esempio:
In questo esempio, ciò che viene fatto è associare due funzioni all'evento del tipo di dati e dove, una volta emesso l'evento di dati, verranno stampate entrambe le stringhe. È importante notare che l'emittente dell'evento è responsabile di chiamare tutti ascoltatori registrati per un tipo di evento e li chiamerà nell'ordine in cui sono stati registrati, il che significa quanto segue:
- Un listener non può essere chiamato immediatamente dopo l'emissione dell'evento, è possibile che altri listener vengano chiamati prima.
- Non rilevare le eccezioni è un comportamento malsano per il nostro codice, quindi se uno di questi ascoltatori genera un errore e non viene rilevato, è possibile che alcuni ascoltatori non vengano chiamati, come possiamo illustrare nell'esempio seguente:
Dove in questo esempio il secondo listener non verrà invocato poiché il primo ha generato un errore.
Utilizzo di .removeListener()
Se in qualsiasi momento non desideriamo più essere informati delle modifiche a un determinato evento o oggetto, possiamo interrompere la registrazione specificando il tipo di evento e la funzione di callback come segue:
Usando .once ()
Nel caso in cui la nostra applicazione stia ascoltando un evento che accadrà almeno una volta o se siamo interessati a farlo accadere solo una volta, possiamo usare .undici(), che aggiunge il listener e lo rimuove una volta che si verifica il primo evento:
Utilizzo di .removeAllListeners ()
Infine possiamo rimuovere tutti i listener per un particolare tipo di evento da un emettitore di eventi come segue:
issuer.removeAllListeners (tipo);
Creazione dell'emettitore di eventi
L'emettitore di eventi ci fornisce un modo generico di creare interfacce, poiché stiamo associando eventi anziché funzioni, rendendo il nostro programma più flessibile, anche se vogliamo usare il modello di Nodo.js In tutta la nostra applicazione possiamo creare una pseudo-classe ed ereditare da EventEmitter come segue:
util = require('util'); var EventEmitter = require ("eventi"). EventEmitter; var MyClass = function () {} util.inherits (MyClass, EventEmitter);In questo modo i metodi di EventEmitter Saranno disponibili per la nostra istanza e possiamo usarli senza problemi e in questo modo La mia classe può emettere eventi:
MyClass.prototype.someMethod = function () {this.emit ("evento personalizzato", "argomento 1", "argomento 2"); };qui quando qualche metodo è chiamato nel caso di La mia classe, l'esempio emette un evento chiamato evento personalizzato, dove a sua volta emette due dati diversi, argomento 1 e argomento 2, che verranno inviati ai listener di eventi. Infine nei casi di La mia classe lato client puoi ascoltare il evento personalizzato come segue:
var MyClass = new MyClass (); MyClass.on ('evento personalizzato', funzione (str1, str2) {console.log ('Evento personalizzato ascoltato con argomenti str1% se str2% s!', Str1, str2);});Come possiamo vedere, l'uso di eventi insieme all'emettitore di eventi ci aiuta a comunicare con la nostra applicazione ed è così che abbiamo concluso questo tutorial, dove siamo stati in grado di andare oltre la programmazione asincrona e l'applicazione di pratiche che ci aiutano a mantenere uno standard e ottimale modello per le nostre applicazioni. 
