What is Chunk in Node.js ?

Last Updated : 13 Jun, 2024

In Node.js, the term "chunk" refers to a small, manageable piece of data that is part of a larger dataset. Node.js processes data in chunks, especially when dealing with streams, which makes handling large files or data sources more efficient and memory-friendly. This article explores what chunks are, how they work, and their significance in Node.js.

What is a Chunk?

A chunk is a piece of data sent through a stream. Streams in Node.js are objects that allow you to read data from a source or write data to a destination in a continuous manner. Instead of reading or writing the entire dataset at once, Node.js processes data in chunks, allowing for efficient handling of large volumes of data without consuming extensive memory resources.

Streams and Chunks

Streams are a powerful feature in Node.js, designed to work with chunks of data. There are four main types of streams:

Readable Streams: Used to read data sequentially.
Writable Streams: Used to write data sequentially.
Duplex Streams: Streams that can be both readable and writable.
Transform Streams: Streams that can modify or transform data as it is read or written.

Each of these streams handles data in chunks, which makes it possible to process large datasets incrementally.

How Chunks Work

Chunks are essential for streaming data efficiently. When data is read from a stream, it is divided into chunks and processed piece by piece. Similarly, when writing data to a stream, data is sent in chunks. This chunked approach is particularly useful for applications such as file processing, video streaming, and real-time data transfer.

Syntax:

request.on('eventName',callback)

Parameters

eventName: It is the name of the event that fired
callback: It is the Callback function i.e Event handler of the particular event.

Return type

The return type of this method is void.

Example: Implementation to show the chunk form in nodejs

Node

// index.js

// Importing http libraries
const http = require('http');

// Creating a server
const server = http.createServer((req, res) => {
    const url = req.url;
    const method = req.method;

    if (url === '/') {
        // Sending the response
        res.write('<html>');
        res.write('<head><title>Enter Message</title><head>');
        res.write(`<body><form action="/message" method="POST">
    <input type="text" name="message"></input>
    <button type="submit">Send</button></form></body></html>`);
        res.write('</html>');
        return res.end();
    }

    // Handling different routes for different type request
    if (url === '/message' && method === 'POST') {
        const body = [];

        req.on('data', (chunk) => {

            // Storing the chunk data
            body.push(chunk);
            console.log(body)
        });

        req.on('end', () => {

            // Parsing the chunk data
            const parsedBody = Buffer.concat(body).toString();
            const message = parsedBody.split('=')[1];
            
            // Printing the data
            console.log(message);
        });

        res.statusCode = 302;
        res.setHeader('Location', '/');
        return res.end();
    }
});

// Starting the server
server.listen(3000);

Step to Run Application: Run the application using the following command from the root directory of the project

node index.js

Output: Your project will be shown in the URL http://localhost:3000/

Console Output:

Practical Applications of Chunks

File Processing: Efficiently reading and writing large files without loading them entirely into memory.
Streaming Media: Handling video or audio streaming by processing data in small chunks.
Real-time Data Transfer: Transferring large datasets over the network in manageable pieces.
Data Piping: Directly passing data from one stream to another, such as reading from a file and writing to another file.

Example of Piping:

const fs = require('fs');

// Create readable and writable streams
const readableStream = fs.createReadStream('input.txt');
const writableStream = fs.createWriteStream('output.txt');

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

writableStream.on('finish', () => {
  console.log('Data has been piped successfully.');
});

In this example, data is read from input.txt and written to output.txt using the pipe method, which handles the data in chunks.

Conclusion

Chunks are a fundamental concept in Node.js, enabling efficient and effective handling of large datasets through streams. By breaking data into manageable pieces, Node.js streams optimize memory usage and performance, making it possible to build scalable applications that can handle large volumes of data. Understanding chunks and how to work with streams is essential for any Node.js developer looking to manage data efficiently.

zack_aayush

Improve

Article Tags :