К содержимому
Войти

Node.js Road Map

🧰 Дженерики и 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 | undefined

T здесь никто не указывал. Компилятор вывел его из аргумента. Явно 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 : T

any в шаблонах тут нормален и встречается в самой стандартной библиотеке: это позиция «что угодно», значения такого типа нигде не появляются

UnwrapPromise снимает один слой: Promise<Promise<number>> превратится в Promise<number>. Встроенный Awaited разворачивает рекурсивно до конца и работает с любым объектом, у которого есть метод then, а не только с Promise. Он моделирует то, что делает await

Шпаргалка

ТипЧто делаетКак устроен
Partial<T>все поля необязательныеmapped-тип с ?
Required<T>все поля обязательныеmapped-тип с -?
Readonly<T>все поля только для чтенияmapped-тип с readonly
Pick<T, K>оставить ключи Kmapped-тип по K extends keyof T
Omit<T, K>убрать ключи KPick<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 и undefinedT & {}
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 }>() // ошибка: нет id

Partial<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