Error Handling in JavaScript

• Prevents application crashes
• Improves user experience with meaningful messages
• Makes debugging easier
• Helps maintain stable, production-ready applications

---

The try...catch statement is the core mechanism for handling runtime errors in JavaScript.

try {
  // Code that may throw an error
} catch (error) {
  // Code that runs if an error occurs
}

• try block → Contains code that might fail
• catch block → Executes if an error occurs in try
• error → An object containing details like name and message

---

Example: Basic try...catch

try {
  let result = 10 / 0;
  console.log(result); // Infinity (no error)

  let person = undefined;
  console.log(person.name); // Error
} catch (error) {
  console.log("An error occurred:", error.message);
}

✅ Instead of crashing, the error is caught and handled safely.

---

The finally block executes regardless of whether an error occurs or not.
It is commonly used for cleanup tasks.

Example

try {
  let result = 10 / 2;
  console.log(result);
} catch (error) {
  console.log("Error:", error.message);
} finally {
  console.log("This always runs.");
}

✅ Use finally for:

• Closing files
• Clearing timers
• Releasing resources

---

JavaScript allows you to manually throw errors using the throw keyword. This is useful when validating conditions or enforcing rules.

throw new Error("Error message");

---

Example: Throwing an Error

function divide(a, b) {
  if (b === 0) {
    throw new Error("Division by zero is not allowed.");
  }
  return a / b;
}

try {
  console.log(divide(10, 2)); // 5
  console.log(divide(10, 0)); // Error
} catch (error) {
  console.log("Error:", error.message);
}

✅ Throwing errors lets you control when and why a failure occurs.

---

JavaScript allows you to create custom error classes by extending the built-in Error class. This helps differentiate between different error types and improves readability.

---

3.1 Creating a Custom Error Class

class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = "ValidationError";
  }
}

function validateInput(input) {
  if (!input || input.length < 5) {
    throw new ValidationError("Input must be at least 5 characters long.");
  }
  return input;
}

try {
  validateInput("abc");
} catch (error) {
  if (error instanceof ValidationError) {
    console.log("Validation Error:", error.message);
  } else {
    console.log("General Error:", error.message);
  }
}

✅ Custom errors allow precise error handling.

---

3.2 Multiple Custom Errors

class AuthenticationError extends Error {
  constructor(message) {
    super(message);
    this.name = "AuthenticationError";
  }
}

class AuthorizationError extends Error {
  constructor(message) {
    super(message);
    this.name = "AuthorizationError";
  }
}

try {
  throw new AuthenticationError("User is not authenticated.");
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.log("Authentication Error:", error.message);
  } else if (error instanceof AuthorizationError) {
    console.log("Authorization Error:", error.message);
  } else {
    console.log("General Error:", error.message);
  }
}

✅ This pattern is very common in real-world applications (auth, APIs, validation).

---

✅ Handle Errors Gracefully

Always provide meaningful feedback and keep the app running.

✅ Use Specific Errors

Custom error classes improve clarity and debugging.

❌ Avoid Silent Errors

Never catch errors without logging or handling them.

✅ Use finally for Cleanup

Ensure resources are released even if an error occurs.

✅ Throw Meaningful Messages

Error messages should help developers understand the cause.

---

Error Handling in JavaScript

Error Type	Description
Error	Generic error
TypeError	Invalid type operation
ReferenceError	Undefined variable
RangeError	Value out of range
SyntaxError	Invalid syntax

---

JavaScript error handling ensures robust and stable applications by:

• Catching runtime errors using try...catch
• Manually throwing errors with throw
• Creating custom error types for clarity
• Using finally for cleanup tasks