TypeScript: утилитные типы — шпаргалка

Основное разделение и категоризация

Для удобства запоминания и использования, все утилитные типы TypeScript можно разделить на две группы:

Объектные (object types)

Утилитные типы (работают с объектными типами)

• Partial<T> - делает все свойства необязательными
• Required<T> - делает все свойства обязательными
• Omit<T, K> - исключает указанные свойства
• Pick<T, K> - выбирает указанные свойства

Объединяющие (union types)

• Exclude<T, U> - исключает типы
• Extract<T, U> - извлекает типы

Мнемонические правила для запоминания

Правило №1: "PROP" для объектных типов

Первые буквы объектных типов складываются в "PROP":

• Partial
• Required
• Omit
• Pick

Правило №2: "EE" или "Double E" для union типов

• Exclude
• Extract

Правило №3: По смыслу операций

• Объектные типы изменяют структуру объекта (его свойства)
• Union-типы фильтруют элементы множества (элементы union-типа)

Визуальная шпаргалка

ОБЪЕКТНЫЕ ТИПЫ (PROP)          |  UNION ТИПЫ (EE)
-------------------------------|------------------
Partial<T> → { prop?: value }  |  Exclude<T, U> → T - U
Required<T> → { prop: value }  |  Extract<T, U> → T ∩ U
Omit<T, K> → { без K }         |
Pick<T, K> → { только K }      |

Альтернативная визуальная памятка

┌─── Объектные типы ────┐     ┌─── Union  типы ────┐
│                       │     │                    │
│  Partial  (все?)      │     │  Exclude (убрать)  │
│  Required (все!)      │     │  Extract (взять)   │
│  Pick     (взять)     │     │                    │
│  Omit     (убрать)    │     │                    │
└───────────────────────┘     └────────────────────┘

Особенности и правила применения

Основное различие между типами трансформаций: объектные типы изменяют структуру объекта, а union-типы фильтруют элементы множества. При работе с вложенными утилитными типами важно помнить о порядке выполнения изнутри наружу и возможности комбинирования для создания сложных трансформаций.

Объектные утилитные типы

1. Основное действие: изменяют структуру объекта, его свойства
2. Мнемоника: "PROP" (Partial, Required, Omit, Pick)
3. Применение к union-типам:
   • Распространяются на каждый член union-типа отдельно
   • Pick и Omit требуют, чтобы выбираемые/исключаемые свойства присутствовали во всех типах union

Union утилитные типы

1. Основное действие: фильтруют элементы множества (union-типа)
2. Мнемоника: "EE" (Exclude, Extract)
3. Математическая аналогия:
   • Exclude<T, U> → T − U (разность множеств)
   • Extract<T, U> → T ∩ U (пересечение множеств)

Простой пример для закрепления

// ОБЪЕКТНЫЕ ТИПЫ
interface User {
  id: number;
  name: string;
  email?: string;
}

// Работаем со СТРУКТУРОЙ объекта:
type OptionalUser = Partial<User>;           // все поля необязательные
type RequiredUser = Required<User>;          // все поля обязательные  
type UserBasic = Pick<User, 'id' | 'name'>; // только id и name
type UserNoId = Omit<User, 'id'>;           // без поля id

// UNION ТИПЫ
type Colors = 'red' | 'green' | 'blue' | 'yellow';
type Primary = 'red' | 'green' | 'blue';

// Работаем с МНОЖЕСТВАМИ значений:
type Secondary = Exclude<Colors, Primary>; // 'yellow'
type OnlyPrimary = Extract<Colors, Primary>; // 'red' | 'green' | 'blue'

Вложенность утилитных типов

Утилитные типы можно комбинировать друг с другом для создания сложных трансформаций:

// Выбираем только name и email, делая их обязательными
type UserContactInfo = Required<Pick<User, 'name' | 'email'>>;

// Делаем все поля необязательными, кроме id
type UpdateUser = Partial<Omit<User, 'id'>> & Pick<User, 'id'>;

Принципы работы вложенных утилитных типов:

1. Порядок выполнения: изнутри наружу
2. Читаемость: внутренний тип применяется первым, результат передается внешнему
3. Дистрибутивность: T<A | B> часто равно T<A> | T<B>

Ключевые ассоциации и практический подход к запоминанию

Тип трансформации	Для объектов	Для union-типов
Делает необязательным	Partial	-
Делает обязательным	Required	-
Выбирает/извлекает	Pick	Extract
Исключает/убирает	Omit	Exclude

Заключительные советы

1. На практике: начинайте с простых трансформаций, постепенно переходя к вложенным
2. Для глубокого понимания: экспериментируйте в TypeScript Playground
3. Разбор типов: используйте функцию type TestType = ... для промежуточной проверки результатов трансформации
4. Индикатор понимания: если вы можете предсказать результат вложенных типов вроде Required<Omit<Partial<T>, K>>, значит вы хорошо освоили тему

Запомните: объектные типы меняют структуру (PROP), а union-типы фильтруют значения (EE).

Правильное использование утилитных типов делает код более типобезопасным, выразительным и уменьшает дублирование определений типов в проекте.

Оригинальный текст статьи gist.github.com/olegopro