Streams in Node.js verstehen – Effiziente Datenverarbeitung

Streams sind eine leistungsstarke Funktion in Node.js, die den effizienten Umgang mit großen Datenmengen ermöglicht, indem sie Stück für Stück verarbeitet werden, anstatt alles auf einmal in den Speicher zu laden. Sie sind besonders nützlich für den Umgang mit großen Dateien, Echtzeitdaten oder sogar Netzwerkverbindungen. In diesem Artikel tauchen wir tief in die Node.js-Streams ein und behandeln die Arten von Streams, deren Verwendung anhand von Codebeispielen und einen Anwendungsfall aus der Praxis, um Ihr Verständnis zu festigen.

Was sind Streams?

Ein Stream ist eine Folge von Daten, die im Laufe der Zeit verarbeitet werden. In Node.js sind Streams Instanzen von EventEmitter, was bedeutet, dass sie Ereignisse ausgeben und darauf reagieren können. Streams ermöglichen das Lesen und Schreiben von Daten in Blöcken (kleinen Teilen), anstatt alle Daten auf einmal zu laden, was sie speichereffizient und schneller macht.

Warum Streams verwenden?

• Effiziente Speichernutzung: Streams verarbeiten Daten in Blöcken, sobald sie ankommen, ohne dass der gesamte Datensatz in den Speicher geladen werden muss.
• Schnellere Verarbeitung: Sie beginnen mit der Datenverarbeitung, sobald sie verfügbar sind, anstatt darauf zu warten, dass alles geladen ist.
• Nicht blockierende E/A: Da Streams asynchron arbeiten, blockieren sie keine anderen Vorgänge, was sie ideal für Echtzeitanwendungen macht.

Arten von Streams

Node.js bietet vier Arten von Streams:

1. Lesbare Streams: Wird zum sequentiellen Lesen von Daten verwendet.
2. Beschreibbare Streams: Werden zum sequentiellen Schreiben von Daten verwendet.
3. Duplex-Streams: Können sowohl lesbar als auch beschreibbar sein.
4. Streams transformieren: Ein Duplex-Stream, bei dem die Ausgabe eine Transformation der Eingabe ist.

Lassen Sie uns jeden Stream-Typ anhand von Beispielen untersuchen.

Lesbare Streams

Mit einem lesbaren Stream können Sie Daten Stück für Stück aus einer Quelle wie einer Datei oder einer Netzwerkanforderung konsumieren.

Beispiel: Lesen einer Datei mithilfe eines lesbaren Streams

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('example.txt', 'utf8');

// Listen for 'data' events to read chunks of data
readableStream.on('data', (chunk) => {
  console.log('New chunk received:');
  console.log(chunk);
});

// Handle 'end' event when the file has been completely read
readableStream.on('end', () => {
  console.log('File reading completed.');
});

// Handle any errors
readableStream.on('error', (err) => {
  console.error('Error reading file:', err.message);
});

Erklärung:

• fs.createReadStream() erstellt einen Stream zum Lesen des Inhalts von example.txt.
• Der Stream gibt „Daten“-Ereignisse für jeden gelesenen Block aus und ein „End“-Ereignis, wenn er mit dem Lesen fertig ist.

Beschreibbare Streams

Schreibbare Streams werden verwendet, um Daten Stück für Stück zu schreiben, beispielsweise um Daten in einer Datei zu speichern.

Beispiel: Schreiben von Daten in eine Datei mithilfe eines beschreibbaren Streams

const fs = require('fs');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Write chunks of data to the file
writableStream.write('First chunk of data.\n');
writableStream.write('Second chunk of data.\n');

// End the stream
writableStream.end('Final chunk of data.');

// Handle 'finish' event when writing is complete
writableStream.on('finish', () => {
  console.log('Data writing completed.');
});

// Handle any errors
writableStream.on('error', (err) => {
  console.error('Error writing to file:', err.message);
});

Erklärung:

• fs.createWriteStream() erstellt einen beschreibbaren Stream zum Schreiben in „output.txt“.
• Die Methode write() wird verwendet, um Datenblöcke an den Stream zu senden. Sobald alle Daten geschrieben sind, wird die end()-Methode aufgerufen und signalisiert, dass der Stream beendet werden soll.

Duplex-Streams

Duplex-Streams können Daten sowohl lesen als auch schreiben und werden für Vorgänge wie Netzwerkprotokolle verwendet, bei denen Sie Daten senden und empfangen müssen.

Beispiel: Benutzerdefinierter Duplex-Stream

const { Duplex } = require('stream');

// Create a custom duplex stream
const myDuplexStream = new Duplex({
  read(size) {
    this.push('Reading data...');
    this.push(null);  // No more data to read
  },
  write(chunk, encoding, callback) {
    console.log(`Writing: ${chunk.toString()}`);
    callback();
  }
});

// Read from the stream
myDuplexStream.on('data', (chunk) => {
  console.log(chunk.toString());
});

// Write to the stream
myDuplexStream.write('This is a test.');
myDuplexStream.end();

Erklärung:

• Duplex-Streams können sowohl Lese- als auch Schreibvorgänge ausführen. Im Beispiel definieren wir benutzerdefinierte Lese- und Schreibmethoden für den Duplex-Stream.

Streams transformieren

Transformationsströme ermöglichen es Ihnen, die Daten während der Übertragung zu ändern oder umzuwandeln. Sie sind eine besondere Art von Duplex-Stream.

Beispiel: Ein einfacher Transformationsstream in Großbuchstabentext

const { Transform } = require('stream');

// Create a custom transform stream
const toUpperCaseTransform = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

// Pipe data through the transform stream
process.stdin.pipe(toUpperCaseTransform).pipe(process.stdout);

Erklärung:

• Transformationsstreams nehmen Eingaben entgegen, verarbeiten sie (in diesem Fall wandeln sie Text in Großbuchstaben um) und geben die geänderten Daten aus.
• In diesem Beispiel werden Daten von der Standardeingabe (process.stdin) durch den Transformationsstream geleitet und das Ergebnis an die Konsole ausgegeben (process.stdout).

Rohrleitungsströme

Eine der gebräuchlichsten Methoden, mit Streams zu arbeiten, besteht darin, sie zusammenzuführen. Dies bedeutet, dass Daten von einem Stream an einen anderen übertragen werden. Dies ist nützlich, wenn Sie Daten Schritt für Schritt verarbeiten müssen, z. B. aus einer Datei lesen und in eine andere Datei schreiben.

Beispiel: Weiterleiten eines lesbaren Streams an einen beschreibbaren Stream

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('input.txt');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Pipe the readable stream into the writable stream
readableStream.pipe(writableStream);

// Handle 'finish' event when piping is done
writableStream.on('finish', () => {
  console.log('File copied successfully.');
});

Erklärung:

• Die Methode „pipe()“ übergibt Daten vom lesbaren Stream (input.txt) direkt an den beschreibbaren Stream (output.txt).

Realer Anwendungsfall: Streaming eines großen Datei-Uploads

In realen Anwendungen müssen Sie möglicherweise große Dateien auf den Server hochladen. Anstatt die gesamte Datei in den Speicher zu laden, können Sie Streams verwenden, um Datei-Uploads effizient abzuwickeln.

Beispiel: Hochladen einer Datei mithilfe von Streams mit Node.js und Multer

const express = require('express');
const multer = require('multer');
const fs = require('fs');

const app = express();
const upload = multer({ dest: 'uploads/' });

app.post('/upload', upload.single('file'), (req, res) => {
  const readableStream = fs.createReadStream(req.file.path);
  const writableStream = fs.createWriteStream(`./uploads/${req.file.originalname}`);

  // Pipe the uploaded file to the writable stream
  readableStream.pipe(writableStream);

  writableStream.on('finish', () => {
    res.send('File uploaded and saved.');
  });

  writableStream.on('error', (err) => {
    res.status(500).send('Error saving file.');
  });
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

Explanation:

• We use multer to handle file uploads. When the file is uploaded, it is piped from a temporary location to the desired directory on the server.
• This method is efficient as it streams the file data instead of holding it all in memory at once.

Best Practices for Working with Streams

1. Error Handling: Always handle errors in streams to avoid unhandled exceptions, especially when dealing with file systems or network operations.

Example:

   readableStream.on('error', (err) => {
     console.error('Stream error:', err.message);
   });

1. Flow Control: Be mindful of flow control when reading and writing data, as writable streams can become overwhelmed if data is being written faster than it can be consumed.

Example:

   writableStream.write(chunk, (err) => {
     if (err) console.error('Error writing chunk:', err.message);
   });

1. Use Pipe for Simplicity: When transferring data between streams, always prefer using pipe() instead of manually managing the flow of data.

Conclusion

Streams in Node.js offer a powerful and efficient way to handle data, especially in cases where data comes in large quantities or needs to be processed incrementally. From reading and writing files to handling network requests and processing data in real time, streams allow you to build scalable and performant applications. In this article, we explored the different types of streams, how to use them, and real-world use cases to deepen your understanding of stream-based processing in Node.js.

Das obige ist der detaillierte Inhalt vonStreams in Node.js verstehen – Effiziente Datenverarbeitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!