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

Задача: свои Pick, Omit, Partial и Record

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

Задачи «реализуйте utility type сами» проверяют знание mapped types ({ [K in Keys]: ... }), оператора keyof, индексного доступа T[K], модификаторов ? и readonly (и их удаления через -?, -readonly) и условных типов с extends. Почти все встроенные утилиты пишутся в одну строку: MyPartial<T> = { [K in keyof T]?: T[K] }.

Вопрос

Реализуйте типы MyPartial, MyRequired, MyReadonly, MyPick, MyOmit, MyRecord, MyExclude и MyExtract, не используя встроенные утилиты.

Решения

type MyPartial<T> = { [K in keyof T]?: T[K] };
 
type MyRequired<T> = { [K in keyof T]-?: T[K] };          // -? снимает необязательность
 
type MyReadonly<T> = { readonly [K in keyof T]: T[K] };
 
type MyMutable<T> = { -readonly [K in keyof T]: T[K] };   // снять readonly
 
type MyPick<T, K extends keyof T> = { [P in K]: T[P] };
 
type MyExclude<T, U> = T extends U ? never : T;           // дистрибутивный условный тип
 
type MyExtract<T, U> = T extends U ? T : never;
 
type MyOmit<T, K extends PropertyKey> = MyPick<T, MyExclude<keyof T, K>>;
 
type MyRecord<K extends PropertyKey, V> = { [P in K]: V };
 
type MyNonNullable<T> = T extends null | undefined ? never : T;

Проверка

type User = { id: number; name: string; email?: string; readonly createdAt: Date };
 
type A = MyPartial<User>;            // все поля необязательные
type B = MyRequired<User>;           // email: string — обязательный
type C = MyPick<User, "id" | "name">;   // { id: number; name: string }
type D = MyOmit<User, "email" | "createdAt">;  // { id: number; name: string }
type E = MyRecord<"ru" | "en", string>;        // { ru: string; en: string }
type F = MyExclude<"a" | "b" | "c", "a">;      // "b" | "c"
type G = MyExtract<string | number | boolean, string | boolean>; // string | boolean
 
// MyPick<User, "phone"> — ошибка: "phone" не является ключом User

Простой способ проверить тип в редакторе — навести курсор или написать «тест» на типах:

type Expect<T extends true> = T;
type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 
type Test1 = Expect<Equal<MyPick<User, "id">, { id: number }>>;

Почему MyExclude работает с объединением

Условный тип над голым параметром T применяется к каждому члену объединения отдельно (дистрибутивность):

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

Чтобы отключить дистрибутивность, оборачивают в кортеж: [T] extends [U] ? ... : ....

Продвинутые варианты

// Pick по типу значения: только строковые поля
type PickByValue<T, V> = { [K in keyof T as T[K] extends V ? K : never]: T[K] };
type StringFields = PickByValue<User, string>;   // { name: string }
 
// сделать необязательными только указанные ключи
type PartialBy<T, K extends keyof T> = MyOmit<T, K> & MyPartial<MyPick<T, K>>;
type NewUser = PartialBy<User, "id" | "createdAt">;
 
// переименование ключей: геттеры
type Getters<T> = { [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K] };
type UserGetters = Getters<{ name: string; age: number }>;   // { getName: () => string; getAge: () => number }

as в mapped type (key remapping) позволяет фильтровать и переименовывать ключи.

Доп. вопросы интервьюера

  • Почему у Omit ограничение K extends PropertyKey, а у Pick — K extends keyof T? так устроены встроенные типы: Omit позволяет передать ключ, которого нет, — это удобно, но менее строго. Строгий вариант: StrictOmit<T, K extends keyof T>.
  • type или interface для результата? mapped types — только через type.
  • Что такое гомоморфный mapped type? { [K in keyof T]: ... } сохраняет модификаторы ? и readonly исходного типа.

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

  • keyof T — объединение ключей, T[K] — тип значения по ключу.
  • -? и -readonly удаляют модификаторы, ? и readonly — добавляют.
  • Условный тип с голым параметром дистрибутивен по объединению.
  • Теория: Utility Types, mapped types, conditional types, keyof.

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

Partial { [K in keyof T]?: T[K] }, Required -?, Readonly readonly, Pick { [P in K]: T[P] }, Exclude T extends U ? never : T, Omit = Pick + Exclude, Record { [P in K]: V }. Фильтрация ключей — as ... ? K : never.

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

TypeScript: Utility Types, TypeScript: Mapped Types, TypeScript: Conditional Types, type-challenges.

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

Поиск

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