module-1.6-error-handling-and-exceptions.md

1.6. Error Handling and Exceptions

Error handling is a crucial aspect of writing reliable and robust JavaScript code. It allows you to anticipate and manage unexpected issues that may arise during the execution of your code. JavaScript provides a mechanism for throwing, catching, and handling exceptions. Let's explore this concept in detail.

1. Types of Errors

JavaScript errors can be categorized into several types, including:

• Syntax Errors: These occur when the code violates the rules of the JavaScript language. They are typically detected by the JavaScript engine during the parsing phase.

  // Syntax Error
  const x = 5;
  console.log(x;

• Runtime Errors: These occur during the execution of the code. They are often the result of unexpected conditions, such as division by zero or trying to access a property of an undefined variable.

  // Runtime Error (division by zero)
  const result = 10 / 0;

• Logical Errors: These are the most challenging to detect. They occur when the code is written incorrectly, but it still runs without throwing an error. Logical errors can lead to incorrect program behavior.

  // Logical Error
  function calculateSum(a, b) {
    return a - b; // Incorrect operation
  }

2. Try...Catch Statements

JavaScript provides the try...catch statement, which allows you to handle exceptions gracefully. It consists of two blocks:

• The try block contains the code that might throw an exception.

• The catch block is executed when an exception occurs, and it contains code to handle the exception.

  try {
    // Code that might throw an exception
    const result = 10 / 0;
  } catch (error) {
    // Handle the exception
    console.error(`An error occurred: ${error.message}`);
  }

3. Throwing Custom Errors

You can also throw custom errors using the throw statement. This is useful for creating more informative error messages and handling specific cases.

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

try {
  const result = divide(10, 0);
  console.log(result);
} catch (error) {
  console.error(`An error occurred: ${error.message}`);
}

4. Error Objects

JavaScript provides various built-in error objects, such as Error, SyntaxError, TypeError, and ReferenceError. These objects can be used to differentiate between different error types and provide more specific error handling.

try {
  // Code that might throw an error
  const x = 5;
  console.log(y); // ReferenceError: y is not defined
} catch (error) {
  if (error instanceof ReferenceError) {
    console.error('ReferenceError occurred.');
  } else {
    console.error(`An error occurred: ${error.message}`);
  }
}

5. Finally Block

You can also use a finally block along with try...catch. Code in the finally block is executed regardless of whether an exception was thrown. It's useful for tasks like resource cleanup.

try {
  // Code that might throw an exception
  console.log('Executing try block.');
  throw new Error('An error occurred.');
} catch (error) {
  console.error(`An error occurred: ${error.message}`);
} finally {
  console.log('Executing finally block.');
}

By effectively handling errors and exceptions, you can ensure that your JavaScript code gracefully deals with unexpected situations, improving the reliability of your applications.