Node.js Streams: FileStream, Pipes & Events

⚡ Intelligente Zusammenfassung

Node.js-Streams lesen und schreiben Daten in kleinen Blöcken, anstatt ganze Dateien in den Speicher zu laden. Diese Seite erklärt die Erstellung von Dateistreams, die Verkettung von Pipes, die Behandlung von Gegendruck und das Ereignismodell, das für einen effizienten Datentransfer im großen Maßstab sorgt.

  • ???? Stream-Typen: Node.js organisiert jeden Stream als lesbar, beschreibbar, duplex oder transformierbar, und jede Node.js-API gibt einen dieser vier Typen zurück.
  • 📂 Dateistream: fs.createReadStream() und fs.createWriteStream() lesen und schreiben Dateien in Blöcken, ohne die gesamte Datei in den Speicher zu laden.
  • 🔗 Piping: Die pipe()-Methode verbindet einen lesbaren Datenstrom direkt mit einem beschreibbaren Datenstrom und verschiebt Daten automatisch zwischen ihnen.
  • ️ Gegendruck: Die Funktion write() gibt false zurück, wenn ihr Puffer voll ist, und das Drain-Ereignis signalisiert, wann das Schreiben wieder sicher fortgesetzt werden kann.
  • 📡 Stream-Ereignisse: data, end, error und finish markieren die Schlüsselmomente im Lebenszyklus eines Datenstroms und sind die Grundlage für den Großteil des Codes zur Datenstromverarbeitung.
  • ⚡ Benutzerdefinierte Ereignisse: Das Ereignismodul und der EventEmitter ermöglichen es jeder Node.js-Anwendung, eigene benannte Ereignisse zu definieren, auszugeben und darauf zu reagieren.
  • ️ Zuhörersteuerung: once(), listenerCount() und das newListener-Ereignis steuern, wie oft ein Handler ausgeführt wird und wie Listener behandelt werden. tracked.

Stream-Typen in Node.js

Jeder von Node.js bereitgestellte Stream lässt sich einem von vier Basistypen zuordnen. Kennt man den Rückgabetyp einer bestimmten API, ist das Verhalten des Streams bereits vor der eigentlichen Programmierung bekannt. Das mit Node.js ausgelieferte Stream-Modul definiert diese Kategorien, und die in diesem Artikel verwendeten Datei-, Netzwerk- und Komprimierungs-APIs basieren darauf.

Stream-Typ Datenrichtung Beispiel-API Häufiger Anwendungsfall
Readable Nur Quelle (Daten fließen aus) fs.createReadStream() Eine Datei wird gelesen, ein HTTP-Anfragetext wird empfangen
Beschreibbar Nur Ziel (Daten fließen hinein) fs.createWriteStream() eine Datei schreiben, eine HTTP-Antwort senden
Duplex In beide Richtungen, unabhängig voneinander net.Socket (TCP-Socket) Zwei-Wege-Netzwerkkommunikation
Transformieren In beiden Richtungen werden die Daten während der Übertragung verändert. zlib.createGzip() Komprimierung oder Kodierung von Daten mitten in der Pipeline

Ein lesbarer und ein beschreibbarer Datenstrom sind die beiden Bausteine, die in diesem Artikel verwendet werden; beide treiben auch ein HTTP-Webserver in Node.js. Ein Duplex-Stream kombiniert beide Rollen in einem Objekt, während ein Transformations-Stream ein Duplex-Stream ist, dessen Ausgabe seine Eingabe verändert, wie zum Beispiel die mitten im Stream angewendete gzip-Komprimierung.

Filestream in Node.js

Nachdem die vier Stream-Kategorien definiert wurden, wird im Folgenden ein Dateitransfer unter Verwendung der lesbaren und beschreibbaren Stream-APIs beschrieben.

Der Knoten nutzt Streams in großem Umfang als Datenübertragungsmechanismus.

Wenn Sie beispielsweise mit der Funktion console.log etwas an die Konsole ausgeben, verwenden Sie tatsächlich einen Stream, um die Daten an die Konsole zu senden.

Node.js bietet außerdem die Möglichkeit, Daten aus Dateien zu streamen, sodass diese entsprechend gelesen und geschrieben werden können. Wir werden uns nun ein Beispiel ansehen, wie wir Streams zum Lesen und Schreiben von Dateien verwenden können. Für dieses Beispiel müssen wir die unten aufgeführten Schritte befolgen

Schritt 1) Erstellen Sie eine Datei mit dem Namen data.txt, die die folgenden Daten enthält. Nehmen wir an, diese Datei ist auf dem Laufwerk D unseres lokalen Computers gespeichert.

Tutorial zu Node.js

Einführung

VERANSTALTUNGEN

Generatoren

Datenkonnektivität

Jasmin verwenden

Schritt 2) Schreiben Sie den entsprechenden Code, der Streams zum Lesen von Daten aus der Datei verwendet.

Filestream in Node.js

var fs = require("fs");
var stream;
stream = fs.createReadStream("D://data.txt");

stream.on("data", function(data) {
    var chunk = data.toString();
    console.log(chunk);
}); 

Code Erläuterung:-

  1. Zuerst müssen wir die „fs“-Module einbinden, die alle zum Erstellen von Streams erforderlichen Funktionen enthalten.
  2. Als nächstes erstellen wir mit der Methode createReadStream einen lesbaren Stream. Als Eingabe geben wir den Speicherort unserer Datei data.txt an.
  3. Die Steam.on-Funktion ist ein Event-Handler und darin geben wir den ersten Parameter als „Daten“ an. Dies bedeutet, dass immer dann, wenn Daten aus der Datei in den Stream eingehen, eine Rückruffunktion ausgeführt wird. In unserem Fall definieren wir eine Callback-Funktion, die zwei grundlegende Schritte ausführt. Die erste besteht darin, die aus der Datei gelesenen Daten in eine Zeichenfolge zu konvertieren. Die zweite wäre, die konvertierte Zeichenfolge als Ausgabe an die Konsole zu senden.
  4. Wir nehmen jeden Datenblock, der aus dem Datenstrom gelesen wird, und wandeln ihn in einen String um.
  5. Schließlich senden wir die Ausgabe jedes String-konvertierten Blocks an die Konsole.

Ausgang:

Filestream in Node.js

  • Wenn der Code ordnungsgemäß ausgeführt wird, sehen Sie die obige Ausgabe in der Konsole. Diese Ausgabe ist dieselbe wie die in der Datei data.txt.

In eine Datei schreiben

Auf die gleiche Weise, wie wir einen Lesestream erstellen, können wir auch einen Schreibstream erstellen, um Daten in eine Datei zu schreiben. Erstellen wir zunächst eine leere Datei ohne Inhalt mit dem Namen data.txt. Nehmen wir an, diese Datei befindet sich auf dem Laufwerk D unseres Computers.

Der folgende Code zeigt, wie wir Daten in die Datei schreiben können.

Filestream in Node.js

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") 

Code Erläuterung:-

  1. Wir erstellen einen beschreibbaren Stream mithilfe der Methode – createWriteStream. Als Eingabe geben wir den Speicherort unserer data.txt-Datei an.
  2. Als nächstes haben wir die Methode stream.write verwendet, um die verschiedenen Textzeilen in unsere Textdatei zu schreiben. Der Stream kümmert sich darum, diese Daten in die Datei data.txt zu schreiben.

Wenn Sie die Datei data.txt öffnen, sehen Sie nun folgende Daten in der Datei

Tutorial zu Node.js

Einführung

VERANSTALTUNGEN

Generatoren

Datenkonnektivität

Die Verwendung von Jasmin

Pipes in Node.js

Das unabhängige Lesen und Schreiben von Datenströmen ist nützlich, aber Node.js ermöglicht es auch, einen lesbaren Datenstrom direkt mit einem beschreibbaren Datenstrom zu verbinden und so Daten ohne manuellen Pufferungscode zu übertragen.

Innerhalb von Node-Anwendungen können Streams mithilfe der Methode „pipe()“ zusammengeleitet werden, die zwei Argumente benötigt:

  • Ein erforderlicher beschreibbarer Stream, der als Ziel für die Daten fungiert und
  • Ein optionales Objekt, das zur Übergabe von Optionen verwendet wird.

Ein typisches Beispiel für die Verwendung von Pipes, wenn Sie Daten von einer Datei in eine andere übertragen möchten.

Sehen wir uns also ein Beispiel an, wie wir mithilfe von Pipes Daten von einer Datei in die andere übertragen können.

Schritt 1) Erstellen Sie eine Datei mit dem Namen datainput.txt, die die folgenden Daten enthält. Nehmen wir an, diese Datei ist auf dem Laufwerk D unseres lokalen Computers gespeichert.

Tutorial zu Node.js

Einführung

VERANSTALTUNGEN

Generatoren

Datenkonnektivität

Jasmin verwenden

Schritt 2) Erstellen Sie eine leere Datei mit dem Namen dataOutput.txt und legen Sie sie auf dem Laufwerk D Ihres lokalen Computers ab.

Schritt 3) Schreiben Sie den folgenden Code, um die Übertragung von Daten aus der Datei datainput.txt in die Datei dataOutput.txt durchzuführen.

Pipes in Node.js

var fs = require("fs");
var readStream = fs.createReadStream("D://datainput.txt");
var writeStream = fs.createWriteStream("D://dataOutput.txt");
readStream.pipe(writeStream);

Code Erläuterung:-

  1. Wir erstellen zunächst einen „Readstream“ zu unserer datainput.txt-Datei, der alle unsere Daten enthält, die in die neue Datei übertragen werden müssen.
  2. Anschließend müssen wir einen „Writestream“ für unsere Datei „dataOutput.txt“ erstellen, die unsere leere Datei ist und das Ziel für die Übertragung von Daten aus der Datei „datainput.txt“ darstellt.
  3. Anschließend verwenden wir den Pipe-Befehl, um die Daten vom Lesestream zum Schreibstream zu übertragen. Der Pipe-Befehl nimmt alle Daten, die in den Lesestream gelangen, und schiebt sie an den Schreibstream.

Wenn Sie nun die Datei dataOutput.txt öffnen, sehen Sie alle Daten, die in der Datei datainput.txt vorhanden waren.

Stream-Ereignisse und Gegendruck in Node.js

Der Aufruf von pipe(), wie oben gezeigt, verbirgt zwei Mechanismen, die bei großem Umfang wichtig sind: die Ereignisse, die jeder Datenstrom ausgibt, und das Gegendrucksystem, das verhindert, dass eine schnelle Quelle ein langsames Ziel überlastet.

  • Daten: wird von einem lesbaren Datenstrom ausgegeben, sobald ein neuer Datenblock verfügbar ist.
  • Ende: Wird ausgelöst, sobald ein lesbarer Datenstrom seinen letzten Teil geliefert hat.
  • Fertig: Wird von einem beschreibbaren Datenstrom ausgegeben, sobald alle in der Warteschlange befindlichen Daten gesendet wurden.
  • Fehler: Wird bei einem Fehler von einem der beiden Stream-Typen ausgelöst; muss immer behandelt werden, da es sonst zu einem Prozessabsturz kommt.

Das unten stehende Beispiel überwacht alle vier Ereignisse und steuert den Gegendruck manuell – genau das Verhalten, das pipe() automatisch bietet.

var fs = require("fs");
var readStream = fs.createReadStream("D://data.txt");
var writeStream = fs.createWriteStream("D://dataOutput.txt");

readStream.on("data", function(chunk) {
    var ok = writeStream.write(chunk);
    if (!ok) {
        readStream.pause();
    }
});

writeStream.on("drain", function() {
    readStream.resume();
});

readStream.on("end", function() {
    writeStream.end();
});

writeStream.on("finish", function() {
    console.log("Write completed.");
});

readStream.on("error", function(err) {
    console.log(err);
});

Gegendruck entsteht, wenn ein lesbarer Datenstrom schneller Daten erzeugt, als ein beschreibbarer Datenstrom sie verarbeiten kann. Die Methode `write()` gibt `false` zurück, sobald ihr Puffer voll ist. Daher pausiert der obige Code die Quelle, bis das Ziel ein Drain-Ereignis ausgibt und somit signalisiert, dass die Verarbeitung fortgesetzt werden kann. `pipe()` führt diesen Zyklus automatisch aus.

⚠ Tipp: Im Produktionsbetrieb ist die pipeline()-Funktion aus dem Stream-Modul einer manuellen pipe()-Kette vorzuziehen, da sie Fehler von jedem Stream weiterleitet und Dateihandles automatisch schließt.

Ereignisse in Node.js

Streams sind ein Beispiel für das umfassendere ereignisgesteuerte Design von Node.js. Im Folgenden wird die Funktionsweise von Ereignissen im Allgemeinen anhand der EventEmitter-Klasse erläutert, auf die auch Streams intern zurückgreifen.

Ereignisse sind eines der Schlüsselkonzepte in Node.js und manchmal wird Node.js als ereignisgesteuertes Framework bezeichnet.

Im Grunde ist ein Ereignis etwas, das passiert. Wenn beispielsweise eine Verbindung zu einer Datenbank hergestellt wird, wird das Datenbankverbindungsereignis ausgelöst. Bei der ereignisgesteuerten Programmierung geht es darum, Funktionen zu erstellen, die ausgelöst werden, wenn bestimmte Ereignisse ausgelöst werden.

Schauen wir uns ein einfaches Beispiel für die Definition eines Ereignisses in Node.js an.

Wir werden ein Ereignis namens „data_received“ erstellen. Wenn dieses Ereignis ausgelöst wird, wird der Text „Daten empfangen“ an die Konsole gesendet.

Ereignisse in Node.js

var events = require('events');
var eventEmitter = new events.EventEmitter();
eventEmitter.on('data_received', function() {
    console.log('data received succesfully.');
});

eventEmitter.emit('data_received'); 

Code Erläuterung:-

  1. Verwenden Sie die Funktion „require“, um das Modul „events“ einzubinden. Mit diesem Modul können Sie Ereignisse in Node.js erstellen.
  2. Erstellen Sie einen neuen Ereignisemitter. Dies wird verwendet, um das Ereignis, das in unserem Fall „data_received“ ist, an eine Rückruffunktion zu binden, die in Schritt 3 definiert wird.
  3. Wir definieren eine ereignisgesteuerte Funktion, die besagt, dass wir, falls das Ereignis „data_received“ ausgelöst wird, den Text „data_received“ an die Konsole ausgeben sollen.
  4. Schließlich haben wir einen manuellen Auslöser unseres Ereignisses mithilfe der Funktion eventEmiter.emit. Dadurch wird das data_received-Ereignis ausgelöst.

Wenn das Programm ausgeführt wird, wird der Text „Daten empfangen“ wie unten gezeigt an die Konsole gesendet.

Ereignisse in Node.js

Ereignisse ausgeben

Neben dem Auslösen und Empfangen von Ereignissen bietet Node.js zusätzliche Methoden zur Steuerung der Registrierung und Überprüfung von Listenern.

Bei der Definition von Ereignissen gibt es verschiedene Methoden für Ereignisse, die aufgerufen werden können. In diesem Thema geht es darum, jeden einzelnen davon im Detail zu betrachten.

  1. Einmalige Event-Handler

Manchmal möchten Sie möglicherweise nur auf ein Ereignis reagieren, wenn es zum ersten Mal auftritt. In diesen Situationen können Sie die Methode Once() verwenden.

Sehen wir uns an, wie wir die Once-Methode für Event-Handler nutzen können.

Ereignisse ausgeben

Code Erläuterung:-

  1. Hier verwenden wir die Methode „once“, um zu sagen, dass die Callback-Funktion für das Ereignis „data_received“ nur einmal ausgeführt werden soll.
  2. Hier lösen wir manuell das Ereignis „data_received“ aus.
  3. Wenn das Ereignis „data_received“ erneut ausgelöst wird, passiert dieses Mal nichts. Dies liegt daran, dass wir im ersten Schritt gesagt haben, dass das Ereignis nur einmal ausgelöst werden kann.

Wenn der Code ordnungsgemäß ausgeführt wird, lautet die Ausgabe im Protokoll „data_received erfolgreich“. Diese Meldung wird nur einmal in der Konsole angezeigt.

  1. Überprüfen von Ereignis-Listenern

Zu jedem Zeitpunkt seiner Lebensdauer können einem Ereignisemitter null oder mehr Listener zugeordnet sein. Die Listener für jeden Ereignistyp können auf verschiedene Arten überprüft werden.

Wenn Sie nur die Anzahl der angeschlossenen Listener ermitteln möchten, ist die Methode EventEmitter.listenerCount() genau das Richtige für Sie.

(Hinweis: Zuhörer sind wichtig, da das Hauptprogramm wissen sollte, ob Zuhörer spontan zu einem Ereignis hinzugefügt werden. Andernfalls kommt es zu Fehlfunktionen des Programms, da zusätzliche Zuhörer aufgerufen werden.)

Ereignisse ausgeben

Code Erläuterung:-

  1. Wir definieren einen eventEmitter-Typ, der für die Verwendung der ereignisbezogenen Methoden erforderlich ist.
  2. Anschließend definieren wir ein Objekt namens Emitter, das zur Definition unserer Event-Handler verwendet wird.
  3. Wir erstellen zwei Event-Handler, die im Grunde nichts tun. In unserem Beispiel ist dies einfach gehalten, nur um zu zeigen, wie die Methode listenerCount funktioniert.
  4. Wenn Sie nun die Methode listenerCount für unser data_received-Ereignis aufrufen, wird die Anzahl der an dieses Ereignis angehängten Ereignis-Listener im Konsolenprotokoll gesendet.

Wenn der Code ordnungsgemäß ausgeführt wird, wird im Konsolenprotokoll der Wert 2 angezeigt.

  1. Das newListener-Ereignis

Jedes Mal, wenn ein neuer Ereignishandler registriert wird, gibt der Ereignisemitter ein newListener-Ereignis aus. Dieses Ereignis wird verwendet, um neue Ereignishandler zu erkennen. Normalerweise verwenden Sie das Ereignis newListener, wenn Sie Ressourcen zuweisen oder eine Aktion für jeden neuen Ereignishandler ausführen müssen.

Ereignisse ausgeben

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() {}); 

Code Erläuterung:-

  1. Wir erstellen einen neuen Eventhandler für das „newListener“-Ereignis. Immer wenn ein neuer Eventhandler registriert wird, wird in der Konsole der Text „Listener für hinzugefügt“ + der Ereignisname angezeigt.
  2. Hier schreiben wir in die Konsole den Text „Hinzugefügter Listener für“ + den Ereignisnamen für jedes registrierte Ereignis.
  3. Wir definieren zwei Event-Handler für unser Event „data_received“.

Wenn der obige Code ordnungsgemäß ausgeführt wird, wird der folgende Text in der Konsole angezeigt. Es zeigt lediglich, dass der Ereignishandler „newListener“ zweimal ausgelöst wurde.

Listener für data_received-Ereignisse hinzugefügt

Listener für data_received-Ereignisse hinzugefügt

Häufig gestellte Fragen

`fs.readFile()` lädt eine gesamte Datei in den Speicher, bevor sie zurückgegeben wird, während `fs.createReadStream()` die Datei in kleinen Teilen liefert, sobald diese eintreffen. Streams benötigen deutlich weniger Speicher für große Dateien und ermöglichen es, die Verarbeitung zu starten, bevor der Lesevorgang abgeschlossen ist.

Ja. Rufen Sie `.pipe()` einmal pro Ziel auf, z. B. `readStream.pipe(destinationA)` gefolgt von `readStream.pipe(destinationB)`. Node.js liefert dieselben Datenblöcke an jedes Ziel, und jeder beschreibbare Stream verwaltet seinen eigenen Gegendruck weiterhin unabhängig.

Ja. Leiten Sie einen lesbaren Datenstrom durch einen Transformationsstrom wie z. B. zlib.createGzip() und anschließend in einen beschreibbaren Datenstrom: readStream.pipe(zlib.createGzip()).pipe(writeStream). Die Datei wird während des Datenstroms komprimiert, ohne dass die gesamte Datei jemals in den Speicher geladen wird.

Sie können zwar schnell funktionierenden readStream- und Pipe-Code erstellen, vernachlässigen aber häufig die Fehlerbehandlung und die Gegendruckbehandlung. Überprüfen Sie daher KI-generierten Stream-Code vor dem Produktiveinsatz immer auf diese beiden Lücken.

Sie können mögliche Ursachen vorschlagen, wie etwa einen fehlenden Drain-Listener oder ein unbehandeltes Fehlerereignis, aber die Bestätigung der tatsächlichen Ursache erfordert immer noch eine manuelle Überprüfung des Stream-Status und der Anwendungsprotokolle.

Fassen Sie diesen Beitrag mit folgenden Worten zusammen: