अध्याय 7: एसिंक्रोनस प्रोग्रामिंग (Asynchronous Programming)

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

इस अध्याय में, हम Node.js में एसिंक्रोनस कोड को संभालने के विभिन्न तरीकों, जैसे कॉलबैक (Callbacks), प्रॉमिस (Promises), और Async/Await, के बारे में जानेंगे। ये तीनों तकनीकें Node.js में एसिंक्रोनस कार्यों को संभालने के लिए महत्वपूर्ण हैं, और इनकी गहरी समझ आपको बेहतर और कुशल एप्लिकेशन बनाने में मदद करेगी।

आइए, एसिंक्रोनस प्रोग्रामिंग की इस यात्रा को शुरू करें और देखें कि कैसे Node.js में आप अपने कोड को नॉन-ब्लॉकिंग बना सकते हैं।

Callbacks, Promises, and Async/Await

Node.js में एसिंक्रोनस प्रोग्रामिंग को संभालने के तीन प्रमुख तरीके हैं: Callbacks, Promises, और Async/Await। ये तीनों तकनीकें आपको नॉन-ब्लॉकिंग I/O ऑपरेशंस के साथ काम करने की अनुमति देती हैं, जो कि Node.js की स्केलेबिलिटी और परफॉर्मेंस का मुख्य कारण है। इस सेक्शन में, हम इन तीनों तकनीकों को विस्तार से समझेंगे और देखेंगे कि कैसे आप इन्हें अपने Node.js एप्लिकेशन में उपयोग कर सकते हैं।

1. Callbacks

Callbacks Node.js में एसिंक्रोनस कार्यों को हैंडल करने का सबसे पुराना तरीका है। एक callback फंक्शन वह फंक्शन होता है जिसे एक ऑपरेशन पूरा होने के बाद कॉल किया जाता है। Node.js में, जब कोई एसिंक्रोनस ऑपरेशन किया जाता है, तो वह ऑपरेशन बैकग्राउंड में चलता रहता है, और ऑपरेशन पूरा होने के बाद callback फंक्शन निष्पादित होता है।

उदाहरण (Example):

const fs = require('fs');

// एसिंक्रोनस फाइल पढ़ने का उदाहरण, जिसमें एक callback उपयोग किया गया है
fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('Error reading file:', err);
    } else {
        console.log('File content:', data);
    }
});

यहां, fs.readFile एक एसिंक्रोनस फंक्शन है, और यह जब फाइल पढ़ने का ऑपरेशन पूरा करता है, तो वह callback फंक्शन को कॉल करता है। यदि फाइल को पढ़ने में कोई त्रुटि होती है, तो err ऑब्जेक्ट सेट होता है, और यदि नहीं, तो फाइल का डेटा data में उपलब्ध होता है।

Callback Hell:

Callbacks को सही ढंग से उपयोग करना थोड़ा जटिल हो सकता है, खासकर जब कई एसिंक्रोनस ऑपरेशंस होते हैं। जब एक के बाद एक कई callback फंक्शन्स नेस्ट किए जाते हैं, तो इसे callback hell कहा जाता है, जो कोड को कठिन और अव्यवस्थित बना देता है।

doSomething((err, result) => {
    if (err) return handleError(err);
    doSomethingElse(result, (err, newResult) => {
        if (err) return handleError(err);
        doAnotherThing(newResult, (err, finalResult) => {
            if (err) return handleError(err);
            console.log(finalResult);
        });
    });
});

2. Promises

Promises एक बेहतर और अधिक पढ़ने योग्य तरीका है एसिंक्रोनस ऑपरेशंस को हैंडल करने का। एक Promise एक ऐसा ऑब्जेक्ट है जो भविष्य में एक वैल्यू प्रदान करेगा – वह या तो सफल होगा (resolved) या विफल (rejected)। Promises का उपयोग करके आप कोड को callback hell से बचा सकते हैं और उसे अधिक सरल बना सकते हैं।

उदाहरण (Example):

const fs = require('fs').promises;

// एसिंक्रोनस फाइल पढ़ने का उदाहरण, जिसमें Promises का उपयोग किया गया है
fs.readFile('example.txt', 'utf8')
    .then(data => {
        console.log('File content:', data);
    })
    .catch(err => {
        console.error('Error reading file:', err);
    });

यहां, fs.readFile() एक Promise लौटाता है, और हम then() और catch() का उपयोग करके उसके परिणाम को हैंडल कर सकते हैं। अगर Promise सफल होता है, तो then() ब्लॉक निष्पादित होता है, और अगर विफल होता है, तो catch() ब्लॉक निष्पादित होता है।

Promises Chaining (चेनिंग):

Promises को चेनिंग के साथ इस्तेमाल किया जा सकता है, जिससे आप एक के बाद एक एसिंक्रोनस ऑपरेशन को लाइन से कर सकते हैं:

doSomething()
    .then(result => doSomethingElse(result))
    .then(newResult => doAnotherThing(newResult))
    .then(finalResult => console.log(finalResult))
    .catch(err => console.error(err));

3. Async/Await

Async/Await Promises पर आधारित एक सिंटैक्सिक शॉर्टकट है, जो आपके कोड को और भी सरल और अधिक पठनीय बनाता है। async और await का उपयोग करके आप Promises को सिंक्रोनस कोड की तरह लिख सकते हैं, हालांकि यह कोड अभी भी एसिंक्रोनस रहता है।

Async/Await का उपयोग (Using Async/Await):

• async: किसी भी फंक्शन के आगे async लगाकर उसे एसिंक्रोनस बनाया जाता है। यह फंक्शन हमेशा एक Promise लौटाता है।
• await: await का उपयोग करके आप किसी Promise के परिणाम की प्रतीक्षा कर सकते हैं। जब तक वह Promise पूरा नहीं होता, तब तक कोड उसी लाइन पर रुका रहता है, और इसके बाद की लाइनें तब चलती हैं जब Promise सफल या विफल हो जाता है।

उदाहरण (Example):

const fs = require('fs').promises;

// Async/Await के साथ फाइल पढ़ने का उदाहरण
async function readFile() {
    try {
        const data = await fs.readFile('example.txt', 'utf8');
        console.log('File content:', data);
    } catch (err) {
        console.error('Error reading file:', err);
    }
}

readFile();

इस उदाहरण में, readFile() फंक्शन एक async फंक्शन है, और await का उपयोग करके हम fs.readFile() के पूरा होने की प्रतीक्षा कर रहे हैं। try-catch ब्लॉक का उपयोग करके हम किसी भी एरर को हैंडल कर सकते हैं।

Async/Await के फायदे (Advantages of Async/Await):

1. सरल और पठनीय कोड: Async/Await Promises की तुलना में अधिक सरल और क्लीन कोड प्रदान करता है।
2. एरर हैंडलिंग में सरलता: Promises की तुलना में एरर हैंडलिंग try-catch के साथ अधिक सहज और सरल हो जाती है।
3. Callback Hell से बचाव: Async/Await का उपयोग करते हुए आप नेस्टेड callbacks से बच सकते हैं और सिंक्रोनस कोड की तरह एसिंक्रोनस कोड लिख सकते हैं।

एसिंक्रोनस कोड में एरर हैंडलिंग (Error Handling in Asynchronous Code)

Node.js में, एसिंक्रोनस प्रोग्रामिंग का उपयोग नॉन-ब्लॉकिंग ऑपरेशंस के लिए किया जाता है, लेकिन जब एसिंक्रोनस कोड में कोई एरर होती है, तो उसे सही तरीके से हैंडल करना ज़रूरी होता है। एरर हैंडलिंग एसिंक्रोनस कोड के विभिन्न तरीकों, जैसे Callbacks, Promises, और Async/Await, में अलग-अलग तरीके से की जाती है। इस सेक्शन में, हम इन तीनों तरीकों में एरर हैंडलिंग को समझेंगे और देखेंगे कि कैसे आप इसे प्रभावी ढंग से लागू कर सकते हैं।

1. Callbacks में एरर हैंडलिंग (Error Handling in Callbacks)

Callbacks में एरर हैंडलिंग का एक प्रमुख तरीका है कि आप कॉलबैक फंक्शन में एक एरर ऑब्जेक्ट पास करें। Node.js में कॉलबैक्स का पहला पैरामीटर आमतौर पर एरर होता है। यदि कोई एरर होती है, तो यह पैरामीटर सेट किया जाता है, और यदि कोई एरर नहीं होती, तो यह null होता है। एरर हैंडलिंग करने के लिए, आपको एरर की जांच करनी होती है और फिर उसे सही तरीके से हैंडल करना होता है।

उदाहरण (Example):

const fs = require('fs');

// Callback में एरर हैंडलिंग
fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        // यदि एरर होती है, तो इसे हैंडल करें
        console.error('Error reading file:', err);
        return;
    }
    // सफल होने पर डेटा को प्रिंट करें
    console.log('File content:', data);
});

इस उदाहरण में, यदि fs.readFile() में कोई एरर होती है, तो err ऑब्जेक्ट सेट होता है और एरर को console.error() के माध्यम से प्रिंट किया जाता है। यदि कोई एरर नहीं होती, तो फाइल की सामग्री प्रिंट की जाती है।

2. Promises में एरर हैंडलिंग (Error Handling in Promises)

Promises में एरर हैंडलिंग को अधिक सरल और संरचित तरीके से किया जा सकता है। Promises का उपयोग करते समय आप एरर को catch() ब्लॉक में हैंडल कर सकते हैं। जब कोई प्रॉमिस विफल होता है (rejected), तो वह एरर catch() ब्लॉक द्वारा कैप्चर की जाती है।

उदाहरण (Example):

const fs = require('fs').promises;

// Promises में एरर हैंडलिंग
fs.readFile('example.txt', 'utf8')
    .then(data => {
        console.log('File content:', data);
    })
    .catch(err => {
        // एरर को हैंडल करें
        console.error('Error reading file:', err);
    });

यहां, यदि readFile प्रॉमिस विफल होती है, तो catch() ब्लॉक एरर को पकड़ लेता है और उसे कंसोल में प्रिंट करता है। इस तरह, Promises के साथ एरर हैंडलिंग करना आसान और क्लीन है।

Multiple Promises में एरर हैंडलिंग (Error Handling in Multiple Promises):

जब आप चेनिंग के साथ कई Promises का उपयोग करते हैं, तो आप एक ही catch() ब्लॉक का उपयोग सभी एरर को हैंडल करने के लिए कर सकते हैं।

doSomething()
    .then(result => doSomethingElse(result))
    .then(newResult => doAnotherThing(newResult))
    .catch(err => {
        // किसी भी स्टेप में एरर होने पर इसे पकड़ें
        console.error('Error occurred:', err);
    });

3. Async/Await में एरर हैंडलिंग (Error Handling in Async/Await)

Async/Await में एरर हैंडलिंग Promises के साथ की जाती है, लेकिन यह try-catch ब्लॉक का उपयोग करके की जाती है। async फंक्शन के अंदर, आप await का उपयोग करते हैं, और यदि कोई एसिंक्रोनस ऑपरेशन विफल होता है, तो उसे catch() की बजाय catch ब्लॉक में कैप्चर किया जाता है। यह एरर हैंडलिंग को और भी स्पष्ट और सिंक्रोनस कोड जैसा बनाता है।

उदाहरण (Example):

const fs = require('fs').promises;

async function readFile() {
    try {
        const data = await fs.readFile('example.txt', 'utf8');
        console.log('File content:', data);
    } catch (err) {
        // एरर को कैप्चर करें
        console.error('Error reading file:', err);
    }
}

readFile();

यहां, readFile फंक्शन के अंदर try-catch ब्लॉक का उपयोग करके एरर को हैंडल किया जाता है। यदि fs.readFile() में कोई एरर होती है, तो उसे catch ब्लॉक में कैप्चर किया जाता है।

Async/Await के साथ Multiple Async Calls में एरर हैंडलिंग (Handling Errors in Multiple Async Calls):

यदि आपके पास कई एसिंक्रोनस कॉल्स हैं, तो आप उन्हें प्रत्येक के लिए अलग-अलग try-catch ब्लॉक्स में हैंडल कर सकते हैं, या आप एक बड़े try-catch ब्लॉक में सभी को शामिल कर सकते हैं।

async function processFiles() {
    try {
        const file1 = await fs.readFile('file1.txt', 'utf8');
        const file2 = await fs.readFile('file2.txt', 'utf8');
        console.log(file1, file2);
    } catch (err) {
        // किसी भी एरर को हैंडल करें
        console.error('Error processing files:', err);
    }
}

processFiles();

यहां, यदि file1.txt या file2.txt में से कोई भी फाइल पढ़ने में एरर होती है, तो उसे एक ही catch ब्लॉक में कैप्चर किया जाएगा।

एरर प्रोपेगेशन (Error Propagation)

कई बार आप एरर को वहीं हैंडल नहीं करना चाहते, बल्कि उसे ऊपर की ओर प्रोपेगेट करना चाहते हैं ताकि उसे बाद में हैंडल किया जा सके। Promises और Async/Await दोनों में एरर प्रोपेगेशन को किया जा सकता है।

Promises में एरर प्रोपेगेशन:

function readFile() {
    return fs.readFile('example.txt', 'utf8');
}

readFile()
    .then(data => {
        console.log('File content:', data);
    })
    .catch(err => {
        // यहां एरर को हैंडल करें
        console.error('Error occurred:', err);
    });

Async/Await में एरर प्रोपेगेशन:

async function readFile() {
    return await fs.readFile('example.txt', 'utf8');
}

async function processFile() {
    try {
        const data = await readFile();
        console.log('File content:', data);
    } catch (err) {
        // यहां एरर को हैंडल करें
        console.error('Error occurred:', err);
    }
}

processFile();