Understanding TypeScript's Error Handling: Best Practices for Beginners

Error handling is an essential part of writing reliable applications. In TypeScript, which adds static typing on top of JavaScript, handling errors properly helps you catch problems early and provide smooth user experiences. This article will introduce you to the core concepts of error handling in TypeScript and share best practices to get started.

The most common way to handle errors is by using try...catch blocks. They allow you to run code that might fail and catch any errors that occur, preventing your program from crashing.

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

try {
  const result = divide(10, 0);
  console.log(result);
} catch (error) {
  if (error instanceof Error) {
    console.error('Error caught:', error.message);
  } else {
    console.error('Unknown error');
  }
}

In this example, we throw a new error if division by zero is attempted. The try block calls the divide function, and if an error occurs, the catch block handles it, checking that the caught error is indeed an Error object.

### Best Practices for Error Handling in TypeScript

1. **Use specific error types when possible:** Instead of using generic Errors, create custom error classes to provide more meaningful context.

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

function validateName(name: string) {
  if (name.length < 3) {
    throw new ValidationError('Name must be at least 3 characters long');
  }
  return true;
}

try {
  validateName('Jo');
} catch (error) {
  if (error instanceof ValidationError) {
    console.error('Validation error:', error.message);
  } else {
    console.error('Unexpected error');
  }
}

2. **Use TypeScript's type narrowing:** In catch blocks, use the `instanceof` operator to narrow error types and safely access properties like `message`.

3. **Avoid empty catch blocks:** Always handle errors in some way, even if it's just logging them for debugging.

4. **Return error information gracefully:** In some cases, especially in asynchronous code, consider returning error details instead of throwing exceptions to keep your app stable.

Here is a simple example of returning errors without throwing:

type Result<T> = {
  data?: T;
  error?: string;
};

function parseJSON(input: string): Result<object> {
  try {
    const data = JSON.parse(input);
    return { data };
  } catch {
    return { error: 'Invalid JSON string' };
  }
}

const result = parseJSON('{ invalid json }');
if (result.error) {
  console.error('Error:', result.error);
} else {
  console.log('Parsed data:', result.data);
}

### Conclusion

Error handling in TypeScript enhances your code's safety and user experience. Use try...catch blocks, leverage TypeScript's type system by creating custom errors, and handle errors gracefully. Mastering these basics will make you more confident in building robust applications.