नोडज में कई घटनाओं की प्रतीक्षा कर रहा है

संभवतः सभी लोग जो नोडज सीखना शुरू करते हैं, उन्हें इवेंट-ओरिएंटेड प्रोग्रामिंग पर स्विच करने में कठिनाई होती है। यह सरल है, जब तक हम क्रमिक रूप से कार्य कर सकते हैं: अगले को शुरू करें, पिछले एक से अंतिम घटना की प्रतीक्षा कर रहे हैं। लेकिन क्या होगा अगर ऐसे कई कार्य हैं और वे लंबे समय तक हैं? और अगर हम तब तक जारी नहीं रख सकते, जब तक कि हम उनमें से प्रत्येक के पूरा होने का इंतजार नहीं करते?

सब कुछ सरल है

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

console.log("begin"); setTimeout(function () { console.log("2000ms timeout"); setTimeout(function () { console.log("1500ms timeout"); setTimeout(function () { console.log("1000ms timeout"); setTimeout(function () { console.log("final"); }, 500); }, 1000); }, 1500); }, 2000); console.log("end"); 

हम 2000ms की लंबाई के साथ एक निश्चित प्रक्रिया शुरू करते हैं, इसके पूरा होने के बाद हम 1500ms पर दूसरा शुरू करते हैं, फिर 1000ms पर तीसरा और अंत में, 500ms पर अंतिम। परिणाम इस प्रकार होगा:

 शुरू करना
 अंत
 2000 मी टाइमआउट
 1500 मी टाइमआउट
 1000 मी टाइमआउट
 अंतिम

सब कुछ खराब है अगर कार्यक्रम द्वारा किए गए कार्यों को वास्तव में क्रमिक रूप से निष्पादित किया जाना चाहिए, और पहले के अंत से पहले दूसरी कार्रवाई शुरू करने का कोई तरीका नहीं है, और तीसरा - दूसरे से पहले। लेकिन अगर संभव है, तो यह संभव नहीं है, लेकिन आवश्यक है!

क्यों जरूरी है?

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

थोड़ा कठिन

मान लीजिए कि हमारे साथ सभी ऑपरेशन एक-दूसरे से स्वतंत्र हैं। फिर उन्हें समानांतर में लॉन्च किया जा सकता है:

 console.log("begin"); setTimeout(function () { console.log("2000ms timeout"); }, 2000); setTimeout(function () { console.log("1500ms timeout"); }, 1500); setTimeout(function () { console.log("1000ms timeout"); }, 1000); setTimeout(function () { console.log("final"); }, 500); console.log("end"); 

निष्पादन परिणाम:

 शुरू करना
 अंत
 अंतिम
 1000 मी टाइमआउट
 1500 मी टाइमआउट
 2000 मी टाइमआउट

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

और भी मुश्किल

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

 var counter = 3; console.log("begin"); setTimeout(function () { console.log("2000ms timeout"); if (-- counter == 0) final(); }, 2000); setTimeout(function () { console.log("1500ms timeout"); if (-- counter == 0) final(); }, 1500); setTimeout(function () { console.log("1000ms timeout"); if (-- counter == 0) final(); }, 1000); function final() { setTimeout(function () { console.log("final"); }, 500); } console.log("end"); 

परिणाम:

 शुरू करना
 अंत
 1000 मी टाइमआउट
 1500 मी टाइमआउट
 2000 मी टाइमआउट
 अंतिम

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

 function Combo(finalCallback) { this.finalCallback = finalCallback; this.result = []; this.counter = 0; } Combo.prototype = { "add" : function (callback) { var that = this; this.counter ++; return function () { that.result[that.counter - 1] = callback.apply(this, arguments); that.check(); }; }, "check" : function () { var that = this; this.counter --; if (this.counter == 0) process.nextTick(function () { that.finalCallback.call(that, that.result); }); } }; 

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

 var test = new Combo( function (result) { console.log("final"); console.log("result:"); for (var i in result) { console.log(" \"" + i + "\" : \"" + result[i] + "\""); } }); console.log("begin"); setTimeout(test.add(function () { console.log("2000ms"); return "2000ms"; }), 2000); setTimeout(test.add(function () { console.log("1500ms"); return "1500ms"; }), 1500); setTimeout(test.add(function () { console.log("1000ms"); return "1000ms"; }), 1000); console.log("end"); 

काम का परिणाम:

 शुरू करना
 अंत
 1000ms
 1500ms
 2000ms
 अंतिम
 परिणाम:
   "0": "2000 मी"
   "1": "1500 मी"
   "2": "1000 मी"

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

सबसे कठिन बात

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

 function Combo(finalCallback) { this.finalCallback = finalCallback; this.result = {}; this.counter = 0; } Combo.prototype = { "add" : function (callback, id) { var that = this; if (!id) id = this.counter; this.counter ++; return function () { if (!that.result.hasOwnProperty(id)) { that.result[id] = callback.apply(this, arguments); that.check(); } }; }, "remove" : function (id, result) { this.result[id] = result; this.check(); }, "check" : function () { var that = this; this.counter --; if (this.counter == 0) process.nextTick(function () { that.finalCallback.call(that, that.result); }); } }; 

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

 var test = new Combo(function (result) { console.log("final"); console.log("result:"); for (var i in result) { console.log(" \"" + i + "\" : \"" + result[i] + "\""); } }); console.log("begin"); setTimeout(test.add(function () { console.log("2000ms"); return "2000ms"; }), 2000); setTimeout(test.add(function () { console.log("1500ms"); return "1500ms"; }, "1500ms"), 1500); setTimeout(test.add(function () { console.log("1000ms"); return "1000ms"; }), 1000); // error setTimeout(function () { console.log("something wrong in 1500ms on 1250ms"); test.remove("1500ms", "error in 1500ms"); }, 1250); console.log("end"); 

परिणाम:

 शुरू करना
 अंत
 1000ms
 1250ms पर 1500ms में कुछ गलत है
 2000ms
 अंतिम
 परिणाम:
  "0": "2000 मी"
  "2": "1000 मी"
  "1500ms": "1500ms में त्रुटि"

निष्कर्ष

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