⚠️ JavaScript Error Handling: try, catch, finally

? Quick Overview

Error handling in JavaScript lets your programs respond gracefully to unexpected situations instead of crashing. The main building blocks are try, catch, and finally, which work together to detect errors, handle them safely, and perform cleanup tasks.

? Key Concepts

• try – Wraps code that might throw an error during execution.
• catch – Runs only if an error occurs inside the try block and receives an error object.
• finally – Always runs after try/catch, whether an error happened or not.
• Error object – Holds details like name, message, and often stack for debugging.
• Built-in errors – Examples include ReferenceError, TypeError, and SyntaxError.
• Custom errors – You can create your own using throw and new Error().

? Syntax / Theory

A complete error-handling structure usually looks like this:

try {
// Code that might throw an error
} catch (error) {
// Code to handle the error
} finally {
// Code that always runs (optional)
}

The JavaScript engine executes the try block first. If everything works, it skips directly to finally (if present). If an error is thrown inside try, control jumps to catch, then finally to finally.

? Code Examples

? Example: Only try Block

Here, we just run a risky operation. If it throws an error, it will stop the script unless handled somewhere else.

try {
let result = riskyOperation();
console.log(result);
}

? Example: try with catch

Now we add catch to safely handle any error that occurs in the try block.

try {
let result = riskyOperation();
console.log(result);
} catch (error) {
console.error("An error occurred:", error.message);
}

? Example: try, catch, and finally

The finally block runs after try/catch regardless of success or failure.

try {
let result = riskyOperation();
console.log(result);
} catch (error) {
console.error("An error occurred:", error.message);
} finally {
console.log("This runs no matter what");
}

? Example: Custom Error with throw

You can validate input and throw a custom error when something is wrong.

function divide(a, b) {
if (b === 0) {
throw new Error("Cannot divide by zero");
}
return a / b;
}

try {
const result = divide(10, 0);
console.log("Result:", result);
} catch (error) {
console.error("Division failed:", error.message);
} finally {
console.log("Division attempt finished");
}

? Live Output & Explanation

? Use Cases / When to Use

• When calling APIs or performing network requests that may fail.
• When working with user input that might be invalid or unexpected.
• When reading/writing files or using browser storage where access might fail.
• When you need to ensure resources are cleaned up (closing connections, clearing timers) in finally.