Streams in Node.js - Tutorial - Part 7

Understanding Streams in Node.js

Streams in Node.js are a powerful way to handle I/O operations efficiently, especially when working with large amounts of data. Instead of reading and writing data all at once, streams allow us to process it in chunks, which improves performance and reduces memory consumption.

Types of Streams

Node.js provides four types of streams:

Stream Type	Description	Example
Readable Streams	Used for reading data	Reading from a file
Writable Streams	Used for writing data	Writing to a file
Duplex Streams	Both readable and writable	Sockets
Transform Streams	A type of duplex stream where data can be modified as it is read or written	Compression

How Streams Work

Streams operate on events, which means they rely on listeners to respond when data is available, ready to be written, or an error occurs. Common events include:

• data: Emitted when a chunk of data is available.
• end: Emitted when there’s no more data to be consumed.
• error: Emitted if any error occurs during the streaming process.

Readable Stream Example

Let’s look at an example of reading a file using a readable stream:

const fs = require('fs');

const readableStream = fs.createReadStream('example.txt', { encoding: 'utf8' });

readableStream.on('data', (chunk) => {
  console.log('Received chunk:', chunk);
});

readableStream.on('end', () => {
  console.log('No more data.');
});

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

Writable Stream Example

Here’s how you can write to a file using a writable stream:

const fs = require('fs');

const writableStream = fs.createWriteStream('output.txt');

writableStream.write('Hello, Node.js streams!\n');
writableStream.end(); // Close the stream

writableStream.on('finish', () => {
  console.log('Finished writing.');
});

writableStream.on('error', (err) => {
  console.error('Error:', err);
});

Why Use Streams?

Streams help in processing large amounts of data efficiently. For example, when working with files, streams allow you to avoid loading the entire file into memory. This is particularly useful when handling media files, big datasets, or data from HTTP requests.

Final Tips

• Always handle stream errors using the error event to avoid crashes.
• Use pipes to easily connect readable streams to writable streams.

readableStream.pipe(writableStream);

Streams are perfect for working with I/O-heavy applications, and they make it easier to manage memory when processing large datasets.

---

Thank you for reading, and happy coding! 🎉