TypeScript Never - Lemborco

Back to: TypeScript Tutorial

TypeScript is a powerful superset of JavaScript that adds optional static typing, which can help to catch errors during the development process. One of the more advanced features of TypeScript is the “never” type. The “never” type represents a type that never occurs, making it useful for some advanced scenarios.

The “never” type is a subtype of all other types in TypeScript, meaning it is assignable to any type, but no other type is assignable to “never”. Essentially, this means that any expression that results in “never” can be used in place of any other type. This can be helpful for ensuring that a function never returns or that an exception is thrown.

Here is an example of how “never” can be used in a function that always throws an exception:

function throwError(message: string): never {
  throw new Error(message);
}

throwError("An error occurred.");

In this example, the function “throwError” takes a string message and throws an exception with that message. The return type of “never” indicates that this function never returns a value. The function can be used in place of any other type, as it will never actually return anything.

Another common use case for “never” is in union types. Union types allow a value to be of more than one type, but sometimes you need to ensure that a value is not of a certain type. For example, let’s say you have a function that takes a string or a number, but you want to ensure that the function is only called with a string:

function printString(value: string | number): void {
  if (typeof value === "string") {
    console.log(value);
  } else {
    // This function will never return, as we know the value is not a string.
    throw new Error("Value must be a string.");
  }
}

printString("Hello, world!");

In this example, the function “printString” takes a value that can be either a string or a number. If the value is a string, the function logs the value to the console. If the value is not a string, the function throws an exception with the message “Value must be a string.” The return type of “never” indicates that this function never returns when the value is not a string.

In conclusion, the “never” type is a powerful feature of TypeScript that can help to catch errors and ensure that functions never return. It is a subtype of all other types, meaning it can be used in place of any other type. By understanding how to use “never” effectively, you can write safer and more robust TypeScript code.

Stay Connected