JavaScript/TypeScript Error Handling: How Much Do You Really Know?

Error handling ensures code runs smoothly, handles unforeseen errors gracefully, and provides informative feedback to developers and users alike.

Error Types

Understanding the types of errors is the first step:

• Syntax errors — code that doesn’t parse correctly
• Runtime errors — errors that occur during execution
• Logical errors — code that runs but produces wrong results

JavaScript try…catch

The fundamental pattern for handling runtime errors:

try {
  const data = JSON.parse(userInput)
} catch (error) {
  console.error('Invalid JSON:', error.message)
}

TypeScript Enhancements

TypeScript adds static type checking that catches many errors at compile time. Key improvements:

Using unknown vs any in catch blocks

try {
  await fetchData()
} catch (error: unknown) {
  if (error instanceof Error) {
    console.error(error.message)
  }
}

Using unknown forces you to check the error type before accessing its properties — much safer than any.

Best Practices

1. Never ignore errors — always handle or propagate them
2. Create custom error types — for domain-specific error handling
3. Use finally for cleanup — ensures resources are released regardless of errors

When NOT to Use try…catch

• Performance-critical code — exception handling has overhead
• Control flow — don’t use exceptions for normal program logic
• Predictable errors — use validation instead
• Input validation — check inputs before processing
• Error propagation — sometimes it’s better to let errors bubble up

Conclusion

Effective error handling is about balance — catching what you can handle, propagating what you can’t, and never silently swallowing errors.