# Error handling mechanism : try-catch-finally

## 1\. What Are Errors in JavaScript?

Errors are problems that occur when your JavaScript code runs. They stop your program from working as expected.

There are mainly **three types** of errors:

**a) Syntax Errors**

These happen when your code breaks JavaScript rules.

Example:

```javascript
console.log("Hello"
```

Missing closing bracket → code won’t run at all.

**b) Runtime Errors**

These happen while the code is running.

Example:

```javascript
let user = null; 

console.log(user.name);
```

Here, you are trying to access name from null.

**c) Logical Errors**

The code runs, but the output is wrong.

Example:

```javascript
let total = 10 + "5";  // "105" instead of 15
```

* * *

## 2\. Why Error Handling Matters ?

**Without error handling:**

*   Your app can crash
    
*   Users get a bad experience
    
*   Debugging becomes difficult.
    

**With error handling:**

*   You can control failures
    
*   Show meaningful messages
    
*   Keep the app running smoothly.
    

This is called graceful failure — your app doesn’t break completely even if something goes wrong.

* * *

## 3\. Using try...catch

JavaScript gives us a way to handle runtime errors using try...catch.

**Basic Syntax:**

```javascript
 try { 
   // code that may cause error 
} catch (error) { 
  // code to handle error 
}
```

**Example**

```javascript
try {
    let data = JSON.parse("invalid json");
} catch (error) {
    console.log("Something went wrong");
}
```

Here:

*   try runs the risky code
    
*   If error occurs → catch runs
    

* * *

## 4\. Understanding the Error Object

Inside catch, you get an error object.

**Example:**

```javascript
try {
    let x = y;
} catch (error) {
    console.log(error.name);    // ReferenceError
    console.log(error.message); // y is not defined
}
```

This helps in debugging.

* * *

## 5\. The finally Block

`finally` always runs — whether error happens or not.

**Syntax**

```javascript
try {
    // risky code
} catch (error) {
    // handle error
} finally {
    // always runs
}
```

**Example**

```javascript
try {
    console.log("Start");
} catch (e) {
    console.log("Error");
} finally {
    console.log("Always runs");
}
```

**Use cases:**

*   Closing files
    
*   Stopping loaders
    
*   Cleaning resources
    

* * *

## 6\. Throwing Custom Errors

You can create your own errors using throw.

**Example**

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

**Using it:**

```javascript
try {
    withdraw(2000);
} catch (error) {
    console.log(error.message);
}
```

* * *

## 7\. Types of Built-in Errors

JavaScript provides different error types:

*   Error (generic)
    
*   ReferenceError
    
*   TypeError
    
*   SyntaxError
    
*   RangeError
    

**Example:**

```javascript
let num = null;
num.toUpperCase(); // TypeError
```

* * *

## 8\. Error Handling Flow

Execution works like this:

```plaintext
Step 1: Try block runs
Step 2: If no error → skip catch → run finally
Step 3: If error → jump to catch → then run finally
```

* * *

## 9\. Nested try...catch

You can use try...catch inside another try block.

```javascript
try {
    try {
        throw new Error("Inner error");
    } catch (inner) {
        console.log("Handled inside");
    }
} catch (outer) {
    console.log("Handled outside");
}
```

* * *

## 10\. Async Error Handling

Errors in async code behave differently.

**Using async/await**

```javascript
async function fetchData() {
    try {
        let res = await fetch("wrong-url");
    } catch (error) {
        console.log("Failed to fetch");
    }
}
```

**Without try...catch (Promises)**

```javascript
fetch("wrong-url")
    .then(res => res.json())
    .catch(error => console.log("Error occurred"));
```

* * *

## 11\. Best Practices

*   Don’t overuse try...catch
    
*   Catch only meaningful errors
    
*   Always log errors while debugging
    
*   Use custom error messages
    
*   Avoid empty catch blocks
    

**Bad:**

```javascript
try {
    riskyCode();
} catch (e) {}
```

**Good:**

```javascript
catch (e) {
    console.error(e.message);
}
```

* * *

## 12\. Real-World Example

```javascript
function login(user) {
    try {
        if (!user) {
            throw new Error("User not found");
        }

        console.log("Login successful");
    } catch (error) {
        console.log("Login failed:", error.message);
    } finally {
        console.log("Process finished");
    }
}
```

* * *

## 13\. Debugging Benefits

**Error handling helps you:**

*   Identify exact issue location
    
*   Understand error type
    
*   Fix bugs faster
    
*   Improve code quality
    

* * *

## Final Thoughts

Error handling is not just about fixing bugs — it’s about writing reliable and user-friendly applications.

**Start with:**

*   Understanding errors
    
*   Using try...catch properly
    

**Then move to:**

*   Custom errors
    
*   Async handling
    
*   Clean debugging practices
    

Mastering this will make your JavaScript code much more professional and robust.

Thank you for taking the time to read this blog. I hope it helped you understand JavaScript **error handling** in a clear and simple way.  
I’m always open to feedback and suggestions, so feel free to share your thoughts or improvements.