In questo tutorial imparerai
- Filestream in Node.js
- Pipes in Node.js
- Eventi in Node.js
- Emissione di eventi
Filestream in Node.js
Node fa un uso estensivo dei flussi come meccanismo di trasferimento dei dati.
Ad esempio, quando invii qualcosa alla console utilizzando la funzione console.log, stai effettivamente utilizzando un flusso per inviare i dati alla console.
Node.js ha anche la capacità di trasmettere dati da file in modo che possano essere letti e scritti in modo appropriato. Vedremo ora un esempio di come possiamo usare i flussi per leggere e scrivere dai file. Dobbiamo seguire i passaggi indicati di seguito per questo esempio
Passaggio 1) Crea un file chiamato data.txt che contiene i dati seguenti. Supponiamo che questo file sia archiviato nell'unità D della nostra macchina locale.
Tutorial su Node.js
introduzione
Eventi
Generatori
Connettività dati
Utilizzando Jasmine
Passaggio 2) Scrivere il codice pertinente che utilizzerà i flussi per leggere i dati dal file.
var fs = require("fs");var stream;stream = fs.createReadStream("D://data.txt");stream.on("data", function(data) {var chunk = data.toString();console.log(chunk);});
Spiegazione del codice: -
- Per prima cosa dobbiamo includere i moduli "fs" che contengono tutte le funzionalità richieste per creare flussi.
- Successivamente creiamo un flusso leggibile utilizzando il metodo - createReadStream. Come input, diamo la posizione del nostro file data.txt.
- La funzione steam.on è un gestore di eventi e in essa stiamo specificando il primo parametro come "dati". Ciò significa che ogni volta che i dati arrivano nel flusso dal file, eseguire una funzione di callback. Nel nostro caso, stiamo definendo una funzione di callback che eseguirà 2 passaggi fondamentali. Il primo è convertire i dati letti dal file come una stringa. Il secondo sarebbe inviare la stringa convertita come output alla console.
- Stiamo prendendo ogni blocco di dati che viene letto dal flusso di dati e lo convertiamo in una stringa.
- Infine, stiamo inviando l'output di ogni blocco convertito di stringa alla console.
Produzione:
- Se il codice viene eseguito correttamente, vedrai l'output sopra nella console. Questo output sarà lo stesso di quello nel file data.txt.
Scrittura su un file
Allo stesso modo, quando creiamo un flusso di lettura, possiamo anche creare un flusso di scrittura per scrivere dati su un file. Creiamo prima un file vuoto senza contenuto chiamato data.txt. Supponiamo che questo file sia inserito nell'unità D del nostro computer.
Il codice seguente mostra come scrivere i dati nel file.
var fs = require("fs");var stream;stream = fs.createWriteStream("D://data.txt");stream.write("Tutorial on Node.js")stream.write("Introduction")stream.write("Events")stream.write("Generators")stream.write("Data Connectivity")stream.write("Using Jasmine")
Spiegazione del codice: -
- Stiamo creando un flusso scrivibile utilizzando il metodo - createWriteStream. Come input, diamo la posizione del nostro file data.txt.
- Successivamente abbiamo utilizzato il metodo stream.write per scrivere le diverse righe di testo nel nostro file di testo. Il flusso si occuperà di scrivere questi dati nel file data.txt.
Se apri il file data.txt, ora vedrai i seguenti dati nel file
Tutorial su Node.js
introduzione
Eventi
Generatori
Connettività dati
Utilizzando Jasmine
Pipes in Node.js
All'interno delle applicazioni Node, i flussi possono essere convogliati insieme utilizzando il metodo pipe (), che accetta due argomenti:
- Un flusso scrivibile obbligatorio che funge da destinazione per i dati e
- Un oggetto opzionale utilizzato per passare le opzioni.
Un tipico esempio di utilizzo di pipe, se si desidera trasferire dati da un file all'altro.
Vediamo quindi un esempio di come possiamo trasferire dati da un file all'altro usando le pipe.
Passaggio 1) Crea un file chiamato datainput.txt che contiene i dati seguenti. Supponiamo che questo file sia archiviato nell'unità D della nostra macchina locale.
Tutorial su Node.js
introduzione
Eventi
Generatori
Connettività dati
Utilizzando Jasmine
Passaggio 2) Crea un file vuoto vuoto chiamato dataOutput.txt e posizionalo sull'unità D della tua macchina locale.
Passaggio 3) Scrivi il codice seguente per eseguire il trasferimento dei dati dal file datainput.txt al file dataOutput.txt.
var fs = require("fs");var readStream = fs.createReadStream("D://datainput.txt");var writeStream = fs.createWriteStream("D://dataOutput.txt");readStream.pipe(writeStream);
Spiegazione del codice: -
- Per prima cosa stiamo creando un "readstream" nel nostro file datainput.txt che contiene tutti i nostri dati che devono essere trasferiti nel nuovo file.
- Dobbiamo quindi creare un "writer" nel nostro file dataOutput.txt, che è il nostro file vuoto ed è la destinazione per il trasferimento dei dati dal file datainput.txt.
- Quindi utilizziamo il comando pipe per trasferire i dati dal readstream al flusso di scrittura. Il comando pipe prenderà tutti i dati che arrivano nel readstream e li invierà al writer.
Se ora apri il file dataOutput.txt, vedrai tutti i dati che erano presenti nel file datainput.txt.
Eventi in Node.js
Gli eventi sono uno dei concetti chiave in Node.js e talvolta Node.js viene definito framework basato sugli eventi.
Fondamentalmente, un evento è qualcosa che accade. Ad esempio, se viene stabilita una connessione a un database, viene attivato l'evento di connessione al database. La programmazione guidata dagli eventi serve a creare funzioni che verranno attivate quando vengono attivati eventi specifici.
Diamo un'occhiata a un esempio di base della definizione di un evento in Node.js.
Creeremo un evento chiamato "data_received". Quando questo evento viene attivato, il testo "dati ricevuti" verrà inviato alla console.
var events = require('events');var eventEmitter = new events.EventEmitter();eventEmitter.on('data_received', function() {console.log('data received succesfully.');});eventEmitter.emit('data_received');
Spiegazione del codice: -
- Usa la funzione require per includere il modulo "events". Con questo modulo, sarai in grado di creare eventi in Node.js.
- Crea un nuovo emettitore di eventi. Viene utilizzato per associare l'evento, che nel nostro caso è "data_received" a una funzione di callback definita nel passaggio 3.
- Definiamo una funzione guidata dagli eventi che dice che se nel caso in cui viene attivato l'evento "data_received", dovremmo inviare il testo "data_received" alla console.
- Infine, abbiamo un trigger manuale del nostro evento utilizzando la funzione eventEmiter.emit. Questo attiverà l'evento data_received.
Quando il programma viene eseguito, il testo "dati ricevuti" verrà inviato alla console come mostrato di seguito.
Emissione di eventi
Quando si definiscono gli eventi, esistono diversi metodi per gli eventi che possono essere richiamati. Questo argomento si concentra sull'analisi di ciascuno di essi in dettaglio.
- Gestori di eventi una tantum
A volte potresti essere interessato a reagire a un evento solo la prima volta che si verifica. In queste situazioni, puoi usare il metodo once ().
Vediamo come possiamo utilizzare il metodo once per i gestori di eventi.
Spiegazione del codice: -
- Qui stiamo usando il metodo "once" per dire che per l'evento "data_received", la funzione di callback dovrebbe essere eseguita solo una volta.
- Qui stiamo attivando manualmente l'evento "data_received".
- Quando l'evento "data_received" viene attivato di nuovo, questa volta non accadrà nulla. Ciò è dovuto al primo passaggio in cui abbiamo affermato che l'evento poteva essere attivato solo una volta.
Se il codice viene eseguito correttamente, l'output nel registro sarà "data_received". Questo messaggio apparirà solo una volta nella console.
- Ispezione dei listener di eventi
In qualsiasi momento della sua vita, un emettitore di eventi può avere zero o più listener collegati ad esso. I listener per ogni tipo di evento possono essere controllati in diversi modi.
Se sei interessato a determinare solo il numero di listener allegati, non cercare oltre il metodo EventEmitter.listenerCount ().
( Nota: gli ascoltatori sono importanti perché il programma principale dovrebbe sapere se gli ascoltatori vengono aggiunti al volo a un evento, altrimenti il programma non funzionerà correttamente perché verranno chiamati ascoltatori aggiuntivi).
Spiegazione del codice: -
- Stiamo definendo un tipo di eventEmitter necessario per utilizzare i metodi correlati agli eventi.
- Stiamo quindi definendo un oggetto chiamato emitter che verrà utilizzato per definire i nostri gestori di eventi.
- Stiamo creando 2 gestori di eventi che praticamente non fanno nulla. Questo è mantenuto semplice per il nostro esempio solo per mostrare come funziona il metodo listenerCount.
- Ora, quando si richiama il metodo listenerCount sul nostro evento data_received, invierà il numero di listener di eventi allegati a questo evento nel log della console.
Se il codice viene eseguito correttamente, il valore 2 verrà visualizzato nel registro della console.
- L'evento newListener
Ogni volta che viene registrato un nuovo gestore di eventi, l'emettitore di eventi emette un evento newListener. Questo evento viene utilizzato per rilevare nuovi gestori di eventi. In genere si utilizza l'evento newListener quando è necessario allocare risorse o eseguire un'azione per ogni nuovo gestore di eventi.
var events = require('events');var eventEmitter = events.EventEmitter;var emitter = new eventEmitter();emitter.on("newListener", function(eventName, listener) {console.log("Added listener for " + eventName + " events");});emitter.on('data_received', function() {});emitter.on('data_received', function() {});
Spiegazione del codice: -
- Stiamo creando un nuovo gestore di eventi per l'evento "newListener". Pertanto, ogni volta che viene registrato un nuovo gestore di eventi, nella console verrà visualizzato il testo "Listener aggiunto per" + il nome dell'evento.
- Qui stiamo scrivendo sulla console il testo "Listener aggiunto per" + il nome dell'evento per ogni evento registrato.
- Stiamo definendo 2 gestori di eventi per il nostro evento "data_received".
Se il codice precedente viene eseguito correttamente, il testo seguente verrà visualizzato nella console. Mostra solo che il gestore di eventi "newListener" è stato attivato due volte.
Listener aggiunto per eventi data_received
Listener aggiunto per eventi data_received
Sommario
- I flussi vengono utilizzati in Node.js per leggere e scrivere dati dai dispositivi di input-output. Node.js utilizza la libreria "fs" per creare flussi leggibili e scrivibili sui file. Questi flussi possono essere utilizzati per leggere e scrivere dati dai file.
- I tubi possono essere utilizzati per collegare più flussi insieme. Uno degli esempi più comuni consiste nel convogliare insieme il flusso di lettura e scrittura per il trasferimento dei dati da un file all'altro.
- Node.js è spesso etichettato anche come framework basato su eventi ed è molto facile definire eventi in Node.js. Si possono definire funzioni che rispondono a questi eventi.
- Gli eventi espongono anche metodi per rispondere a eventi chiave. Ad esempio, abbiamo visto il gestore di eventi once () che può essere utilizzato per assicurarsi che una funzione di callback venga eseguita solo una volta quando viene attivato un evento.