Die Grundlagen von Node.js Streams

node.js, die asynchron und ereignisgesteuert sind, exzentiert bei I/O-gebundenen Operationen. Das Nutzung von Node.js -Streams vereinfacht diese Aufgaben erheblich, indem Daten in kleineren Stücken effizient verarbeitet werden. Lassen Sie uns in die Welt der Streams eintauchen und sehen, wie sie i/o rationalen

rationalisieren.

Schlüsselkonzepte:

node.js Streams, asynchron und ereignisgesteuert, optimieren Sie die E/A, indem Sie Daten in überschaubaren Teilen bearbeiten.
Streams werden als lesbar, beschreibbar oder Duplex (sowohl lesbar als auch beschreibbar) eingestuft. Lesbare Streams holen Daten aus einer Quelle; Beschreibbare Streams senden Daten an ein Ziel.
• pipe() Die
-Funktion ist von unschätzbarem Wert und erleichtert die nahtlose Datenübertragung zwischen Quelle und Ziel ohne manuelle Flussverwaltung.
• Readable.pause() Methoden wie Readable.resume(), readable.unpipe() und
bieten eine granulare Kontrolle über den Datenfluss und verbessert die Stream -Funktionalität.

Streams verstehen:

EventEmitter Streams sind analog zu UNIX -Rohren und ermöglichen mühelosen Datenübertragungen von Quelle zu Ziel. Im Wesentlichen ist ein Stream ein

mit speziellen Methoden. Die implementierten Methoden bestimmen, ob ein Stream lesbar, beschreibbar oder Duplex ist. Lesbare Streams liefern Dateneingaben. Beschreibbare Streams verwalten die Datenausgabe.

fs Sie haben wahrscheinlich bereits Streams in Node.js gestoßen. In einem HTTP -Server ist die Anforderung ein lesbarer Stream, und die Antwort ist ein beschreibbarer Stream. Das Modul

bietet sowohl lesbare als auch beschreibbare Dateistromfunktionen.

Dieser Artikel konzentriert sich auf lesbare und beschreibbare Streams. Duplexströme liegen außerhalb des Rahmens.

lesbare Streams:

EventEmitter Ein lesbarer Stream liest Daten aus einer Quelle (eine Datei, In-Memory-Puffer oder einen anderen Stream). Da sie

s sind, lösen sie verschiedene Ereignisse aus. Wir verwenden diese Ereignisse, um mit den Streams zu interagieren.

Lesen aus Streams:

data Der häufigste Ansatz besteht darin, auf das data -Ereignis zu hören und einen Rückruf anzuhängen. Wenn Daten verfügbar sind, feuert das Ereignis von

und führt den Rückruf aus.

const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');
let data = '';
readableStream.on('data', (chunk) => { data += chunk; });
readableStream.on('end', () => { console.log(data); });

fs.createReadStream() data erstellt einen lesbaren Stream. Zunächst statisch, fällt es beim Anbringen eines data Ereignishörers. Datenbrocken werden dann an den Rückruf übergeben. Die Häufigkeit von

Ereignissen wird durch die Stream -Implementierung bestimmt (z. B. kann eine HTTP -Anforderung ein Ereignis pro KB ausgeben, während ein Dateistrom pro Zeile ausgibt).

end Das Ereignis signalisiert das Ende der Daten.

Alternativ wiederholt auf der Stream -Instanz read() aufrufen, bis alle Daten gelesen werden:

const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');
let data = '';
readableStream.on('data', (chunk) => { data += chunk; });
readableStream.on('end', () => { console.log(data); });

read() ruft Daten aus dem internen Puffer ab. Es gibt null zurück, wenn keine Daten bestehen bleiben. Das Ereignis readable zeigt die Datenverfügbarkeit an.

Einstellung der Codierung:

Daten sind typischerweise ein Buffer Objekt. Verwenden Sie für Zeichenfolgen Readable.setEncoding():

const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');
let data = '';
let chunk;
readableStream.on('readable', () => {
  while ((chunk = readableStream.read()) !== null) {
    data += chunk;
  }
});
readableStream.on('end', () => { console.log(data); });

Diese interpretiert die Daten als UTF-8 und übergeben Sie sie als Zeichenfolge an den Rückruf.

Rohrleitungen:

Rohrleitungen vereinfacht die Datenübertragung zwischen Quelle und Ziel:

const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');
let data = '';
readableStream.setEncoding('utf8');
readableStream.on('data', (chunk) => { data += chunk; });
readableStream.on('end', () => { console.log(data); });

pipe() verarbeitet den Datenfluss automatisch.

Verkettung:

Streams können gekettet werden:

const fs = require('fs');
const readableStream = fs.createReadStream('file1.txt');
const writableStream = fs.createWriteStream('file2.txt');
readableStream.pipe(writableStream);

Dies dekomprimiert input.txt.gz und schreibt das Ergebnis in output.txt.

Zusätzliche lesbare Stream -Methoden:

• Readable.pause(): Pause den Stream.
• Readable.resume(): wieder aufnimmt einen pausierten Stream.
• readable.unpipe(): Entfernt Zielströme aus dem Rohr.

beschreibbare Streams:

beschreibbare Streams senden Daten an ein Ziel. Wie lesbare Streams sind sie EventEmitter s.

Schreiben in Streams:

Verwenden Sie write(), um Daten zu senden:

const fs = require('fs');
const zlib = require('zlib');
fs.createReadStream('input.txt.gz')
  .pipe(zlib.createGunzip())
  .pipe(fs.createWriteStream('output.txt'));

write() Gibt einen Booleschen zurück, der den Erfolg zeigt. Wenn falsch, ist der Stream vorübergehend voll; Warten Sie auf das Ereignis drain, bevor Sie mehr schreiben.

Datenende:

rufen Sie end() auf, um das Ende der Daten zu signalisieren. Das finish -Ereignis wird emittiert, nachdem alle Daten gespült sind. Sie können nicht schreiben, nachdem Sie end().

angerufen haben

Wichtige Ereignisse für beschreibbare Streams:

• error: Zeigt einen Fehler an.
• pipe: emittiert, wenn ein lesbarer Strom geleitet wird.
• unpipe: emittiert, wenn unpipe() auf dem lesbaren Stream aufgerufen wird.

Schlussfolgerung:

Streams sind ein leistungsstarkes Merkmal in Node.js, was die Effizienz der E/A verbessert. Das Verständnis von Streams, Rohrleitungen und Ketten ermöglicht das Schreiben von sauberem, performantem Code.

node.js Streams FAQ:

• Was sind Node.js -Streams?

• Haupttypen von Knoten.js Streams?

  lesbar, beschreibbar, Duplex und Transformation.

Erstellen eines lesbaren Streams?

• Gemeinsame Anwendungsfälle für lesbare Streams? stream.Readable _read

Erstellen eines beschreibbaren Streams?

• Häufige Verwendungen von beschreibbaren Streams? Daten in Dateien speichern, Daten an Dienste senden.

• Duplex -Stream? kombiniert lesbare und beschreibbare Funktionen.

• Transformationsströme?

• Rohrleitungsdaten zwischen Streams?

  Verwenden Sie die -Methode. .pipe()

Best Practices für die Arbeit mit Node.js-Streams?

Das obige ist der detaillierte Inhalt vonDie Grundlagen von Node.js Streams. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!