Задача: свои 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.