Error Handling in JavaScript: Try, Catch, Finally

1. Introduction

Errors are a normal part of programming. In JavaScript, errors occur when something goes wrong during code execution, such as accessing an undefined variable or performing an invalid operation. If not handled properly, these errors can stop the entire program.

Error handling allows developers to manage these situations gracefully instead of letting the application crash. Using constructs like try, catch, and finally, JavaScript provides a way to control what happens when an error occurs. This improves debugging, prevents unexpected failures, and ensures better user experience. Understanding error handling is essential for writing stable and reliable applications.

---

2. Core Concept Explanation

---

2.1 What Are Errors in JavaScript

Errors are problems that occur during code execution.

Example:

let x = y + 10;

This causes an error because y is not defined.

Without handling, the program stops immediately.

Types of common runtime errors:

• Reference errors (undefined variables)

• Type errors (invalid operations)

• Syntax errors (incorrect code structure)

---

2.2 Using try and catch Blocks

The try block contains code that may cause an error. The catch block handles the error.

Example:

try {
  let result = x + 10;
} catch (error) {
  console.log("An error occurred");
}

Explanation:

• Code inside try runs first

• If an error occurs → execution jumps to catch

• Program continues instead of crashing

You can also access error details:

try {
  let result = x + 10;
} catch (error) {
  console.log(error.message);
}

---

2.3 The finally Block

The finally block always runs, whether an error occurs or not.

Example:

try {
  console.log("Try block");
} catch (error) {
  console.log("Catch block");
} finally {
  console.log("Finally block");
}

Output:

Try block
Finally block

If an error occurs:

Try block
Catch block
Finally block

Use finally for cleanup tasks like:

• closing resources

• stopping loaders

• resetting states

---

2.4 Throwing Custom Errors

You can create your own errors using throw.

Example:

function checkAge(age) {
  if (age < 18) {
    throw new Error("Age must be 18 or above");
  }

  console.log("Access granted");
}

try {
  checkAge(16);
} catch (error) {
  console.log(error.message);
}

Output:

Age must be 18 or above

This allows you to enforce rules in your program.

---

2.5 Why Error Handling Matters

Without error handling:

• Program crashes

• User experience breaks

• Debugging becomes difficult

With error handling:

• Application continues running

• Errors are logged clearly

• Failures are controlled

Example:

try {
  JSON.parse("invalid json");
} catch (error) {
  console.log("Invalid JSON format");
}

Instead of crashing, the program handles the error safely.

---

3. Detailed Code Examples

---

Example 1: Basic Try-Catch

try {
  let num = 10;
  console.log(num.toUpperCase());
} catch (error) {
  console.log("Type error occurred");
}

---

Example 2: Access Error Message

try {
  let value = x + 5;
} catch (error) {
  console.log(error.message);
}

---

Example 3: Using Finally

try {
  console.log("Executing code");
} catch (error) {
  console.log("Error occurred");
} finally {
  console.log("Execution finished");
}

---

Example 4: Custom Error

function withdraw(amount) {
  if (amount > 1000) {
    throw new Error("Limit exceeded");
  }

  console.log("Withdrawal successful");
}

try {
  withdraw(1500);
} catch (error) {
  console.log(error.message);
}

---

4. Common Mistakes

• Not using try-catch for risky operations

• Ignoring error messages

• Using try-catch for normal logic instead of actual errors

• Forgetting finally when cleanup is required

• Throwing errors without proper messages

These mistakes reduce code reliability and make debugging harder.

---

5. Real-World Use Case

Error handling is used in almost every application.

Example: API response handling

try {
  let data = JSON.parse('{"name": "Ashwin"}');
  console.log(data.name);
} catch (error) {
  console.log("Failed to parse data");
}

Example: user input validation

function login(password) {
  if (!password) {
    throw new Error("Password required");
  }

  console.log("Login successful");
}

Error handling ensures applications behave predictably even when something goes wrong.

---

6. Conclusion

Error handling allows JavaScript programs to manage failures gracefully instead of crashing. This article covered:

• What errors are

• Using try and catch

• The finally block

• Throwing custom errors

• Why error handling is important

Understanding error handling is essential for building stable, debuggable, and user-friendly applications.