Prev Next

TS Special Types

TypeScript provides special types that handle more nuanced cases like uncertain values, uninhabited states, or unknown inputs. This section covers any, unknown, never, null, and undefined.

Key Topics

Any vs Unknown

The any type disables type checking, effectively opting out of the TypeScript system. The unknown type is safer; you must narrow the type before you can use it.

let dataAny: any = "hello";
// No type errors, but less safety
dataAny = 42;

let dataUnknown: unknown = "world";
// Must check or assert the type before usage
if (typeof dataUnknown === "string") {
    console.log(dataUnknown.toUpperCase());
} else {
    console.log("Not a string");
}

Output

WORLD

Explanation: Using any bypasses type safety. With unknown, you must ensure the type is narrowed or type-asserted before using it in a way that requires a specific type.

Never Type

The never type indicates a value that never occurs, such as a function that never returns. It’s useful for unreachable code or functions that throw errors.

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

// This function never returns, so its return type is never.

Null & Undefined

In strict mode, null and undefined are distinct types that must be explicitly handled if a variable might have those values.

let optionalValue: string | null = null;

if (optionalValue !== null) {
    console.log(optionalValue.toLowerCase());
} else {
    console.log("Value is null");
}

Output

Value is null

Explanation: By including null in the type definition (string | null), TypeScript enforces checks for the null case before using the string value.

Key Takeaways

  • any: Opt-out of type checking; use sparingly.
  • unknown: Safer alternative to any; requires type checks before usage.
  • never: Functions or expressions that never produce a value.
  • null & undefined: Must be explicitly handled in strict mode.
Prev Next