Node.js मैनुअल, भाग 7: अतुल्यकालिक प्रोग्रामिंग

आज, Node.js मैनुअल के सातवें भाग के अनुवाद में, हम अतुल्यकालिक प्रोग्रामिंग के बारे में बात करेंगे, कॉलबैक, वादे और async / प्रतीक्षा निर्माण जैसे मुद्दों पर विचार करें, और घटनाओं पर काम करने के तरीके पर चर्चा करें।

प्रोग्रामिंग भाषाओं में अतुल्यकालिक

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

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

एक नियम के रूप में, प्रोग्रामिंग भाषाएं अतुल्यकालिक हैं, उनमें से कुछ प्रोग्रामर को अंतर्निहित भाषा उपकरणों या विशेष पुस्तकालयों का उपयोग करके, अतुल्यकालिक तंत्रों को नियंत्रित करने की क्षमता प्रदान करते हैं। हम C, Java, C #, PHP, Go, Ruby, Swift, Python जैसी भाषाओं के बारे में बात कर रहे हैं। उनमें से कुछ आपको अतुल्यकालिक शैली में प्रोग्राम करने की अनुमति देते हैं, धागे का उपयोग करते हुए, नई प्रक्रियाएं शुरू करते हैं।

जावास्क्रिप्ट अतुल्यकालिक

जैसा कि पहले ही उल्लेख किया गया है, जावास्क्रिप्ट एक एकल-थ्रेडेड सिंक्रोनस भाषा है। जेएस में लिखी गई कोड की पंक्तियों को उस क्रम में निष्पादित किया जाता है जिसमें वे पाठ में दिखाई देते हैं, एक के बाद एक। उदाहरण के लिए, यहाँ एक बहुत ही सामान्य JS प्रोग्राम है जो इस व्यवहार को प्रदर्शित करता है:

const a = 1 const b = 2 const c = a * b console.log(c) doSomething() 

लेकिन जावास्क्रिप्ट ब्राउज़र में उपयोग के लिए बनाया गया था। इसका मुख्य कार्य, शुरुआत में, उपयोगकर्ता गतिविधियों से संबंधित घटनाओं के प्रसंस्करण को व्यवस्थित करना था। उदाहरण के लिए, ये onClick , onMouseOver , onSubmit , onSubmit , और इसी तरह की घटनाएं हैं। कैसे एक तुल्यकालिक प्रोग्रामिंग मॉडल के ढांचे के भीतर ऐसी समस्याओं को हल करने के लिए?

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

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

कॉलबैक

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

ईवेंट हैंडलर एक फ़ंक्शन को स्वीकार करता है जिसे इवेंट होने पर बुलाया जाएगा। यह इस तरह दिखता है:

 document.getElementById('button').addEventListener('click', () => { //    }) 

ऐसे कार्यों को कॉलबैक फ़ंक्शन या कॉलबैक भी कहा जाता है।

कॉलबैक एक नियमित फ़ंक्शन है जिसे किसी अन्य फ़ंक्शन के मान के रूप में पास किया जाता है। यह तभी कहा जाएगा जब कोई निश्चित घटना घटेगी। जावास्क्रिप्ट प्रथम श्रेणी के कार्यों की अवधारणा को लागू करता है। इस तरह के कार्यों को चर के लिए सौंपा जा सकता है और अन्य कार्यों के लिए पारित किया जा सकता है (जिसे उच्च-क्रम फ़ंक्शन कहा जाता है)।

क्लाइंट-साइड जावास्क्रिप्ट डेवलपमेंट में एक सामान्य दृष्टिकोण वह है जब सभी क्लाइंट कोड एक window ऑब्जेक्ट के load इवेंट के श्रोता में लिपटे होते window , जो पेज के काम के लिए तैयार होने के बाद इसे कॉलबैक को कॉल करता है:

 window.addEventListener('load', () => { //  //     }) 

कॉलबैक का उपयोग हर जगह किया जाता है, न कि केवल DOM ईवेंट्स को हैंडल करने के लिए। उदाहरण के लिए, हम पहले ही समय में उनके उपयोग के साथ मिल चुके हैं:

 setTimeout(() => { //   2  }, 2000) 

XHR अनुरोध भी कॉलबैक का उपयोग करते हैं। इस मामले में, यह संबंधित संपत्ति के लिए एक कार्य सौंपने जैसा दिखता है। एक निश्चित फ़ंक्शन होने पर एक समान फ़ंक्शन को बुलाया जाएगा। निम्नलिखित उदाहरण में, इस तरह की घटना एक अनुरोध राज्य परिवर्तन है:

 const xhr = new XMLHttpRequest() xhr.onreadystatechange = () => { if (xhr.readyState === 4) {   xhr.status === 200 ? console.log(xhr.responseText) : console.error('error') } } xhr.open('GET', 'https://yoursite.com') xhr.send() 

S कॉलबैक में त्रुटि से निपटने

चलो कॉलबैक में त्रुटियों को कैसे संभालना है, इसके बारे में बात करते हैं। ऐसी त्रुटियों से निपटने के लिए एक सामान्य रणनीति है, जिसका उपयोग Node.js. में भी किया जाता है। यह इस तथ्य में शामिल है कि किसी भी कॉलबैक फ़ंक्शन का पहला पैरामीटर त्रुटि ऑब्जेक्ट है। यदि कोई त्रुटि नहीं है, तो इस पैरामीटर को null लिखा जाएगा। अन्यथा, इसके वर्णन और इसके बारे में अतिरिक्त जानकारी युक्त एक त्रुटि वस्तु होगी। यहाँ यह कैसा दिखता है:

 fs.readFile('/file.json', (err, data) => { if (err !== null) {   //    console.log(err)   return } // ,   console.log(data) }) 

Problem कॉलबैक समस्या

कॉलबैक सरल स्थितियों में उपयोग करने के लिए सुविधाजनक हैं। हालाँकि, प्रत्येक कॉलबैक कोड नेस्टिंग का एक अतिरिक्त स्तर है। यदि कई नेस्टेड कॉलबैक का उपयोग किया जाता है, तो यह जल्दी से कोड संरचना की एक महत्वपूर्ण जटिलता की ओर जाता है:

 window.addEventListener('load', () => { document.getElementById('button').addEventListener('click', () => {   setTimeout(() => {     items.forEach(item => {       //,  -      })   }, 2000) }) }) 

इस उदाहरण में, कोड के केवल 4 स्तरों को दिखाया गया है, लेकिन व्यवहार में बड़ी संख्या में स्तरों का सामना किया जा सकता है, जिसे आमतौर पर "कॉलबैक नरक" कहा जाता है। आप अन्य भाषा निर्माणों का उपयोग करके इस समस्या से निपट सकते हैं।

वादे और async / प्रतीक्षा करें

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

▍ वादा करता है

प्रॉमिस (वादा वस्तुएं) जावास्क्रिप्ट में एसिंक्रोनस सॉफ्टवेयर निर्माण के साथ काम करने के तरीकों में से एक है, जो सामान्य तौर पर, कॉलबैक के उपयोग को कम करता है।

वादे के साथ परिचित

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

वादे कैसे काम करते हैं?

एक वादा कहा जाता है के बाद, यह एक लंबित स्थिति में चला जाता है। इसका मतलब यह है कि वादा करने वाले फ़ंक्शन को निष्पादित किया जाता है, जबकि वादे में कुछ गणना की जाती है, जिसके बाद वादा इसके बारे में सूचित करता है। यदि वादे के अनुसार किया गया ऑपरेशन सफलतापूर्वक पूरा हो जाता है, तो वादा पूरा होने वाले राज्य में स्थानांतरित कर दिया जाता है। ऐसा वादा सफलतापूर्वक हल करने के लिए कहा जाता है। यदि ऑपरेशन एक त्रुटि के साथ पूरा होता है, तो वादे को अस्वीकृत स्थिति में रखा जाता है।

वादों के साथ काम करने की बात करते हैं।

वादे बनाएँ

वादों के साथ काम करने के लिए एपीआई हमें संबंधित कंस्ट्रक्टर देता है, जिसे फॉर्म के new Promise() कमांड new Promise() आदेश द्वारा बुलाया जाता है। यहां वादे कैसे किए जाते हैं:

 let done = true const isItDoneYet = new Promise( (resolve, reject) => {   if (done) {     const workDone = 'Here is the thing I built'     resolve(workDone)   } else {     const why = 'Still working on something else'     reject(why)   } } ) 

प्रॉमिस वैश्विक निरंतरता की जांच करता done , और यदि इसका मूल्य true , तो यह सफलतापूर्वक हल हो गया है। अन्यथा, वादा अस्वीकार कर दिया जाता है। resolve का उपयोग करना और मापदंडों reject करना, जो कार्य हैं, हम वादे से मूल्यों को वापस कर सकते हैं। इस मामले में, हम एक स्ट्रिंग लौटाते हैं, लेकिन यहां एक ऑब्जेक्ट का उपयोग किया जा सकता है।

वादे के साथ काम करें

हमने ऊपर एक वादा किया था, अब इसके साथ काम करने पर विचार करें। यह इस तरह दिखता है:

 const isItDoneYet = new Promise( //... ) const checkIfItsDone = () => { isItDoneYet   .then((ok) => {     console.log(ok)   })   .catch((err) => {     console.error(err)   }) } checkIfItsDone() 

checkIfItsDone() को कॉल करने से isItDoneYet isItDoneYet() और उसके समाधान की प्रतीक्षा करने वाले संगठन को निष्पादन मिलेगा। यदि वादा सफलतापूर्वक हल हो जाता है, .then() विधि में कॉलबैक पास हो जाएगा। यदि कोई त्रुटि होती है, अर्थात, वादे को अस्वीकार कर दिया जाएगा, तो इसे .catch() पद्धति से पारित फ़ंक्शन में संसाधित किया जा सकता है।

चैनिंग प्रॉमिस

वादे के तरीके वादे वापस करते हैं, जिससे आप उन्हें जंजीरों में बांध सकते हैं। इस व्यवहार का एक अच्छा उदाहरण ब्राउज़र-आधारित API Fetch है , जो XMLHttpRequest पर एक अमूर्त परत है। Node.js के लिए एक काफी लोकप्रिय npm पैकेज है जो Fetch API को लागू करता है, जिसके बारे में हम बाद में चर्चा करेंगे। इस एपीआई का उपयोग कुछ नेटवर्क संसाधनों को लोड करने के लिए किया जा सकता है, और चेन में वादों के संयोजन की संभावना के लिए धन्यवाद, डाउनलोड किए गए डेटा के बाद के प्रसंस्करण को व्यवस्थित करने के लिए। वास्तव में, जब आप fetch() फ़ंक्शन के लिए कॉल के माध्यम से Fetch API कॉल करते हैं, तो एक वादा बनाया जाता है।

ज्वलंत वादों के निम्नलिखित उदाहरण पर विचार करें:

 const fetch = require('node-fetch') const status = (response) => { if (response.status >= 200 && response.status < 300) {   return Promise.resolve(response) } return Promise.reject(new Error(response.statusText)) } const json = (response) => response.json() fetch('https://jsonplaceholder.typicode.com/todos') .then(status) .then(json) .then((data) => { console.log('Request succeeded with JSON response', data) }) .catch((error) => { console.log('Request failed', error) }) 

यहां हम JSON डेटा के स्रोत के रूप में npm पैकेज नोड- भ्रूण और jsonplaceholder.typicode.com संसाधन का उपयोग करते हैं।

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

• status एक संख्यात्मक मान है जो HTTP स्थिति कोड का प्रतिनिधित्व करता है।
• statusText - HTTP स्थिति कोड का एक शाब्दिक विवरण, जिसे स्ट्रिंग OK द्वारा दर्शाया गया है यदि अनुरोध सफल रहा।

response ऑब्जेक्ट में एक json() विधि है जो एक वादा लौटाती है, जिसके समाधान पर अनुरोध निकाय की संसाधित सामग्री प्रस्तुत की जाती है, JSON प्रारूप में प्रस्तुत की जाती है।

उपरोक्त को देखते हुए, हम वर्णन करते हैं कि इस कोड में क्या हो रहा है। श्रृंखला में पहला वादा उस status() फ़ंक्शन द्वारा दर्शाया गया है जिसे हमने घोषित किया था, जो प्रतिक्रिया की स्थिति की जांच करता है, और यदि यह इंगित करता है कि अनुरोध विफल हो गया है (यानी, HTTP स्थिति कोड 200 और 299 के बीच सीमा में नहीं है), तो वादा अस्वीकार कर दिया गया है। यह ऑपरेशन इस तथ्य की ओर जाता है कि वादों की श्रृंखला में अन्य .then() अभिव्यक्तियों को निष्पादित नहीं किया जाता है और हम तुरंत .catch() विधि पर .catch() , कंसोल के लिए आउटपुट, त्रुटि संदेश के साथ, पाठ Request failed ।

अगर HTTP स्टेटस कोड हमें सूट करता है, तो हमारे द्वारा घोषित json() फ़ंक्शन को कहा जाता है। पिछले वादे के बाद से, यदि सफलतापूर्वक हल हो गया है, तो response ऑब्जेक्ट लौटाता है, हम इसे दूसरे वादे के इनपुट मूल्य के रूप में उपयोग करते हैं।

इस स्थिति में, हम संसाधित JSON डेटा लौटाते हैं, इसलिए तीसरा वादा इसे प्राप्त करता है, जिसके बाद वे एक संदेश से पहले अनुरोध करते हैं कि अनुरोध आवश्यक डेटा प्राप्त करने में सक्षम था, कंसोल में प्रदर्शित होते हैं।

हैंडलिंग में त्रुटि

पिछले उदाहरण में, हमारे पास वादों की श्रृंखला से जुड़ी एक .catch() विधि थी। यदि वादों की श्रृंखला में कुछ गलत हो जाता है और एक त्रुटि उत्पन्न होती है, या यदि वादों में से एक खारिज कर दिया जाता है, तो नियंत्रण को निकटतम अभिव्यक्ति में स्थानांतरित कर दिया जाता है .catch() । यहां वह स्थिति है जब किसी वादे में त्रुटि होती है:

 new Promise((resolve, reject) => { throw new Error('Error') }) .catch((err) => { console.error(err) }) 

यहां एक वादे को अस्वीकार करने के बाद ट्रिगर .catch() का एक उदाहरण दिया गया है:

 new Promise((resolve, reject) => { reject('Error') }) .catch((err) => { console.error(err) }) 

कैस्केडिंग त्रुटि हैंडलिंग

यदि कोई त्रुटि .catch() अभिव्यक्ति में होती है तो क्या होगा? इस त्रुटि को संभालने के लिए, आप वादों की श्रृंखला में एक और .catch() अभिव्यक्ति शामिल कर सकते हैं (और फिर आप उतने संलग्न कर सकते हैं। .catch() आवश्यकतानुसार श्रृंखला में .catch() अभिव्यक्ति)।

 new Promise((resolve, reject) => { throw new Error('Error') }) .catch((err) => { throw new Error('Error') }) .catch((err) => { console.error(err) }) 

अब आइए वादों को प्रबंधित करने के लिए इस्तेमाल किए जाने वाले कुछ उपयोगी तरीकों को देखें।

Promise.all ()

यदि आपको कई वादों को हल करने के बाद कुछ कार्रवाई करने की आवश्यकता है, तो आप Promise.all() कमांड का उपयोग करके ऐसा कर सकते हैं। एक उदाहरण पर विचार करें:

 const f1 = fetch('https://jsonplaceholder.typicode.com/todos/1') const f2 = fetch('https://jsonplaceholder.typicode.com/todos/2') Promise.all([f1, f2]).then((res) => {   console.log('Array of results', res) }) .catch((err) => { console.error(err) }) 

ES2015 में, विनाशकारी असाइनमेंट का सिंटैक्स दिखाई दिया है; इसका उपयोग करके, आप निम्न फॉर्म के निर्माण बना सकते हैं:

 Promise.all([f1, f2]).then(([res1, res2]) => {   console.log('Results', res1, res2) }) 

यहाँ, एक उदाहरण के रूप में, हमने API Fetch पर विचार किया, लेकिन Promise.all() , निश्चित रूप से, आपको किसी भी वादे के साथ काम करने की अनुमति देता है।

प्रॉमिस.्रेस ()

Promise.race() कमांड आपको दिए गए वादों में से एक को हल करने के बाद निर्दिष्ट कार्रवाई करने की अनुमति देता है। इस पहले वादे के परिणामों वाले संगत कॉलबैक को केवल एक बार कहा जाता है। एक उदाहरण पर विचार करें:

 const first = new Promise((resolve, reject) => {   setTimeout(resolve, 500, 'first') }) const second = new Promise((resolve, reject) => {   setTimeout(resolve, 100, 'second') }) Promise.race([first, second]).then((result) => { console.log(result) // second }) 

अनियोजित TypeError त्रुटि जो वादों के साथ काम करते समय होती है

यदि, वादों के साथ काम करते समय, आप Uncaught TypeError: undefined is not a promise सामना करते हैं Uncaught TypeError: undefined is not a promise त्रुटि Uncaught TypeError: undefined is not a promise , तो सुनिश्चित करें कि new Promise() करते समय new Promise() निर्माण का उपयोग केवल Promise() बजाय किया जाता है।

▍ async / प्रतीक्षा डिज़ाइन

Async / प्रतीक्षित निर्माण, अतुल्यकालिक प्रोग्रामिंग के लिए एक आधुनिक दृष्टिकोण है, इसे सरल बनाता है। अतुल्यकालिक कार्यों को वादों और जनरेटर के संयोजन के रूप में दर्शाया जा सकता है, और सामान्य तौर पर, यह निर्माण वादों पर अमल है।

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

जिन समस्याओं का समाधान किया गया था उनमें से एक प्रसिद्ध "कॉलबैक का नरक" था, लेकिन उन्होंने इस समस्या को हल करते हुए, एक समान प्रकृति की अपनी समस्याओं का निर्माण किया।

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

कैसे निर्माण कार्य करता है

एक एसिंक्रोनस फ़ंक्शन एक वादा लौटाता है, निम्न उदाहरण में:

 const doSomethingAsync = () => {   return new Promise((resolve) => {       setTimeout(() => resolve('I did something'), 3000)   }) } 

जब आपको एक समान फ़ंक्शन को कॉल करने की आवश्यकता होती है, तो आपको इसे कॉल करने के लिए कमांड से पहले await कीवर्ड रखना होगा। यह कोड को कॉल करने के लिए अनुमति देने या संबंधित वादे को अस्वीकार करने का कारण होगा। यह ध्यान दिया जाना चाहिए कि एक फ़ंक्शन जो await कीवर्ड का उपयोग करता है उसे async का उपयोग करके घोषित किया जाना चाहिए:

 const doSomething = async () => {   console.log(await doSomethingAsync()) } 

उपरोक्त दो कोड टुकड़ों को मिलाएं और इसके व्यवहार की जांच करें:

 const doSomethingAsync = () => {   return new Promise((resolve) => {       setTimeout(() => resolve('I did something'), 3000)   }) } const doSomething = async () => {   console.log(await doSomethingAsync()) } console.log('Before') doSomething() console.log('After') 

यह कोड निम्नलिखित आउटपुट देगा:

 Before After I did something 

पाठ I did something 3 सेकंड की देरी के साथ कंसोल में हो जाता है।

वादे और अतुल्यकालिक कार्यों के बारे में

यदि आप async का उपयोग करके एक निश्चित फ़ंक्शन की घोषणा करते हैं, तो इसका मतलब यह होगा कि ऐसा फ़ंक्शन एक वादा वापस कर देगा भले ही यह स्पष्ट रूप से नहीं किया गया हो। इसीलिए, उदाहरण के लिए, निम्नलिखित उदाहरण एक कार्य कोड है:

 const aFunction = async () => { return 'test' } aFunction().then(console.log) //    'test' 

यह डिजाइन इस तरह है:

 const aFunction = async () => { return Promise.resolve('test') } aFunction().then(console.log) //    'test' 

एसिंक्स / वेट की ताकत

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

 const getFirstUserData = () => { return fetch('/users.json') //      .then(response => response.json()) //  JSON   .then(users => users[0]) //      .then(user => fetch(`/users/${user.name}`)) //       .then(userResponse => userResponse.json()) //  JSON } getFirstUserData() 

यहाँ वही समस्या का समाधान है जो async / wait के उपयोग से दिखता है:

 const getFirstUserData = async () => { const response = await fetch('/users.json') //    const users = await response.json() //  JSON const user = users[0] //    const userResponse = await fetch(`/users/${user.name}`) //     const userData = await userResponse.json() //  JSON return userData } getFirstUserData() 

एसिंक्रोनस कार्यों से अनुक्रम का उपयोग करना

एसिंक्रोनस फ़ंक्शंस को आसानी से उन डिज़ाइनों में जोड़ा जा सकता है जो प्रोमिस चेन से मिलते जुलते हैं। इस तरह के संयोजन के परिणाम, हालांकि, बेहतर पठनीयता हैं:

 const promiseToDoSomething = () => {   return new Promise(resolve => {       setTimeout(() => resolve('I did something'), 10000)   }) } const watchOverSomeoneDoingSomething = async () => {   const something = await promiseToDoSomething()   return something + ' and I watched' } const watchOverSomeoneWatchingSomeoneDoingSomething = async () => {   const something = await watchOverSomeoneDoingSomething()   return something + ' and I watched as well' } watchOverSomeoneWatchingSomeoneDoingSomething().then((res) => {   console.log(res) }) 

यह कोड निम्नलिखित पाठ का उत्पादन करेगा:

 I did something and I watched and I watched as well 

सरलीकृत डिबगिंग

वाद-विवाद करना मुश्किल है, क्योंकि उनका उपयोग करने से आप डिबगर के सामान्य साधनों का उपयोग नहीं कर सकते हैं (जैसे "स्टेप बायपास", स्टेप-ओवर)। एसिंक्स / वेट का उपयोग करके लिखे गए कोड को नियमित सिंक्रोनस कोड के समान विधियों का उपयोग करके डीबग किया जा सकता है।

इवेंट जनरेशन Node.js में

यदि आपने एक ब्राउज़र में जावास्क्रिप्ट के साथ काम किया है, तो आप जानते हैं कि पृष्ठ के साथ उपयोगकर्ता इंटरैक्शन को संभालने में ईवेंट बड़ी भूमिका निभाते हैं। यह क्लिक और माउस आंदोलनों के कारण होने वाली घटनाओं से निपटने के बारे में है, कीबोर्ड पर कीस्ट्रोक्स और इसी तरह। Node.js में, आप उन घटनाओं के साथ काम कर सकते हैं जो प्रोग्रामर अपने दम पर बनाता है। यहां आप इवेंट मॉड्यूल का उपयोग करके अपना स्वयं का ईवेंट सिस्टम बना सकते हैं। विशेष रूप से, यह मॉड्यूल हमें EventEmitter वर्ग प्रदान करता है, जिनमें से क्षमताओं का उपयोग घटनाओं के साथ काम को व्यवस्थित करने के लिए किया जा सकता है। इस तंत्र का उपयोग करने से पहले, आपको इसे कनेक्ट करने की आवश्यकता है:

 const EventEmitter = require('events').EventEmitter 

इसके साथ काम करते समय, दूसरों के बीच, on() और emit() तरीके हमारे लिए उपलब्ध हैं। emit विधि emit उपयोग घटनाओं को कॉल करने के लिए किया जाता है। on मेथड का उपयोग कॉलबैक, ईवेंट हैंडलर को कॉन्फ़िगर करने के लिए किया जाता है, जिसे एक निश्चित ईवेंट कहा जाता है।

उदाहरण के लिए, चलिए एक start इवेंट बनाते हैं। जब ऐसा होता है, तो हम कंसोल में कुछ आउटपुट करेंगे:

 eventEmitter = new EventEmitter(); eventEmitter.on('start', () => { console.log('started') }) 

इस घटना को ट्रिगर करने के लिए, निम्नलिखित निर्माण का उपयोग किया जाता है:

 eventEmitter.emit('start') 

इस कमांड के क्रियान्वयन के परिणामस्वरूप, ईवेंट हैंडलर कहा जाता है और स्ट्रिंग कंसोल को मिलने लगती है।

आप ईवेंट हैंडलर को तर्क पास कर सकते हैं, उन्हें emit() विधि के अतिरिक्त तर्क के रूप में प्रस्तुत कर सकते हैं:

 eventEmitter.on('start', (number) => { console.log(`started ${number}`) }) eventEmitter.emit('start', 23) 

यही बात उन मामलों में भी होती है जहां हैंडलर को कई तर्क देने पड़ते हैं:

 eventEmitter.on('start', (start, end) => { console.log(`started from ${start} to ${end}`) }) eventEmitter.emit('start', 1, 100) 

EventEmitter वर्ग की EventEmitter में कुछ अन्य उपयोगी विधियाँ हैं:

• once() - आप एक घटना हैंडलर को पंजीकृत करने की अनुमति देता है जिसे केवल एक बार कहा जा सकता है।
• removeListener() - आपको उस हैंडलर को उस तक removeListener() अनुमति देता है, जो उस इवेंट के हैंडलर के पास से गुजरता है।
• removeAllListeners() - आपको इस पर दिए गए ईवेंट के सभी हैंडलर्स को निकालने की अनुमति देता है।

परिणाम

आज हमने जावास्क्रिप्ट में अतुल्यकालिक प्रोग्रामिंग के बारे में बात की, विशेष रूप से, हमने कॉलबैक, वादों और एसिंक्स / वेट निर्माण पर चर्चा की। यहां हमने events मॉड्यूल का उपयोग करके डेवलपर द्वारा वर्णित घटनाओं के साथ काम करने के मुद्दे पर छुआ। हमारा अगला विषय Node.js प्लेटफ़ॉर्म का नेटवर्किंग तंत्र होगा।

प्रिय पाठकों! जब Node.js के लिए प्रोग्रामिंग करते हैं, तो क्या आप async / प्रतीक्षा निर्माण का उपयोग करते हैं?