Tutorial sui flussi di Node js: Filestream, Pipes
James Hartmann
Filestream in Node.js
Node fa ampio uso dei flussi come meccanismo di trasferimento dei dati.
Ad esempio, quando esegui l'output di qualcosa sulla console utilizzando la funzione console.log, stai effettivamente utilizzando un flusso per inviare i dati alla console.
Node.js ha anche la capacità di eseguire lo streaming di dati dai file in modo che possano essere letti e scritti in modo appropriato. Vedremo ora un esempio di come possiamo utilizzare i flussi per leggere e scrivere da file. Dobbiamo seguire i passaggi indicati di seguito per questo esempio
Passo 1) Crea un file chiamato data.txt che contiene i dati seguenti. Supponiamo che questo file sia archiviato nell'unità D del nostro computer locale.
Tutorial su Node.js
Introduzione
Eventi
Connettività dati
Usando il gelsomino
Passo 2) Scrivi 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: -
- Dobbiamo prima includere i moduli 'fs' che contengono tutte le funzionalità richieste per creare flussi.
- Successivamente creiamo un flusso leggibile utilizzando il metodo createReadStream. Come input forniamo la posizione del nostro file data.txt.
- La funzione steam.on è un gestore di eventi e in esso specifichiamo il primo parametro come "dati". Ciò significa che ogni volta che i dati arrivano nel flusso dal file, viene eseguita una funzione di callback. Nel nostro caso, stiamo definendo una funzione di callback che effettuerà 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 letto dal flusso di dati e convertendolo in una stringa.
- Infine, inviamo alla console l'output di ogni blocco convertito in stringa.
Produzione:
- Se il codice viene eseguito correttamente, vedrai l'output sopra nella console. Questo output sarà uguale a quello nel file data.txt.
Scrittura su un file
Allo stesso modo in cui 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 possiamo 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 forniamo 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. Lo stream 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
Generators
Connettività dati
utilizzando Jasmine
Pipe 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 facoltativo utilizzato per passare le opzioni.
Un tipico esempio di utilizzo delle 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 utilizzando le pipe.
Passo 1) Crea un file chiamato datainput.txt che contiene i dati seguenti. Supponiamo che questo file sia archiviato nell'unità D del nostro computer locale.
Tutorial su Node.js
Introduzione
Eventi
Generators
Connettività dati
Usando il gelsomino
Passo 2) Crea un file vuoto chiamato dataOutput.txt e posizionalo sull'unità D del tuo computer locale.
Passo 3) Scrivi il codice seguente per effettuare 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: -
- Stiamo innanzitutto 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 "writestream" nel nostro file dataOutput.txt, che è il nostro file vuoto ed è la destinazione per il trasferimento dei dati dal file datainput.txt.
- Utilizziamo quindi il comando pipe per trasferire i dati dal flusso di lettura al flusso di scrittura. Il comando pipe prenderà tutti i dati che entrano nel readstream e li invierà al writestream.
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 un 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 consiste nel creare funzioni che verranno attivate quando vengono attivati eventi specifici.
Diamo un'occhiata a un esempio base di definizione di un evento in Node.js.
Creeremo un evento chiamato "data_received". Quando viene attivato questo evento, 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: -
- Utilizza la funzione require per includere il modulo 'eventi'. 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. Ciò 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'esame 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 utilizzare il metodo once().
Vediamo come 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 nuovamente attivato, questa volta non accadrà nulla. Ciò è dovuto al primo passaggio in cui abbiamo detto che l'evento poteva essere attivato solo una volta.
Se il codice viene eseguito correttamente, l'output nel registro sarà "data_received con successo". 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ù ascoltatori ad esso collegati. Gli ascoltatori per ciascun tipo di evento possono essere controllati in diversi modi.
Se sei interessato solo a determinare il numero di ascoltatori collegati, 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 ulteriori ascoltatori.)
Spiegazione del codice: -
- Stiamo definendo un tipo eventEmitter richiesto per utilizzare i metodi relativi agli eventi.
- Stiamo quindi definendo un oggetto chiamato emettitore 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 invochi il metodo listenerCount sul nostro evento data_received, invierà il numero di listener di eventi allegati a questo evento nel registro della console.
Se il codice viene eseguito correttamente, il valore 2 verrà mostrato nel registro della console.
- Il nuovo evento Listener
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 eventi. In genere utilizzi l'evento newListener quando devi allocare risorse o eseguire alcune azioni per ogni nuovo gestore 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 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, nella console verrà visualizzato il testo seguente. Mostra semplicemente che il gestore eventi "newListener" è stato attivato due volte.
Aggiunto ascoltatore per eventi data_received
Aggiunto ascoltatore per eventi data_received
Sintesi
- I flussi vengono utilizzati in Node.js per leggere e scrivere dati dai dispositivi 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 da file.
- I tubi possono essere utilizzati per collegare più flussi insieme. Uno degli esempi più comuni è quello di convogliare insieme il flusso di lettura e scrittura per il trasferimento di dati da un file all'altro.
- Node.js è spesso contrassegnato anche come framework basato su eventi ed è molto semplice definire eventi in Node.js. È possibile definire funzioni che rispondono a questi eventi.
- Gli eventi espongono anche metodi per rispondere agli eventi chiave. Ad esempio, abbiamo visto il gestore di eventi once() che può essere utilizzato per garantire che una funzione di callback venga eseguita solo una volta quando viene attivato un evento.