Node.JS में केंद्रीकृत अपवाद हैंडलिंग

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

try { process.nextTick(function() { throw new Error('Catch Me If You Can'); }); } catch (e) { console.log('Exception caught:', e); } 

यह अपवाद, निश्चित रूप से पकड़ा नहीं जाएगा, और यह पूरी प्रक्रिया को छोड़ देगा। एक महीने पहले, नोड.जेएस संस्करण 0.8.0 एक ताज़ा (प्रायोगिक) डोमेन मॉड्यूल के साथ जारी किया गया था जो इस तरह की समस्याओं को हल करने के लिए डिज़ाइन किया गया है। हालांकि, मैं उस वर्ग को श्रद्धांजलि देना चाहूंगा जिसका मैं अभी भी उपयोग करता हूं। आइए जाने:

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

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

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

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

 /** *  Block        . */ function Block(errback) { this._parent=Block.current; this._errback=errback; } Block.current=null; /** *  ,   ,     , *           guard(). *     ,   . * * Example: stream.on('end', Block.guard(function() { ... })); */ Block.guard=function(f) { if (this.current) return this.current.guard(f); else return f; }; /** *      .  -     (" try"). *  -    ('catch'). */ Block.begin=function(block, rescue) { var ec=new Block(rescue); return ec.trap(block); }; /** *   function(err),        , *       (  ,    ). *      err  true. * * Example: request.on('error', Block.errorHandler()) */ Block.errorHandler=function() { // Capture the now current Block for later var current=this.current; return function(err) { if (!err) return; if (current) return current.raise(err); else throw err; }; }; /** *    .     error handler,     . *   raise(...)     .    , *        throw. *  ,   error handler'  , *     error handler'. */ Block.prototype.raise=function(err) { if (this._errback) { try { this._errback(err); } catch (nestedE) { if (this._parent) this._parent.raise(nestedE); else throw nestedE; } } else { if (this._parent) this._parent.raise(err); else throw(err); } }; /** *   callback    . *       raise()  . *  return value   undefined   . */ Block.prototype.trap=function(callback) { var origCurrent=Block.current; Block.current=this; try { var ret=callback(); Block.current=origCurrent; return ret; } catch (e) { Block.current=origCurrent; this.raise(e); } }; /** *  ,        . *     trap(),       . */ Block.prototype.guard=function(f) { if (f.__guarded__) return f; var self=this; var wrapped=function() { var origCurrent=Block.current; Block.current=self; try { var ret=f.apply(this, arguments); Block.current=origCurrent; return ret; } catch (e) { Block.current=origCurrent; self.raise(e); } }; wrapped.__guarded__=true; return wrapped; }; 

(मैंने ब्लॉक / रेस्क्यू की शब्दावली को चुना क्योंकि मैं रूबी को पसंद नहीं करता, लेकिन क्योंकि ऐसा समाधान जेएस में आरक्षित शब्दों का उपयोग नहीं करता है)।

लगभग। अनुवादक: लेख की शुरुआत से एक उदाहरण है, लेकिन ब्लॉक का उपयोग करके, इस फॉर्म को लेता है:

 Block.begin(function() { process.nextTick(Block.guard(function() { throw new Error; })); }, function(err) { console.log('Exception caught:', err); }); 

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

अब आइए केंद्रीकृत त्रुटि हैंडलिंग के लिए ब्लॉक का उपयोग करने का एक उदाहरण देखें। हमारे उदाहरण में, कनेक्ट मिडलवेयर का उपयोग किया जाता है, और इस मामले में अगला फ़ंक्शन एक उत्कृष्ट त्रुटि हैंडलर है: यह http क्लाइंट को सही त्रुटि लौटाएगा। यदि हमें किसी तरह स्वयं को त्रुटि से निपटने की आवश्यकता है, तो हम कॉलबैक को function(err) { ; next(err); } रूप में बता सकते हैं function(err) { ; next(err); } function(err) { ; next(err); } function(err) { ; next(err); } । आप कोशिश / पकड़ने के लिए अधिक दृश्य समानता के लिए ब्लॉक.बेगिन कॉल में इनलाइन फ़ंक्शन का भी उपयोग कर सकते हैं, लेकिन मैं पठनीयता बढ़ाने के लिए कॉलबैक के नाम का उपयोग करना पसंद करता हूं।

 function handleUserAgent(req, res, next) { return Block.begin(process, next); function process() { jsonifyRequest(req, withRequest); //  ,   jsonifyRequest , //    Block.guard() } function withRequest(requestObj) { var r=validators.UserAgentRecord(requestObj, {fix:true}); if (!r.valid) { res.writeHead(400); return res.end('Invalid request object: ' + r.reason); } var uar=r.object; if (uar.token) { // Verify //return handler.verifyUserAgent(uar); throw new Error('verifyUserAgent not yet implemented'); } else { // Create uar.token=null; uar.type='auth'; // TODO: Maybe support unauth in the future? handler.createUserAgent(uar, Block.guard(withUserAgent)); } } function withUserAgent(userAgent) { var r=validators.UserAgentRecord(userAgent, {fix:true}); return respondJson(r.object, res); } } 

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

कॉलबैक में ब्लॉक के स्पष्ट उपयोग के एक और उदाहरण पर विचार करें। इस मामले में, हम एक HTTP अनुरोध करते हैं, प्रतिक्रिया पाठ को संचित करते हैं, कॉलबैक कहते हैं, इसमें बनाए गए CouchResponse को पास करते हैं (जो प्रतिक्रिया और अन्य चीजों को पार्स करता है जो अपवाद को फेंक सकते हैं)।

 request: function(options, callback) { var req=http.request(options, function(res) { var text=''; res.setEncoding('utf8'); res.on('data', function(chunk) { text+=chunk; }); res.on('end', Block.guard(function() { callback(new CouchResponse(res, text)); })); res.on('error', Block.errorHandler()); }); req.on('error', Block.errorHandler()); req.end(); } 

अभी भी कुछ स्थान हैं जहाँ हमारे पास अप्रत्याशित अपवाद हो सकते हैं पूरी प्रक्रिया को छोड़ने वाले:

• सीधे कॉलबैक फ़ंक्शन (रेस) में।
• कॉलबैक 'डेटा' में।

मैं उन्हें ब्लॉक.गार्ड के साथ भी लपेट सकता था, लेकिन मुझे लगता है कि यह बहुत अच्छा है। इसके अलावा, मुझे 100% यकीन है कि इस मामले में त्रुटि महत्वपूर्ण है, और यूनिट परीक्षणों द्वारा कवर किया जाना चाहिए। हालांकि, 'एंड' हैंडलर, कुछ ऐसा करता है जिसे मैं तुरंत नहीं देख सकता (और मुझे पता है कि इसमें JSON.parse कॉल है), इसलिए मैं इसे गार्ड के साथ संरक्षित करना पसंद करता हूं। अंत में, मैं अनुरोध और प्रतिक्रिया त्रुटि घटनाओं को पकड़ने के लिए मानक त्रुटिहैंडलर () ब्लॉक का उपयोग करता हूं। यह सरल केंद्रीकृत त्रुटि हैंडलिंग पैटर्न यह स्पष्ट करता है कि ये त्रुटियां कहाँ जाती हैं और किसी भी स्तर पर उन्हें संभालती हैं जहां यह समझ में आता है। आप नेस्टेड कॉल को ब्लॉक.बेगिन () ( try{try{}catch{}}catch{} का एक एनालॉग try{try{}catch{}}catch{} ) का उपयोग कर सकते हैं। यह फ्रेमवर्क कोड में उपयोगी है, जो किसी और के कोड द्वारा बनाए गए ब्लॉक के भीतर कुछ काम करना चाहिए।

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

मेरा सुझाव है कि आप पूरा मूल पाठ पढ़ें, जैसा कि यह नोड पर बुलेटप्रूफ कोड लिखने के लिए 10 सिफारिशों के रूप में कई के रूप में सूचीबद्ध करता है।

ब्लॉक क्लास I जिसे एक जीथब रिपॉजिटरी और एक एनपीएम मॉड्यूल (एनपीएम इंस्टॉल कंट्रोल-ब्लॉक) के रूप में डिज़ाइन किया गया है।