पहचान

मैं जावा डेवलपर के रूप में काम करता था और मुझे याद है कि पहली बार मैं जावास्क्रिप्ट में वादों के संपर्क में आया था। हालाँकि अवधारणा सरल लग रही थी, फिर भी मैं पूरी तरह से समझ नहीं पाया कि प्रॉमिस कैसे काम करता है। यह तब बदल गया जब मैंने परियोजनाओं में उनका उपयोग करना शुरू किया और उनके द्वारा हल किए गए मामलों को समझा। फिर अहा क्षण आया और सब कुछ और अधिक स्पष्ट हो गया। समय के साथ, प्रॉमिस मेरे टूलबेल्ट पर एक मूल्यवान हथियार बन गया। यह अजीब तरह से संतोषजनक है जब मैं उन्हें काम पर उपयोग कर सकता हूं और कार्यों के बीच एसिंक हैंडलिंग को हल कर सकता हूं।

एपीआई से डेटा लाते समय संभवत: सबसे पहले आपका सामना प्रॉमिस से होता है, जो सबसे आम उदाहरण भी है। हाल ही में, मेरा साक्षात्कार हुआ है, और अनुमान है कि पहला प्रश्न क्या था "क्या आप मुझे प्रॉमिस और एसिंक्स वेट के बीच अंतर बता सकते हैं?"। मैं इसका स्वागत करता हूं क्योंकि मैं इसे बेहतर तरीके से जानने के लिए एक अच्छे शुरुआती बिंदु के रूप में देखता हूं कि आवेदक कैसे समझता है कि तंत्र कैसे काम करता है। हालाँकि, वह अधिकतर अन्य पुस्तकालयों और रूपरेखाओं का उपयोग कर रहा है। इसने मुझे अंतर लिखने और एसिंक फ़ंक्शन त्रुटियों से निपटने के लिए अच्छे अभ्यासों का वर्णन करने दिया।

वादा क्या है

आइए प्रारंभिक प्रश्न से शुरू करें: "वादा क्या है?" प्रॉमिस उस मूल्य के लिए एक प्लेसहोल्डर है जिसे हम अभी तक नहीं जानते हैं लेकिन हम इसे अतुल्यकालिक गणना/फ़ंक्शन के परिणामस्वरूप प्राप्त करेंगे। वादा अच्छा रहेगा तो फल मिलेगा. यदि वादा पूरा नहीं हुआ, तो वादा एक त्रुटि लौटाएगा।

वादे का एक बुनियादी उदाहरण

एक वादे को परिभाषित करना

आप इसके कंस्ट्रक्टर को कॉल करके और दो कॉलबैक फ़ंक्शन पास करके प्रॉमिस को परिभाषित करते हैं: resolve और reject।

const newPromise = new Promise((resolve, reject) => {
    resolve('Hello');
    // reject('Error');
});

जब हम वादे को सफलतापूर्वक हल करना चाहते हैं तो हम रिज़ोल्यूशन फ़ंक्शन को कॉल करते हैं। अस्वीकार उस स्थिति में वादे को अस्वीकार करने के लिए है जब हमारे तर्क का मूल्यांकन करने के दौरान कोई त्रुटि होती है।

वादा परिणाम पुनः प्राप्त करना

हम वादे का परिणाम प्राप्त करने के लिए अंतर्निहित फ़ंक्शन का उपयोग करते हैं। इसमें दो पारित कॉलबैक हैं, परिणाम और त्रुटि। परिणाम तब कॉल किया जाता है जब फ़ंक्शन रिज़ॉल्यूशन द्वारा वादा सफलतापूर्वक हल हो जाता है। यदि वादा हल नहीं हुआ है, तो दूसरा फ़ंक्शन त्रुटि कहा जाता है। यह फ़ंक्शन या तो अस्वीकार द्वारा या किसी अन्य त्रुटि द्वारा ट्रिगर किया गया है।

newPromise.then(result => {
    console.log(result); // Hello
}, error => {
    console.log("There shouldn't be an error");
});

हमारे उदाहरण में, हमें नमस्ते परिणाम मिलेगा क्योंकि हमने सफलतापूर्वक वादा पूरा कर लिया है।

वादों के प्रबंधन में त्रुटि

जब वादा खारिज कर दिया जाता है तो हमेशा इसकी दूसरी त्रुटि कॉलबैक लागू होती है।

const newPromise1 = new Promise((resolve, reject) => {
  reject('An error occurred in Promise1');
});

newPromise1.then(
  (result) => {
    console.log(result); // It is not invoked
  },
  (error) => {
    console.log(error); // 'An error occurred in Promise1'
  }
);

इसकी स्पष्टता के लिए एक अधिक अनुशंसित दृष्टिकोण अंतर्निहित कैच विधि का उपयोग करना है।

const newPromise2 = new Promise((resolve, reject) => {
  reject('An error occurred in Promise2');
});

newPromise2
  .then((result) => {
    console.log(result); // It is not invoked
  })
  .catch((error) => {
    console.log(error); // 'An error occurred in Promise2'
  });

कैच विधि जंजीर है और उसने अपना स्वयं का त्रुटि कॉलबैक प्रदान किया है। यह तब लागू होता है जब वादा खारिज कर दिया जाता है।

दोनों संस्करण अच्छी तरह से काम करते हैं लेकिन चेनिंग आईएमओ अधिक पठनीय है और अन्य अंतर्निहित तरीकों का उपयोग करते समय यह आसान है जिसे हम आगे कवर करते हैं।

वादों की जंजीर

एक वादे का परिणाम संभवतः दूसरा वादा हो सकता है। उस स्थिति में, हम तत्कालीन कार्यों की एक मनमानी संख्या को श्रृंखलाबद्ध कर सकते हैं।

getJSON('categories.json')
    .then(categories => {
        console.log('Fetched categories:', categories);

        return getJSON(categories[0].itemsUrl);
    })
    .then(items => {
        console.log('Fetched items:', items);

        return getJSON(items[0].detailsUrl);
    })
    .then(details => {
        console.log('Fetched details:', details);
    })
    .catch(error => {
        console.error('An error has occurred:', error.message);
    });

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

सभी से वादा करो

कभी-कभी हम अधिक स्वतंत्र वादों के परिणामों की प्रतीक्षा करना चाहते हैं और फिर परिणामों पर कार्य करना चाहते हैं। यदि हमें वादों के समाधान के क्रम की परवाह नहीं है तो हम अंतर्निहित फ़ंक्शन Promise.all का उपयोग कर सकते हैं।

Promise.all([
    getJSON('categories.json'),
    getJSON('technology_items.json'),
    getJSON('science_items.json')
])
    .then(results => {
        const categories = results[0];
        const techItems = results[1];
        const scienceItems = results[2];

        console.log('Fetched categories:', categories);
        console.log('Fetched technology items:', techItems);
        console.log('Fetched science items:', scienceItems);

        // Fetch details of the first item in each category
        return Promise.all([
            getJSON(techItems[0].detailsUrl),
            getJSON(scienceItems[0].detailsUrl)
        ]);
    })
    .then(detailsResults => {
        const laptopDetails = detailsResults[0];
        const physicsDetails = detailsResults[1];

        console.log('Fetched laptop details:', laptopDetails);
        console.log('Fetched physics details:', physicsDetails);
    })
    .catch(error => {
        console.error('An error has occurred:', error.message);
    });

Promise.all वादों की एक श्रृंखला लेता है और परिणामों की एक श्रृंखला लौटाता है। यदि वादों में से एक को अस्वीकार कर दिया जाता है तो Promise.all को भी अस्वीकार कर दिया जाता है।

रेसिंग का वादा

एक अन्य अंतर्निहित कार्यक्षमता Promise.race है। इसका उपयोग तब किया जाता है जब आपके पास एकाधिक एसिंक्रोनस फ़ंक्शंस - वादे - होते हैं और आप उनसे रेस करना चाहते हैं।

Promise.race([
    getJSON('technology_items.json'),
    getJSON('science_items.json')
])
    .then(result => {
        console.log('First resolved data:', result);
    })
    .catch(error => {
        console.error('An error has occurred:', error.message);
    });

वादों के निष्पादन में अलग-अलग समय लग सकता है और Promise.race सरणी से पहले हल किए गए या अस्वीकृत वादे का मूल्यांकन करता है। इसका उपयोग तब किया जाता है जब हमें ऑर्डर की परवाह नहीं होती है लेकिन हम सबसे तेज़ एसिंक्रोनस कॉल का परिणाम चाहते हैं।

Async प्रतीक्षा क्या है?

जैसा कि आप देख सकते हैं, प्रॉमिस लिखने के लिए बहुत सारे बॉयलरप्लेट कोड की आवश्यकता होती है। सौभाग्य से, हमारे पास मूल Async Await सुविधा है, जो प्रॉमिस का उपयोग करना और भी आसान बना देती है। हम किसी फ़ंक्शन को async शब्द से चिह्नित करते हैं और इसके द्वारा, हम कहते हैं कि कोड में कहीं न कहीं हम एसिंक्रोनस फ़ंक्शन को कॉल करेंगे और हमें इसके लिए इंतजार नहीं करना चाहिए। फिर async फ़ंक्शन को wait शब्द के साथ कॉल किया जाता है।

Async प्रतीक्षा का मूल उदाहरण

const fetchData = async () => {
    try {
        // Fetch the categories
        const categories = await getJSON('categories.json');
        console.log('Fetched categories:', categories);

        // Fetch items from the first category (Technology)
        const techItems = await getJSON(categories[0].itemsUrl);
        console.log('Fetched technology items:', techItems);

        // Fetch details of the first item in Technology (Laptops)
        const laptopDetails = await getJSON(techItems[0].detailsUrl);
        console.log('Fetched laptop details:', laptopDetails);
    } catch (error) {
        console.error('An error has occurred:', error.message);
    }
};

fetchData();

हमारे फ़ेचडेटा को एसिंक के रूप में चिह्नित किया गया है और यह हमें फ़ंक्शन के अंदर एसिंक्रोनस कॉल को संभालने के लिए wait का उपयोग करने की अनुमति देता है। हम और वादे बुलाते हैं और उनका मूल्यांकन एक के बाद एक किया जाएगा।

अगर हम त्रुटियों को संभालना चाहते हैं तो हम ट्राई...कैच ब्लॉक का उपयोग करते हैं। अस्वीकृत त्रुटि फिर कैच ब्लॉक में पकड़ी जाती है और हम त्रुटि को लॉग करने की तरह इस पर कार्य कर सकते हैं।

क्या अलग है

वे दोनों एसिंक्रोनस कोड के साथ जावास्क्रिप्ट हैंडलिंग की विशेषताएं हैं। मुख्य अंतर सिंटैक्स में है जब प्रॉमिस तब और कैच के साथ चेनिंग का उपयोग करते हैं लेकिन एसिंक वेट सिंटैक्स सिंक्रोनस तरीके से अधिक होता है। इससे पढ़ना आसान हो जाता है. जब यह ट्राई...कैच ब्लॉक का लाभ उठाता है तो एसिंक वेट के लिए त्रुटि प्रबंधन अधिक सरल हो जाता है। यह एक ऐसा सवाल है जिसे आप इंटरव्यू में आसानी से पा सकते हैं। उत्तर के दौरान, आप दोनों के विवरण में गहराई से उतर सकते हैं और उन अंतरों को उजागर कर सकते हैं।

वादा सुविधाएँ

बेशक, आप एसिंक वेट के साथ सभी सुविधाओं का उपयोग कर सकते हैं। उदाहरण के लिए Promise.all.

const fetchAllData = async () => {
    try {
        // Use await with Promise.all to fetch multiple JSON files in parallel
        const [techItems, scienceItems, laptopDetails] = await Promise.all([
            getJSON('technology_items.json'),
            getJSON('science_items.json'),
            getJSON('laptops_details.json')
        ]);

        console.log('Fetched technology items:', techItems);
        console.log('Fetched science items:', scienceItems);
        console.log('Fetched laptop details:', laptopDetails);
    } catch (error) {
        console.error('An error occurred:', error.message);
    }
};

व्यावहारिक उपयोग के मामले

एसिंक्रोनस कोड को संभालने के लिए वादे जावास्क्रिप्ट में एक मूलभूत विशेषता हैं। इसका उपयोग करने के मुख्य तरीके यहां दिए गए हैं:

एपीआई से डेटा लाया जा रहा है

जैसा कि ऊपर दिए गए उदाहरणों में पहले ही दिखाया गया था, यह प्रॉमिस के लिए सबसे अधिक उपयोग किए जाने वाले मामलों में से एक है और आप इसके साथ रोजाना काम करते हैं।

फ़ाइल संचालन को संभालना

फ़ाइलों को अतुल्यकालिक रूप से पढ़ना और लिखना वादों का उपयोग करके किया जा सकता है, विशेष रूप से Node.js मॉड्यूल fs.promises द्वारा

import * as fs from 'fs/promises';

const writeFileAsync = async (filePath, content, options = {}) => {
    try {
        await fs.writeFile(filePath, content, options);
        console.log(`File successfully written to ${filePath}`);
    } catch (error) {
        console.error(`Error writing file to ${filePath}:`, error.message);
    }
};

const filePath = 'output.txt';
const fileContent = 'Hello, this is some content to write to the file!';
const fileOptions = { encoding: 'utf8', flag: 'w' }; // Optional file write options

writeFileAsync(filePath, fileContent, fileOptions);

वादा आधारित पुस्तकालय

एक्सिओस एक पुस्तकालय है जिससे आपको परिचित होना चाहिए। Axios क्लाइंट में HTTP अनुरोधों को संभालता है और इसका व्यापक रूप से उपयोग किया जाता है।

एक्सप्रेस Node.js के लिए एक वेब फ्रेमवर्क है। इससे वेब ऐप्स और एपीआई बनाना आसान हो जाता है, और जब आप एक्सप्रेस के साथ वादों का उपयोग करते हैं, तो आपका कोड साफ रहता है और प्रबंधन करना आसान हो जाता है।

उदाहरण सहित भंडार

सभी उदाहरण यहां पाए जा सकते हैं: https://github.com/PrincAm/promise-example

सारांश

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

इस लेख में, हमने पता लगाया कि वादे क्या हैं, उनके परिणामों को कैसे परिभाषित करें और पुनः प्राप्त करें, और त्रुटियों को प्रभावी ढंग से कैसे संभालें। हमने चेनिंग, प्रॉमिस.ऑल और प्रॉमिस.रेस जैसी प्रमुख विशेषताओं को भी कवर किया। अंत में, हमने एसिंक वेट सिंटैक्स पेश किया, जो वादों के साथ काम करने का अधिक सरल तरीका प्रदान करता है।

इन अवधारणाओं को समझना किसी भी जावास्क्रिप्ट डेवलपर के लिए महत्वपूर्ण है, क्योंकि ये ऐसे उपकरण हैं जिन पर आप रोजाना भरोसा करेंगे।

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