re:re:actable
Урок 043 минуты чтения

Типы как множества: почему never — пустое множество

На этой странице
Кратко

Тип в TypeScript удобно представлять как множество значений: string — все строки, "a" — множество из одного элемента, string | number — объединение множеств, A & B — пересечение. never — пустое множество: ни одно значение ему не принадлежит, поэтому never является подтипом любого типа и исчезает в union. unknown — множество всех значений (верхний тип). Совместимость «A присваивается в B» означает «A — подмножество B».

Вопрос

Как теория множеств помогает понимать типы TypeScript? Почему never — это «пустое множество»?

Типы как множества

unknown          — все значения
  ├── string     — все строки
  │     └── "a"  — одна строка
  ├── number
  │     └── 42
  ├── object
  │     └── { id: number }
  └── ...
never            — ни одного значения
Операция с типамиОперация с множествами
A | Bобъединение A ∪ B
A & Bпересечение A ∩ B
A extends BA ⊆ B (A — подмножество B)
Exclude<A, B>разность A \ B
never∅ пустое множество
unknownуниверсальное множество

Совместимость = подмножество

let s: string = "a";     // "a" ⊆ string — можно
let lit: "a" = s;        // string ⊄ "a" — нельзя
 
type Admin = { id: number; role: "admin" };
type User = { id: number };
const u: User = {} as Admin; // Admin ⊆ User — объектов с id и role меньше, чем объектов с id

Для объектов это сначала кажется контринтуитивным: больше свойств — меньше множество значений, поэтому Admin — подтип User.

Почему never — пустое множество

type A = string & number;          // строк, которые одновременно числа, нет → never
type B = "a" | never;              // A ∪ ∅ = A → "a"
type C = "a" & never;              // A ∩ ∅ = ∅ → never
 
const x: never = 1;                // нельзя: 1 ∉ ∅
function fail(): never { throw new Error(); } // функция не возвращает ни одного значения
 
function anything(value: never) {
  const s: string = value;         // можно: ∅ ⊆ любого множества
}

Следствия:

  • never присваивается в любой тип (пустое множество — подмножество любого);
  • в never нельзя присвоить ничего, кроме never;
  • never исчезает из union — поэтому условные типы возвращают never, чтобы отфильтровать варианты:
type OnlyStrings<T> = T extends string ? T : never;
type R = OnlyStrings<"a" | 1 | "b">; // "a" | "b"

unknown и any

  • unknown — всё множество: любое значение принадлежит ему, но о конкретном значении ничего не известно;
  • any — не множество, а отключение проверок: он одновременно «надмножество» и «подмножество» всего.

Практическая польза

  • понимать, почему string | "a" упрощается до string;
  • читать ошибки «Type X is not assignable to type Y» как «X не входит в Y»;
  • строить utility-типы через объединение, пересечение и фильтрацию;
  • правильно использовать exhaustive check: после обработки всех вариантов остается пустое множество.

Что важно помнить

  • {} в TypeScript — множество всех значений, кроме null и undefined, а не «пустой объект».
  • object — все непримитивные значения.
  • Литеральный тип — множество из одного значения.
  • keyof (A | B) = общие ключи (пересечение), keyof (A & B) = все ключи (объединение).

Мини-шпаргалка

  • Тип = множество значений.
  • | — объединение, & — пересечение, extends — подмножество.
  • never = ∅: подтип всего, исчезает в union.
  • unknown = всё множество.
  • Больше свойств у объекта — меньше множество.

Документация

TypeScript Handbook: Types as Sets, TypeScript Handbook: The never type.

Дочитали до конца?
Отметьте урок — прогресс сохранится в браузере.

Поиск

Поиск по урокам