TypeScript never Type

Summary: in this tutorial, you will learn about the TypeScript never type that contains no value.

Introduction to the TypeScript never type

The never type is a type that contains no values. Because of this, you cannot assign any value to a variable with a never type.

Typically, you use the never type to represent the return type of a function that always throws an error. For example:

function raiseError(message: string): never {
    throw new Error(message);
}Code language: TypeScript (typescript)

The return type of the following function is inferred to the never type:

function reject() { 
   return raiseError('Rejected');
}Code language: TypeScript (typescript)

If you have a function expression that contains an indefinite loop, its return type is also the never type. For example:

let loop = function forever() {
    while (true) {
        console.log('Hello');
    }
}Code language: TypeScript (typescript)

In this example, the type of the return type of the forever() function is never.

If you see that the return type of a function is never, then you should ensure that it is not what you intended to do.

Variables can also acquire the never type when you narrow its type by a type guard that can never be true.

For example, without the never type, the following function causes an error because not all code paths return a value.

function fn(a: string | number): boolean {
  if (typeof a === "string") {
    return true;
  } else if (typeof a === "number") {
    return false;
  }   
}Code language: TypeScript (typescript)

To make the code valid, you can return a function whose return type is the never type.

function fn(a: string | number): boolean {
  if (typeof a === "string") {
    return true;
  } else if (typeof a === "number") {
    return false;
  }  
  // make the function valid
  return neverOccur();
}

let neverOccur = () => {
   throw new Error('Never!');
} Code language: TypeScript (typescript)

Summary

• The never type contains no value.
• The never type represents the return type of a function that always throws an error or a function that contains an indefinite loop.