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

Intersection-типы: пересечение типов, примитивов, readonly и optional

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

Intersection-тип A & B означает «значение, которое одновременно является A и B»: для объектов это объединение их свойств. Пересечение несовместимых примитивов (string & number) дает never, а конфликтующие поля объектов получают тип never. Модификаторы при пересечении комбинируются: поле обязательно, если оно обязательно хотя бы в одном типе, и readonly, если readonly хотя бы в одном.

Вопрос

Что такое intersection-тип? Что будет при пересечении примитивов и как ведут себя readonly и optional поля в пересечении?

Пересечение объектов

type Entity = { id: string };
type Timestamps = { createdAt: Date; updatedAt: Date };
type Named = { name: string };
 
type User = Entity & Timestamps & Named;
 
const user: User = {
  id: "1",
  createdAt: new Date(),
  updatedAt: new Date(),
  name: "Анна",
};

Пересечение — основной способ «наследования» для type alias и композиции миксинов:

type WithLoading<T> = T & { isLoading: boolean };
type ButtonProps = React.ComponentProps<"button"> & { variant: "primary" | "ghost" };

Пересечение примитивов

type A = string & number;       // never — значения, которое одновременно строка и число, нет
type B = "a" & string;          // "a" — литерал входит в string
type C = string & {};           // string без null и undefined (используется в NonNullable)

Пересечение примитива с объектным типом используют для «брендирования»:

type Email = string & { readonly __brand: "Email" };

Конфликт полей

type X = { value: string };
type Y = { value: number };
 
type Z = X & Y;           // { value: never }
const z: Z = { value: 1 }; // ошибка — такой объект создать невозможно

interface extends в такой ситуации сразу сообщает об ошибке, а пересечение молча дает never.

Readonly и optional в пересечении

type A = { name?: string; readonly id: number };
type B = { name: string; id: number };
 
type C = A & B;
// name: string — обязательно, потому что обязательно в B
// id: readonly — readonly, потому что readonly в A
МодификаторВ AВ BВ A & B
?optionalrequiredrequired
?optionaloptionaloptional
readonlyreadonlymutablereadonly

Логика: значение должно удовлетворять обоим типам, поэтому побеждает более строгое требование.

Пересечение с union

type Shape = { kind: "circle"; r: number } | { kind: "square"; size: number };
type Colored = Shape & { color: string };
// распределяется: ({ kind: "circle"; r: number } & { color }) | ({ kind: "square"; ... } & { color })

Union и intersection как множества

Множества значенийДоступные свойства
A | Bобъединение — значений большеменьше (только общие)
A & Bпересечение — значений меньшебольше (все свойства)

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

  • Для объектных иерархий лучше interface extends — ошибки понятнее и проверка быстрее.
  • Пересечение функций создает перегруженную функцию: ((a: string) => void) & ((a: number) => void).
  • Если пересечение «схлопнулось» в never, ищите конфликт типов полей.
  • Утилита Prettify<T> = { [K in keyof T]: T[K] } & {} делает подсказку IDE для пересечений читаемой.

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

  • A & B — значение одновременно A и B.
  • Объекты: объединение свойств.
  • string & number → never, конфликт полей → поле never.
  • Optional + required → required, readonly + mutable → readonly.
  • Union расширяет множество значений, intersection сужает.

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

TypeScript Handbook: Intersection Types, TypeScript Handbook: Interfaces vs. Intersections.

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

Поиск

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