🧰 Дженерики и utility-типы
Дженерик — функция или тип с параметром, вместо которого компилятор подставляет конкретный тип в месте вызова. На них держится типизация репозиториев, ответов API и DTO в любом NestJS-проекте, а utility-типы вроде Partial и Omit встречаются почти в каждом файле. На собеседовании мидлу почти всегда дают написать Partial или ReturnType руками: так проверяют, понимаешь ли ты mapped-типы и условные типы, на которых всё это построено
🧠 Как это устроено
Дженерик против any
Функция с any принимает что угодно и теряет информацию: что бы ни пришло, на выходе тоже any, и компилятор дальше ничего не проверяет. Дженерик принимает что угодно и сохраняет связь между входом и выходом
function firstAny(arr: any[]): any { return arr[0] }
function first<T>(arr: T[]): T | undefined { return arr[0] }
const a = firstAny([1, 2]) // any: a.toUpperCase() скомпилируется и упадёт
const n = first([1, 2]) // number | undefinedT здесь никто не указывал. Компилятор вывел его из аргумента. Явно first<number>(...) пишут редко: когда вывести не из чего, например у new Map<string, User>(), или когда вывод получился шире, чем нужно
Вывод сохраняет литерал, если может. id('prod') для function id<T>(x: T) даёт тип 'prod', а тот же вызов со строковой переменной из let — уже string. С объектом литерал расширяется: поле можно переписать. Если нужен точный тип объекта, параметр объявляют как <const T>, и { mode: 'prod' } выведется как { readonly mode: 'prod' }, будто ты написал as const
extends как ограничение
Внутри функции про T ничего не известно, поэтому x.length не скомпилируется. extends задаёт нижнюю границу: «T — любой тип, у которого есть хотя бы это»
function getLength<T extends { length: number }>(x: T) {
return x.length
}
getLength('abc') // ok
getLength([1]) // ok
getLength(42) // ошибка: у number нет length
function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key]
}
getProp({ id: 1, name: 'a' }, 'name') // string
getProp({ id: 1, name: 'a' }, 'email') // ошибка: такого ключа нетВо втором примере три приёма, которые спрашивают вместе. keyof T — объединение ключей типа: для { id: number; name: string } это 'id' | 'name'. T[K] — indexed access, тип поля по ключу, как обращение к свойству, только на уровне типов. А K extends keyof T связывает два параметра: ключ обязан существовать в объекте
Параметру можно дать значение по умолчанию: type ApiResponse<T = unknown>. Тогда ApiResponse без угловых скобок значит ApiResponse<unknown>
Mapped-типы
Mapped-тип проходит по ключам и строит новый объектный тип. Синтаксис похож на цикл: { [K in keyof T]: T[K] } — для каждого ключа K из T поле того же типа. Без модификаторов это просто копия типа
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] } // добавить readonly
type Mutable<T> = { -readonly [K in keyof T]: T[K] } // снять readonly
type MyPick<T, K extends keyof T> = { [P in K]: T[P] }Минус перед модификатором снимает его, плюс или его отсутствие добавляет. Pick отличается только тем, что идёт не по всем ключам, а по переданному подмножеству K
Условные типы и дистрибутивность
Условный тип T extends U ? X : Y — тернарный оператор для типов. Здесь extends значит уже не ограничение, а проверку: «можно ли присвоить T в U». Одно слово в двух ролях, и на собеседовании это любят
Если T — голый параметр, а в него пришло объединение, условие применяется к каждому члену по отдельности, и результаты снова объединяются. Это называется дистрибутивностью. На ней построен Exclude:
type Exclude<T, U> = T extends U ? never : T
// Exclude<'a' | 'b', 'a'> раскладывается так:
// ('a' extends 'a' ? never : 'a') | ('b' extends 'a' ? never : 'b')
// never | 'b'
// 'b'never в объединении исчезает, поэтому «вернуть never» в условном типе значит «выкинуть этот вариант». Extract устроен зеркально
Дистрибутивность иногда мешает. ToArray<string | number> для T extends unknown ? T[] : never даст string[] | number[], а не (string | number)[]. Чтобы её выключить, обе стороны заворачивают в кортеж: [T] extends [unknown]. Голого параметра больше нет, и объединение проверяется целиком. У того же правила есть побочный эффект: never — пустое объединение, и IsString<never> вернёт не false, а never
infer
infer объявляет переменную прямо внутри условия: «если T подходит под этот шаблон, запомни, что стоит на этом месте». Так из типа достают кусок
type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never
type MyParameters<T> = T extends (...args: infer P) => any ? P : never
type UnwrapPromise<T> = T extends Promise<infer U> ? U : Tany в шаблонах тут нормален и встречается в самой стандартной библиотеке: это позиция «что угодно», значения такого типа нигде не появляются
UnwrapPromise снимает один слой: Promise<Promise<number>> превратится в Promise<number>. Встроенный Awaited разворачивает рекурсивно до конца и работает с любым объектом, у которого есть метод then, а не только с Promise. Он моделирует то, что делает await
Шпаргалка
| Тип | Что делает | Как устроен |
|---|---|---|
Partial<T> | все поля необязательные | mapped-тип с ? |
Required<T> | все поля обязательные | mapped-тип с -? |
Readonly<T> | все поля только для чтения | mapped-тип с readonly |
Pick<T, K> | оставить ключи K | mapped-тип по K extends keyof T |
Omit<T, K> | убрать ключи K | Pick<T, Exclude<keyof T, K>> |
Record<K, V> | объект с ключами K и значениями V | { [P in K]: V } |
Exclude<T, U> | убрать из объединения то, что подходит под U | дистрибутивный условный тип |
Extract<T, U> | оставить то, что подходит под U | то же, ветки наоборот |
NonNullable<T> | убрать null и undefined | T & {} |
ReturnType<F> | тип результата функции | условный тип с infer R |
Parameters<F> | кортеж типов аргументов | условный тип с infer P |
Awaited<T> | тип после await | рекурсивный условный тип по then |
🛠️ На практике
Репозиторий и DTO обновления
Базовый репозиторий пишут один раз и переиспользуют для всех сущностей. Ограничение T extends Entity гарантирует, что у строки есть id, а DTO обновления выводится из сущности, а не дублируется руками
TypeScript · Repository<T> с типизированным update
interface Entity { id: number }
interface User extends Entity { name: string; email: string; createdAt: Date }
class Repository<T extends Entity> {
private rows = new Map<number, T>()
findById(id: number): T | undefined {
return this.rows.get(id)
}
update(id: number, patch: Partial<Omit<T, 'id'>>): T {
const row = this.rows.get(id)
if (!row) throw new Error(`Row ${id} not found`)
const next = { ...row, ...patch }
this.rows.set(id, next)
return next
}
}
const users = new Repository<User>()
users.update(1, { name: 'Анна' }) // ok
users.update(1, { id: 2 }) // ошибка: id менять нельзя
users.update(1, { nmae: 'x' }) // ошибка: опечатка в поле
new Repository<{ name: string }>() // ошибка: нет idPartial<Omit<User, 'id'>> читается справа налево: убрали id, остальное сделали необязательным. Добавишь поле в User, и оно само появится в DTO обновления. В NestJS ту же идею дают PartialType и OmitType из @nestjs/mapped-types: они работают с классами, поэтому переносят ещё и декораторы class-validator
Обёртка ответа API
type ApiResponse<T = unknown> =
| { ok: true; data: T }
| { ok: false; error: string }
async function getUser(id: number): Promise<ApiResponse<User>> { /* ... */ }
// достать тип data из ответа функции, не импортируя User
type Data<R> = R extends { ok: true; data: infer D } ? D : never
type U = Data<Awaited<ReturnType<typeof getUser>>> // UserПоследняя строка собирает всё со страницы. typeof getUser в позиции типа берёт тип функции, ReturnType достаёт Promise<ApiResponse<User>>, Awaited снимает промис, а Data через дистрибутивность и infer выбирает успешную ветку объединения. Так типизируют ответы чужого SDK, который не экспортирует свои типы
keyof typeof
typeof в позиции типа превращает значение в тип. С keyof получается частый приём: ключи конфига или словаря без отдельного объявления
const config = { port: 8080, host: 'localhost' }
type ConfigKey = keyof typeof config // 'port' | 'host'
const roles = ['admin', 'user'] as const
type Role = (typeof roles)[number] // 'admin' | 'user'keyof config без typeof не скомпилируется: keyof работает с типами, а config — значение. Во втором примере [number] — тот же indexed access: тип элемента массива по любому числовому индексу
⚠️ Где ошибаются
Omit с несуществующим ключом. У Pick ключи ограничены K extends keyof T, а у Omit — только K extends keyof any, то есть любая строка, число или символ. Omit<User, 'idd'> скомпилируется и вернёт User целиком. После переименования поля такой Omit молча перестаёт что-то убирать. Если нужна строгость, пишут свой StrictOmit<T, K extends keyof T>
Ожидание, что Partial глубокий. Он делает необязательными только поля верхнего уровня. Для { db: { host: string; port: number } } объект { db: { host: 'x' } } не пройдёт: внутри db поля по-прежнему обязательны. Рекурсивный DeepPartial пишут сами, через условный тип внутри mapped-типа, и аккуратно обходят массивы, Date и функции, которые тоже object
Дженерик, который ничего не связывает. function log<T>(x: T): void ничем не лучше x: unknown: параметр встречается один раз и не связывает вход с выходом. Правило из документации: если параметр типа появляется в сигнатуре один раз, он скорее всего не нужен
Удивление от дистрибутивности. Свой условный тип внезапно возвращает объединение массивов или never вместо false. Если тип должен смотреть на объединение целиком, оборачивай обе стороны в [T]
🎯 Вопросы с собеседований
Что такое дженерики и чем они лучше any?
Это параметры типа: функция или тип описывается один раз, а конкретный тип подставляется при использовании, обычно компилятор выводит его сам. С any проверка выключается и информация о типе теряется на выходе. Дженерик сохраняет связь: first<T>(arr: T[]): T для массива чисел вернёт number, и дальше компилятор проверяет код как обычно
Что делает extends в дженерике и в условном типе?
В объявлении параметра, <T extends { length: number }>, это ограничение: подставить можно только тип, у которого есть length, и внутри функции этим полем можно пользоваться. В условном типе T extends U ? X : Y это вопрос «присваивается ли T в U» с выбором ветки. Смысл в обоих случаях общий — совместимость по присваиванию, но в первом случае компилятор требует её, а во втором проверяет
Что делают Partial, Pick, Omit, Record? Напиши Partial
Partial делает все поля необязательными, Pick оставляет указанные ключи, Omit убирает указанные, Record<K, V> описывает объект с ключами K и значениями V. Все они mapped-типы. Partial: type MyPartial<T> = { [K in keyof T]?: T[K] }. Pick отличается тем, что идёт по переданным ключам: { [P in K]: T[P] } с K extends keyof T. Omit в стандартной библиотеке — это Pick с Exclude по ключам
Что такое условные типы и infer? Напиши свой ReturnType
Условный тип выбирает один из двух типов по проверке присваиваемости, как тернарный оператор. infer внутри условия объявляет переменную, которую компилятор заполнит при совпадении с шаблоном. ReturnType: type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never. Достать тип из промиса: T extends Promise<infer U> ? U : T. Встроенный Awaited делает это рекурсивно и для любого объекта с then
Почему Exclude<'a' | 'b', 'a'> даёт 'b'?
Exclude<T, U> — это T extends U ? never : T, а условный тип над голым параметром дистрибутивен: объединение раскладывается, и условие применяется к каждому члену. Для 'a' получается never, для 'b' — 'b'. never из объединения пропадает, остаётся 'b'. Если обернуть обе стороны в кортеж, [T] extends [U], раскладывания не будет
Что такое keyof, typeof в позиции типа и T[K]?
keyof T — объединение ключей типа. typeof x в позиции типа берёт тип значения x, поэтому keyof typeof config даёт ключи объекта без отдельного интерфейса. T[K] — indexed access, тип поля по ключу. User['id'] это number, а (typeof arr)[number] даёт тип элемента массива. Вместе с K extends keyof T это даёт типобезопасный getProp(obj, key)
Каверзный: чем Omit не строгий и чем Partial не глубокий?
У Omit ключ ограничен keyof any, а не keyof T, поэтому Omit<User, 'опечатка'> компилируется и возвращает исходный тип. После переименования поля такая ошибка не всплывёт. Partial применяет ? только к полям верхнего уровня, вложенные объекты остаются со всеми обязательными полями. Обе проблемы решают своими типами: StrictOmit с K extends keyof T и рекурсивный DeepPartial
📚 Что почитать
- Generics — официальный учебник: ограничения, параметры по умолчанию, дженерик-классы
- Utility Types — справочник по всем встроенным utility-типам с примерами, включая
NoInferиInstanceType - Conditional Types —
infer, дистрибутивность и как её выключить - Mapped Types — модификаторы
-?и-readonlyи переименование ключей черезas