React Hooks: как писать новый React без классов и не потерять голову
Текст написан с позиции февраля 2019 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Есть редкая категория изменений в экосистеме, которые сдвигают не библиотеку рядом с языком, а сам язык повседневного кода. React Hooks — именно такой случай. Их уже нельзя воспринимать как любопытную экспериментальную идею с конференции или как будущее, до которого еще когда-нибудь дойдут. Они стали реальной частью современного React, и теперь у команды появляется новый соблазн: бросить классы, переписать все в функции, объявить новую эпоху и, желательно, сделать это немедленно. Именно в этот момент и важно не потерять голову.
Самая вредная реакция на Hooks — услышать «теперь можно без классов» и решить, что классы внезапно стали «неправильным React», а любой код без useState теперь выглядит старомодно. Ценность Hooks не в этом. Они меняют способ композиции логики в компонентах: позволяют использовать состояние, эффекты, контекст и другие возможности React без классов, а главное — дают новый способ собирать повторно используемое stateful-поведение без танцев вокруг render props и тяжелых HOC-оберток. Это сильное изменение. Но сильные изменения в React почти всегда сопровождаются периодом, когда сообщество сначала восторгается, потом переусложняет, а затем постепенно учится использовать новый инструмент спокойно. Hooks находятся как раз в этой точке.
Если описать, почему они вызвали такой шум, ответ довольно прост. До сих пор у React была странная асимметрия. С одной стороны, функции всегда казались более легкой и чистой формой компонента: их проще читать, проще тестировать, проще воспринимать как прямое отображение props в UI. С другой стороны, как только компоненту требовалось состояние, побочные эффекты, доступ к lifecycle или более сложная логика, разработчик почти автоматически возвращался к классу. Получалось, что наиболее приятная форма компонента была ограничена в выразительности, а более мощная форма тащила за собой более высокий порог сложности. Hooks ломают эту старую развилку. Теперь функция больше не обязана быть «только dumb-компонентом» — она может нести в себе полноценную интерфейсную жизнь.
Поэтому столько людей воспринимают Hooks не просто как новое API, а как попытку переосмыслить весь стиль написания React. Но здесь и начинается зона риска. Когда инструмент предлагает более чистую и выразительную форму, очень хочется немедленно считать старую форму устаревшей, а новый стиль — автоматически лучшим. На практике это почти никогда не работает так просто. Hooks не делают классы немедленно вредными. Они не превращают любой старый компонент в технический долг только потому, что тот написан через extends React.Component. И самое главное — они не избавляют от необходимости думать об архитектуре. Они меняют точку приложения этой мысли, но не отменяют ее.
Hooks убирают церемонию, а не обязанность думать
Разговор о Hooks лучше начинать не с революции, а с очень прагматичного наблюдения: они делают код проще там, где классы раньше были формой технической обязанности, а не реального удобства. До сих пор состояние даже в самом небольшом локальном сценарии быстро тянуло за собой class syntax, this, binding или стрелочные методы, lifecycle-методы и более громоздкую оболочку компонента. С Hooks значительная часть таких случаев начинает звучать гораздо ближе к тому, как разработчик реально думает о задаче. Нужен локальный счетчик — используем state. Нужен побочный эффект после изменения данных — добавляем effect. Нужен доступ к контексту — читаем его внутри функции.
В этом есть огромная психологическая выгода. React-код становится менее церемониальным там, где раньше церемония была почти неизбежной. Но эта же легкость быстро создает и новый тип опасности. Классы, при всех их недостатках, имели одно любопытное свойство: они своим синтаксисом как будто предупреждали разработчика, что здесь начинается более «тяжелый» компонент. Сам переход к классу уже служил небольшим тормозом: нужно было осознанно сказать себе, что этот компонент теперь живет более сложной жизнью.
Hooks убирают этот порог. И это, с одной стороны, прекрасно. Но с другой — делает очень легким путь к компоненту, который снаружи выглядит как аккуратная функция, а внутри содержит уже несколько состояний, несколько эффектов, сложную координацию значений, колбэки, контекст, редьюсер и еще пару кастомных hooks. Визуальная легкость возрастает быстрее, чем архитектурная простота. И если этого не замечать, можно довольно быстро получить новый хаос, только уже без классов.
Писать без классов — вопрос дисциплины, а не синтаксиса
Именно поэтому «как писать новый React без классов и не потерять голову» — вопрос не про синтаксис. Он про дисциплину. Hooks дают очень сильный новый язык, но этот язык требует иной внутренней аккуратности. В классовом компоненте логика была размазана по привычным зонам: constructor, lifecycle-методы, методы экземпляра, render. Это было многословно, но хотя бы визуально структурировано. В функциональном компоненте с Hooks все находится ближе друг к другу.
Это может быть удивительно удобно, потому что логика конкретного поведения действительно оказывается собрана рядом. Но это же делает код уязвимее к бесформенному накоплению. Несколько вызовов Hooks, несколько локальных функций, условный рендер, эффект с зависимостями, пара вычисленных значений — и вот уже перед нами компонент, который значительно сложнее, чем выглядит на первый взгляд.
В этом смысле Hooks не столько упрощают React раз и навсегда, сколько переносят центр тяжести. Раньше сложность часто жила в форме класса. Теперь она чаще живет в том, как организованы функциональные компоненты и кастомные hooks. И это требует другого навыка чтения: внимательнее относиться к порядку вызова Hooks, к группировке логики, к смысловым блокам внутри компонента, к тому, где заканчивается разумная локальность и начинается перегрузка одной функции слишком большим количеством обязанностей.
Обе крайности внедрения одинаково вредны
Полезно сразу отказаться от двух крайностей. Первая — считать, что Hooks нужно внедрить везде и как можно быстрее. Это почти всегда плохая стратегия. Сообщество еще только начинает привыкать к новой модели, best practices только складываются, а сама команда React не предлагает переписывать существующие приложения за одну ночь. Если у вас есть устойчивые классовые компоненты, которые работают и не создают архитектурной боли, нет никакого смысла срочно переписывать их только ради ощущения современности. Hooks нужно внедрять там, где они дают реальный выигрыш: в новом коде, в новых feature, в тех участках, где классовая форма явно мешает и где новая композиция логики действительно упрощает жизнь.
Вторая крайность — считать, что Hooks вообще ничем принципиально не отличаются от классов и являются просто более коротким способом записать тот же код. Это тоже неверно. Да, многие старые сценарии можно выразить через useState и useEffect вместо локального state и lifecycle-методов. Но настоящая сила Hooks раскрывается не в этой механической замене, а в возможности выносить stateful-логику в переиспользуемые кастомные hooks без лишних структурных надстроек. И вот это уже действительно меняет стиль архитектуры React-приложения.
Кастомные hooks полезны ровно настолько, насколько у них есть граница
До Hooks повторное использование логики часто выглядело несколько искусственно. Либо приходилось выносить поведение в HOC, что добавляло уровни оберток и не всегда было приятно читать. Либо использовались render props, которые решали задачу, но тоже не делали JSX спокойнее. Hooks позволяют вынести логику в обычную функцию, которая опирается на React-механизмы и возвращает нужное поведение или состояние. Это очень элегантная идея. Она делает повторное использование логики заметно естественнее. И именно здесь новый React действительно ощущается новым.
Но и в этой зоне легко потерять голову. Как только команда распробует кастомные hooks, возникает соблазн выносить туда почти все подряд. В результате появляются hooks, которые на деле становятся скрытыми сервисами, управляют слишком большим количеством поведения, знают о слишком многом контексте и иногда уже не упрощают компонент, а просто выталкивают сложность в другое место. То есть само по себе извлечение логики в кастомный hook не является добром автоматически.
Хороший hook должен выделять связанное поведение, а не служить черным ящиком для всего, что не хочется держать в компоненте. Это почти та же самая проблема, что и с утилитами, сервисами или контейнерами в других архитектурных стилях. Новый инструмент не отменяет старого закона: абстракция полезна только тогда, когда у нее есть ясная граница.
useEffect — это не новое имя для lifecycle-методов
Особенно много путаницы вызывает useEffect. И это неудивительно. Если useState ощущается довольно прямым и почти интуитивным переходом от локального состояния класса к функциональному компоненту, то useEffect требует другого способа думать. Его очень легко начать воспринимать как прямую замену старых lifecycle-методов, но это сравнение полезно только до определенного предела. Эффект — это не просто новое имя для componentDidMount и друзей. Это способ описывать синхронизацию между данными компонента и внешним миром после рендера. А значит, если относиться к нему слишком механически, можно быстро получить либо лишние эффекты, либо неправильные зависимости, либо код, который работает, но читается хуже, чем старые lifecycle-методы, которые он вроде бы должен был упростить.
Именно здесь многие впервые сталкиваются с тем, что Hooks требуют не меньшей, а большей концептуальной аккуратности. В классовом мире логика эффекта часто была размазана, но хотя бы привязана к понятным точкам жизненного цикла. В Hooks-модели нужно думать точнее: от каких значений реально зависит этот эффект, что он синхронизирует, когда должен запускаться повторно, что нужно очищать, что является стабильным, а что нет. Это делает код более выразительным в хороших руках, но менее терпимым к небрежности. Писать новый React без классов спокойно — это в том числе научиться видеть эффекты не как «место, куда складывается побочный код», а как аккуратный механизм работы с внешним миром.
Ранняя оптимизация делает код тяжелее, а не легче
Еще один важный источник путаницы — соблазн переусложнить новый React за счет ранней оптимизации. Hooks приходят в комплекте не только с useState и useEffect, но и с более тонкими инструментами вроде useMemo, useCallback, useReducer, useRef. И почти неизбежно многие начинают использовать их слишком рано, просто потому, что теперь они рядом и выглядят как часть «правильного нового стиля». Отсюда очень быстро рождаются компоненты, где логика вроде бы без классов, но при этом каждый второй фрагмент кода завернут в мемоизацию, callback-обертку, reducer или ref-обходной путь. Формально это все React Hooks. Но на практике подобный код очень легко становится труднее, а не легче для чтения.
Один из лучших способов не потерять голову — начинать с минимального набора и не делать вид, будто весь смысл Hooks в том, чтобы использовать как можно больше разных вызовов в одном компоненте. Для огромного числа задач достаточно понять по-настоящему две вещи: как работает локальное состояние через useState и как работает эффект как синхронизация через useEffect. Уже этого хватает, чтобы начать писать новый React заметно чище в большом количестве сценариев. Все остальное имеет смысл подключать по мере реальной необходимости, а не как обязательный символ продвинутости.
Легкость функции прячет рост ответственности
Есть и другой важный психологический сдвиг. Hooks очень способствуют тому, чтобы компонент снова воспринимался как функция от состояния и props, но уже не в слишком наивном смысле. Класс всегда был чуть более тяжеловесной сущностью. Функциональный компонент с Hooks позволяет держать компонент ближе к идее «вот входы, вот локальное состояние, вот эффект, вот вывод». Для большого числа интерфейсных задач это действительно делает код ближе к тому, как о нем думаешь.
Но именно поэтому особенно важно не перегружать один компонент слишком многими ответственностями. Пока компонент был визуально тяжелым классом, разработчик чувствовал, что компонент уже вырос. В функции этот момент ощущается слабее. Значит, нужно сознательно следить за размером и ролью компонента, иначе новая элегантность быстро начнет скрывать старую перегруженность.
Hooks меняют и разговор о повторном использовании логики между feature-областями. В старом React это часто воспринималось как нечто особенное: раз уж мы выносим stateful-логику, значит, нужен HOC, контейнер или специальный render-props-компонент. В новом React это может быть просто hook. И это прекрасно, пока не превращается в бесконтрольное размножение полускрытых зависимостей. Очень легко создать набор hooks, которые зависят друг от друга, от контекста, от внешнего API, от формы данных и от еще одного хука, лежащего рядом, — и в итоге получить не облегчение, а новую туманную архитектуру. Поэтому для кастомных hooks особенно важна честность: они должны быть понятны по названию, по возвращаемому значению и по области ответственности. Иначе новый React начнет напоминать старый мир с утилитами и helpers, только с более модным названием.
Переход команды — это не соревнование поколений
Нельзя не сказать и о командной стороне вопроса. Когда в проект приходит Hooks-стиль, команда очень быстро оказывается в переходном режиме: часть кода остается классовой, часть уже пишется функциями, best practices еще не до конца устоялись, а у людей разный уровень комфорта с новой моделью. Это абсолютно нормальное состояние. Проблема начинается только тогда, когда переход начинают воспринимать как соревнование поколений: старый React против нового React, классы против функций, вчерашний код против завтрашнего.
На практике для команды полезнее договориться не о полном немедленном единообразии, а о понятных правилах эволюции. Новый код можно писать через Hooks. Старый — переписывать только тогда, когда для этого есть реальная причина. Общие принципы простые:
- следить за размером компонентов и не давать функции тихо разрастаться;
- не превращать эффекты в свалку побочного кода;
- аккуратно вводить кастомные hooks с ясной границей ответственности;
- не форсировать сложные паттерны и мемоизацию раньше времени.
Очень помогает и то, что Hooks не требуют отказа от прежних сильных сторон React. Компонентная композиция остается. Однонаправленный поток данных остается. Контроль над props и state остается. Разделение на UI и логику по-прежнему имеет смысл. Контексты, reducers, memoization, feature-based организация проекта — все это никуда не исчезает. Hooks не заменяют архитектурные принципы, они дают им новый, часто более удобный синтаксический и композиционный носитель. А значит, писать новый React спокойно — это не значит забыть все, что было известно раньше. Это значит научиться выражать знакомые хорошие идеи в новой форме, не обожествляя саму форму.
Новый язык — не право на новую небрежность
Самое зрелое отношение к Hooks выглядит так: это очень сильный новый инструмент, который делает React проще и выразительнее там, где раньше классы были вынужденной тяжелой оболочкой. Он особенно хорош для локального состояния, эффектов и повторного использования stateful-логики через кастомные hooks. Но он не отменяет сложности интерфейсов, не делает архитектуру хорошей автоматически и не требует тотальной немедленной переписи старого кода. Более того, без дисциплины Hooks легко создают новый тип беспорядка: визуально легкий, но концептуально перегруженный.
Этот момент тем и важен, что Hooks уже достаточно реальны, чтобы начать менять повседневную разработку, но еще достаточно новы, чтобы многие команды могли выбрать тон перехода. Можно броситься в новую эпоху с фанатизмом и быстро запутать проект. А можно принять Hooks как сильный, но требующий спокойствия инструмент, и постепенно вырастить из него действительно более чистый стиль React-кода. Во втором случае новый React окажется не революцией ради революции, а вполне зрелым следующим шагом. Использовать Hooks стоит там, где они упрощают компонент; не превращать useEffect в универсальную мусорную зону для всего, что не вошло в render; не выносить в кастомные hooks то, что не имеет ясной общей границы; не переписывать классы ради одного только ощущения современности.
Главное достоинство нового React не в том, что он без классов, а в том, что он дает шанс писать более компактную и лучше компонуемую логику — и реализуется этот шанс только при условии, что новый язык не путают с правом на новую небрежность.