DanLevy.net

प्रश्नोत्तरी: उन्नत JS त्रुटि महारत

क्या आपके अपवाद वास्तव में विशिष्ट हैं?

क्या आप जावास्क्रिप्ट एरर्स को पूरी तरह समझते हैं?

1. 

सीरियलाइज़ेशन आश्चर्य

JSON.stringify(error) क्या लौटाता है?

const error = new Error('Oops');
console.log(JSON.stringify(error));

Error ऑब्जेक्ट में गैर‑enumerable प्रॉपर्टी (message, name, stack) होती हैं, इसलिए JSON.stringify() {} लौटाता है। यह API प्रतिक्रियाओं में एरर भेजते समय अक्सर होने वाला गड़बड़ है। JSON.stringify(error, Object.getOwnPropertyNames(error)) का उपयोग करें या सीधे एक साधारण ऑब्जेक्ट बनाएं।

2. 

सीरियलाइज़ेशन आश्चर्य

इन दोनों में क्या अंतर है?

const err = new Error('Test');
console.log(err);
console.log(JSON.stringify(err));

console.log(err) त्रुटि को उसके संदेश और स्टैक ट्रेस के साथ दिखाता है क्योंकि कंसोल में Error ऑब्जेक्ट्स के लिए विशेष हैंडलिंग होती है। JSON.stringify(err) '{}' लौटाता है क्योंकि Error की प्रॉपर्टीज़ enumerable नहीं होतीं। यह अंतर कई डेवलपर्स को API डिबग करते समय फँसाता है।

3. 

टाइप जांच ट्रिक्स

इन जाँचों के परिणाम क्या हैं?

class CustomError extends Error {}
const err = new CustomError('test');


console.log(err instanceof CustomError);
console.log(err instanceof Error);
console.log(err instanceof Object);

तीनों true लौटाते हैं। CustomError Error को विस्तारित करता है, जो Object को विस्तारित करता है। instanceof ऑपरेटर पूरी प्रोटोटाइप चेन को जांचता है, इसलिए CustomError का एक इंस्टेंस भी Error और Object का इंस्टेंस होता है।

4. 

टाइप चेकिंग ट्रिक्स

यदिफ़्रेम्स के बीच instanceof Error के साथ क्या होता है?

// In iframe:
const iframeError = new Error('test');
// In parent window:
console.log(iframeError instanceof Error);

instanceof विभिन्न निष्पादन संदर्भों (iframes, workers) के बीच false लौटा सकता है क्योंकि प्रत्येक संदर्भ का अपना Error कंस्ट्रक्टर होता है। संदर्भों के बीच विश्वसनीय त्रुटि पहचान के लिए Object.prototype.toString.call(obj) === '[object Error]' का उपयोग करें।

5. 

गैर‑त्रुटियों को थ्रो करना

जब आप स्ट्रिंग थ्रो करते हैं तो क्या होता है?

try {
  throw "Oops!";
} catch (e) {
  console.log(e instanceof Error);
  console.log(typeof e);
}

JavaScript किसी भी मान को थ्रो करने की अनुमति देता है। यहाँ, e instanceof Error false है और typeof e "string" है। यह उन त्रुटि‑हैंडलिंग कोड को तोड़ सकता है जो मानते हैं कि सभी पकड़ी गई अपवाद Error ऑब्जेक्ट हैं। बेहतर डिबगिंग के लिए हमेशा Error इंस्टेंस थ्रो करें।

6. 

कस्टम त्रुटियाँ

err.name का मान क्या है?

class CustomError extends Error {
  constructor(message) {
    super(message);
    this.name = this.constructor.name;
  }
}
const err = new CustomError('test');
console.log(err.name);

err.name "CustomError" है क्योंकि this.constructor.name क्लास का नाम लौटाता है। this.name = this.constructor.name सेट करना एक सामान्य पैटर्न है जिससे कस्टम एरर क्लासेस स्टैक ट्रेस और एरर मैसेज में सही नाम दिखाते हैं।

7. 

कस्टम एरर्स

बिना name सेट किए आउटपुट क्या होगा?

class MyError extends Error {
  // No constructor or name setting
}
const err = new MyError('test');
console.log(err.name);

यदि आप स्पष्ट रूप से this.name सेट नहीं करते हैं, तो त्रुटि Error क्लास की डिफ़ॉल्ट name प्रॉपर्टी को विरासत में ले लेती है, जो "Error" है। इसलिए कस्टम एरर क्लासों को हमेशा अपने कंस्ट्रक्टर में this.name = this.constructor.name सेट करना चाहिए।

8. 

Error कारण

wrapper.cause.message क्या लौटाता है?

const original = new Error('Original error');
const wrapper = new Error('Wrapper',
  { cause: original }
);
console.log(wrapper.cause.message);

Error.cause (ES2022) त्रुटियों को चेन करने की अनुमति देता है ताकि मूल त्रुटि संदर्भ संरक्षित रहे। wrapper.cause मूल त्रुटि को संदर्भित करता है, इसलिए wrapper.cause.message "Original error" लौटाता है। यह निचले‑स्तर की त्रुटियों को उच्च‑स्तर के संदर्भ में रैप करने में उपयोगी है।

9. 

स्टैक ट्रेसेस

Error.captureStackTrace क्या करता है?

function createError(msg) {
  const err = new Error(msg);
  Error.captureStackTrace(err, createError);
  return err;
}
const error = createError('test');

Error.captureStackTrace (V8/Node.js) स्टैक ट्रेस से निर्दिष्ट फ़ंक्शन (createError) को हटा देता है, जिससे एरर फ़ैक्टरी फ़ंक्शन उपयोगकर्ताओं को दिखाई नहीं देते। इससे साफ़ स्टैक ट्रेस मिलते हैं जो फ़ैक्टरी को कॉल किए गए स्थान को दिखाते हैं, फ़ैक्टरी खुद को नहीं।

10. 

संदेश टेम्प्लेट

त्रुटि संदेश क्या है?

function validate(value) {
  if (!value) {
    throw new Error(
      `Value ${value} is invalid`
    );
  }
}
try {
  validate(undefined);
} catch (e) {
  console.log(e.message);
}

टेम्प्लेट लिटेरल्स इंटरपोलेशन के दौरान undefined को स्ट्रिंग "undefined" में बदल देते हैं। त्रुटि संदेश बन जाता है "Value undefined is invalid"। साफ़ संदेशों के लिए, इंटरपोलेशन से पहले value ?? 'null' या इसी तरह की जाँचों का उपयोग करने पर विचार करें।

11. 

API गड़बड़ियाँ

क्लाइंट को क्या भेजा जाता है?

// Express.js route
app.get('/api/data', (req, res) => {
  const error = new Error('Database failed');
  res.json({ error });
});

res.json() अंदर JSON.stringify() का उपयोग करता है, इसलिए Error ऑब्जेक्ट {} बन जाता है। क्लाइंट को {"error":{}} मिलता है। इसे ठीक करने के लिए, res.json({ error: error.message }) या res.json({ error: { message: error.message, name: error.name } }) का उपयोग करें।

12. 

असिंक्रोनस त्रुटियाँ

Promise.reject() क्या स्वीकार कर सकता है?

Promise.reject('string').catch(e =>
  console.log(typeof e)
);
Promise.reject({code: 404}).catch(e =>
  console.log(e.code)
);
Promise.reject(42).catch(e =>
  console.log(e)
);

throw की तरह, Promise.reject() कोई भी मान स्वीकार करता है – स्ट्रिंग्स, ऑब्जेक्ट्स, नंबर आदि। यह "string", 404, और 42 प्रिंट करता है। प्रॉमिस चेन में पकड़े गए मानों के प्रकार की हमेशा जाँच करें, खासकर जब थर्ड‑पार्टी कोड गैर‑Error मानों से रिजेक्ट कर सकता है।

13. 

त्रुटि गुण

error.code और error.errno कितने भरोसेमंद हैं?

const fs = require('fs');
fs.readFile('missing.txt', (err, data) => {
  if (err) {
    console.log(err.code);    // 'ENOENT'
    console.log(err.errno);   // -2
  }
});

code और errno जैसे गुण पर्यावरण‑विशिष्ट हैं (इस मामले में Node.js) और मानक Error ऑब्जेक्ट का हिस्सा नहीं हैं। ब्राउज़र त्रुटियों में ये गुण नहीं होते। हमेशा इनके अस्तित्व की जाँच करें: if (err.code === 'ENOENT') बजाय यह मानने के कि वे मौजूद हैं।

14. 

एरर बाउंडरीज

इन जाँचों का परिणाम क्या है?

const fakeError = {
  name: 'Error',
  message: 'Fake error',
  stack: 'fake stack'
};


console.log(fakeError instanceof Error);
console.log(Object.prototype.toString.call(
  fakeError
) === '[object Error]');

instanceof Error false लौटाता है क्योंकि ऑब्जेक्ट Error कंस्ट्रक्टर से नहीं बनाया गया था। Object.prototype.toString.call() भी false लौटाता है (यह '[object Object]' लौटाता है) क्योंकि यह आंतरिक [[Class]] स्लॉट को जांचता है। दोनों मेथड सही तरीके से इसे एक नकली एरर ऑब्जेक्ट के रूप में पहचानते हैं।

त्रुटि‑हैंडलिंग की कला में निपुण बनें

सीरियलाइज़ेशन के फंदों से लेकर क्रॉस‑कॉन्टेक्स्ट instanceof विफलताओं तक, ये उन्नत अवधारणाएँ जूनियर डेवलपर्स को सीज़नड क्षतिग्रस्त पेशेवरों से अलग करती हैं।

और अधिक चुनौतियों के लिए तैयार हैं? हमारे पूरा क्विज़ संग्रह में जाएँ और जावास्क्रिप्ट, एल्गोरिदम और अन्य विषयों पर अतिरिक्त दिमागी पहेलियों को देखें!

Loading comments...