Master TypeScript’s any, unknown, and never Types: When and How to Use Them

TypeScript is a superset of JavaScript that adds static typing to improve code quality and readability. Understanding the differences among the any, unknown, and never types is essential, especially for beginners.

Declaring basic types in TypeScript

TypeScript allows you to explicitly define variable types. Examples of basic type declarations:

let age: number = 30;
let name: string = "Alice";
let isActive: boolean = true;
let numbers: number[] = [1, 2, 3];
let person: [string, number] = ["Alice", 30];
enum Color { Red, Green, Blue }
let c: Color = Color.Green;

1. any: Flexible type

The any type lets a variable hold a value of any data type, providing maximum flexibility when strict typing is unnecessary.

When and how to use any? Use any when the variable’s type is unknown or can change, such as values from user input or external APIs. Overusing any defeats TypeScript’s type‑checking benefits.

let mystery: any = 'a surprise!';
// Reassign to different types
mystery = 42; // number
mystery = false; // boolean
// Perform typical operations
console.log(mystery.toString());
// Reassign to an object
mystery = { key: 'value' };
console.log(mystery.key);

2. unknown: Safe and versatile type

The unknown type represents a value whose type is not known at compile time. It is the type‑safe counterpart of any; you must narrow the type before performing most operations.

When and how to use unknown? Use unknown for values from external sources (e.g., API responses) when you need to ensure type safety.

let uncertainValue: unknown = 'Hello World';
// Direct use causes error
// console.log(uncertainValue.toUpperCase());
// Type check before use
if (typeof uncertainValue === 'string') {
  console.log(uncertainValue.toUpperCase()); // safe
}

Example with an array of mixed types:

let unknownValue: unknown = ["one", 2, "three", 4];
// Direct array operations cause error
// console.log(unknownValue.length);
if (Array.isArray(unknownValue)) {
  unknownValue.forEach(item => {
    if (typeof item === 'string') {
      console.log(`String: ${item}`);
    } else if (typeof item === 'number') {
      console.log(`Number: ${item}`);
    }
  });
}

3. never: Unreachable type

The never type represents values that never occur, such as functions that always throw errors or have infinite loops.

When and how to use never? Use never for functions that never return or in exhaustive type checks to ensure all cases are handled.

function throwError(message: string): never {
  throw new Error(message);
}
throwError('Something went wrong'); // never returns

Example of exhaustive checking with a union type:

type Pet = 'dog' | 'cat' | 'fish';
function handlePet(pet: Pet) {
  switch (pet) {
    case 'dog':
      console.log('Handle a dog');
      break;
    case 'cat':
      console.log('Handle a cat');
      break;
    case 'fish':
      console.log('Handle a fish');
      break;
    default:
      const exhaustiveCheck: never = pet;
      return exhaustiveCheck;
  }
}
handlePet('dog'); // Output: Handle a dog

When to use each type

any – when migrating from JavaScript or when type safety is not a priority.

unknown – for dynamic content or third‑party data where the type is uncertain.

never – to guarantee that a function never returns or to enforce exhaustive checks.

Conclusion

Understanding any, unknown, and never is crucial for effective TypeScript development. Any offers flexibility, unknown ensures safety, and never helps model unreachable code paths. Balancing these types lets you leverage the full power of TypeScript’s type system.