NodeJS stream Module : stream In NodeJS In Hindi

If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.

NodeJS stream Module

NodeJS stream Module

Node.js में stream module एक built-in module है जो data streaming के लिए utilities provide करता है। Streams sequential data chunks के रूप में data handle करते हैं, और इन्हें processing के दौरान memory में load करने की जरूरत नहीं होती। इस वजह से streams को large files, network requests, या किसी भी data source को handle करने के लिए use किया जाता है जहां continuous data flow होता है।

Types of streams in NodeJS

Node.js में चार प्रकार के streams होते हैं -

1. Readable Streams : यह वो streams हैं जो data को read करने के लिए use होती हैं. Example: fs.createReadStream().

2. Writable Streams : यह वो streams हैं जो data को write करने के लिए use होती हैं. Example: fs.createWriteStream().

3. Duplex Streams : यह वो streams हैं जो readable और writable दोनो होते हैं. Example: TCP sockets.

4. Transform Streams : यह special type of duplex streams हैं जो input data को transform कर सकते हैं output data में. Example: zlib.createGzip().

●●●

How stream works in NodeJS

Streams data को chunks में handle करते हैं , हर stream के पास एक internal buffer होता है जो data को temporarily store करता है. Streams asynchronous होती हैं, जो non-blocking operations को enable करती हैं।

NodeJS Readable Stream Example

चलिए एक example देखते हैं कैसे एक readable stream का use किया जाता है -

Copy
const { Readable } = require('stream');

class CustomReadableStream extends Readable {
    constructor(options) {
        super(options);
        this.data = ["Node.js", "Streams", "are", "awesome!"];
        this.index = 0;
    }

    _read(size) {
        if (this.index < this.data.length) {
            this.push(this.data[this.index]);
            this.index++;
        } else {
            this.push(null); // No more data
        }
    }
}

const readableStream = new CustomReadableStream();

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

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

इस example में, हमने Readable stream class को extend किया है और _read method को override किया है। _read method data chunks को provide करता है जब stream को read किया जाता है। जब data समाप्त हो जाता है, तब null push किया जाता है जिससे stream को पता चलता है कि कोई और data नहीं है।

●●●

NodeJS Writable Stream Example

अब देखते हैं कैसे एक writable stream का use किया जाता है -

Copy
const { Writable } = require('stream');

class CustomWritableStream extends Writable {
    _write(chunk, encoding, callback) {
        console.log(`Writing: ${chunk.toString()}`);
        callback();
    }
}

const writableStream = new CustomWritableStream();

writableStream.write('Hello, ', 'utf8', () => {
    console.log('Finished writing Hello');
});

writableStream.write('world!', 'utf8', () => {
    console.log('Finished writing world!');
});

writableStream.end('End of stream.');

इस example में, हमने Writable stream class को extend किया है और _write method को override किया है। _write method data chunks को handle करता है जब उन्हें stream में लिखा जाता है। यह method asynchronous है और callback को call करता है जब write operation complete हो जाता है।

●●●

NodeJS Duplex Stream Example

Duplex stream को demonstrate करने के लिए, हम एक custom duplex stream बनाएंगे जो data को uppercase में transform करेगा -

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

class UppercaseDuplexStream extends Duplex {
    constructor(options) {
        super(options);
    }

    _read(size) {
        // No custom reading logic required for this example
    }

    _write(chunk, encoding, callback) {
        this.push(chunk.toString().toUpperCase());
        callback();
    }

    _final(callback) {
        this.push(null); // Indicate the end of the stream
        callback();
    }
}

const duplexStream = new UppercaseDuplexStream();

duplexStream.on('data', (chunk) => {
    console.log(`Transformed chunk: ${chunk}`);
});

duplexStream.write('hello, ');
duplexStream.write('world!');
duplexStream.end();

इस example में, हमने Duplex stream class को extend किया है और _write method को override किया है ताकि input data को uppercase में transform किया जा सके।

_final method यह indicate करता है कि कोई और data नहीं होगा।

●●●

NodeJS Transform Stream Example

Transform streams input data को transform करती हैं। हम एक transform stream बनाएंगे जो input data को reverse करेगा -

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

class ReverseTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        this.push(chunk.toString().split('').reverse().join(''));
        callback();
    }
}

const transformStream = new ReverseTransformStream();

transformStream.on('data', (chunk) => {
    console.log(`Reversed chunk: ${chunk}`);
});

transformStream.write('Hello');
transformStream.write('Node.js');
transformStream.end();

इस example में, हमने Transform stream class को extend किया है और _transform method को override किया है ताकि input data को reverse किया जा सके।

●●●

Advantages of Streams

• Memory Efficiency : Streams memory का efficient use करते हैं क्योंकि data को chunks में handle करते हैं।

• Performance : Streams asynchronous होते हैं, इस वजह से non-blocking operations perform करते हैं, जो performance को improve करता है।

• Scalability : Streams large data को handle करने में helpful होते हैं, इस वजह से scalable applications build करना easier होता है।

●●●

Conclusion

Node.js streams एक powerful tool हैं जो आपको large data को efficiently handle करने की permission देते हैं। Streams को सही तरीके से use करने से आपकी applications की performance और scalability improve हो सकती है।

उम्मीद है कि इस blog से streams के concept को समझने में मदद मिली होगी।

Happy Coding :)