TypeScript + React: как типизировать props и не возненавидеть всё вокруг
Текст написан с позиции февраля 2017 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Сочетание TypeScript и React к началу 2017 года перестало быть экзотикой для любителей строгих языков и все чаще выглядит как вполне практичный разговор о том, как навести порядок в большом интерфейсном коде. Но у этого разговора есть одна характерная особенность: почти все начинают с энтузиазма, а потом очень быстро упираются в props. Именно на props становится видно, насколько приятно или мучительно будет жить с типами в реальном React-проекте. В теории все звучит отлично: есть компонент, у него есть входной контракт, TypeScript помогает сделать этот контракт явным. На практике же очень быстро начинаются сомнения. Как описывать обязательные и необязательные свойства? Как не утонуть в длинных интерфейсах? Что делать с callback-функциями? Как жить с defaultProps? Как не превратить каждый маленький компонент в бюрократическое упражнение? И главный вопрос: как получить пользу от типизации props, а не постоянное раздражение от того, что приходится уговаривать компилятор принять очевидные вещи?
Если смотреть на проблему честно, то сама идея типизировать props в React абсолютно здравая. Компонент в React — это не просто кусок разметки. Это единица интерфейса с вполне конкретным входным контрактом. Она ожидает определенный набор данных, определенные обработчики, иногда дочерние элементы, иногда настройки поведения. Пока проект маленький, этот контракт можно держать в голове. Но как только компонентов становится много, как только они начинают переиспользоваться, как только их пишут несколько человек, неявность становится дорогой. Именно в этом месте TypeScript и выглядит привлекательно: он позволяет перенести знания о входе компонента из головы разработчика в сам код.
Проблема не в цели, а в том, как к ней подходят. Многие первые попытки типизировать props становятся болезненными не потому, что TypeScript плох сам по себе, а потому что разработчик старается типизировать React-компоненты так, будто перед ним формальная задача «описать все как можно подробнее» вместо более практичной задачи «сделать контракт компонента понятным и устойчивым». В результате появляются перегруженные интерфейсы, избыточно сложные объединения типов, постоянная борьба с необязательными свойствами, неудачные попытки угодить сразу всем сценариям повторного использования, и через несколько дней у команды уже возникает ощущение, что типы только мешают двигаться. На самом деле чаще всего мешают не типы, а неправильный стиль их применения.
Props типизируются ради человека, а не ради компилятора
Полезно начать с очень простой мысли: props типизируются не ради компилятора, а ради человека, который будет читать, использовать и менять компонент. Да, машина проверяет корректность. Но настоящий выигрыш появляется тогда, когда по описанию props сразу видно, что это за компонент, что ему нужно для жизни, что он обещает делать и какие ожидания с ним связаны. Если типизация делает контракт компонента понятнее, она работает. Если она превращает входной интерфейс в ребус из обобщений и вложенных условностей, она уже проигрывает, даже если формально все строго.
Если props тяжело типизировать, чаще виновата не строгость, а перегруженный компонент
Именно поэтому в React-проектах особенно важно сопротивляться соблазну переусложнить типизацию props в погоне за универсальностью. Очень часто проблема начинается с благой идеи: компонент хочется сделать гибким, пригодным на будущее, способным работать в нескольких режимах. Для этого в него добавляют все новые свойства, часть обязательная, часть опциональная, часть влияет только в одном режиме, часть нужна только при определенном типе данных. А потом поверх этого пытаются наложить TypeScript и получают длинное описание входного контракта, которое само по себе стало сложнее, чем внутренний код компонента. В такой ситуации раздражение вызывает не TypeScript как таковой, а то, что он честно подсветил архитектурную перегруженность самого компонента.
Это важный момент, который стоит принять как можно раньше: если props тяжело типизировать, иногда проблема в том, что компонент взял на себя слишком много обязанностей. Слишком универсальная кнопка, слишком общий список, слишком гибкая карточка, которая умеет все сразу, — все это неудобно не только для типизации, но и для поддержки в целом. TypeScript просто делает боль видимой. И в этом смысле типизация props часто оказывается полезным диагностическим инструментом. Она вынуждает прямо сформулировать, что именно получает компонент на вход, а если эта формулировка распадается на хаос, значит, стоит вернуться на шаг назад и пересмотреть саму компонентную границу.
Самый здоровый путь обычно выглядит довольно скромно. У компонента должен быть небольшой и ясный набор входных свойств. Обязательные props действительно должны быть обязательными. Необязательные — только там, где компонент может адекватно жить без них. Callback-функции должны быть описаны по смыслу, а не как абстрактные функции с любыми аргументами. Структуры данных, которые приходят в компонент, должны отражать реальные сущности интерфейса, а не временную форму случайного ответа сервера. Когда эти принципы соблюдены, типизация props перестает быть борьбой и становится просто способом записать уже более-менее здравую структуру.
Граница обязательного и необязательного — это не занудство, а честность контракта
Отдельная тема, которая особенно часто раздражает в сочетании TypeScript и React, — это граница между обязательными и необязательными свойствами. В обычном JavaScript разработчик нередко привыкает к расслабленному стилю: если чего-то нет, ничего страшного, проверим внутри компонента или положимся на defaultProps. Но TypeScript не любит расплывчатость без причины. Он заставляет честно ответить на вопрос: компоненту действительно нужно это свойство для корректной работы или он умеет жить без него? Это иногда кажется занудством, но на деле именно здесь начинается реальная польза от типизации. Чем яснее вы разделяете обязательное и факультативное, тем меньше скрытых предположений остается в коде.
Особенно заметно, что многие React-разработчики все еще мыслят props как «мешок настроек», а не как четкий контракт компонента. Такой подход еще может работать в небольших участках приложения, но с типами он быстро начинает ломаться. Если компоненту передают десять опциональных свойств, из которых в реальности четыре почти всегда обязательны, два зависят от третьего, а еще одно нужно только в одном редком сценарии, TypeScript будет выглядеть не как помощник, а как недовольный инспектор. Однако проблема снова не в нем. Хорошая типизация заставляет перестать притворяться, что размытый контракт — это нормальный контракт.
Callback-props лучше описывать конкретно, а не «на все случаи жизни»
Много неприятных эмоций вызывает и типизация callback-пропсов. В теории тут все просто: если компонент вызывает переданный обработчик, надо описать, какие аргументы этот обработчик принимает и что он возвращает. На практике разработчики часто ленятся об этом думать заранее. Они пишут что-то очень широкое, почти формальное, лишь бы код компилировался. Или наоборот — пытаются сделать описание слишком универсальным, чтобы покрыть все будущие сценарии. В обоих случаях появляется трение. Либо callback теряет смысл, потому что из типа почти ничего не ясно, либо становится таким многословным, что им неудобно пользоваться. Намного спокойнее подходить к этому прагматично: описывать ровно тот вызов, который компонент реально делает, и не пытаться проектировать за один раз все потенциальные варианты жизни обработчика.
Вообще, хорошая типизация props очень любит конкретность. Если компонент вызывает onSelect с объектом определенного типа, так и стоит писать. Если кнопка просто сообщает о клике без полезной нагрузки, не надо придумывать лишних абстракций. Если список требует массив конкретных элементов, полезнее описать эти элементы как осмысленную структуру, а не как безликий объект с кучей необязательных полей. Чем ближе типы к реальному поведению компонента, тем меньше ощущение, что вы обслуживаете формальность.
Не передавайте в компонент больше данных, чем ему реально нужно
Отдельный источник боли — вложенные props-объекты. Очень легко сделать компонент, который принимает один большой объект данных, а внутри использует из него только часть полей. В JavaScript это выглядит удобно: меньше аргументов, меньше шума в месте использования. Но в TypeScript такое решение часто оборачивается лишней связанностью. Компоненту начинают приписывать знание о гораздо большей структуре, чем ему реально нужно. Потом этот объект меняется в другой части системы, и типизация либо заставляет обновлять компонент без реальной необходимости, либо соблазняет слишком широко описывать вход, чтобы «не мешало». В итоге контракт становится менее честным.
Поэтому один из самых практичных советов здесь звучит почти не как совет о TypeScript, а как совет о React-дизайне: не передавайте в компонент больше данных, чем ему реально нужно. Если карточке нужен заголовок, превью и callback выбора, не обязательно отдавать ей целую сущность со всей серверной моделью. Да, иногда это удобно на старте. Но чем точнее и уже входной контракт компонента, тем легче его типизировать и тем спокойнее он живет в долгосрочной перспективе. TypeScript лишь усиливает выгоду этой дисциплины.
Вокруг children и defaultProps не нужно изобретать сложность без нужды
Еще один частый раздражитель — дети, то есть children. Вокруг них легко накопить лишнюю тревогу, потому что React активно опирается на композицию, а TypeScript заставляет хоть как-то объяснить, что именно может находиться внутри компонента. На практике здесь не стоит изобретать сложность без нужды. Если компонент действительно является оберткой и смысл его именно в том, что внутрь может быть передано нечто визуальное, не нужно строить вокруг этого сложную типовую систему. Намного важнее понимать, какую роль играет композиция в конкретном компоненте. Если же дети должны иметь особую форму или если компонент ожидает определенный паттерн использования, это уже архитектурная тема, а не просто вопрос синтаксиса типов.
Много боли вызывают и defaultProps, особенно в сочетании с необязательными свойствами. В обычном React-мышлении удобно объявить часть props необязательной, а затем заполнить их значениями по умолчанию. Но в TypeScript это место часто оказывается менее гладким, чем хотелось бы. И тут важно не начать воевать со всем миром из-за того, что это место пока не идеально. Полезнее помнить, что значения по умолчанию — это способ упростить использование компонента, а не оправдание для расплывчатого контракта. Если свойство действительно имеет разумный стандарт и его отсутствие не ломает логику, оно может быть необязательным. Если же без него компонент теряет смысл, лучше не маскировать обязательность через набор обходных решений.
Хорошо ограниченный компонент типизируется почти сам собой
Вообще, сочетание React и TypeScript особенно хорошо работает там, где разработчик мыслит компонент как хорошо ограниченную единицу интерфейса. Компонент принимает понятный набор данных, предоставляет понятные точки взаимодействия наружу, не знает лишнего о мире и не пытается быть фреймворком внутри фреймворка. Такой компонент типизируется почти естественно. Проблемы начинаются там, где компонент становится слишком хитрым: поддерживает множество режимов, знает слишком много о состоянии приложения, принимает половину store в props, рендерит по десяти флагам и при этом еще рассчитывает быть универсальным. В такой ситуации нет магического типа, который спасет от раздражения. Нужна более спокойная архитектура.
Начинать стоит не с тотального формализма, а с компонентов с ясной ролью
Поэтому лучший способ не возненавидеть типизацию props — не начинать с тотального формализма. Не стоит первым делом пытаться описать все с максимальной строгостью на всех уровнях сразу. Намного полезнее сначала типизировать основные входы тех компонентов, которые уже имеют ясную роль в приложении. Типизация списка, карточки, формы, кнопки действия, контейнера с конкретным контрактом обычно дает довольно быструю отдачу. Вы начинаете видеть, где реальные границы компонентов, какие props повторяются, где интерфейсы данных стоит переосмыслить. И только после этого имеет смысл углубляться в более тонкие случаи.
В подвижном UI здоровее разумная достаточность, а не математическая полнота
Есть и психологическая ловушка, о которой стоит сказать отдельно. Многие ждут от TypeScript ощущения почти математического комфорта: вот сейчас мы опишем типы, и все станет идеально строго, безопасно и красиво. В React-мире это ожидание почти всегда обречено разочаровать. UI по природе очень подвижен. Компоненты часто живут в переходных состояниях. Формы меняются. API эволюционирует. Дизайн подталкивает к новым сценариям. Типизация props должна помогать в этой подвижной среде, а не делать вид, будто интерфейс — это неподвижная схема. Поэтому здоровый подход здесь — не максимальная формальная полнота, а разумная достаточность. Типы должны ловить основные несоответствия и объяснять контракт компонента, а не пытаться превратить весь UI в абстрактную теорию.
Props — это внешний интерфейс, и он не должен зависеть от деталей реализации
Очень помогает и различение между внешним и внутренним. Props — это прежде всего внешний интерфейс компонента. И если типизация props слишком сильно зависит от деталей внутренней реализации, это тревожный сигнал. Хороший контракт не должен каждый раз расползаться, когда вы немного переставили код внутри компонента. Чем устойчивее внешний интерфейс и чем меньше он привязан к случайным техническим решениям, тем приятнее с ним жить и в TypeScript, и без него. И наоборот, если props напрямую отражают внутреннюю кухню, типизация начинает казаться шумной просто потому, что сам контракт нестабилен.
Презентационные и связанные с данными компоненты не стоит типизировать одинаково
Есть еще один полезный практический принцип: компоненты уровня представления и компоненты, связанные с данными, не стоит типизировать одинаковым мышлением. Презентационный компонент обычно имеет более чистый и понятный набор props: данные для отображения, флаги состояния, обработчики. Его удобно типизировать и относительно легко читать. Компонент, который связан с внешним состоянием приложения, маршрутом, асинхронной загрузкой и более сложной логикой, почти неизбежно имеет более широкий контекст. Если пытаться обращаться с обоими типами компонентов одинаково, раздражение возрастает. Намного спокойнее сначала наводить порядок на границе представления, а уже потом разбираться с более тяжелыми случаями.
Уже сейчас становится заметно, что TypeScript неплохо работает как инструмент воспитания интерфейсов. Он не просто проверяет корректность, он подталкивает к лучшим вопросам. Почему этот компонент принимает так много свойств? Почему половина из них опциональна? Почему callback здесь неочевиден? Почему карточка зависит от всей серверной сущности? Почему форма получает данные в неустойчивой форме? Если использовать типизацию props в таком ключе, она перестает быть обременением и начинает выполнять роль архитектурного зеркала. Иногда неприятного, но полезного.
При этом важно не превращать повторно используемые типы в новую форму глобального хаоса. Как только команда распробует удобство описания интерфейсов для props, возникает соблазн создать общий каталог типов и складывать туда все подряд: интерфейсы кнопок, карточек, форм, строк таблиц, фильтров, ответов API. Через некоторое время получается новый types.ts или набор общих файлов, в которых сложно разобраться не меньше, чем в старом util.js. Это почти всегда плохая идея. Типы, как и код, должны жить ближе к своей смысловой области. Общими их стоит делать только там, где общность действительно устойчива. Иначе типизация вместо ясности создает дополнительный слой путаницы.
Еще один способ не начать ненавидеть все вокруг — принять, что миграция на TypeScript в React-проекте может быть постепенной. Не обязательно каждый компонент немедленно доводить до идеального типового контракта. Более того, такая попытка часто и рождает усталость. Гораздо продуктивнее двигаться по критичным поверхностям: сначала типизировать публичные props часто используемых компонентов, затем интерфейсы общих сущностей, затем callback-контракты и лишь потом углубляться в более тонкие места. Такой путь дает пользу раньше и психологически заметно легче, чем попытка ввести полную строгость за один заход.
Стоит также помнить, что сама по себе типизация props не заменяет хороших имен. Иногда разработчики, вдохновившись системой типов, начинают меньше заботиться о названиях, будто тип уже все объяснил. Это опасная ошибка. Имя свойства по-прежнему имеет огромное значение. Тип может показать, что сюда приходит строка, объект или функция, но он не всегда объясняет, зачем именно это нужно компоненту. Хорошие названия и хорошая типизация работают вместе. Когда у вас есть title, isLoading, onSubmit, selectedUser и другие осмысленные props, типы усиливают понятность. Когда props называются туманно, никакая строгость не спасает интерфейс от когнитивной тяжести.
TypeScript не спасает архитектуру, а усиливает уже имеющуюся ясность
Если подводить все к практическому выводу, то типизировать props в React и не возненавидеть происходящее можно, если перестать воспринимать типизацию как экзамен на максимальную формальность. Она лучше всего работает там, где компонент уже достаточно хорошо спроектирован: у него ясная роль, разумный размер, честный входной контракт и ограниченная ответственность. В такой среде TypeScript не мешает, а помогает. Он делает props видимыми, защищает от нелепых несоответствий, облегчает повторное использование и снижает цену изменений.
Напротив, ненависть обычно приходит тогда, когда с помощью типов пытаются героически удержать неудачную архитектуру на плаву. Когда компонент слишком общий, props слишком запутаны, границы слишком размыты, а типы становятся последней линией обороны перед хаосом. Никакая система описания не сделает такой код приятным. И это, пожалуй, самая полезная мысль во всей теме. TypeScript + React — это не рецепт идеальности, а усилитель ясности. Если ясность уже есть, он дает очень ощутимую отдачу. Если вместо нее накоплена путаница, он честно покажет боль, но не сможет ее вылечить.
Для React-разработчика это на самом деле хорошая новость. Значит, чтобы жить с типами спокойно, не нужно становиться жрецом сложных аннотаций. Достаточно начать с более зрелого отношения к самим компонентам: меньше случайной универсальности, меньше расплывчатых контрактов, больше осмысленных props, больше конкретности в callback-функциях, больше дисциплины в данных. Тогда типизация props перестает быть поводом возненавидеть все вокруг и становится тем, чем и должна быть: нормальным рабочим инструментом, который делает компонентный код чуть честнее, понятнее и спокойнее в развитии.
Если сформулировать совсем прямо: не воюйте с TypeScript за то, чтобы удержать перегруженный компонент, — сначала упростите сам компонент, и тогда типизация props перестанет быть налогом и станет бесплатным следствием честного контракта.