16 - JavaScript - Errors Handling

JavaScript is a programming language that is known for its flexibility and dynamic nature. However, like any other programming language, JavaScript also encounters errors while executing code. Error handling is the process of dealing with these errors in a controlled manner. In JavaScript, there are different types of error handling techniques available.

Try-Catch Block

The try-catch block is one of the most commonly used error handling techniques in JavaScript. It is used to catch and handle exceptions that occur in the try block. The syntax for the try-catch block is as follows:

try {
   // Code that may throw an exception
} catch (error) {
   // Code to handle the exception
}

Example:

try {
  const a = 10;
  const b = 0;
  const c = a / b; // This will throw an exception
} catch (error) {
  console.log(error.message); // "Cannot divide by zero"
}

Output:

Cannot divide by zero

Throw Statement

The throw statement is used to throw an exception. It is often used in combination with the try-catch block. The syntax for the throw statement is as follows:

throw errorObject;

Example:

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

try {
  const a = 10;
  const b = 0;
  const c = divide(a, b); // This will throw an exception
} catch (error) {
  console.log(error.message); // "Cannot divide by zero"
}

Output:

Cannot divide by zero

Finally Block

The finally block is used to execute code after the try-catch block, regardless of whether an exception was thrown or not. The syntax for the finally block is as follows:

try {
  // Code that may throw an exception
} catch (error) {
  // Code to handle the exception
} finally {
  // Code to be executed after the try-catch block
}

Example:

try {
  console.log("try block");
} catch (error) {
  console.log("catch block");
} finally {
  console.log("finally block");
}

Output:

try block
finally block

Error Object

The Error object is used to create an error message. It can be used in combination with the throw statement to throw an exception. The syntax for the Error object is as follows:

new Error(message);

Example:

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

try {
  const a = 10;
  const b = 0;
  const c = divide(a, b); // This will throw an exception
} catch (error) {
  console.log(error.name); // "Error"
  console.log(error.message); // "Cannot divide by zero"
}

Output:

Error
Cannot divide by zero

Custom Errors

In addition to the built-in Error object, you can also create custom errors by extending the Error object. This allows you to create more specific error messages that are tailored to your application. The syntax for creating custom errors is as follows:

class CustomError extends Error {
  constructor(message) {
    super(message);
    this.name = "CustomError";
  }
}

Summarizing Up

JavaScript error handling is a crucial aspect of writing robust and reliable code. There are different types of error handling techniques in JavaScript, including the try-catch block, throw statement, finally block, Error object, and custom errors. The try-catch block is the most commonly used technique, which catches and handles exceptions that occur in the try block. The throw statement is used to throw an exception, often in combination with the try-catch block. The finally block is used to execute code after the try-catch block, regardless of whether an exception was thrown or not. The Error object is used to create an error message, while custom errors allow developers to create more specific error messages tailored to their application.

Proper error handling is essential to prevent unexpected behavior and ensure the smooth functioning of an application. It helps identify and resolve issues quickly, improving the overall user experience. Effective error handling requires careful consideration of potential errors and proper handling techniques. Developers should be familiar with the different types of errors that may occur in JavaScript and how to handle them using the appropriate techniques.