DEV Community

Abdelhakim mohamed
Abdelhakim mohamed

Posted on

2

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);
});
Enter fullscreen mode Exit fullscreen mode

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);
});
Enter fullscreen mode Exit fullscreen mode

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);
Enter fullscreen mode Exit fullscreen mode

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! 🎉

SurveyJS custom survey software

Simplify data collection in your JS app with a fully integrated form management platform. Includes support for custom question types, skip logic, integrated CCS editor, PDF export, real-time analytics & more. Integrates with any backend system, giving you full control over your data and no user limits.

Learn more

Top comments (0)

A Workflow Copilot. Tailored to You.

Pieces.app image

Our desktop app, with its intelligent copilot, streamlines coding by generating snippets, extracting code from screenshots, and accelerating problem-solving.

Read the docs

👋 Kindness is contagious

Please leave a ❤️ or a friendly comment on this post if you found it helpful!

Okay