javascript - क्यों `.कैच(इरेट== कंसोल.रोर(इरेट))` हतोत्साहित किया गया है?




node.js promise (4)

return ….catch(err => console.error(err)) क्या गलत है return ….catch(err => console.error(err)) ?

यह एक वादा देता है जो त्रुटि को संभालने के बाद undefined साथ पूरा होगा।

यह स्वयं है, त्रुटियों को पकड़ना और उन्हें लॉग करना एक वादा श्रृंखला के अंत में ठीक है:

function main() {
    const element = document.getElementById("output");
    getStuff().then(result => {
        element.textContent = result;
    }, error => {
        element.textContent = "Sorry";
        element.classList.add("error");
        console.error(error);
    });
    element.textContent = "Fetching…";
}

हालाँकि अगर getStuff() इसे लॉग इन करने के लिए त्रुटि को पकड़ता है और इसे संभालने के लिए और कुछ नहीं करता है जैसे कि एक समझदार वापसी परिणाम प्रदान करता है, तो यह " क्षमा करें " के बजाय पृष्ठ में undefined देता है।

मैंने बहुत सारे कोड देखे हैं जो ऐसा करता है, क्यों?

ऐतिहासिक रूप से, लोगों को वादों की त्रुटियों से डर लगता था, जो कहीं से भी गायब हो जाते हैं, जो उन्हें पूरी तरह से गायब हो जाते हैं - वादे से "निगल लिया"। इसलिए उन्होंने यह सुनिश्चित करने के लिए कि वे कंसोल में त्रुटियों को नोटिस करेंगे, प्रत्येक फ़ंक्शन में .catch(console.error) जोड़ा।

यह अब आवश्यक नहीं है क्योंकि सभी आधुनिक वादा कार्यान्वयन अखंडित वादों को खारिज कर सकते हैं और कंसोल पर आग की चेतावनी देंगे।

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

इसके बजाय मुझे क्या करना चाहिए?

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

यह भी कोड को बहुत सरल बनाता है:

function getStuff() { 
  return fetchStuff().then(stuff => process(stuff));
}

async function getStuff() { 
  const stuff = await fetchStuff();
  return process(stuff);
}

यदि आप अस्वीकृति के कारण (लॉगिंग जानकारी में संशोधन) के साथ कुछ करने पर जोर देते हैं, तो त्रुटि को पुन: फेंकना सुनिश्चित करें:

function getStuff() { 
  return fetchStuff().then(stuff =>
    process(stuff)
  ).catch(error => {
    stuffDetails.log(error);
    throw new Error("something happened, see detail log");
  });
}

async function getStuff() {
  try {
    const stuff = await fetchStuff();
    return process(stuff);
  } catch(error) {
    stuffDetails.log(error);
    throw new Error("something happened, see detail log");
  }
}

यदि आप कुछ त्रुटियों को संभाल रहे हैं तो वही करें:

function getStuff() { 
  return fetchStuff().then(stuff =>
    process(stuff)
  ).catch(error => {
    if (expected(error))
      return defaultStuff;
    else
      throw error;
  });
}

async function getStuff() {
  try {
    const stuff = await fetchStuff();
    return process(stuff);
  } catch(error) {
    if (expected(error))
      return defaultStuff;
    else
      throw error;
  }
}

मैं वादों का उपयोग कर रहा हूं और कोड है जो निम्न की तरह दिखता है:

function getStuff() { 
  return fetchStuff().then(stuff => 
    process(stuff)
  ).catch(err => {
    console.error(err);
  });
}

या:

async function getStuff() { 
  try {
    const stuff = await fetchStuff();
    return process(stuff);
  } catch (err) { 
    console.error(err);
  }
}

मैं त्रुटियों को याद करने से बचने के लिए ऐसा कर रहा था, लेकिन एक साथी उपयोगकर्ता द्वारा मुझे बताया गया था कि मुझे ऐसा नहीं करना चाहिए और यह गलत है।

  • return ….catch(err => console.error(err)) क्या गलत है return ….catch(err => console.error(err)) ?
  • मैंने बहुत सारे कोड देखे हैं जो ऐसा करता है, क्यों?
  • इसके बजाय मुझे क्या करना चाहिए?

पुराना कोड ऐसा क्यों करता है?

ऐतिहासिक रूप से, पुराने (पूर्व 2013) वादों के पुस्तकालयों को 'स्वेच्छित' बिना सोचे-समझे वादा अस्वीकार कर दिया गया है जिसे आपने खुद नहीं संभाला है। तब से लिखी गई किसी भी बात में ऐसा नहीं है।

आज क्या होता है?

ब्राउज़र और नोड.जेएस पहले से ही स्वचालित रूप से अनकहा वादा अस्वीकारों को लॉग इन करते हैं या उन्हें संभालने के लिए व्यवहार करते हैं और उन्हें स्वचालित रूप से लॉग इन करेंगे।

इसके अलावा - .catch को जोड़कर आप उस फ़ंक्शन को कॉल करने के लिए संकेत दे रहे हैं जिसे undefined लौटाया गया है:

// undefined if there was an error
getStuff().then(stuff => console.log(stuff)); 

प्रश्न यह है कि async कोड लिखते समय किसी को अपने आप से पूछना चाहिए "आमतौर पर कोड का तुल्यकालिक संस्करण क्या होगा?":

function calculate() { 
  try {
    const stuff = generateStuff();
    return process(stuff);
  } catch (err) { 
    console.error(err);
    // now it's clear that this function is 'swallowing' the error.
  }
}

मुझे नहीं लगता कि यदि कोई त्रुटि होती है तो एक उपभोक्ता इस फ़ंक्शन को undefined वापस करने की उम्मीद करेगा।

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

इसके बजाय क्या करें:

कुछ भी तो नहीं। यही इसकी खूबसूरती है - अगर आपने लिखा:

async function getStuff() { 
  const stuff = await fetchStuff();
  return process(stuff);
}
// or without async/await
const getStuff = fetchStuff().then(process);

पहली जगह में आप वैसे भी चारों ओर बेहतर त्रुटियाँ प्राप्त करेंगे :)

यदि मैं Node.js का पुराना संस्करण चला रहा हूं तो मुझे क्या करना चाहिए?

Node.js के पुराने संस्करण त्रुटियों को लॉग नहीं कर सकते हैं या एक डिप्रेसेशन चेतावनी दिखा सकते हैं। उन संस्करणों में आप विश्व स्तर पर console.error (या उचित लॉगिंग इंस्ट्रूमेंटेशन) का उपयोग कर सकते हैं:

// or throw to stop on errors
process.on('unhandledRejection', e => console.error(e));

त्रुटि बहुत अधिक सामान्य है, यह एक पकड़ है, लेकिन केवल बहुत सी चीजें हैं जो ऑपरेशन के साथ विफल हो जाएंगी, त्रुटि सब कुछ है।


यहां सबसे सामान्य कथन, जो कि जावास्क्रिप्ट से परे की भाषाओं में लागू होता है, जब तक आप त्रुटि को ' हैंडल ' करने की योजना नहीं बनाते हैं, तब तक यह ' कैच ' नहीं है। लॉगिंग संभाल नहीं रहा है।

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





try-catch