Error Handling in Node.js Using TypeScript

1. Introduction

Welcome to this tutorial on Error Handling in Node.js using TypeScript. Our goal is to understand how to effectively handle and log errors in a Node.js application. By the end of this tutorial, you will have learned:

• The basics of error handling in Node.js
• How to create and throw custom errors
• How to log errors in a Node.js application

Prerequisites for this tutorial include a basic understanding of JavaScript, Node.js, and TypeScript.

2. Step-by-Step Guide

Error handling is a crucial part of any application. It allows developers to anticipate potential problems and address them before they impact the user experience.

In Node.js, there are several ways to handle errors, including:

• Using try/catch blocks
• Using error-first callbacks
• Using error events
• Using promises

In this guide, we will focus on try/catch blocks and custom errors in TypeScript.

Try/Catch Blocks

In TypeScript, you can use try/catch blocks to handle synchronous and asynchronous errors. The 'try' block contains the code that may throw an error, while the 'catch' block contains the code to handle the error.

Custom Errors

In TypeScript, you can create custom error classes to throw specific errors. These classes should extend the built-in Error class in TypeScript.

3. Code Examples

Try/Catch Example

Here is an example of a try/catch block in a Node.js application using TypeScript:

try {
  // This code may throw an error
  let data = fs.readFileSync('file.txt', 'utf8');
  console.log(data);
} catch (error) {
  // This block will handle the error
  console.log('Error:', error.message);
}

In this example, if the file 'file.txt' does not exist or cannot be read for other reasons, an error will be thrown. The 'catch' block will then catch this error and log it to the console.

Custom Error Example

Here is an example of a custom error class in TypeScript:

class CustomError extends Error {
  constructor(message?: string) {
    super(message); // Pass the message to the Error class constructor
    this.name = 'CustomError'; // Set the name of the error
  }
}

try {
  throw new CustomError('This is a custom error');
} catch (error) {
  console.log('Error:', error.message);
}

In this example, we create a new 'CustomError' class that extends the built-in Error class. We then throw a new instance of CustomError, which is caught and logged in the catch block.

4. Summary

In this tutorial, we've seen how to handle errors in a Node.js application using TypeScript. We've learned how to use try/catch blocks and how to create and use custom errors.

For further learning, consider exploring other methods of error handling in Node.js, such as error-first callbacks, error events, and promises.

5. Practice Exercises

1. Write a function that reads a file and catches any errors that occur. Test your function with a non-existent file.

2. Create a custom error class that includes additional properties such as a status code. Throw and catch an instance of your custom error.

Solutions:

function readFile(file: string) {
  try {
    let data = fs.readFileSync(file, 'utf8');
    console.log(data);
  } catch (error) {
    console.log('Error:', error.message);
  }
}

readFile('non-existent-file.txt');

2.

class CustomError extends Error {
  constructor(public message: string, public statusCode: number) {
    super(message);
    this.name = 'CustomError';
  }
}

try {
  throw new CustomError('Not Found', 404);
} catch (error) {
  console.log('Error:', error.message, 'Status Code:', error.statusCode);
}

Keep practicing to become more comfortable with error handling in Node.js using TypeScript.