🏷️
Error Handling

Error Types & Custom Errors

TypeError, ReferenceError, Custom Classes
💡 JavaScript ke built-in error types alag "alarm categories" hain — TypeError (jaise "galat cheez ko galat tarike se use kiya"), ReferenceError ("cheez hi exist nahi karti"), SyntaxError ("grammar galat hai"). Custom errors apne khud ke specific alarm types banana hai.

Common built-in error types: TypeError (jaise null.property access karna, ya function na hone wali cheez ko call karna), ReferenceError (undefined variable use karna), SyntaxError (invalid JavaScript syntax — usually parse-time), RangeError (invalid number range, jaise array length -1).

Custom error classes Error se extend karke banate hain — application-specific errors ko clearly represent karne ke liye, extra data carry karne ke liye (jaise error code).

// Built-in error types example:
try {
  null.someProperty;   // TypeError
} catch (e) {
  console.log(e.name, e.message);   // "TypeError" "Cannot read properties of null..."
}

try {
  console.log(undefinedVariable);   // ReferenceError
} catch (e) {
  console.log(e.name);   // "ReferenceError"
}

// Custom error class:
class ValidationError extends Error {
  constructor(message, field) {
    super(message);
    this.name = "ValidationError";
    this.field = field;
  }
}

function validateAge(age) {
  if (age < 0) {
    throw new ValidationError("Age negative nahi ho sakti", "age");
  }
}

try {
  validateAge(-5);
} catch (e) {
  if (e instanceof ValidationError) {
    console.log("Field '" + e.field + "': " + e.message);
  }
}
🏷️
JavaScript ke built-in error types alag "alarm categories" hain — TypeError (jaise "galat cheez ko galat tarike se use kiya"), ReferenceError ("cheez hi exist nahi karti"), SyntaxError ("grammar galat hai"). Custom errors apne khud ke specific alarm types banana hai.
1 / 2
⚡ Quick Recap
  • TypeError/ReferenceError/SyntaxError/RangeError = common built-in types
  • class MyError extends Error = custom error classes
  • instanceof = specific error type check karne ke liye
Is page mein (2 subtopics)

Kabhi-kabhi ek error ko partially handle karke, use AAGE bhi throw karna hai (jaise logging karke, phir caller ko bhi batana) — throw error; catch block ke andar use karke.

function processData(data) {
  try {
    return JSON.parse(data);
  } catch (error) {
    console.log("Logging error for monitoring: " + error.message);
    throw error;   // re-throw — caller ko bhi pata chalna chahiye
  }
}

try {
  processData("invalid json");
} catch (error) {
  console.log("Caller ne bhi error pakadi: " + error.message);
}
💡Tip: Re-throwing common hai layered applications mein — inner layer LOG karta hai (monitoring ke liye), lekin actual handling (jaise user ko message dikhana) outer layer ki responsibility hai.

Modern JavaScript (ES2022+) Error ko "cause" option deta hai — original error ka context preserve karte hue, ek naya, higher-level error throw kar sakte ho. Debugging mein poori error chain trace kar sakte ho.

try {
  JSON.parse("invalid");
} catch (originalError) {
  throw new Error("Failed to process user data", { cause: originalError });
}

// Baad mein, catch karte waqt:
// catch (error) {
//   console.log(error.message);        // "Failed to process user data"
//   console.log(error.cause.message);  // original JSON parse error
// }
💡Tip: Error.cause relatively naya feature hai — complex applications mein error ki "poori story" trace karne ke liye useful, na sirf sabse aakhri error jo throw hua.