Union types (A | B) allow a value to be one of several types, enabling flexible handling of multiple input possibilities. 2. Intersection types (A & B) combine multiple types into one that must satisfy all members, useful for creating complex object shapes. 3. The never type represents unreachable or impossible states, commonly used in exhaustiveness checks and functions that never return. Together, these advanced TypeScript features enable more robust, self-documenting, and type-safe code by making invalid states unrepresentable.

When working with TypeScript, basic type annotations are just the beginning. To write more robust, expressive, and maintainable code, you need to go beyond string, number, or boolean and leverage advanced type hints like union types, intersection types, and the special never type. These tools give you fine-grained control over how values and functions behave in complex scenarios.

Let’s break down each of these concepts with practical examples and use cases.

Union Types: Handling Multiple Possibilities

A union type allows a value to be one of several types. You define it using the vertical bar (|).

let userId: string | number;
userId = "abc123"; // ?
userId = 123;       // ?

This is especially useful when dealing with APIs, user input, or legacy data where the type isn’t guaranteed.

Practical Example: Status Handling

function getStatus(status: "loading" | "success" | "error") {
  // ...
}
getStatus("loading"); // ?
getStatus("pending"); // ? Argument not assignable

You can also use unions with complex types:

type User = { name: string; age: number };
type Admin = { name: string; permissions: string[] };

function printInfo(entity: User | Admin) {
  console.log(entity.name); // ? 'name' exists on both
  // console.log(entity.age); // ? Error: 'age' not on Admin
}

? Tip: Use a type guard to narrow down union types at runtime.

if ("age" in entity) {
  console.log(entity.age); // Now safe
}

Intersection Types: Combining Types

An intersection type combines multiple types into one. It uses the & operator and means “this value must satisfy all types.”

type User = { name: string; email: string };
type Timestamp = { createdAt: Date; updatedAt: Date };

type UserWithTimestamp = User & Timestamp;

const user: UserWithTimestamp = {
  name: "Alice",
  email: "alice@example.com",
  createdAt: new Date(),
  updatedAt: new Date(),
};

Real-World Use Case: Mixins or Configuration Objects

type WithId = { id: number };
type WithName = { name: string };
type Active = { isActive: boolean };

type Account = WithId & WithName & Active;

const account: Account = {
  id: 1,
  name: "Pro User",
  isActive: true,
};

?? Be careful with object intersections that have conflicting fields:

type A = { data: string };
type B = { data: number };
type C = A & B;

const example: C = {
  data: ??? // What could this be? Must be string & number → impossible → `never`
};

Which leads us to…

The never Type: Representing Unreachable States

The never type represents values that should never occur. It’s used in two main scenarios:

1. Functions that never return
2. Values that can’t exist due to type narrowing

1. Functions That Never Return

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

This function doesn’t just return void — it never returns. TypeScript uses never to model that.

2. Exhaustiveness Checking in Unions

A classic use of never is ensuring all cases are handled in a union:

type Mode = "dark" | "light" | "auto";

function getTheme(mode: Mode) {
  switch (mode) {
    case "dark":
      return "Black";
    case "light":
      return "White";
    case "auto":
      return window.prefersDark ? "Black" : "White";
    default:
      // If all cases are covered, `mode` becomes `never` here
      const _exhaustiveCheck: never = mode;
      return _exhaustiveCheck;
  }
}

If you later add a new value to Mode but forget to handle it, this line will throw a type error, helping you catch incomplete logic.

How never Works in Type Systems

• never is the bottom type — it can be assigned to any type.
• But no type can be assigned to never (except never itself).
• It appears during type narrowing when possibilities are exhausted.

function handleValue(x: string | number) {
  if (typeof x === "string") {
    // x is string
  } else if (typeof x === "number") {
    // x is number
  } else {
    // x is `never` — no other possibility
    const unexpected: never = x;
    throw new Error(`Unexpected value: ${unexpected}`);
  }
}

Putting It All Together

Imagine building a form validation system:

type Success = { success: true; data: string };
type Failure = { success: false; error: string };
type Result = Success & Failure; // Wait — what?

// That doesn’t make sense. Instead:
type ValidationResult = Success | Failure;

function isValid(input: string): ValidationResult {
  if (input.length > 0) {
    return { success: true, data: input };
  } else {
    return { success: false, error: "Empty input" };
  }
}

// Then, handle the result safely:
function processResult(res: ValidationResult) {
  if (res.success) {
    console.log("Data:", res.data); // ? Type is Success
  } else {
    console.log("Error:", res.error); // ? Type is Failure
  }
}

Here, union types enable conditional typing, and TypeScript narrows the type based on the success field.

Summary

• Union types (A | B): Value is either A or B — great for flexible inputs.
• Intersection types (A & B): Value must be both A and B — useful for combining features.
• never: Represents impossible or unreachable states — essential for exhaustiveness checks and error functions.

These advanced type features help you write safer code by making invalid states unrepresentable. Once you get comfortable with them, your TypeScript becomes not just typed — it becomes self-documenting and self-enforcing.

Basically, that’s how you level up from basic annotations to truly powerful type modeling.

The above is the detailed content of Advanced Type Hinting: Union Types, Intersection Types, and `never`. For more information, please follow other related articles on the PHP Chinese website!