Node.js
उपवाद सम्भालना

Node.Js में एक्सेप्शन हैंडलिंग

अपवादों / त्रुटियों को संभालने के लिए Node.js के 3 मूल तरीके हैं:

1. कोशिश - पकड़ ब्लॉक
2. callback के पहले तर्क के रूप में त्रुटि
3. emit eventEmitter का उपयोग कर एक त्रुटि घटना

तुल्यकालिक कोड निष्पादन से फेंके गए अपवादों को पकड़ने के लिए try-catch का उपयोग किया जाता है। यदि कॉलर (या कॉलर का कॉलर, ...) ने कोशिश की / पकड़ लिया, तो वे त्रुटि पकड़ सकते हैं। यदि कॉल करने वालों में से कोई भी प्रोग्राम क्रैश होने की कोशिश नहीं करता था।
यदि किसी एस्किऑन ऑपरेशन पर ट्राई-कैच का उपयोग किया जाता है और एसिंक्स पद्धति के कॉलबैक से अपवाद को फेंक दिया जाता है, तो यह ट्राई-कैच द्वारा पकड़ा नहीं जाएगा। Async ऑपरेशन कॉलबैक से एक अपवाद को पकड़ने के लिए, वादों का उपयोग करना पसंद किया जाता है।
इसे बेहतर समझने के लिए उदाहरण

// ** Example - 1  **
function doSomeSynchronousOperation(req, res) {
    if(req.body.username === ''){
        throw new Error('User Name cannot be empty');
    }  
    return true;  
}

// calling the method above
try {
    // synchronous code   
    doSomeSynchronousOperation(req, res)    
catch(e) {
    //exception handled here   
    console.log(e.message);  
} 

// ** Example - 2 **
function doSomeAsynchronousOperation(req, res, cb) {
    // imitating async operation
    return setTimeout(function(){
        cb(null, []);
    },1000);
}
 
try {
    // asynchronous code   
    doSomeAsynchronousOperation(req, res, function(err, rs){
        throw new Error("async operation exception");
    })   
} catch(e) {
     // Exception will not get handled here
     console.log(e.message);  
}
// The exception is unhandled and hence will cause application to break

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

function doSomeAsynchronousOperation(req, res, callback) {
   setTimeout(function(){
        return callback(new Error('User Name cannot be empty'));    
   }, 1000);  
   return true;
}

doSomeAsynchronousOperation(req, res, function(err, result) {
   if (err) {
       //exception handled here 
       console.log(err.message);
   }
   
   //do some stuff with valid data
});

emit अधिक जटिल मामलों के लिए, कॉलबैक का उपयोग करने के बजाय, फ़ंक्शन स्वयं एक EventEmitter ऑब्जेक्ट को वापस कर सकता है, और कॉल करने वाले से emitter पर त्रुटि घटनाओं के लिए सुनने की उम्मीद की जाएगी।

const EventEmitter = require('events');

function doSomeAsynchronousOperation(req, res) {
    let myEvent = new EventEmitter();

    // runs asynchronously
    setTimeout(function(){
        myEvent.emit('error', new Error('User Name cannot be empty'));
    }, 1000);

    return myEvent;
}

// Invoke the function
let event = doSomeAsynchronousOperation(req, res);

event.on('error', function(err) {
    console.log(err);
});

event.on('done', function(result) {
    console.log(result); // true
});

अनहैंड एक्सेप्शन मैनेजमेंट

चूँकि Node.js एकल प्रक्रिया पर चलता है, बिना अपवाद के अपवाद अनुप्रयोग विकसित करते समय जागरूक होना एक मुद्दा है।

चुपचाप अपवादों को संभालना

अधिकतर लोग नोड.जेएस सर्वर (एस) को चुपचाप त्रुटियों को निगल लेते हैं।

• चुपचाप अपवाद को संभालना

process.on('uncaughtException', function (err) {
  console.log(err);
});

यह बुरा है , यह काम करेगा लेकिन:

• मूल कारण अज्ञात रहेगा, जैसे कि अपवाद (त्रुटि) के कारण के समाधान में योगदान नहीं करेगा।

• डेटाबेस कनेक्शन के मामले में (पूल) किसी कारण से बंद हो जाता है, जिसके परिणामस्वरूप त्रुटियों का निरंतर प्रसार होगा, जिसका अर्थ है कि सर्वर चल रहा होगा लेकिन यह डीबी को फिर से कनेक्ट नहीं करेगा।

प्रारंभिक अवस्था में वापस आना

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

• यह सुनिश्चित करने के लिए हमेशा (या अन्य सीएलआई उपकरण स्थापित करना कि नोड सर्वर लगातार चलता है)

npm install forever -g

• सर्वर को हमेशा के लिए शुरू करना

forever start app.js

कारण यह क्यों शुरू किया गया है और क्यों हम हमेशा के लिए उपयोग करते हैं सर्वर समाप्त होने के बाद हमेशा के लिए प्रक्रिया सर्वर फिर से शुरू हो जाएगी।

• सर्वर को पुनरारंभ करना

process.on('uncaughtException', function (err) {
    console.log(err);

    // some logging mechanisam
    // ....        

    process.exit(1); // terminates process
});

एक ओर ध्यान दें तो क्लस्टर्स और डोमेन के साथ अपवादों को संभालने का एक तरीका भी था।

डोमेन को यहां अधिक जानकारी दी गई है ।

त्रुटियां और वादे

प्रोमिस हैंडल को अलग-अलग तरीके से सिंक्रोनस या कॉलबैक-चालित कोड में बदल देता है।

const p = new Promise(function (resolve, reject) {
    reject(new Error('Oops'));
});

// anything that is `reject`ed inside a promise will be available through catch
// while a promise is rejected, `.then` will not be called
p
    .then(() => {
        console.log("won't be called");
    })
    .catch(e => {
        console.log(e.message); // output: Oops
    })
    // once the error is caught, execution flow resumes
    .then(() => {
        console.log('hello!'); // output: hello!
    });

वर्तमान में, त्रुटियों को उस वादे में फेंक दिया जाता है जो त्रुटि में नहीं पकड़ा जाता है, जो निगल लिया जा रहा है, जिससे त्रुटि को ट्रैक करना मुश्किल हो सकता है। इसे लिलिंटिंग टूल जैसे कि एस्लिंट के उपयोग से या यह सुनिश्चित करके हल किया जा सकता है कि आपके पास हमेशा एक catch क्लॉज हो।

यह व्यवहार नोड 8 में नोड प्रक्रिया को समाप्त करने के पक्ष में पदावनत है।