Understanding TypeScript's Type Narrowing for Better Error Handling

TypeScript is a powerful extension of JavaScript that adds static types to the language. One of its most helpful features is type narrowing, which lets you refine a variable's type within certain parts of your code. This is especially useful for handling errors and ensuring your program behaves correctly.

Type narrowing happens when you use control flow statements like `if`, `typeof`, or `instanceof` to check a variable’s type. TypeScript then 'narrows' the variable's type inside that block, giving you better type safety and preventing common runtime errors.

Let's look at a simple example where we want to safely handle a value that can either be a string or null:

function printLength(value: string | null) {
  if (value !== null) {
    // Here, TypeScript knows 'value' is a string
    console.log(value.length);
  } else {
    console.log('No value provided');
  }
}

In this example, the condition `value !== null` narrows the type from `string | null` to just `string` inside the `if` block. Without this check, if you tried to access `value.length` directly, TypeScript would warn you about a possible error because `null` does not have a `.length` property.

Type narrowing is also very helpful when working with error objects, especially if you want to check for specific types of errors.

function handleError(error: unknown) {
  if (error instanceof Error) {
    // Narrowed from 'unknown' to 'Error'
    console.log('Error message:', error.message);
  } else {
    console.log('Unexpected error', error);
  }
}

Here, using `error instanceof Error` narrows the `error` type from the wide `unknown` to a specific `Error` object, making it safe to access `error.message`. This is a common and recommended way to improve error handling safety.

You can also use type predicates to create your own narrowing functions. For example, to check if a value is a string:

function isString(value: unknown): value is string {
  return typeof value === 'string';
}

function printValue(value: unknown) {
  if (isString(value)) {
    // Within this block, TypeScript knows 'value' is a string
    console.log(value.toUpperCase());
  } else {
    console.log('Not a string');
  }
}

In summary, type narrowing helps you write safer code by refining types based on runtime checks. This prevents errors like calling methods on `null` or handling data incorrectly. Understanding and using type narrowing will make your TypeScript code more robust and easier to maintain.