The Project | About Us | Contribute | Donations | License

HOME

Error handling is a crucial aspect of programming, as it allows you to manage and respond to unexpected situations that may arise during the execution of your code. In JavaScript, the try-catch statement is used to handle exceptions and errors gracefully.

Key Concepts

try-catch Statement: The try block contains code that might throw an error, and the catch block contains code that executes if an error occurs.
Error Object: When an error occurs, an error object is created, which contains information about the error.
finally Block: An optional finally block can be used to execute code after the try and catch blocks, regardless of whether an error occurred.

Syntax

try {
    // Code that may throw an error
} catch (error) {
    // Code to handle the error
} finally {
    // Code that will always execute
}

Practical Example

Let's look at a practical example to understand how try-catch works.

Example 1: Basic try-catch

try {
    let result = 10 / 0;
    console.log(result); // Infinity
    let data = JSON.parse('{"name": "John"}');
    console.log(data.name); // John
    let invalidData = JSON.parse('Invalid JSON');
} catch (error) {
    console.log('An error occurred:', error.message);
} finally {
    console.log('Execution completed.');
}

Explanation

try Block: The code inside the try block is executed. If an error occurs, the control is transferred to the catch block.
catch Block: The catch block captures the error and executes the code inside it. The error object contains details about the error.
finally Block: The finally block executes regardless of whether an error occurred or not.

Example 2: Handling Specific Errors

try {
    let data = JSON.parse('Invalid JSON');
} catch (error) {
    if (error instanceof SyntaxError) {
        console.log('JSON Syntax Error:', error.message);
    } else {
        console.log('An error occurred:', error.message);
    }
} finally {
    console.log('Execution completed.');
}

Explanation

Specific Error Handling: The catch block checks if the error is an instance of SyntaxError and handles it accordingly.
General Error Handling: If the error is not a SyntaxError, it is handled by the general error handler.

Practical Exercises

Exercise 1: Basic try-catch

Write a function that takes a JSON string as input and returns the parsed object. If the input is not valid JSON, the function should return null.

function parseJSON(jsonString) {
    try {
        return JSON.parse(jsonString);
    } catch (error) {
        return null;
    }
}

// Test Cases
console.log(parseJSON('{"name": "Alice"}')); // { name: 'Alice' }
console.log(parseJSON('Invalid JSON')); // null

Exercise 2: Advanced Error Handling

Write a function that takes a divisor and divides 100 by the divisor. If the divisor is zero, the function should throw an error with a custom message.

function divideBy(divisor) {
    try {
        if (divisor === 0) {
            throw new Error('Division by zero is not allowed.');
        }
        return 100 / divisor;
    } catch (error) {
        console.log('An error occurred:', error.message);
    } finally {
        console.log('Execution completed.');
    }
}

// Test Cases
console.log(divideBy(10)); // 10
console.log(divideBy(0)); // An error occurred: Division by zero is not allowed.

Common Mistakes and Tips

Not Using try-catch: Always use try-catch for code that might throw errors, especially when dealing with external inputs or APIs.
Ignoring Errors: Do not ignore errors in the catch block. Log them or handle them appropriately.
Overusing try-catch: Do not overuse try-catch for code that does not require it, as it can make the code harder to read and maintain.

Conclusion

In this section, we learned about error handling in JavaScript using the try-catch statement. We covered the syntax, practical examples, and exercises to reinforce the concepts. Proper error handling is essential for writing robust and reliable code. In the next module, we will explore functions in JavaScript, starting with defining and calling functions.

Error Handling with try-catch

Key Concepts

Syntax

Practical Example

Example 1: Basic try-catch

Explanation

Example 2: Handling Specific Errors

Explanation

Practical Exercises

Exercise 1: Basic try-catch

Exercise 2: Advanced Error Handling

Common Mistakes and Tips

Conclusion

JavaScript: From Beginner to Advanced

Module 1: Introduction to JavaScript

Module 2: Control Structures

Module 3: Functions

Module 4: Objects and Arrays

Module 5: Advanced Objects and Functions

Module 6: The Document Object Model (DOM)

Module 7: Browser APIs and Advanced Topics

Module 8: Testing and Debugging

Module 9: Performance and Optimization

Module 10: JavaScript Frameworks and Libraries

Module 11: Final Project