Error Handling in TypeScript Best Practices and Effective Patterns

Error handling is a crucial part of writing robust and maintainable TypeScript applications. Without proper error management, applications can crash unexpectedly, making debugging difficult and affecting user experience.

This article explores best practices and effective patterns for handling errors in TypeScript, including typed error handling, error propagation, functional error handling, and structured logging.

For synchronous operations, wrapping code in a try-catch block helps handle unexpected errors gracefully.

function divide(a: number, b: number): number {
  try {
    if (b === 0) {
      throw new Error("Cannot divide by zero");
    }
    return a / b;
  } catch (error) {
    console.error("Error:", error);
    return NaN;
  }
}

Best Practice: Always log errors with meaningful messages to help with debugging.

Since async functions return promises, errors must be handled inside try-catch blocks.

async function fetchData(url: string): Promise<any> {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }
    return await response.json();
  } catch (error) {
    console.error("Fetch error:", error);
    throw error; // Re-throw for higher-level handling
  }
}

Best Practice: Always check response status before parsing data to avoid unexpected runtime errors.

For cases where await is not used, .catch() can handle errors in promise chains.

fetch("https://api.example.com/data")
  .then((response) => {
    if (!response.ok) {
      throw new Error(`Request failed with status: ${response.status}`);
    }
    return response.json();
  })
  .then((data) => console.log(data))
  .catch((error) => console.error("Error fetching data:", error));

Best Practice: Use .catch() at the end of the promise chain to handle any errors gracefully.

Custom error classes improve error categorization and allow for more precise error handling.

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

function validateUserInput(input: string) {
  if (input.trim() === "") {
    throw new ValidationError("Input cannot be empty");
  }
}

Best Practice: Use meaningful error names to distinguish between different error types.

To handle different error types correctly, type guards can ensure that the error object matches expected types.

function handleError(error: unknown) {
  if (error instanceof ValidationError) {
    console.warn("Validation error:", error.message);
  } else if (error instanceof Error) {
    console.error("General error:", error.message);
  } else {
    console.error("Unknown error:", error);
  }
}

Best Practice: Always use instanceof checks to ensure safe error handling.

A functional programming approach using Either types (from libraries like fp-ts) helps manage errors without throwing exceptions.

import { Either, left, right } from "fp-ts/Either";

function safeDivide(a: number, b: number): Either<string, number> {
  return b === 0 ? left("Cannot divide by zero") : right(a / b);
}

const result = safeDivide(10, 2);
console.log(result);

Best Practice: Avoid exceptions when possible and return error values explicitly.

A centralized error-handling function ensures consistent error reporting across an application.

function globalErrorHandler(error: unknown) {
  console.error("Application Error:", error);
}

process.on("uncaughtException", globalErrorHandler);
process.on("unhandledRejection", globalErrorHandler);

Best Practice: Use global handlers to catch uncaught exceptions and unhandled promise rejections.

Structured logging helps developers debug issues efficiently.

import winston from "winston";

const logger = winston.createLogger({
  level: "error",
  format: winston.format.json(),
  transports: [new winston.transports.Console()],
});

try {
  throw new Error("Something went wrong!");
} catch (error) {
  logger.error("Error occurred", { error });
}

Best Practice: Integrate logging tools like Winston or Pino for structured error tracking.

Effective error handling in TypeScript ensures that applications remain stable and maintainable. Using structured patterns like custom error classes, type guards, functional error handling, and centralized error logging, developers can write resilient code that gracefully handles failures.

By following these best practices, you can minimize crashes, improve debugging efficiency, and enhance the reliability of your TypeScript applications.