वादे करना आभूषण कला है

लेख ज्वैलर्स के लिए लिखा गया है, जो गहनों की बढ़ती लोकप्रियता के कारण, अपना काम छोड़ कर अपने पिछले वाले से थोड़ा और सटे हुए थे।

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

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

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

Node.js गैर-अवरोधक I / O के साथ घटना-उन्मुख और अतुल्यकालिक (या प्रतिक्रियाशील) प्रोग्रामिंग पर आधारित है - यह विकी से लिया गया था। वादों के संदर्भ में हमारे लिए यह सब क्या मायने रखता है। एक तीर के साथ एक घड़ी की कल्पना करें, हर बार जब यह "टिक" नियंत्रण हमारी स्क्रिप्ट में स्थानांतरित हो जाता है, और जब यह "जैसे" नियंत्रण नोड को हस्तांतरित हो जाता है, लेकिन इसका मतलब यह नहीं है कि नोड केवल "तो" चरण में काम करता है, बस "में" इसलिए "हम यह मानेंगे कि वह हमें अतुल्यकालिक I / O कार्यों के मुद्दों पर उसकी गतिविधियों के परिणामों की सूचना देता है। हमने भविष्य की संरचना का पहला प्रयास किया, हमने इसे फिर से टिक-टू-टिक में विभाजित किया, ठीक है, मुझे फिर से बहुत सारे टिक्स पर एक ऑर्डर रिलेशन पेश किया। जाहिर तौर पर इससे दूर होने का कोई रास्ता नहीं है, और भगवान का शुक्र है कि मुझे पता नहीं है कि लोग बिना कारण कनेक्शन के कैसे प्रोग्राम करेंगे। टिक-टू-डील मॉडल की ओर मुड़ते हुए, हम भविष्य के अपने मॉडल को सरल बनाकर जिम्मेदारी के दायरे को कम करते हैं, जिससे हमारे वादे पूरे होते हैं।
अब हम जानते हैं कि हमारे भविष्य में हमेशा एक "टिक" चरण होता है, हम इस भविष्य में संप्रभु मेजबान हैं। हमें नियंत्रण देने से नोड को उम्मीद है कि हम इसे कार्यों के साथ लोड करेंगे, और हम आमतौर पर ऐसा करते हैं। हम यह कैसे करते हैं, शुरू करें, एक शुरुआत स्क्रिप्ट है, यह टिक चरण में अपना निष्पादन शुरू करता है, इसके निष्पादन का परिणाम मूल नोड एपीआई द्वारा बनाए गए कार्य होंगे, उदाहरण के लिए fs.readFile(filename, [options], callback) , यदि कोई हो कोई कार्य नहीं होगा, कार्यक्रम अपना काम पूरा करेगा। जैसे ही कार्य पूरा हो जाता है, नोड अगले "टिक" चरण में कॉलबैक के निष्पादन की योजना बनाने की कोशिश करेगा, इसे (कॉलबैक) और इसके परिणामस्वरूप, हमारे लिए नियंत्रण स्थानांतरित करेगा। और फिर हम इसमें अन्य नोड कार्य सेट करते हैं। और चूंकि पूरे अतुल्यकालिक एपीआई को नोड के कॉलबैक पर लागू किया जाता है, इसलिए हम जिन कार्यों का वर्णन करते हैं, वे उनमें स्थित हैं।
और इस स्थिति को "कॉलबैक कार्यों का नरक" कहा गया है। वैसे, जब मंचों पर कुछ मुद्दों पर चर्चा होती है, तो लोग इस नरक से बहुत अच्छे दोस्त होते हैं, क्योंकि मंचों पर संदेश विनिमय की शैली इस शैली के सभी मानकों को पूरा करती है। और यह कोड में एक समस्या क्यों बन सकता है, ओह हां, प्रोग्रामर को केवल कोड की लंबाई के लिए भुगतान किया जाता है, कोई भी इसे क्षैतिज रूप से विस्तारित करने के लिए भुगतान नहीं करेगा, या नहीं, शायद सभी प्रोग्रामर के पास विस्तृत स्क्रीन नहीं है, किसी कारण के लिए कारण दयालु हैं। ठीक है, बेशक वे कोडिंग शैली के संदर्भ में कॉलबैक नरक के बारे में लिखते हैं और इस तरह की शैली के पीछे क्या छिपाया जा सकता है, इसके बारे में थोड़ा चूकना।

आइए इस स्थिति को देखें।

 a(arg1, function() { var x1; b(arg2, function() { var x2; setInterval(function Task() { console.log('tik'); }, interval); }); }) 

यहां, जब हम कुछ करने के लिए अंतराल अंतराल के साथ अंतराल में नोड कार्य निर्धारित करते हैं, तो कॉल ट्री की पूरी शाखा, इसे एक श्रृंखला भी कहा जाता है, बंद करना, तब तक स्मृति में मौजूद रहता है जब तक टास्क रहता है और निष्पादित होता है, हालांकि इसका उपयोग नहीं किया जा सकता है। X1, x2, arg1, arg2 ... के ऊपर वर्णित चर और तर्क ... और यह पहले से ही आपको आश्चर्यचकित करता है कि क्या यह ऐसे नेस्टेड कार्यों को लिखने के लायक है। उदाहरण के लिए, हमारे मामले में, टास्क केवल "टिक" शब्द प्रदर्शित कर सकता है।

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

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

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

 Q.fcall(function task1() {…}).then(function task2(){…}); 

यहाँ, fcall और फिर बस आवरण कार्य, टास्क 1 और टास्क 2 प्राप्त करना उनके कार्य बन जाते हैं, हमने कार्यों के लिए इसके लिए कुछ नहीं किया, और वे ऊपर दिए गए कोड को निष्पादित करने की प्रक्रिया में किसी भी छिपे हुए गुण को जमा नहीं करेंगे। यह कोड हमें क्या देता है, लेकिन यह हमें task1 के लिए task2 के निष्पादन की गारंटी देगा, लेकिन पहले से ही निम्नलिखित "टिक्स" में। किसी कार्य के निष्पादन से मेरा अभिप्राय किसी कार्य के निष्पादन से है, अर्थात। जब रिटर्न एक्सप्रेशन या उसका अंत फंक्शन (उपज स्टेटमेंट, यहां मुझे याद होगा) में पहुंच गया है। यदि, फ़ंक्शन टास्क 1 और टास्क 2 में, अतुल्यकालिक कॉलबैक के साथ एक एपीआई कॉल है, तो निष्पादन अनुक्रम को कोड द्वारा गारंटी नहीं दी जाती है; ऊपर देखें, कॉलबैक अपने आप ही होगा यदि हम इसके लिए विशेष कार्रवाई नहीं करते हैं। फिर आप पूछते हैं कि फिर ऐसे निर्माण की आवश्यकता क्यों है, आप बस लिख सकते हैं:

 task1(); task2(); 

हां, यह संभव है, लेकिन जब उनमें से एक, उदाहरण के लिए पहले, स्वयं के भीतर अतुल्यकालिक एपीआई तक पहुंच होगी, और दूसरा नहीं होगा, तो कार्य 1 () कोड के साथ ऑर्डर सेट करें; कार्य 2 (); उनके लिए कुछ भी किए बिना, यह विफल हो जाएगा। एक और उदाहरण, हमारे पास कार्यों का ऐसा अनुक्रम ए (), बी (), सी (ए) और सी अतुल्यकालिक हैं, और बी सिंक्रोनस हैं, फिर हम Q.fcall(A).then(B).then(C) लिख सकते हैं। , और जैसा कि हम बाद में फ़ंक्शन बी में देखेंगे, एक विशेष वादा ऑब्जेक्ट को वापस करने की कोई आवश्यकता नहीं है, क्यू लाइब्रेरी हमारे लिए ऐसा करेगी।

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

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

यहाँ मैनुअल लाइब्रेरी Q से एक उदाहरण दिया गया है:

 Q.nfapply(FS.readFile, ["foo.txt", "utf-8"]).done(function task (text) { … }); 

यहां आप देख सकते हैं कि मानक readFile Node JS फ़ंक्शन को कॉल कैसे किया जाता है। एक nfapply कॉल में बदल जाता है, जिसमें दो तर्क होते हैं: एक लिपटे हुए कार्य और तर्कों की एक सरणी, जिसे बाद में readFile पर पास किया जाएगा जब इसे अगले टिक में कहा जाता है। और कॉलबैक फ़ंक्शन रीडफाइल कहां गया? एक फ़ंक्शन स्वचालित रूप से इस तरह के निर्माण में अपनी जगह लेता है; हमारे उदाहरण में, इसका नाम कार्य है, वादे किए गए ऑब्जेक्ट विधि को पारित किया गया। कुछ आश्चर्यजनक तरीके से, क्यू को एहसास होना शुरू हुआ कि जैसे ही एसिंक्रोनस फ़ंक्शन ने अपना कार्य पूरा किया, यह हमारे कार्य पर नियंत्रण स्थानांतरित कर देगा। और वह यह कैसे करती है।

यहाँ nfapply फ़ंक्शन लगभग क्या करता है का छद्म कोड है:

 function nfapply(readFile, [args…]) { var deffered = Q.defer(); readFile([args…], deffered .resolver()); return deferred.promise; } 

यहां एक अस्वीकृत वस्तु बनाई गई है; इसकी रिज़ॉल्वर विधि एक फ़ंक्शन देती है, चलो इसे हैंडलर कहते हैं, जिसे रीडफ़ाइल फ़ंक्शन के कॉलबैक के रूप में प्रतिस्थापित किया जाता है, हैंडलर का एक सरलीकृत रूप कुछ इस तरह दिखता है:

 function handler(err, result) { if (err) deffered.reject(err); else deffered.resolve(result); } 

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

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

 Q.fcall(function task1() { var deferred = Q.defer(); asyncOp(function callback(result) { … deferred .resolve(result); };) return deferred.promise; }).then(function task2(result){ console.log(result); }); 

यदि हम समझते हैं कि दो लिंक कैसे जोड़े जाएं, तो हमें आसानी से मल्टी-लिंक चेन को इकट्ठा करना चाहिए। लेकिन यहां एक बात है, लेकिन होनहार कार्यों के पूरे सेट पर नहीं जो हम विचार कर रहे हैं, वास्तविक जीवन में एक ऑर्डर रिलेशन हो सकता है, अर्थात्। कुछ कार्यों के लिए हम उनके बीच क्रम निर्धारित कर सकते हैं, लेकिन कुछ के लिए नहीं। और जो एक दूसरे के संबंध में आदेश का निर्धारण नहीं करते हैं उन्हें एक दूसरे से स्वतंत्र कार्यों के समूह में जोड़ा जा सकता है, उन्हें समानांतर में प्रदर्शन किया जा सकता है। और इस मामले के लिए, क्यू लाइब्रेरी में ऐसे निर्माण हैं जो आपको चीजों के इस व्यवहार को लागू करने की अनुमति देते हैं। Q.all फ़ंक्शन ([...]) वादे के रूप में वादों की एक सरणी लेता है, हमें एक वादा देता है कि जैसे ही उन सभी को निष्पादित किया जाता है या कम से कम उनमें से एक को खारिज कर दिया जाता है, यह हमें इसके बारे में बताएगा। और वह बस यही करती है, हमारे पास एक ही वादे (वादे वाली वस्तु) की ओर लौटती है, जिसे हम दूसरे के साथ जोड़ना जारी रख सकते हैं, लेकिन पहले से ही। समानांतर कार्यों को एक श्रृंखला पर सजावट के रूप में माना जा सकता है। अब हम पहले से ही मानक गहने बना सकते हैं।

हम अधिक विस्तार से कक्षा में एक वादा रखने की प्रक्रिया पर विचार करेंगे, जब हम Q.defer () लिखते हैं तो हमें एक आस्थगित वस्तु मिलती है, क्यों वादे का वादा तुरंत नहीं होता है, क्यों कुछ सहायक वस्तु की आवश्यकता होती है, फिर से किसी प्रकार का द्वंद्व। जब हम एक रॉकेट को कक्षा में लॉन्च करते हैं, तो टेक-ऑफ के दौरान यह क्या खोता है?, सही ढंग से, दूसरे चरण के बाद। उसी के बारे में यहाँ होता है। अपनी नौकरी को टाल दिया, अब वह साहसपूर्वक चल सकता है। जब हम इस ऑब्जेक्ट को बनाते हैं, तो हमें इसकी आवश्यकता है, एक नियम के रूप में, इसके निम्नलिखित तरीकों में से एक को कॉल करना, अस्वीकार करना, हल करना, जो हमारे वादे को कुछ, लेकिन पहले से अपरिवर्तित स्थिति में अनुवाद करता है। इन तरीकों की कॉल की तुलना उस पल से की जा सकती है जब चरण को रॉकेट से अलग किया गया था, स्टेज से अलग होने के बाद रॉकेट पहले से ही एक अलग स्थिति में होगा, यदि चरण सफलतापूर्वक अलग हो गया है, तो त्वरित में, यदि नहीं, तो मलबे की स्थिति में।वही हमारे वादों के साथ है, या तो इसे या तो हल किया जाएगा या खारिज कर दिया जाएगा, और मैं इन राज्यों को अपरिवर्तित दोहराऊंगा, यदि केवल इसलिए कि चरण को अलग करने के बाद हम इसे क्यू पुस्तकालय के ढांचे के भीतर किसी भी तरह से खुद को संलग्न नहीं कर सकते, लेकिन अंतर। अभी तक वहाँ है, चरण अलग, रॉकेट कुछ भी संचारित नहीं कर सकता है। और हम अगले कार्य को मान दे सकते हैं यदि हम deferred.resolve (मान) या deferred.reject (मान) को उस मान को पास करते हैं।

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

आपका ध्यान के लिए धन्यवाद, मुझे उम्मीद है कि यह जानकारी किसी के लिए उपयोगी हो सकती है।