Streams are used in Node.js to efficiently process large amounts of data. There are four types of streams: readable, writable, duplex, and transform. Readable streams are used to read data from a source, writable streams write to a destination, duplex streams both read and write, and transform streams modify data as it flows through. Streams allow data to be processed sequentially in chunks rather than all at once, making them useful for large datasets and network connections.

1. Streams in Node.js
One of the critical features of Node.js is its ability to handle streams, which are
used to efficiently process large amounts of data in real-time. In simple terms,
a stream is a sequence of data that is continuously flowing from one point to
another. In Node.js, streams are objects that facilitate the efficient processing
of large amounts of data in a non-blocking and event-driven way.
What are Streams?
Streams are a way of handling input and output data in Node.js. They allow
data to be read or written in small chunks, rather than loading the entire file
or data set into memory. This can be particularly useful for large data sets or
network connections, where loading everything into memory at once could
cause performance issues.
Streams are based on the concept of a sequence of data elements that are
processed one at a time. A stream is essentially a sequence of chunks of data,
which can be read or written in a sequential manner. Streams can be used to
read or write data from files, network sockets, or even memory buffers.
Streams in Node.js can be classified into four types: Readable, Writable,
Duplex, and Transform streams.
Readable streams in Node.js
As the name suggests, a Readable stream is used to read data from a source.
For example, you can use a Readable stream to read data from a file, a

2. network socket, or a database. A Readable stream emits events such as ‘data’,
‘end’, and ‘error’, which you can listen to in order to handle the data being
read.
Writable streams in Node.js
A Writable stream is used to write data to a destination.
Writable stream is a mechanism that allows data to be written to a destination.
For example, you can use a Writable stream to write data to a file, a network
socket, or a database. A Writable stream also emits events such as ‘drain’,
‘finish’, and ‘error’, which you can listen to in order to handle the data being
written.
Duplex streams in Node.js
A Duplex stream is a combination of a Readable and a Writable stream. It
allows you to read data from a source and write data to a destination at the
same time. Duplex streams can be useful for applications that require
bidirectional communication, such as chat applications or real-time games.
Transform streams in Node.js
A Transform stream is a type of Duplex stream that can be used to modify data
as it flows through the stream. For example, you can use a Transform stream
to compress data, encrypt data, or convert data from one format to another.
Why are streams important?

3. Streams are important for building efficient and scalable applications because
they allow you to process large amounts of data in small chunks, without
loading the entire dataset into memory. This is particularly useful for
applications that deal with large files or real-time data streams.
In addition, streams are non-blocking and event-driven, which means that
they can run concurrently with other parts of your application. This allows you
to build applications that can handle multiple requests at the same time,
without being slowed down by I/O operations.
How to use streams in Node.js
Using streams in Node.js is straightforward. To create a stream, you first need
to import the ‘stream’ module:
const stream = require('stream');
Once you have the stream module imported, you can create a stream by
instantiating one of the four types of ‘streams’:
const readableStream = new stream.Readable();
const writableStream = new stream.Writable();
const duplexStream = new stream.Duplex();
const transformStream = new stream.Transform();
After creating a stream, you can use methods such as ‘read’, ‘write’, ‘pipe’, and
‘end’ to interact with the data. For example, you can use the ‘write’ method to
write data to a writable stream:

4. writableStream.write('Hello, World!');
You can also use the ‘pipe’ method to transfer data from a readable stream to a
writable stream:
readableStream.pipe(writableStream);
Examples
Here are some examples of how you can use streams in Node.js:
Reading a File in Nodejs
To read a file using a readable stream, you can use the fs module to create a
readable stream:
const fs = require('fs');
const readableStream = fs.createReadStream('input.txt');
readableStream.on('data', function(chunk) {
console.log(chunk)
This code reads a file named ‘input.txt’ and creates a readable stream from it.
The on method is used to listen for the ‘data’ event, which is emitted each time
a chunk of data is read from the stream.
Writing to a File in Nodejs
To write data to a file using a writable stream, you can use the fs module to
create a writable stream:

5. const fs = require('fs');
const writableStream = fs.createWriteStream('output.txt');
writableStream.write('Hello, World!');
Output
Hello World!
This code creates a writable stream to a file named ‘output.txt’ and writes the
string ‘’Hello, World!’’ to it.
Transforming Data in Nodejs
To transform data using a transform stream, you can create a custom
transform stream that modifies the data as it is being read or written. Here is
an example:
const stream = require('stream');
class UpperCaseTransform extends stream.Transform
Piping or chaining streams in Nodejs
Piping or chaining streams is a way to connect multiple streams together so
that the output of one stream becomes the input of the next stream, creating a
data processing pipeline. This can be very useful when working with large
amounts of data or when performing complex data transformations.

6. In Node.js, streams are a powerful and flexible way to handle data processing,
allowing you to read and write data in chunks, rather than loading it all into
memory at once. Streams can be piped together using the ‘pipe()’ method.
Here is an example of how to read data from a file, convert it to uppercase,
and write it to another file using piping:
const fs = require('fs');
// create a read stream from input.txt
const readStream = fs.createReadStream('input.txt');
// create a write stream to output.txt
const writeStream = fs.createWriteStream('output.txt');
// pipe the read stream to the write stream, converting to
uppercase
readStream.pipe(
new Transform({
transform(chunk, encoding, callback) {
callback(null, chunk.toString().toUpperCase());
}
})
).pipe(writeStream);
In this example, we create a read stream from the file ‘input.txt’ and a write
stream to the file ‘output.txt’. We then pipe the read stream to a ‘Transform’
stream that converts the data to uppercase and pipes it to the write stream.
Another example using piping can be seen in the following code snippet where
we use ‘http’ module to create a server that reads a request from a client,
converts the request data to uppercase and sends the result back to the client:

7. const http = require('http');
http.createServer((req, res) => {
// create a writable stream to store the transformed data
const writeStream = new Writable({
write(chunk, encoding, callback) {
res.write(chunk.toString());
callback();
}
});
// pipe the request stream to the write stream, converting to
uppercase
req.pipe(
new Transform({
transform(chunk, encoding, callback) {
callback(null, chunk.toString().toUpperCase());
}
})
).pipe(writeStream);
}).listen(3000);
Writable streams in Node.js
In Node.js, streams are a core part of the API and they provide a powerful
mechanism for handling data in a flexible and efficient way. One of the key
types of streams is the Writable stream.
A Writable stream is a mechanism for writing data to a destination. Writable
streams are used to write data to a variety of destinations, including files,
sockets, and HTTP responses.
Here’s an example of how to create a writable stream in Node.js:

8. const { Writable } = require('stream');
const writableStream = new Writable({
write(chunk, encoding, callback) {
// do something with the chunk of data
console.log(`Received chunk: ${chunk.toString()}`);
// call the callback to signal that the chunk has been
processed
callback();
}
});
In this example, we create a new ‘Writable’ stream using the Writable class
from the Node.js ‘stream’ module. The ‘write’ method is called every time data
is written to the stream. The ‘chunk’ parameter contains the data that was
written, the ‘encoding’ parameter specifies the encoding of the data, and the
‘callback’ parameter is a function that must be called when the data has been
processed.
To use the Writable stream, we can write data to it using the ‘write()’ method:
writableStream.write('Hello, world!');
This will write the string “Hello, world!” to the writable stream.
It’s important to note that the ‘write()’ method is asynchronous, so it returns
‘true’ if the data was successfully written to the stream’s internal buffer, or
‘false’ if the buffer is full and the data cannot be written yet.

9. You can also use the ‘end()’ method to signal the end of the stream:
writableStream.end();
This will close the stream and signal that no more data will be written to it.
Overall, Writable streams provide a flexible and efficient way to write data to
various destinations, and are a fundamental part of the Node.js streaming
API.
Advantages of Streams
Streams have several advantages over traditional data processing methods,
especially when it comes to handling large amounts of data. Here are some of
the main advantages of using streams:
● Memory efficiency: Streams can handle large amounts of data
without requiring a large amount of memory.
● Processing speed: Streams can start processing data immediately,
leading to faster processing times.
● Modular design: Streams are modular and can be easily combined
and reused to create more complex data processing pipelines.
● Backpressure: Streams provide built-in backpressure mechanisms
that prevent data loss or resource exhaustion.
● Compatibility: Streams are a core part of the Node.js API and are
widely supported in many other programming languages and
frameworks.
Conclusion:

10. Streams are a powerful abstraction in Node.js that allows data to be read or
written in chunks. They can be used to handle input and output data in a
sequential manner, which is particularly useful for large data sets or network
connections.
● Streams can handle input and output data.
● They work in a sequential manner.
● This is useful for large data sets.
● This is also useful for network connections.
Node.js provides four stream types, namely Readable, Writable, Duplex, and
Transform, which serve distinct purposes in processing data. By using the
methods provided by the stream module, developers can easily create and use
streams to handle data in a more efficient and scalable way.