जावास्क्रिप्ट में वादों का उपयोग करना

हम समय-समय पर उन सामग्रियों को प्रकाशित करते हैं जो एक या दूसरे तरीके से जावास्क्रिप्ट में वादों के उपयोग से संबंधित हैं।


वादों पर इतना ध्यान क्यों दिया जाता है? हम मानते हैं कि पूरी बात यह है कि यह तकनीक बहुत मांग में है, और यह समझना काफी मुश्किल है।

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



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

एक शुरुआतकर्ता की आंखों के माध्यम से जावास्क्रिप्ट

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

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

वादों के बारे में एक सरल कहानी

वचन वचन वादा करने के लिए अनुवाद करता है। प्रोग्रामिंग में वस्तुओं का वादा करते हैं, जिसे हम "वादे" कहते हैं, वे सामान्य वादों के समान हैं जो लोग वास्तविक जीवन में एक-दूसरे को देते हैं। तो चलिए पहले इन वादों के बारे में बात करते हैं।

विकिपीडिया पर, आप "वचन" शब्द की निम्नलिखित परिभाषा पा सकते हैं: "दायित्व, किसी को कुछ पूरा करने की सहमति या, इसके विपरीत, करने के लिए नहीं"। Ozhegov के शब्दकोश में, "वादा" "कुछ करने के लिए एक स्वैच्छिक प्रतिबद्धता है।"

तो हम वादों के बारे में क्या जानते हैं?

1. एक वादा आपको गारंटी देता है कि कुछ किया जाएगा। इससे कोई फर्क नहीं पड़ता कि वास्तव में ऐसा कौन करता है: जिसने वादा किया था, या जिसने वादा किया था, उसके अनुरोध पर कोई और। एक वादा किसी चीज में विश्वास दिलाता है, इस विश्वास के आधार पर जिसने वादा किया था, उदाहरण के लिए, कुछ योजनाएं बना सकता है।
2. एक वादा पूरा हो सकता है या नहीं।
3. यदि वादा पूरा होता है, तो, परिणामस्वरूप, आप कुछ ऐसी चीजों की अपेक्षा करते हैं जो आप भविष्य में किसी भी कार्रवाई को करने या किसी भी योजना को लागू करने के लिए उपयोग कर सकते हैं।
4. यदि वादा पूरा नहीं हुआ है, तो आप यह पता लगाना चाहेंगे कि जिसने दिया था वह उसे पूरा क्यों नहीं कर पाया। आपके द्वारा जो हुआ उसका कारण जानने के बाद और आपको यकीन होगा कि वादा पूरा नहीं हुआ है, आप सोच सकते हैं कि आगे क्या करना है, या स्थिति का सामना कैसे करना है।
5. आपके द्वारा कुछ वादा किया जाने के बाद, आपके पास किसी तरह की गारंटी है। आप उस चीज का लाभ नहीं उठा सकते हैं जिसका आप तुरंत वादा करते हैं। आप अपने लिए निर्धारित कर सकते हैं - यदि वादा पूरा हो गया है तो आपको क्या करने की आवश्यकता है (इसलिए, आपको वादा प्राप्त होगा), और यदि आपको पता चला है कि क्या करने की आवश्यकता है तो वह टूट जाएगा (इस मामले में आप जो हुआ उसका कारण जानते हैं, और इसलिए आप एक बैकअप योजना पर विचार कर सकते हैं। )।
6. यह संभावना है कि जिसने वादा किया था वह बस गायब हो जाएगा। ऐसे मामलों में, यह उपयोगी है कि वादा किसी तरह के समय सीमा में बंधा हो। उदाहरण के लिए, यदि आपने जो वादा किया था वह 10 दिनों में प्रकट नहीं होता है, तो आप मान सकते हैं कि उसे कुछ समस्याएं थीं और उसने वादा तोड़ दिया। नतीजतन, भले ही वादा किया गया व्यक्ति इसे 15 दिनों में पूरा करे, इससे कोई फर्क नहीं पड़ेगा, इसलिए आप पहले से ही वैकल्पिक योजना पर काम कर रहे हैं, वादे पर भरोसा नहीं कर रहे हैं।

अब जावास्क्रिप्ट पर जाएँ।

जावास्क्रिप्ट वादा करता है

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

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

वादे बनाएँ

यहां वादे कैसे किए जाते हैं:

new Promise( /* executor */ function(resolve, reject) { ... } ); 

कंस्ट्रक्टर एक फ़ंक्शन को स्वीकार करता है जो कुछ कार्यों को करता है, हमने इसे executor कहा है। यह फ़ंक्शन दो मापदंडों को लेता है - resolve और reject , जो बदले में, फ़ंक्शन भी हैं। वादे आमतौर पर अतुल्यकालिक संचालन या कोड करने के लिए उपयोग किए जाते हैं जो मुख्य धागे को ब्लॉक कर सकते हैं, उदाहरण के लिए, एक जो फाइलों के साथ काम करता है, कुछ एपीआई को कॉल करता है, डेटाबेस क्वेरी बनाता है, I / O के साथ सौदे करता है, और इसी तरह। ऐसे अतुल्यकालिक संचालन की शुरुआत executor समारोह में की executor है। यदि एसिंक्रोनस ऑपरेशन सफलतापूर्वक पूरा हो गया है, तो वादे से अपेक्षित परिणाम resolve फ़ंक्शन को कॉल करके वापस किया जाएगा। जिस स्थिति में यह फ़ंक्शन कहा जाता है वह वादे के निर्माता द्वारा निर्धारित किया जाता है। इसी तरह, जब कोई त्रुटि होती है, तो reject फ़ंक्शन reject कॉल करके क्या हुआ है के बारे में जानकारी।

अब जब हम जानते हैं, सामान्य शब्दों में, वादों को कैसे बनाया जाए, तो हम हर चीज को बेहतर ढंग से समझने के लिए एक साधारण वादा करेंगे।

 var keepsHisWord; keepsHisWord = true; promise1 = new Promise(function(resolve, reject) { if (keepsHisWord) {   resolve("The man likes to keep his word"); } else {   reject("The man doesnt want to keep his word"); } }); console.log(promise1); 

इस कोड का आउटपुट क्या होगा:


वादा एक राज्य (PromiseStatus) और एक मूल्य (PromiseValue) है

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

 promise2 = new Promise(function(resolve, reject) { setTimeout(function() {   resolve({     message: "The man likes to keep his word",     code: "aManKeepsHisWord"   }); }, 10 * 1000); }); console.log(promise2); 

इस कोड में, एक वादा बनाया गया है जो निश्चित रूप से 10 सेकंड में हल हो जाएगा। यह हमें एक अनधिकृत वादे की स्थिति को देखने का अवसर देता है।


अनारक्षित वचन

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


वादा 10 सेकंड के बाद और एक वस्तु वापस करने का हल

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

 keepsHisWord = false; promise3 = new Promise(function(resolve, reject) { if (keepsHisWord) {   resolve("The man likes to keep his word"); } else {   reject("The man doesn't want to keep his word"); } }); console.log(promise3); 

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


रिजेक्टेड प्रॉमिस

अब, तीनों उदाहरणों का विश्लेषण करते हुए, हम देख सकते हैं कि तीन अलग-अलग मूल्य PromiseStatus में दिखाई दे सकते हैं: pending (लंबित), resolved (सफल संकल्प) और rejected (अस्वीकार)। जब कोई वादा किया जाता है, तो PromiseStatus pending होगा, और PromiseValue undefined होगा। जब तक वादा हल या अस्वीकार नहीं किया जाता है तब तक ये मूल्य बने रहेंगे। जब कोई वादा एक settled या rejected राज्य में होता है, तो उसे एक settled वादा कहा जाता है। इस तरह का एक वादा एक प्रतीक्षा राज्य से एक राज्य में पारित हो गया है जिसमें यह या तो एक resolved राज्य है या एक rejected राज्य है।

अब जब हमें पता चला है कि वादे कैसे किए जाते हैं, तो हम इस बारे में बात कर सकते हैं कि वे कैसे वापस लौटते हैं। इसका पता लगाने के लिए, हमें Promise ऑब्जेक्ट की संरचना को समझने की आवश्यकता है।

वादा वस्तु

एमडीएन प्रलेखन के अनुसार, एक Promise वस्तु एक अतुल्यकालिक ऑपरेशन के सफल या असफल समापन का परिणाम है।

Promise ऑब्जेक्ट में स्थिर तरीके और ऑब्जेक्ट के प्रोटोटाइप तरीके हैं। ऑब्जेक्ट के इंस्टेंस को बनाए बिना स्टेटिक तरीकों को बुलाया जा सकता है, और प्रोटोटाइप के तरीकों को कॉल करने के लिए, आपको Promise ऑब्जेक्ट के इंस्टेंस की आवश्यकता होती है। ध्यान रखें कि स्थिर और नियमित दोनों ही तरीके Promise ऑब्जेक्ट लौटाते हैं। इससे काम आसान हो जाता है।

▍ वादा वस्तु प्रोटोटाइप तरीके

सबसे पहले बात करते हैं Promise ऑब्जेक्ट के प्रोटोटाइप तरीकों के बारे में। ऐसी तीन विधियाँ हैं। यह मत भूलो कि इन तरीकों को Promise वस्तु उदाहरण पर कहा जा सकता है, और वे स्वयं वादे वापस करते हैं। इन सभी तरीकों के लिए धन्यवाद, आप हैंडलर को असाइन कर सकते हैं जो वादों की स्थिति में परिवर्तन का जवाब देते हैं। जैसा कि हमने पहले ही देखा है, जब कोई वादा किया जाता है, तो यह pending स्थिति में होता है। जब एक वादे का resolved या rejected राज्य में परिवर्तन होता है, तो निम्न विधियों में से कम से कम एक को बुलाया जाएगा:

 Promise.prototype.catch(onRejected) Promise.prototype.then(onFulfilled, onRejected) Promise.prototype.finally(onFinally) 

नीचे वादा और ईवेंट के संचालन का एक आरेख है जो कि .catch और .catch के कॉल की ओर ले जाता है। चूँकि ये विधियाँ Promise वस्तुओं को Promise हैं, उनके कॉल को जंजीर में बाँधा जा सकता है, यह भी चित्र में परिलक्षित होता है। यदि वादे का .finally विधि का उपयोग करता है, तो यह कहा जाएगा कि जब वादे को settled है, चाहे वह वादा सफलतापूर्वक हल किया गया हो या खारिज कर दिया गया हो।


प्रोमिस कार्य योजना ( यहाँ से ली गई छवि)

यहाँ एक छोटी कहानी है। आप एक छात्र हैं और अपनी माँ से आपको एक सेल फोन खरीदने के लिए कहते हैं। वह कहती है: "अगर हमारी बचत फोन की लागत से अधिक है, तो मैं इसे आपके लिए खरीदूंगा।" अब इस कहानी को जावास्क्रिप्ट में पुनः लिखें।

 var momsPromise = new Promise(function(resolve, reject) { momsSavings = 20000; priceOfPhone = 60000; if (momsSavings > priceOfPhone) {   resolve({     brand: "iphone",     model: "6s"   }); } else {   reject("We donot have enough savings. Let us save some more money."); } }); momsPromise.then(function(value) { console.log("Hurray I got this phone as a gift ", JSON.stringify(value)); }); momsPromise.catch(function(reason) { console.log("Mom coudn't buy me the phone because ", reason); }); momsPromise.finally(function() { console.log(   "Irrespecitve of whether my mom can buy me a phone or not, I still love her" ); }); 

इस कोड का आउटपुट क्या होगा:


माँ ने वादा नहीं निभाया

यदि हम परिवर्तनशील momsSavings के मूल्य को 200,000 में बदल देते हैं, तो माँ अपने बेटे के लिए एक उपहार खरीद सकेगी। इस स्थिति में, उपरोक्त कोड निम्नलिखित आउटपुट देगा।


माँ ने एक वादा रखा

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

चूंकि onFulfilled को onFulfilled हैंडलर दोनों को सौंपा जा सकता है, जिसे तब वादा किया जाता है जब वादा सफलतापूर्वक हल हो जाता है और onRejected हैंडलर जिसे वादे को खारिज कर दिया जाता है, तब .catch मेथड और .catch मेथड दोनों का उपयोग करने के बजाय, हम सिर्फ एक के साथ एक ही प्रभाव प्राप्त कर सकते हैं। .then विधि। यहाँ यह है कि यह कैसा दिख सकता है:

 momsPromise.then( function(value) {   console.log("Hurray I got this phone as a gift ", JSON.stringify(value)); }, function(reason) {   console.log("Mom coudn't buy me the phone because ", reason); } ); 

यह एक कार्यशील उदाहरण है, लेकिन कोड पठनीयता को रोकने के लिए, एक सार्वभौमिक .catch और .catch विधियों का उपयोग करना बेहतर है।

इन उदाहरणों को एक ब्राउज़र और विशेष रूप से Google Chrome में चलाने के लिए, मैंने बाहरी निर्भरता से बचने का प्रयास किया। बाद में हम क्या विचार करेंगे, इसे बेहतर ढंग से समझने के लिए, आइए एक ऐसा फ़ंक्शन बनाएं जो एक वादा, प्रस्ताव या अस्वीकृति देता है जो यादृच्छिक रूप से होता है। यह हमें वादों के साथ काम करने के विभिन्न परिदृश्यों का अनुभव करने की अनुमति देगा। अतुल्यकालिक कार्यों की सुविधाओं को समझने के लिए, हम अपने वादों में यादृच्छिक विलंब निर्धारित करेंगे। चूंकि हमें यादृच्छिक संख्याओं की आवश्यकता होती है, हम एक फ़ंक्शन बनाते हैं जो x और y बीच एक यादृच्छिक संख्या देता है। यहाँ समारोह है।

 function getRandomNumber(start = 1, end = 10) { //,      start  end >=1  end > start return parseInt(Math.random() * end) % (end-start+1) + start; } 

अब एक फ़ंक्शन बनाएं जो वादे लौटाता है। इसे promiseTRRARNOSG । इस फ़ंक्शन का नाम promiseThatResolvesRandomlyAfterRandomNumnberOfSecondsGenerator के लिए खड़ा है। promiseThatResolvesRandomlyAfterRandomNumnberOfSecondsGenerator , promiseThatResolvesRandomlyAfterRandomNumnberOfSecondsGenerator , यह उन वादों का एक जनरेटर है जो यादृच्छिक रूप से हल या सेकंड की एक यादृच्छिक संख्या के बाद अस्वीकार कर दिया जाता है। यह फ़ंक्शन एक वादा बनाएगा जिसे 2 से 10 सेकंड के बीच यादृच्छिक समय के बाद अनुमति या अस्वीकार कर दिया जाएगा। किसी वादे को बेतरतीब ढंग से अनुमति देने या अस्वीकार करने के लिए, हमें 1 और 10. के बीच एक यादृच्छिक संख्या मिलती है। यदि यह संख्या 5 से अधिक है, तो वादे को अनुमति दी जाएगी, यदि नहीं, तो इसे अस्वीकार कर दिया जाएगा।

 function getRandomNumber(start = 1, end = 10) { //,      start  end >=1  end > start return (parseInt(Math.random() * end) % (end - start + 1)) + start; } var promiseTRRARNOSG = (promiseThatResolvesRandomlyAfterRandomNumnberOfSecondsGenerator = function() { return new Promise(function(resolve, reject) {   let randomNumberOfSeconds = getRandomNumber(2, 10);   setTimeout(function() {     let randomiseResolving = getRandomNumber(1, 10);     if (randomiseResolving > 5) {       resolve({         randomNumberOfSeconds: randomNumberOfSeconds,         randomiseResolving: randomiseResolving       });     } else {       reject({         randomNumberOfSeconds: randomNumberOfSeconds,         randomiseResolving: randomiseResolving       });     }   }, randomNumberOfSeconds * 1000); }); }); var testProimse = promiseTRRARNOSG(); testProimse.then(function(value) { console.log("Value when promise is resolved : ", value); }); testProimse.catch(function(reason) { console.log("Reason when promise is rejected : ", reason); }); //             ,    .     ,  - . for (i=1; i<=10; i++) { let promise = promiseTRRARNOSG(); promise.then(function(value) {   console.log("Value when promise is resolved : ", value); }); promise.catch(function(reason) {   console.log("Reason when promise is rejected : ", reason); }); } 

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

एक वादा वस्तु के ofStatic तरीके

एक Promise वस्तु के चार स्थिर तरीके हैं।

यहाँ दो विधियाँ हैं - Promise.reject(reason) और Promise.resolve(value) , जो आपको क्रमशः वादे, अस्वीकृत और अनुमति देने वाले वादे करने की अनुमति देते हैं।

यहां बताया गया है कि Promise.reject पद्धति के साथ कैसे काम किया जाए, जो अस्वीकृत वादे करता है।

 var promise3 = Promise.reject("Not interested"); promise3.then(function(value){ console.log("This will not run as it is a rejected promise. The resolved value is ", value); }); promise3.catch(function(reason){ console.log("This run as it is a rejected promise. The reason is ", reason); }); 

यहाँ Promise.resolve पद्धति का उपयोग करके एक उदाहरण है जो सफलतापूर्वक हल किए गए वादे बनाता है।

 var promise4 = Promise.resolve(1); promise4.then(function(value){ console.log("This will run as it is a resovled promise. The resolved value is ", value); }); promise4.catch(function(reason){ console.log("This will not run as it is a resolved promise", reason); }); 

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

 var promise4 = Promise.resolve(1); promise4.then(function(value){ console.log("This will run as it is a resovled promise. The resolved value is ", value); }); promise4.then(function(value){ console.log("This will also run as multiple handlers can be added. Printing twice the resolved value which is ", value * 2); }); promise4.catch(function(reason){ console.log("This will not run as it is a resolved promise", reason); }); 

यह वह है जो ब्राउज़र कंसोल में प्रदर्शित होता है:


प्रॉमिस के साथ काम करते समय कई

निम्नलिखित दो विधियाँ, Promise.all और Promise.race , वादों के सेट के साथ काम करने के लिए डिज़ाइन की गई हैं। यदि, एक निश्चित समस्या को हल करने के लिए, कई वादों को संसाधित करना आवश्यक है, तो इन वादों को एक सरणी में रखना सबसे सुविधाजनक है, और फिर उनके साथ आवश्यक क्रियाएं करें। यहां दिए गए तरीकों के सार को समझने के लिए, हम अपने सुविधाजनक फ़ंक्शन promiseTRRARNOSG का उपयोग नहीं कर पाएंगे, क्योंकि इसके काम का परिणाम मामले की इच्छा पर बहुत अधिक निर्भर करता है। हमारे लिए यह अधिक सुविधाजनक होगा कि हम किसी ऐसी चीज का उपयोग करें जो अधिक पूर्वानुमानित वादों का उत्पादन करती है, जो हमें उनके व्यवहार को समझने की अनुमति देगा। इसलिए, हम दो नए कार्य बनाएंगे। उनमें से एक ( promiseTRSANSG ) n सेकंड के बाद हल किए गए वादों को बनाएगा, दूसरा ( promiseTRJANSG ) - ऐसे वादे जो n सेकंड के बाद खारिज कर दिए जाते हैं।

 var promiseTRSANSG = (promiseThatResolvesAfterNSecondsGenerator = function( n = 0 ) { return new Promise(function(resolve, reject) {   setTimeout(function() {     resolve({       resolvedAfterNSeconds: n     });   }, n * 1000); }); }); var promiseTRJANSG = (promiseThatRejectsAfterNSecondsGenerator = function( n = 0 ) { return new Promise(function(resolve, reject) {   setTimeout(function() {     reject({       rejectedAfterNSeconds: n     });   }, n * 1000); }); }); 

अब हम Promise.all पद्धति की विशेषताओं को समझने के लिए इन कार्यों का उपयोग करेंगे।

▍ विधि Promise.all

MDN दस्तावेज़ीकरण से, आप यह पता लगा सकते हैं कि Promise.all(iterable) विधि एक वादा वापस करती है जिसे हल किया जाएगा जब सभी वादों को एक iterable तर्क के रूप में पारित किया जाता है, या जब इस तर्क में कोई वादे नहीं होते हैं। यह वादा खारिज कर दिया जाएगा यदि हस्तांतरित वादों में से कोई भी खारिज कर दिया गया है
आइए कुछ उदाहरण देखें।

उदाहरण संख्या १

यहां सभी वादों की अनुमति दी जाएगी। यह परिदृश्य सबसे आम है।

 console.time("Promise.All"); var promisesArray = []; promisesArray.push(promiseTRSANSG(1)); promisesArray.push(promiseTRSANSG(4)); promisesArray.push(promiseTRSANSG(2)); var handleAllPromises = Promise.all(promisesArray); handleAllPromises.then(function(values) { console.timeEnd("Promise.All"); console.log("All the promises are resolved", values); }); handleAllPromises.catch(function(reason) { console.log("One of the promises failed with the following reason", reason); }); 

यहाँ यह कोड कंसोल में आउटपुट करेगा:


सभी वादा किया है

इस उदाहरण के परिणामों का विश्लेषण करने के बाद, दो महत्वपूर्ण अवलोकन किए जा सकते हैं।

सबसे पहले, तीसरा वादा, जिसके संकल्प में 2 सेकंड लगते हैं, दूसरे से पहले पूरा हो जाता है, लेकिन, जैसा कि कोड द्वारा उत्पन्न आउटपुट से देखा जा सकता है, सरणी में वादों का क्रम संरक्षित है।

दूसरे, कोड में एक टाइमर होता है जिसका उपयोग यह पता लगाने के लिए किया जाता है कि Promise.all निर्देश को निष्पादित करने में कितना समय लगता है।

यदि वादों को क्रमिक रूप से निष्पादित किया गया था, तो इस निर्देश का निष्पादन समय 7 सेकंड (1 + 4 + 2) होगा। हालांकि, टाइमर ने हमें सूचित किया कि यदि हम परिणाम को पूरा करते हैं तो पूरे ऑपरेशन में 4 सेकंड लगते हैं। यह इस बात का प्रमाण है कि सभी वादे समानांतर रूप से निष्पादित किए जाते हैं।

उदाहरण संख्या 2

अब उस स्थिति पर विचार करें जब Promise.all को दिए गए सरणी में कोई वादे नहीं हैं। मेरा मानना ​​है कि यह इस सुविधा के लिए सबसे कम उपयोग का मामला है।

 console.time("Promise.All"); var promisesArray = []; promisesArray.push(1); promisesArray.push(4); promisesArray.push(2); var handleAllPromises = Promise.all(promisesArray); handleAllPromises.then(function(values) { console.timeEnd("Promise.All"); console.log("All the promises are resolved", values); }); handleAllPromises.catch(function(reason) { console.log("One of the promises failed with the following reason", reason); }); 

यहाँ आउटपुट है कि यह कोड उत्पन्न करेगा:


Promise.all आह्वान करें और इस विधि से कोई वादा नहीं करते हुए एक सरणी दें

चूंकि सरणी में कोई वादा नहीं है, Promise.all लगभग तुरंत Promise.all है।

उदाहरण संख्या 3

अब देखते हैं कि क्या होता है जब वादे में से एक वादा किया गया था।

 console.time("Promise.All"); var promisesArray = []; promisesArray.push(promiseTRSANSG(1)); promisesArray.push(promiseTRSANSG(5)); promisesArray.push(promiseTRSANSG(3)); promisesArray.push(promiseTRJANSG(2)); promisesArray.push(promiseTRSANSG(4)); var handleAllPromises = Promise.all(promisesArray); handleAllPromises.then(function(values) { console.timeEnd("Promise.All"); console.log("All the promises are resolved", values); }); handleAllPromises.catch(function(reason) { console.timeEnd("Promise.All"); console.log("One of the promises failed with the following reason ", reason); }); 

जैसा कि आप नीचे दिखाए गए कोड निष्पादन परिणामों से देख सकते हैं, Promise.all निष्पादन उस संदेश के आउटपुट के साथ पहले खारिज किए गए वादे के बाद बंद हो जाता है जो यह वादा देता है।


पहले खारिज किए गए वादे के बाद निष्पादन बंद हो जाता है

▍ वादा करो। विधि

MDN रिपोर्ट करता है कि Promise.race(iterable) विधि एक अनुमत या अस्वीकृत वादे के साथ एक अस्वीकृत या अस्वीकार किए गए वादे के बाद एक लौटाया गया है जो क्रमशः प्रेषित वादों में से एक को अनुमति या अस्वीकार कर दिया गया है।

आइए Promise.race साथ काम करने के उदाहरण देखें।

उदाहरण संख्या १

यह दिखाता है कि क्या होता है जब वादे में से एक वादा किया गया हो।

 console.time("Promise.race"); var promisesArray = []; promisesArray.push(promiseTRSANSG(4)); promisesArray.push(promiseTRSANSG(3)); promisesArray.push(promiseTRSANSG(2)); promisesArray.push(promiseTRJANSG(3)); promisesArray.push(promiseTRSANSG(4)); var promisesRace = Promise.race(promisesArray); promisesRace.then(function(values) { console.timeEnd("Promise.race"); console.log("The fasted promise resolved", values); }); promisesRace.catch(function(reason) { console.timeEnd("Promise.race"); console.log("The fastest promise rejected with the following reason ", reason); }); 

इस उदाहरण को निष्पादित करने के बाद कंसोल को यही मिलता है।


प्रोमिस, जिसने हर किसी की तुलना में तेजी से हल किया

यहां सभी वादे समानांतर रूप से किए जाते हैं। तीसरा वादा 2 सेकंड के बाद हल किया जाता है। जैसे ही ऐसा होता है, वादा द्वारा लौटाया गया वादा।

उदाहरण संख्या 2

अब उस स्थिति पर विचार करें जब वादे में से एक वादा किया गया था।

 console.time("Promise.race"); var promisesArray = []; promisesArray.push(promiseTRSANSG(4)); promisesArray.push(promiseTRSANSG(6)); promisesArray.push(promiseTRSANSG(5)); promisesArray.push(promiseTRJANSG(3)); promisesArray.push(promiseTRSANSG(4)); var promisesRace = Promise.race(promisesArray); promisesRace.then(function(values) { console.timeEnd("Promise.race"); console.log("The fasted promise resolved", values); }); promisesRace.catch(function(reason) { console.timeEnd("Promise.race"); console.log("The fastest promise rejected with the following reason ", reason); }); 

इस उदाहरण को निष्पादित करने के बाद, कंसोल को निम्नलिखित मिलेगा:


बाकी सभी के सामने वादा खारिज कर दिया

यहां के वादे, पिछले उदाहरणों की तरह, समानांतर में किए गए हैं। चौथा वादा 3 सेकंड के बाद खारिज कर दिया जाता है। जैसे ही ऐसा होता है, वादा करके वापस किया गया वादा।

सामान्य उदाहरण और प्रयोग

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

इन उदाहरणों को स्वयं खोजकर, आप कोड के साथ प्रयोग कर सकते हैं, चर के मूल्यों के साथ, और वादों का उपयोग करने के लिए विभिन्न परिदृश्यों का अध्ययन कर सकते हैं। विशेष रूप से, आप वादों का उपयोग करने के लिए बहुत सारे परिदृश्यों का अनुकरण करने के लिए वादे के संयोजन, वादों की संख्या और वादों के promiseTRRARNOSG का उपयोग कर सकते हैं, जिससे आप उन्हें बेहतर ढंग से समझ पाएंगे। इसके अलावा, ध्यान दें कि console.time कमांड का उपयोग करने से आपको कोड के एक निश्चित टुकड़े को निष्पादित करने के लिए आवश्यक समय का पता लगाने की अनुमति मिलती है, और, उदाहरण के लिए, यह पता लगाने के लिए कि क्या वादे समानांतर या क्रमिक रूप से निष्पादित किए जाते हैं। यहाँ कोड के साथ जिस्ट पेज का लिंक दिया गया है। और वैसे, यदि आप चाहते हैं, तो ब्लूबर्ड लाइब्रेरी पर एक नज़र डालें, जिसमें वादों के साथ काम करने के कुछ दिलचस्प तरीके शामिल हैं।

परिणाम

मैं आपको उन नियमों की सूची प्रदान करता हूं, जिनका मैं सही ढंग से उपयोग करने के लिए वादों के साथ काम करता हूं।

1. जब आप अतुल्यकालिक या अवरोधक कोड के साथ काम करते हैं तो स्थितियों में वादों का उपयोग करें।
2. किसी वादे को सफलतापूर्वक हल करने की स्थिति को संभालने के लिए, .catch विधि का उपयोग करें; उन मामलों के लिए जहां वादा खारिज कर दिया गया है, .catch उपयोग .catch ।
3. सभी वादों में .catch और .catch उपयोग करें।
4. - , , .finally .
5. , , , .
6. , .
7. Promise , , , .
8. Promise.all , .

, , , .

प्रिय पाठकों! , , ?