Свои hooks на практике: выносим повторяемую логику без HOC и render props
Текст написан с позиции мая 2019 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Появление React Hooks довольно быстро изменило не только то, как мы пишем новые компоненты, но и то, как вообще думаем о повторном использовании логики в React-приложении. Если раньше разговор о переиспользуемом stateful-поведении почти автоматически приводил либо к HOC, либо к render props, то сейчас ситуация уже выглядит иначе. Hooks появились в стабильном React 16.8, который вышел 6 февраля 2019 года, и довольно быстро перестали быть просто новой синтаксической возможностью — они стали вполне рабочим способом собирать общую логику в обычные функции.
Для React-экосистемы это не мелкая косметика, а важный сдвиг. Не потому, что появился еще один способ писать состояние, а потому, что повторное использование логики всегда было одной из самых болезненных тем в больших интерфейсах. Самая вредная реакция на эту новость — услышать «теперь можно выносить логику в функции» и решить, что проблема архитектуры переиспользования наконец-то закрыта. Это не так. Hooks не отменяют сложность повторного использования, они переносят ее в новую, более удобную плоскость — и вместе с удобством приносят новый класс ошибок.
Зафиксируем сразу, в чем тут вообще была проблема. Есть компонент: в нем состояние, эффекты, подписка, загрузка данных, работа с формой, отслеживание размеров окна, поведение модального окна, debounce, синхронизация с URL. Пока компонент один, все терпимо. Но как только похожее поведение нужно повторить в другом месте, начинается знакомая развилка. Можно дублировать код. Можно выносить часть логики в утилиты — но утилиты не умеют жить вместе со state и lifecycle-подобным поведением. Можно собирать HOC. Можно использовать render props. Каждое решение работало, но почти каждое привносило свой тип трения.
Поэтому вопрос этой статьи не в том, как технически написать свой hook. С этим уже более или менее понятно. Вопрос в том, какую именно логику имеет смысл выносить, как это делать так, чтобы hook действительно улучшал архитектуру, и где проходит граница между полезной инкапсуляцией и новым видом скрытой сложности.
Hooks убирают не саму логику, а лишние слои композиции вокруг нее
HOC были мощным приемом, но нередко делали дерево компонентов более многослойным, чем хотелось бы. Чем больше таких оберток появлялось, тем менее прямым становился путь от JSX к реальному поведению. Render props позволяли делать логику явно переиспользуемой, но часто превращали компонентную структуру в матрешку из вложенных функций. Все это не было катастрофой. React много лет вполне успешно жил с такими техниками. Но в них всегда ощущалась некоторая архитектурная цена: нужно было как будто специально переустраивать компонент ради того, чтобы логика стала разделяемой.
Hooks изменили именно этот момент. Теперь стало возможным выносить stateful-поведение в обычную функцию, не меняя радикально форму UI. Именно поэтому свои hooks так быстро стали естественным следующим шагом после знакомства с базовыми useState и useEffect. Как только разработчик понимает, что hook — это не магическая встроенная конструкция, а просто функция, которая использует другие hooks и инкапсулирует связанное поведение, картина React-композиции начинает перестраиваться.
Оказывается, что повторяемая логика больше не обязана жить либо внутри тяжелого класса, либо внутри HOC-слоя, либо в специальном render-props-компоненте. Она может жить в функции с понятным названием и возвращать готовый набор состояния, действий и производных значений. Но именно здесь нужно быть особенно осторожным. Соблазн вынести все подряд в кастомные hooks почти так же велик, как раньше был соблазн вынести все подряд в utils.js. Новый инструмент не отменяет старую опасность: если абстракцию вводят слишком рано или без ясной границы, она не упрощает код, а просто перемещает путаницу в другое место.
Хороший hook выделяет не «кусок кода», а повторяющееся поведение
Полезно начать с очень простой мысли: хороший кастомный hook выделяет не «кусок кода», а повторяющееся поведение. Это важная разница. Очень легко заметить внутри компонента группу строк и решить, что раз они стоят рядом, значит, их можно вынести. Но сама близость строк еще не делает их хорошим кандидатом на отдельный hook.
Намного лучше спрашивать иначе: есть ли здесь осмысленная логика, которая встречается в нескольких местах или может стать самостоятельной единицей использования? Например, подписка на событие окна, состояние поля формы с валидацией, загрузка сущности по id, синхронизация query-параметров, поведение раскрывающегося меню, дебаунс значения, управление модальным окном, логика пагинации, доступ к текущему пользователю или настройкам. Вот это уже похоже не на «кусок кода», а на действительно повторяемое поведение.
Как только hook начинает выражать поведение, а не просто механический фрагмент, у него появляется шанс стать хорошей абстракцией. У него можно придумать ясное имя. Он может иметь понятный вход и понятный результат. Его легче тестировать и переиспользовать. И, что особенно важно, он начинает облегчать чтение компонента. Вместо того чтобы видеть в компоненте вперемешку состояние, эффект, обработчики и вспомогательные детали, разработчик видит более крупные смысловые блоки: здесь мы работаем с поиском, здесь — с модальным окном, здесь — с текущим ресурсом, здесь — с формой. То есть hook помогает не только удалить дублирование, но и вернуть компоненту более читаемую карту его обязанностей.
Кастомный hook делает изнутри то, что HOC делали снаружи
Это, пожалуй, одно из главных практических достоинств hooks по сравнению со старыми техниками. HOC и render props тоже позволяли разделять логику, но они часто делали это снаружи компонента, надстраивая вокруг него дополнительные слои композиции. Кастомный hook делает похожую работу изнутри. Он оставляет сам компонент функцией, но поднимает уровень выражения логики. В этом есть огромный выигрыш для повседневного React-кода: переиспользование становится не отдельным архитектурным аттракционом, а обычным способом писать компонент спокойнее.
Особенно хорошо это заметно на примере логики работы с формами. До hooks подобное поведение либо часто оставалось размазанным по компоненту, либо выносилось в более тяжелые абстракции. Теперь можно довольно естественно собрать состояние значений, ошибки, touched-флаги, submit-логику и обработчики в один или несколько hooks, не превращая саму форму в сложную конструкцию с внешними render props. То же самое касается загрузки данных. Если в нескольких местах приложения повторяется сценарий: загрузить данные по какому-то ключу, отдать loading, error, data, возможно, reload, — hook выглядит почти идеальным местом для такой логики. Он скрывает внутреннюю механику эффекта и состояния, но оставляет компоненту понятный контракт.
Судьбу hook решает не его внутренняя техника, а качество контракта
Именно слово «контракт» здесь особенно важно. Свой hook на практике становится хорошим только тогда, когда его интерфейс ясен. Какие параметры он принимает? Что он возвращает? Каковы ожидания от его использования? Может ли он полагаться на контекст? Есть ли у него побочные эффекты? Возвращает ли он голые данные, набор действий, объект состояния или кортеж? Эти вопросы нельзя считать второстепенными.
Очень часто хорошая или плохая жизнь кастомного hook определяется не внутренней техникой, а качеством его внешнего интерфейса. Если hook возвращает слишком расплывчатую смесь всего подряд, компоненту с ним будет жить не легче, а тяжелее. Если же контракт собран ясно и экономно, то hook действительно начинает работать как осмысленная единица повторного использования. Это снова та же антитеза: проблема не в количестве кода внутри hook, а в том, насколько честно описана его внешняя граница.
Hook не должен превращаться в тайный центр управления feature
Проблема в том, что в начале работы с hooks почти все проходят через стадию архитектурного азарта. Хочется вынести много логики, хочется сделать компоненты чище, хочется отказаться от старых HOC и render props как можно быстрее. И в этот момент очень легко начать создавать hooks, которые знают слишком много. Например, hook может не просто загружать данные, а одновременно читать роут, дергать API, управлять локальным UI-состоянием, синхронизировать query-string, вызывать аналитику и решать, что именно должен показать компонент. Формально все это можно спрятать в одну функцию. Но пользы от такого выноса будет немного. Да, компонент стал короче. Но сама сложность не уменьшилась, а просто ушла в новый черный ящик.
Поэтому один из лучших практических принципов здесь такой: hook должен инкапсулировать связанную логику, но не должен становиться тайным центром управления feature. Если поведение слишком разношерстное, его стоит либо разбить на несколько hooks, либо признать, что перед нами уже не просто переиспользуемый фрагмент, а более крупный слой архитектуры, который, возможно, требует другого оформления. Hooks отлично подходят для композиции, но легко становятся неудобными, если пытаться превратить один из них в мини-фреймворк для целой области приложения.
Hook ради одного компонента — это композиция, а не обязательно ошибка
Есть и еще одна полезная проверка: если hook вынесен, но используется только в одном компоненте, это еще не обязательно ошибка. Важно не впадать в противоположную крайность и не считать, будто hook должен быть оправдан только многоразовым использованием. Иногда вынос полезен уже потому, что помогает структурировать один большой компонент. Если внутри компонента есть самостоятельный кусок поведения — скажем, работа с фильтрами, логика сворачивания панели, загрузка и обновление конкретного ресурса, — локальный hook в пределах feature может быть прекрасным способом разложить обязанности по смыслу, даже если он не станет глобально переиспользуемым. Это одно из тех мест, где hooks оказываются лучше утилит: они полезны не только для повторения, но и для внутренней композиции.
Однако и здесь важно не спутать композицию с бегством от сложности. Иногда разработчик выносит логику в hook только потому, что сам компонент уже трудно читать. После выноса визуально становится легче, но архитектурно ничего не изменилось: один перегруженный компонент превратился в один перегруженный hook и один визуально чистый shell. Поэтому при выносе логики полезно честно спрашивать: мы действительно выделили самостоятельное поведение или просто убрали неудобный код с глаз? Ответ не всегда приятен, но он очень влияет на качество решения.
Композиция стала легче, но читаемость теперь полностью на разработчике
Что особенно хорошо в hooks по сравнению с HOC и render props — это естественная композиция нескольких логик без наращивания JSX-слоев. Раньше, если компонент использовал, например, данные пользователя, состояние фильтра, подписку на размер окна и поведение модального окна, объединение всего этого могло превратиться в довольно многослойную конструкцию. С hooks это может выглядеть как несколько последовательных вызовов в начале функции. Само по себе это огромный шаг к более прямому коду.
Но именно поэтому очень важно следить за порядком и смысловой группировкой. Если hooks просто накиданы один за другим без явной структуры, компонент начинает напоминать список заклинаний, где понять взаимосвязи уже не так просто. То есть новый React действительно облегчает композицию, но не освобождает от необходимости делать ее читаемой. Это и есть скрытая цена: классы раньше давали структуру почти автоматически, а функция с десятком вызовов требует большего участия от разработчика.
Очень помогает группировать hooks по роли. Например, сначала входные данные и контекст, затем локальное состояние, затем вычисленные значения, затем эффекты, затем действия, возвращаемые в JSX. Это не закон, но это пример того, как команда может выработать ритм чтения новых компонентов. Хорошие кастомные hooks здесь выступают не только как механизм выноса логики, но и как средство возвращения компоненту более высокоуровневого строения.
Лучшие hooks — те, у которых есть ясная граница
На практике очень удачными оказываются hooks, которые решают один повторяющийся сценарий взаимодействия с внешним миром. Например, useWindowSize, useDebouncedValue, useModal, usePagination, useCurrentUser, useFetchSomething, useFormField. Это не потому, что все хорошие hooks обязаны быть маленькими. А потому, что у них обычно есть ясная граница. Они либо синхронизируют компонент с конкретным внешним источником, либо инкапсулируют одно устойчивое UI-поведение, либо оформляют понятный прикладной сценарий. Чем яснее эта граница, тем меньше шансов, что hook расползется в новый клубок обязанностей.
Интересно, что hooks очень хорошо высвечивают границу между «общей логикой» и «общим кодом». Раньше в мире HOC и render props повторное использование stateful-поведения было настолько формально дорогим, что многие команды откладывали его до последнего. Теперь цена входа ниже, а значит, возрастает и риск преждевременной абстракции. Это почти зеркальная проблема. Если раньше логику часто дублировали слишком долго, то теперь ее иногда начинают выносить слишком рано.
Поэтому здравый подход снова состоит в том, чтобы не гнаться за «абсолютной сухостью» кода. Если поведение еще не стабилизировалось, если два случая только кажутся похожими, если обобщение потребует слишком широкого интерфейса, возможно, лучше пока оставить две локальные реализации. Hook должен рождаться не из любви к красивым архитектурным жестам, а из реальной повторяемости и ясности абстракции.
Не все, что можно обернуть в use, должно жить в hook
Есть еще один практически важный момент: hooks не заменяют границы между слоями приложения. Очень легко, особенно на раннем этапе, начать использовать их как универсальный контейнер для чего угодно — и для доступа к API, и для управления UI, и для чтения контекста, и для трансформации данных, и для вызова аналитики, и для бизнес-правил. Внешне это выглядит удобно: все можно обернуть в функции с префиксом use. Но хороший React-проект от этого не становится автоматически лучше. Hook — это способ организовать React-зависимую логику, а не новый тип бесконечно общего слоя. Если код не связан с состоянием, эффектами, контекстом или другими React-механизмами, возможно, ему лучше жить как обычной функции, сервису, селектору или другой более подходящей сущности.
Это особенно заметно в приложениях, где уже есть Redux, Context или другой слой управления состоянием. Появление hooks не означает, что теперь вся прикладная логика должна переехать в custom hooks. Наоборот, hooks хорошо работают как интерфейс доступа к уже существующим слоям. Например, hook может скрывать подписку на store, выбор нужных данных, работу с dispatch, обращение к контексту feature-уровня. Но если начать сваливать в hook все то, что раньше было отделено как селекторы, сервисы и domain logic, получится новая форма архитектурной неясности. Hooks делают React-код приятнее, но не отменяют важность разделения ответственности между UI, состоянием и доменной логикой.
Миграция от HOC и render props не требует войны со старым кодом
Очень полезно и то, что hooks позволяют постепенно отказываться от HOC и render props без войны со старым кодом. Это важный практический аспект текущего момента, когда многие команды находятся в переходной фазе. Нет необходимости переписывать все паттерны прошлого за один раз. Там, где HOC или render props уже работают и не мешают, они могут продолжать жить. Но новый код часто уже удобнее писать через hooks, а часть старых случаев естественно мигрирует сама, когда возникает повод для рефакторинга.
Такой спокойный переход обычно намного здоровее, чем попытка одномоментно заменить весь старый слой композиции только потому, что появился новый красивый инструмент. Почему это так важно? Потому что массовый рефакторинг ради рефакторинга — это всегда риск дестабилизировать работающую систему, не получив взамен ничего, кроме другого синтаксиса. А реальная ценность hooks проявляется не в скорости замены старого, а в качестве нового кода.
В повседневной практике особенно ценен один результат: hooks делают повторяемую логику ближе к месту использования и ближе к обычному языку JavaScript. Это, пожалуй, и есть их самая большая победа над HOC и render props. Переиспользование больше не требует обязательно менять форму JSX-дерева. Логика становится обычной функцией, которую можно читать, называть, комбинировать и тестировать более прямым способом. Но ровно поэтому так важно не утратить чувство меры. Чем легче становится создавать абстракции, тем выше риск плодить их там, где следовало бы сначала лучше понять саму задачу.
Выносите устойчивые поведения, а не куски строк
Если подвести итог совсем практично, то свои hooks действительно оказываются очень сильным способом выносить повторяемую логику без HOC и render props — тогда, когда эта логика представляет собой связанное поведение с ясным контрактом и понятной областью ответственности. Hooks прекрасно подходят для работы с состоянием UI, эффектами, подписками, загрузкой данных, формами, синхронизацией значений, повторяющимися сценариями взаимодействия. Они особенно хороши там, где раньше для той же цели приходилось строить отдельный компонент-обертку или усложнять дерево JSX ради одной только композиции поведения.
Но hooks начинают приносить меньше пользы, когда их используют как новый способ спрятать сложность или как обязательный ритуал выноса всего подряд. В таких случаях они ничем не лучше старых абстракций: просто выглядят современнее. Используйте hooks не как повод объявить конец всем предыдущим паттернам, а как способ сделать повторяемую логику ближе к реальной форме React-компонента. Следите за интерфейсом hook, не превращайте его в черный ящик на половину feature, и тогда новый стиль React действительно даст то, что обещал.
Свой hook стоит создавать не тогда, когда код хочется куда-то убрать, а тогда, когда у поведения есть устойчивое имя, ясный контракт и одна область ответственности — все остальное лучше пока оставить там, где оно есть.