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

Exclude, Extract и NonNullable

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

Эти utility-типы фильтруют union-типы. Exclude<T, U> убирает из T варианты, совместимые с U. Extract<T, U> оставляет только совместимые с U. NonNullable<T> убирает null и undefined. Все они основаны на дистрибутивных условных типах: условие применяется к каждому члену union отдельно.

Вопрос

Что делают Exclude, Extract и NonNullable? Чем они отличаются от Omit и Pick?

Exclude

type Status = "idle" | "loading" | "success" | "error";
 
type FinalStatus = Exclude<Status, "idle" | "loading">; // "success" | "error"
type NoStrings = Exclude<string | number | boolean, string>; // number | boolean

Extract

type Event =
  | { type: "click"; x: number; y: number }
  | { type: "submit"; formId: string }
  | { type: "reset" };
 
type SubmitEvent = Extract<Event, { type: "submit" }>;
// { type: "submit"; formId: string }
 
type Common = Extract<"a" | "b" | "c", "b" | "c" | "d">; // "b" | "c" — пересечение union

NonNullable

type MaybeUser = User | null | undefined;
type DefinitelyUser = NonNullable<MaybeUser>; // User
 
function assertDefined<T>(value: T): NonNullable<T> {
  if (value == null) throw new Error("Значение отсутствует");
  return value;
}

Как они устроены

type MyExclude<T, U> = T extends U ? never : T;
type MyExtract<T, U> = T extends U ? T : never;
type MyNonNullable<T> = T & {}; // в современных версиях TS

Дистрибутивность: для T = "a" | "b" | "c" условие проверяется для каждого члена, а never исчезает из результата:

Exclude<"a" | "b" | "c", "a">
= ("a" extends "a" ? never : "a") | ("b" extends "a" ? never : "b") | ("c" extends "a" ? never : "c")
= never | "b" | "c"
= "b" | "c"

Exclude/Extract и Omit/Pick

Работает сЧто делает
Exclude, Extractunion-типамифильтрует варианты
Omit, Pickобъектными типамиудаляет или выбирает свойства
type Keys = Exclude<keyof User, "password">; // фильтр union ключей
type SafeUser = Pick<User, Keys>;            // = Omit<User, "password">

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

  • Exclude и Extract не проверяют, что U относится к T: опечатка просто ничего не исключит.
  • Для объектов Extract сравнивает структурно: Extract<Event, { type: "submit" }> найдет все варианты с таким полем.
  • NonNullable не убирает void и не сужает значение в runtime — только тип.
  • Для фильтрации массива с null используйте type guard: items.filter((x): x is T => x != null).

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

  • Exclude<T, U> — убрать варианты union.
  • Extract<T, U> — оставить варианты union.
  • NonNullable<T> — убрать null и undefined.
  • Основа — дистрибутивные условные типы.
  • Для объектов — Omit/Pick.

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

TypeScript: Exclude, TypeScript: Extract, TypeScript: NonNullable.

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

Поиск

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