46. What are the various error handling statements used in JavaScript?
medium
In JavaScript, there are several error handling statements that can be used to handle exceptions and errors that occur during program execution. Here's an overview of some of the most commonly used error handling statements in JavaScript:

1. Try-catch blocks: As mentioned earlier, try-catch blocks are a pair of statements in which the first statement (try) contains the code that might throw an exception, and the second statement (catch) specifies what to do when an exception occurs. Here's an example:
try {
  // Code that might throw an exception
  const result = 10 / 0;
} catch (error) {
  // Code to handle the exception
  console.log("An error occurred:", error);
}
In this example, we're attempting to divide 10 by 0, which will throw a TypeError because division by zero is not allowed. We wrap this code in a try-catch block to handle the exception that might occur.

2. Global error handling: JavaScript provides global error handling using the window.onerror event. This event fires when an unhandled exception occurs anywhere in the browser. Here's an example:
window.onerror = function(message, source, lineNumber, columnNumber) {
  // Code to handle the exception
  console.log("An error occurred:", message);
};
In this example, we're setting up a global error handler that will catch any unhandled exceptions in the browser and log them to the console.
3. Throw statements: The throw statement is used to intentionally throw an exception from within your code. Here's an example:
function divide(a, b) {
  if (b === 0) {
    throw new Error("Division by zero");
  }
  return a / b;
}

try {
  const result = divide(10, 0);
} catch (error) {
  console.log("An error occurred:", error);
}
In this example, we're defining a function called divide that will throw an Error if the second argument is zero. We then call this function with arguments 10 and 0, which will trigger the exception.

4. Finally statements: The finally statement is used to execute code after all try-catch blocks have completed execution, whether or not an exception was thrown. Here's an example:
function divide(a, b) {
  if (b === 0) {
    throw new Error("Division by zero");
  }
  return a / b;
}

try {
  const result = divide(10, 0);
} catch (error) {
  console.log("An error occurred:", error);
} finally {
  console.log("Exception handling complete");
}
In this example, we're defining the same function as before and wrapping it in a try-catch block. We then add a finally statement to execute code after all try-catch blocks have completed execution.

In conclusion, JavaScript provides several error handling statements that can be used to handle exceptions and errors that occur during program execution. Try-catch blocks are the most commonly used method for handling exceptions in JavaScript, but global error handling and throw statements can also be used to ensure that your code runs smoothly and efficiently.
PreviousNext