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

Conditional types и дистрибутивность union

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

Условный тип T extends U ? X : Y выбирает тип в зависимости от того, совместим ли T с U: «если T — подтип U, то X, иначе Y». Если T — «голый» параметр типа, а на вход пришел union, условие применяется к каждому члену union отдельно (дистрибутивность), и результаты объединяются. Чтобы отключить распределение, параметр оборачивают в кортеж: [T] extends [U].

Вопрос

Что такое conditional type и conditional generics? Что такое дистрибутивное поведение union-типов в условных типах?

Синтаксис

type IsString<T> = T extends string ? true : false;
 
type A = IsString<"hello">; // true
type B = IsString<42>;      // false
 
type ApiResult<T> = T extends Array<infer Item>
  ? { items: Item[]; total: number }
  : { item: T };
 
type R1 = ApiResult<User[]>; // { items: User[]; total: number }
type R2 = ApiResult<User>;   // { item: User }

Conditional generics в функциях

type Output<T> = T extends string ? number : string;
 
function convert<T extends string | number>(value: T): Output<T> {
  return (typeof value === "string" ? value.length : String(value)) as Output<T>;
}
 
const len = convert("abc"); // number
const str = convert(42);    // string

Внутри реализации TypeScript не умеет сопоставить ветку if с условным типом, поэтому нужен as — или перегрузки функции, которые часто читаются проще.

Дистрибутивность

type ToArray<T> = T extends unknown ? T[] : never;
 
type X = ToArray<string | number>;
// = (string extends unknown ? string[] : never) | (number extends unknown ? number[] : never)
// = string[] | number[]

Именно так работают Exclude и Extract:

type MyExclude<T, U> = T extends U ? never : T;
type S = MyExclude<"a" | "b" | "c", "a">; // "b" | "c"

Как отключить распределение

type ToArrayNonDist<T> = [T] extends [unknown] ? T[] : never;
 
type Y = ToArrayNonDist<string | number>; // (string | number)[]
 
type IsNever<T> = [T] extends [never] ? true : false;
type N1 = IsNever<never>; // true
 
type IsNeverWrong<T> = T extends never ? true : false;
type N2 = IsNeverWrong<never>; // never — union из нуля членов, нечего распределять

Распределение происходит только когда проверяемый тип — голый параметр (T), а не T[], [T] или Promise<T>.

Практические примеры

type NonFunctionKeys<T> = {
  [K in keyof T]: T[K] extends (...args: any[]) => any ? never : K;
}[keyof T];
 
type Data = { id: number; name: string; save(): void };
type DataKeys = NonFunctionKeys<Data>; // "id" | "name"
 
type Nullable<T> = T extends null | undefined ? T : T | null;
 
type PropsFor<T> = T extends "link" ? { href: string } : { onClick: () => void };

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

  • extends в условном типе — «совместим с / подмножество», а не наследование.
  • never на входе дистрибутивного условного типа дает never — частая причина неожиданных результатов.
  • Условные типы, зависящие от еще не известного T, откладываются (deferred) — подсказка IDE покажет само выражение.
  • Сложные условные типы трудно читать — давайте им говорящие имена и пишите примеры в тестах типов (expectTypeOf).

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

  • T extends U ? X : Y — выбор типа по условию.
  • С infer — извлечение частей типа.
  • Голый T + union → распределение по членам.
  • [T] extends [U] — без распределения.
  • IsNever — только через [T] extends [never].

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

TypeScript Handbook: Conditional Types, TypeScript Handbook: Distributive Conditional Types.

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

Поиск

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