Node.js में स्ट्रीम के लिए संपूर्ण मार्गदर्शिका

नोड.जेएस में स्ट्रीम निरंतर तरीके से डेटा को पढ़ने और लिखने को संभालने का एक शक्तिशाली तरीका है। वे आपको डेटा को कुशलतापूर्वक संसाधित करने की अनुमति देते हैं, खासकर जब बड़ी मात्रा में जानकारी या I/O संचालन से निपटते हैं। यह मार्गदर्शिका स्ट्रीम के प्रकार, उनका उपयोग कैसे करें, और व्यावहारिक उदाहरणों को कवर करेगी ताकि आपको यह समझने में मदद मिल सके कि स्ट्रीम Node.js में कैसे काम करती हैं।

धाराएँ क्या हैं?

स्ट्रीम वे ऑब्जेक्ट हैं जो आपको किसी स्रोत से डेटा पढ़ने या किसी गंतव्य पर निरंतर तरीके से डेटा लिखने की अनुमति देते हैं। वे संपूर्ण फ़ाइलों या बफ़र्स को एक साथ पढ़ने या लिखने के बजाय टुकड़े-टुकड़े में डेटा संसाधित करने के लिए आदर्श हैं। बड़े डेटासेट के साथ काम करते समय यह विशेष रूप से उपयोगी है, क्योंकि यह मेमोरी उपयोग को काफी कम कर सकता है।

महत्वपूर्ण अवधारणाएं

• फ्लोइंग मोड: डेटा स्रोत से गंतव्य तक स्वचालित रूप से प्रवाहित होता है।
• रोका गया मोड: डेटा को स्रोत से मैन्युअल रूप से पढ़ने की आवश्यकता है।
• पढ़ने योग्य स्ट्रीम: स्ट्रीम जिनसे आप डेटा पढ़ सकते हैं।
• लिखने योग्य स्ट्रीम: स्ट्रीम जिसमें आप डेटा लिख ​​सकते हैं।
• डुप्लेक्स स्ट्रीम: स्ट्रीम जो डेटा पढ़ और लिख सकती हैं।
• ट्रांसफ़ॉर्म स्ट्रीम: स्ट्रीम जो डेटा को पढ़ने या लिखने के दौरान संशोधित या परिवर्तित करती है।

धाराओं के प्रकार

1. पढ़ने योग्य स्ट्रीम: ये स्ट्रीम आपको डेटा पढ़ने की अनुमति देती हैं। उदाहरणों में fs.createReadStream() और http.IncomingMessage शामिल हैं।

2. लिखने योग्य स्ट्रीम: ये स्ट्रीम आपको डेटा लिखने की अनुमति देती हैं। उदाहरणों में fs.createWriteStream() और http.ServerResponse शामिल हैं।

3. डुप्लेक्स स्ट्रीम: ये स्ट्रीम डेटा पढ़ और लिख सकते हैं। उदाहरणों में टीसीपी सॉकेट और नेट.डुप्लेक्स शामिल हैं।

4. ट्रांसफ़ॉर्म स्ट्रीम: ये एक प्रकार की डुप्लेक्स स्ट्रीम हैं जो डेटा को पढ़ने या लिखने के दौरान संशोधित कर सकती हैं। उदाहरणों में संपीड़न के लिए zlib.createGzip() शामिल है।

पठनीय धाराएँ बनाना

आप फ़ाइलों को पढ़ने के लिए अंतर्निहित एफएस मॉड्यूल का उपयोग करके या कस्टम पठनीय स्ट्रीम बनाने के लिए स्ट्रीम.रीडेबल का उपयोग करके एक पठनीय स्ट्रीम बना सकते हैं।

उदाहरण: किसी फ़ाइल को पढ़ने योग्य स्ट्रीम के साथ पढ़ना

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('example.txt', { encoding: 'utf8' });

// Handling the 'data' event
readableStream.on('data', (chunk) => {
    console.log('New chunk received:', chunk);
});

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

उदाहरण: कस्टम पठनीय स्ट्रीम

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

class MyReadableStream extends Readable {
    constructor(options) {
        super(options);
        this.current = 0;
    }

    _read(size) {
        if (this.current  {
    console.log('Received:', chunk.toString());
});

लिखने योग्य स्ट्रीम बनाना

आप एफएस मॉड्यूल का उपयोग करके या स्ट्रीम.राइटेबल क्लास का विस्तार करके लिखने योग्य स्ट्रीम बना सकते हैं।

उदाहरण: किसी फ़ाइल को लिखने योग्य स्ट्रीम के साथ लिखना

const fs = require('fs');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Write data to the stream
writableStream.write('Hello, World!\n');
writableStream.write('Writing to a file using streams.\n');

// End the stream
writableStream.end(() => {
    console.log('Finished writing to file.');
});

उदाहरण: कस्टम लिखने योग्य स्ट्रीम

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

class MyWritableStream extends Writable {
    _write(chunk, encoding, callback) {
        console.log('Writing:', chunk.toString());
        callback(); // Call when done
    }
}

const myWritableStream = new MyWritableStream();
myWritableStream.write('Hello, World!\n');
myWritableStream.write('Writing to custom writable stream.\n');
myWritableStream.end();

डुप्लेक्स स्ट्रीम का उपयोग करना

डुप्लेक्स स्ट्रीम एक साथ डेटा पढ़ और लिख सकती हैं। एक सामान्य उपयोग का मामला टीसीपी सॉकेट है।

उदाहरण: डुप्लेक्स स्ट्रीम बनाना

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

class MyDuplexStream extends Duplex {
    _read(size) {
        this.push('Data from duplex stream\n');
        this.push(null); // No more data
    }

    _write(chunk, encoding, callback) {
        console.log('Received:', chunk.toString());
        callback();
    }
}

const myDuplexStream = new MyDuplexStream();
myDuplexStream.on('data', (chunk) => {
    console.log('Reading:', chunk.toString());
});

// Write to the duplex stream
myDuplexStream.write('Hello, Duplex!\n');
myDuplexStream.end();

ट्रांसफ़ॉर्म स्ट्रीम का उपयोग करना

ट्रांसफ़ॉर्म स्ट्रीम डेटा को संशोधित करने के लिए उपयोगी हैं क्योंकि यह स्ट्रीम के माध्यम से प्रवाहित होता है। उदाहरण के लिए, आप डेटा को संपीड़ित करने के लिए ट्रांसफ़ॉर्म स्ट्रीम का उपयोग कर सकते हैं।

उदाहरण: एक ट्रांसफॉर्म स्ट्रीम बनाना

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

class MyTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        const upperChunk = chunk.toString().toUpperCase();
        this.push(upperChunk);
        callback();
    }
}

const myTransformStream = new MyTransformStream();
myTransformStream.on('data', (chunk) => {
    console.log('Transformed:', chunk.toString());
});

// Pipe data through the transform stream
process.stdin.pipe(myTransformStream).pipe(process.stdout);

पाइपिंग धाराएँ

धाराओं की शक्तिशाली विशेषताओं में से एक उन्हें एक साथ पाइप करने की क्षमता है। पाइपिंग आपको एक पढ़ने योग्य स्ट्रीम को एक लिखने योग्य स्ट्रीम से कनेक्ट करने की अनुमति देता है, जिससे डेटा ट्रांसफर करना आसान हो जाता है।

उदाहरण: पाइपिंग धाराएँ

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('input.txt');

// Create a writable stream
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 written to output.txt');
});

Node.js में इवेंट स्ट्रीम करें

1. पठनीय स्ट्रीम घटनाएँ

पढ़ने योग्य स्ट्रीम कई महत्वपूर्ण घटनाओं का उत्सर्जन करती हैं जो आपको डेटा प्रवाह प्रबंधित करने में मदद करती हैं:

• डेटा: जब डेटा का एक हिस्सा पढ़ने के लिए उपलब्ध होता है तो उत्सर्जित होता है।
• end: तब उत्सर्जित होता है जब पढ़ने के लिए कोई डेटा नहीं होता है।
• त्रुटि: पढ़ने के दौरान कोई त्रुटि होने पर उत्सर्जित होता है।
• बंद करें: तब उत्सर्जित होता है जब स्ट्रीम और कोई अंतर्निहित संसाधन (जैसे फ़ाइल डिस्क्रिप्टर) बंद कर दिए जाते हैं।

उदाहरण: पठनीय स्ट्रीम घटनाएँ

const fs = require('fs');

const readableStream = fs.createReadStream('example.txt');

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

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

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

readableStream.on('close', () => {
    console.log('Stream closed.');
});

2. लिखने योग्य स्ट्रीम इवेंट

लिखने योग्य स्ट्रीम भी कई घटनाओं का उत्सर्जन करती हैं:

• ड्रेन: तब उत्सर्जित होता है जब स्ट्रीम पूर्ण होने के बाद अधिक डेटा स्वीकार करने के लिए तैयार होती है।
• finish: उत्सर्जित जब सभी डेटा स्ट्रीम में लिखा गया है और अंत () विधि को बुलाया गया है।
• त्रुटि: लिखने के दौरान कोई त्रुटि होने पर उत्सर्जित होती है।
• बंद करें: तब उत्सर्जित होता है जब स्ट्रीम और कोई अंतर्निहित संसाधन बंद कर दिए जाते हैं।

उदाहरण: लिखने योग्य स्ट्रीम इवेंट

const fs = require('fs');

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

writableStream.on('finish', () => {
    console.log('All data has been written to output.txt');
});

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

// Writing data
writableStream.write('Hello, World!\n');
writableStream.write('Writing to a file using streams.\n');
writableStream.end(); // Call end to finish the writing process

3. स्ट्रीम इवेंट को रूपांतरित करें

ट्रांसफॉर्म स्ट्रीम को पढ़ने योग्य और लिखने योग्य दोनों स्ट्रीम से इवेंट विरासत में मिलते हैं, और वे उत्सर्जित करते हैं:

• डेटा: तब उत्सर्जित होता है जब एक रूपांतरित खंड पढ़ने के लिए उपलब्ध होता है।
• end: तब उत्सर्जित होता है जब रूपांतरित करने के लिए कोई डेटा नहीं होता है।
• त्रुटि: परिवर्तन के दौरान कोई त्रुटि होने पर उत्सर्जित होता है।
• समाप्त: जब सभी डेटा संसाधित और लिखा जाता है तब उत्सर्जित होता है।

उदाहरण: स्ट्रीम इवेंट को रूपांतरित करें

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

class MyTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        const upperChunk = chunk.toString().toUpperCase();
        this.push(upperChunk);
        callback();
    }
}

const myTransformStream = new MyTransformStream();

myTransformStream.on('data', (chunk) => {
    console.log('Transformed chunk:', chunk.toString());
});

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

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

// Write data to the transform stream
myTransformStream.write('Hello, World!\n');
myTransformStream.write('Transforming this text.\n');
myTransformStream.end(); // End the stream

घटनाओं का सारांश

• पठनीय स्ट्रीम: डेटा, अंत, त्रुटि, बंद
• लिखने योग्य स्ट्रीम: ख़त्म करना, ख़त्म करना, त्रुटि, बंद करना
• ट्रांसफ़ॉर्म स्ट्रीम: पढ़ने योग्य और लिखने योग्य दोनों स्ट्रीम से डेटा, अंत, त्रुटि, समापन प्राप्त करता है

निष्कर्ष

Node.js में स्ट्रीम निरंतर तरीके से डेटा को संभालने का एक शक्तिशाली और कुशल तरीका प्रदान करती हैं। वे आपको डेटा को टुकड़े-टुकड़े में पढ़ने और लिखने की अनुमति देते हैं, जिससे वे I/O संचालन और बड़े डेटासेट के साथ काम करने के लिए विशेष रूप से उपयोगी हो जाते हैं। विभिन्न प्रकार की स्ट्रीम बनाने और उनका उपयोग करने के साथ-साथ घटनाओं को संभालने के तरीके को समझने से आपको Node.js में अधिक कुशल और स्केलेबल एप्लिकेशन बनाने में मदद मिलेगी।

चाहे आप पढ़ने योग्य, लिखने योग्य, डुप्लेक्स, या ट्रांसफ़ॉर्म स्ट्रीम बना रहे हों, स्ट्रीम एपीआई का लचीलापन आपको डेटा प्रोसेसिंग को इस तरह से संभालने की अनुमति देता है जो आपके एप्लिकेशन की आवश्यकताओं के लिए सबसे उपयुक्त हो।