TypeScript utility types, которые реально полезны в React-проекте
Текст написан с позиции августа 2019 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Когда в React-проект приходит TypeScript, первая волна пользы почти всегда выглядит прямолинейно. Компоненты получают более ясные props, функции — понятные сигнатуры, API-ответы — хотя бы минимально формализованную форму, а редактор перестает быть умной текстовой областью и начинает действительно помогать ориентироваться в коде. Но довольно быстро после этого наступает следующий этап, и именно он интереснее. Команда уже привыкла к базовой типизации и начинает замечать, что значительная часть кода крутится вокруг одних и тех же преобразований типов: где-то надо взять интерфейс и сделать часть полей необязательными, где-то выбрать несколько свойств, где-то убрать лишнее, где-то собрать структуру по ключам, где-то получить тип пропсов уже существующего компонента, а не переписывать его руками второй раз.
Здесь utility types из приятного дополнения превращаются в рабочий инструмент. Но вокруг них почти сразу возникает два вида перегиба, и оба вредны. Первый — когда разработчик ими не пользуется и продолжает дублировать типы руками, как будто TypeScript не умеет помогать на этом уровне. Второй — когда utility types превращаются в маленькую религию и код начинает выглядеть как соревнование по типовой акробатике. На выходе команда получает либо скучное дублирование, либо трудночитаемый набор вложенных обобщений, где реальная форма данных уже теряется за техникой.
Поэтому полезнее говорить не о «самых мощных» utility types, а о тех, что реально приносят пользу каждый день. И держать в голове одну мысль: utility type хорош не тогда, когда делает типы умнее любой ценой, а тогда, когда уменьшает дублирование и делает контракт кода честнее. Цель не в том, чтобы впечатлить коллег конструкцией. Цель в том, чтобы компонент, hook или feature-модуль было легче сопровождать, менять и переиспользовать. Если utility type делает код короче, а связь между сущностями яснее, он полезен. Если он превращает простую идею в туманную головоломку, его ценность под вопросом — даже если формально все типизировано красиво.
Дальше — разбор тех помощников, которые в React-разработке окупаются почти ежедневно, и честный разговор о том, где они перестают помогать.
Partial<T> — про частичную форму, а не про ослабление контракта
Пожалуй, первым utility type, который почти всегда реально полезен в React-проекте, остается Partial<T>. Его сила настолько проста, что ее легко недооценить. Очень часто в UI есть полная форма сущности, но в конкретном сценарии нужна не вся она, а версия, где часть полей может отсутствовать. Форма редактирования профиля работает с частичным обновлением. Локальное состояние фильтра инициализируется неполным набором значений. Конфигурационный объект компонента имеет значения по умолчанию и принимает только часть переопределений. Во всех таких случаях ручное объявление «почти того же типа, но с вопросительными знаками» быстро начинает пахнуть повторением. Partial снимает эту боль почти без усилий.
Особенно хорошо он работает там, где есть базовый интерфейс и поверх него строятся сценарии обновления. Есть User или ProfileSettings, а для формы обновления логично использовать не полную сущность, а частичную форму, которая может содержать любое подмножество полей. То же касается конфигурации UI-компонентов: если есть объект настроек по умолчанию, а снаружи хочется разрешить передавать только часть значений, Partial обычно оказывается самым прямым способом это выразить. Но важно зафиксировать сразу: Partial — это про частичную форму, а не про реальный доменный контракт. Если все поля становятся необязательными просто ради удобства, а логически часть из них все равно обязана существовать, вы ослабляете тип сильнее, чем было полезно, и переносите проверку из компилятора обратно в голову.
Pick и Omit делают зависимость компонента честнее
Рядом с Partial почти неизбежно стоит Pick<T, K>. В React-проекте он работает почти как нож шеф-повара: вроде бы ничего сверхсложного, но без него быстро начинаешь чувствовать лишние движения. Pick позволяет взять существующий тип и выбрать из него только нужные поля. Польза огромная, потому что интерфейсные компоненты почти никогда не работают со всей сущностью целиком. Карточке товара нужны id, title, priceи thumbnail. Небольшому списку пользователей — id, nameи avatar. Кнопке удаления — только id. И если каждый раз описывать такие срезы вручную, типы быстро начинают дублировать друг друга и расходиться с исходной моделью.
Самое ценное здесь даже не экономия строк. Pick делает зависимость компонента честнее. Вместо того чтобы передавать внутрь весь объект User или Product, а потом использовать из него четыре поля, можно типизировать контракт уже как срез нужных данных. Это про типы и про дизайн компонентов одновременно. Чем точнее компонент описывает, что ему реально нужно, тем легче его переиспользовать и тем ниже связность. В этом смысле Pick — не средство типизации, а способ дисциплинировать сам API компонентов.
Обратная сторона Pick — это Omit<T, K>. Он выглядит чуть менее фундаментально, но в практической жизни бывает почти так же полезен. Часто у нас уже есть тип, который почти подходит, но из него надо исключить одно-два поля. Классический пример — форма создания или редактирования, где не должно быть id, createdAt, служебных признаков или вычисляемых полей полной сущности. Второй случай — обертки над компонентами: вы строите компонент поверх другого, хотите пробросить почти все его props, но переопределяете несколько свойств, и Omit избавляет от ручного повторения длинного набора пропсов.
В современном React это особенно важно, потому что композиция часто строится именно через «почти тот же контракт, но с небольшими отличиями». Есть базовый инпут, а есть его версия с внутренним управлением значением. Есть базовая кнопка, а есть ее специализированный вариант. Есть компонент, который прокидывает почти все props в DOM-элемент, но контролирует один-два сам. Без Omit такие типы становятся либо дублирующимися, либо чересчур широкими. С ним связь с исходным контрактом сохраняется без повторения всего списка руками.
Record<K, T> переводит «договоренность в голове» в явную форму
Очень полезен Record<K, T>. На первый взгляд он кажется чуть более абстрактным и «не интерфейсным», но в реальных React-проектах встречается постоянно. Как только появляется словарь по ключам, карта конфигураций, мапа статусов, таблица иконок, набор текстов по enum-значениям, конфиги роутов или наборы handlers по типу сущности — Record становится одним из самых удобных способов выразить такую структуру. Его прелесть в том, что он типизирует не просто «объект с какими-то строковыми ключами», а объект, где набор ключей известен и значим. Фронтенд любит хранить конфигурации в объектах, а без хорошей типизации такие объекты слишком легко становятся местом тихих опечаток и расхождений.
Если в приложении есть набор статусов заказа и каждому соответствует лейбл или цвет, Record<OrderStatus, string> дает более честный и безопасный контракт, чем объект с неопределенными строковыми ключами. Стоит добавить статус в union — и компилятор сам потребует заполнить для него ячейку. То же касается роутинга, сопоставления фич-флагов, режимов отображения, небольших UI-словарей локализации. В команде, где много конфигурационных объектов, Recordтихо экономит массу времени, потому что переводит «объект с договоренностью в голове» в форму, за которой следит компилятор.
Readonly и Required делают явным уровень гарантии
Следующий полезный на практике помощник — Readonly<T>. Тема неизменяемости в JavaScript всегда была немного психологически сложной: все понимают ее пользу, но не всегда делают ограничения явными на уровне типов. В React это особенно чувствительно, потому что состояние, props и многие derived data выигрывают от того, что разработчик не воспринимает их как нечто, что можно бездумно мутировать. Readonly полезен не как инструмент тотального фанатизма, а как способ подчеркнуть границу: этот объект предназначен для чтения, а не для изменения. Лучше всего он работает в props-like контрактах, в доменных структурах, которые должны восприниматься как входные данные, и там, где случайная мутация была бы особенно неприятна.
Заворачивать в Readonly вообще все подряд только ради ощущения строгости было бы странно. Но в ключевых местах он помогает не только машине, но и человеку — делает намерение явным. В TypeScript ценно именно это: хорошие типы должны не только ловить ошибки, но и подсказывать, как код задуман. В проекте, где данные проходят через много слоев компонентов, такие сигналы дорогого стоят.
Рядом стоит Required<T>. Он используется реже, но в интерфейсной разработке бывает удивительно уместным. Часто у нас есть тип с необязательными полями, но в конкретной точке приложения мы уже знаем, что часть из них обязана быть заполнена. Вместо того чтобы создавать почти новый интерфейс вручную, можно усилить существующий. Локальное состояние формы на старте бывает частичным, а перед отправкой — обязательным. Данные пользователя, пришедшие в упрощенной форме, после загрузки дополнительных полей используются как более полный контракт. Required фиксирует именно эту смену уровня гарантии.
Но здесь особенно легко начать врать самому себе. Если вы постоянно «усиливаете» типы без реального контроля над тем, почему это безопасно, вы получаете не гарантию, а красивую типовую фикцию. Utility types полезны там, где отражают уже реальный переход в логике программы, а не заменяют его словами. Это касается почти всех помощников: они хороши как отражение структуры, а не как попытка перехитрить реальность.
ReturnType и Parameters особенно окупаются в эпоху hooks
Очень практичны utility types, связанные с функциями: ReturnType<T>и Parameters<T>. В React-проекте они полезны там, где есть hooks, selectors, factory-функции, helper-методы для API или обвязка над библиотеками. Допустим, кастомный hook возвращает сложную структуру состояния и действий, и где-то нужно получить тип результата, не дублируя его руками. Или есть helper для создания колбэка, и нужно сослаться на тип его аргументов. Или есть selector, контракт которого уже определен самой функцией, и не хочется описывать его еще раз отдельным интерфейсом. ReturnType и Parameters экономят не столько строки, сколько расхождение между тем, что функция реально делает, и тем, как мы описываем это словами в другом месте.
В эпоху hooks это особенно заметно. У команды быстро появляются функции, возвращающие составные объекты: данные, флаги загрузки, ошибки, действия, вычисленные значения. И очень заманчиво создать под каждый результат отдельный интерфейс. Иногда это правильно — особенно если контракт важен сам по себе и нужен как публичная поверхность. Но часто честнее вывести тип из самой функции. Это уменьшает дублирование и делает код менее хрупким при рефакторинге: изменил hook возвращаемую форму — и тип, завязанный на ReturnType, изменится вместе с ним. Это не лень, а способ держать описание и поведение в одной точке правды.
NonNullable фиксирует уже устраненную неопределенность, а не уговаривает компилятор
Отдельного внимания заслуживает NonNullable<T>. В React-проектах он не так бросается в глаза, как Pick или Partial, но на практике очень полезен. UI-код постоянно имеет дело с промежуточными состояниями: что-то может быть null, undefined, отсутствовать до загрузки, появляться после выбора, очищаться при сбросе. И довольно часто в конкретной точке компонента или helper-функции уже известно, что значение точно существует. Если это логически подтверждено — через проверку, guard или структуру жизненного цикла — NonNullable помогает зафиксировать более сильную гарантию. Польза не в типовой красоте, а в том, что код перестает звучать так, будто живет в мире полной неопределенности, когда часть ее уже устранена.
Правда, здесь, как и с Required, легко начать притворяться, будто гарантия сильнее, чем она есть. Это важно не перепутать: utility type должен делать явным то, что уже стало правдой в логике программы, а не быть способом «уговорить компилятор». Если этой правды нет, NonNullable лишь маскирует будущую ошибку и переносит ее на runtime, где она дороже.
Exclude и Extract держат union-состояния в синхроне
Для React-команды полезны Exclude<T, U> и Extract<T, U>, хотя это шаг ближе к работе с union types. В больших UI-проектах unions встречаются постоянно: статусы загрузки, режимы отображения, варианты действий, объединения событий, наборы допустимых значений для пропсов. И часто нужно не объявить union заново, а вывести из существующего более узкий или широкий срез. Из общего множества состояний убрать одно, которое на данном шаге уже невозможно. Или, наоборот, выбрать только конкретные варианты. На практике это помогает писать код, где состояние интерфейса выражено честно и не дублируется вручную собранными типами.
Особенно уместно это в компонентах с несколькими режимами работы. Если есть общий union режимов, а отдельный подкомпонент должен работать только с подмножеством, Extractи Exclude избавляют от плодящихся вручную списков строковых литералов. Это как раз тот тип маленького повседневного выигрыша, который особенно ценен в долгоживущем React-коде: union в одном месте меняется, и зависимые срезы едут за ним сами.
React.ComponentProps — вывести контракт компонента, а не переписывать его
Отдельно стоит сказать про Props-ориентированные техники. Один из самых практичных паттернов в React — получать тип пропсов из уже существующего компонента, а не переписывать его руками. Здесь в реальной жизни часто используется React.ComponentProps<typeof SomeComponent> и производные формы для DOM-элементов. Строго говоря, это не встроенный utility type TypeScript, а utility-like техника на стыке языка и React typings, но по практической пользе она огромна. Как только вы пишете обертки вокруг HTML-элементов, специализированные версии базовых компонентов или композиции поверх существующих UI-блоков, возможность сослаться на готовый набор props экономит массу времени и снижает риск расхождения контрактов.
Это особенно заметно на обертках над кнопками, инпутами, ссылками, модальными окнами, типографическими примитивами. Вместо того чтобы заново описывать весь контракт базового компонента и потом поддерживать его руками, можно вывести его и поверх делать Omit, Pick или расширение. Такой стиль хорошо соответствует самой природе utility types: использовать уже существующее знание о форме кода, а не переписывать его в другом месте.
Главная польза в том, что типы перестают дрейфовать отдельно от модели данных
Если попытаться назвать единый эффект всех этих помощников, он не в отдельных трюках, а в синхронности между моделью данных и интерфейсным слоем. Фронтенд-код любит постепенно дрейфовать: сущности меняются, API-ответы становятся шире, подмножества полей используются в разных местах, и если все это описывать руками отдельными интерфейсами, расхождения почти неизбежны. Pick, Omit, Partial, ReturnType и другие уменьшают именно вероятность дрейфа. Они говорят: не изобретай новый тип там, где можно честно выразить зависимость от уже существующего. Для большого React-проекта это очень практическая ценность.
С появлением hooks в React 16.8 это стало особенно заметно. Компоненты сделались более функциональными, логика чаще выносится в кастомные hooks, контракты подвижнее, а TypeScript все чаще описывает не только API и сущности, но и внутренние интерфейсы UI. В такой среде utility types — не экзотическая часть языка, а обычный способ держать код в живом состоянии без лишнего копирования. И, пожалуй, это лучший критерий их настоящей полезности: когда они перестают ощущаться как «продвинутый TypeScript» и становятся просто инструментом повседневной дисциплины.
Когда сами utility types превращаются в новый шум
Здесь важно не свалиться в другую крайность и не построить весь проект из бесконечно вложенных utility types. Это реальный риск, и он наступает быстрее, чем кажется. Как только команда открывает для себя мощь Pick, Omit, Partial, Recordи ReturnType, появляется искушение собирать из них любые типы, даже когда явный интерфейс был бы понятнее. Если у вас есть важный публичный контракт компонента или feature-модуля, часто лучше назвать его явно, чем собирать на месте из четырех вложенных обобщений. Utility types хороши для уменьшения шума и дублирования. Но если они сами становятся новым шумом, выигрыш теряется — и это не аккуратная типизация, а просто другая форма беспорядка.
У абстракции есть цена, и в случае utility types она вполне конкретна. Цепочка вроде Omit<Pick<...>, ...> поверх выведенного ReturnType требует от читателя держать в голове несколько уровней преобразования, чтобы понять итоговую форму. Сообщения об ошибках на таких типах становятся длиннее и менее читаемыми. А каждое лишнее звено — это место, где при рефакторинге что-то может тихо разъехаться. Поэтому вопрос всегда не «можно ли это выразить через utility types», а «дешевле ли так читать и поддерживать, чем явный именованный тип».
Лучший практический критерий очень прост и хорошо виден на код-ревью: станет ли код проще понять человеку, который откроет его через неделю или месяц? Если да — типы работают на вас. Если нет — абстракция, скорее всего, слишком умна для своей задачи. Хороший TypeScript в React-проекте не должен заставлять команду постоянно декодировать типовые трюки. Он должен помогать быстрее видеть форму данных, контракт компонента и отношения между сущностями. Там, где utility type перестает это делать, его место занимает обычный явный интерфейс — и это не поражение, а зрелость.
Итог
В реальном React-проекте особенно полезными оказываются не те utility types, которые выглядят наиболее интеллектуально, а те, что честно выражают обычные ежедневные отношения между типами. Partial — когда нужна частичная форма существующей структуры. Pick — когда компоненту нужен только срез сущности. Omit — когда нужно исключить несколько полей и не переписывать остальное. Record — когда есть словари, конфиги и карты по известным ключам. Readonly и Required — когда нужно явнее обозначить уровень гарантии. ReturnType и Parameters — когда хочется перестать дублировать контракты функций и hooks. NonNullable, Excludeи Extract — когда состояние UI и unions требуют более точной работы с вариантами.
За всем этим стоит одна и та же дисциплина, а не коллекция трюков. Utility types приносят максимум пользы не там, где вы знаете их много, а там, где чувствуете, где именно они экономят дублирование и делают код честнее. Они должны помогать видеть структуру, а не прятать ее за техникой. Лучший utility type в React-проекте — не самый хитрый, а тот, после которого кодовая база становится спокойнее: меньше ручного повторения, меньше расходящихся контрактов, меньше ложной универсальности и больше ясной связи между тем, как устроены данные, компоненты и логика вокруг них.