typescript-utility-types.md

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

Содержание

• Основное разделение и категоризация
• Мнемонические правила для запоминания
• Подробные таблицы утилитных типов
• Визуальная шпаргалка
• Особенности и правила применения
• Простой пример для закрепления
• Вложенность утилитных типов
• Ключевые ассоциации и практический подход к запоминанию
• Заключительные советы

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

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

1. "Объектные" утилитные типы (работают с объектными типами)

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

2. "Юнион" утилитные типы (работают с union-типами)

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

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

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

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

• Partial
• Required
• Omit
• Pick

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

• Exclude
• Extract

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

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

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

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

Утилитный тип	Описание	Пример
Partial<T>	Делает все свойства необязательными	Partial<User> → { id?: number; name?: string; }
Required<T>	Делает все свойства обязательными	Required<User> → { id: number; name: string; }
Pick<T, K>	Выбирает указанные свойства	Pick<User, 'id'> → { id: number; }
Omit<T, K>	Исключает указанные свойства	Omit<User, 'id'> → { name: string; }

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

Утилитный тип	Описание	Пример
Exclude<T, U>	Исключает типы из T, присутствующие в U	Exclude<'a' | 'b' | 'c', 'a'> → 'b' | 'c'
Extract<T, U>	Извлекает из T типы, присутствующие в U	Extract<'a' | 'b' | 'c', 'a' | 'b'> → 'a' | 'b'

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

ОБЪЕКТНЫЕ ТИПЫ (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     (убрать)    │     │                    │
└───────────────────────┘     └────────────────────┘

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

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

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).

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