The Plan for React 18 простыми словами: что готовить в кодовой базе уже сейчас

•
Опубликовано
•
19 мин чтения

Текст написан с позиции июля 2021 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

Когда команда React рассказывает о будущем крупном релизе, у сообщества почти автоматически включается один и тот же режим. Все начинают искать список “что именно поменяется”, какие API придется переписывать, что срочно учить, что станет новым стандартом и не означает ли все это очередную архитектурную встряску. Летом 2021 года React 18 — это пока не вышедшая версия, а опубликованный план и открытая Working Group вокруг него. И именно поэтому в истории с React 18 гораздо полезнее смотреть не на список возможностей, а на сам вектор изменений. Потому что здесь важен не один новый метод и не одна “фича для демо”, а более глубокий сдвиг: React все заметнее движется к модели, где интерфейс можно рендерить, обновлять и подготавливать гибче, чем раньше.

Если говорить совсем по-человечески, то основной смысл плана вокруг React 18 не в том, что разработчикам внезапно предложат новый синтаксис ради синтаксиса. Смысл в другом: библиотека готовится лучше управлять приоритетами обновлений, работать с асинхронной природой интерфейса и давать разработчику более точные инструменты для разделения “срочного” и “несрочного” в пользовательском опыте. И вот это уже действительно важно. Не только потому, что это красиво звучит в архитектурном обсуждении, но и потому, что такие изменения почти всегда затрагивают привычки, которые давно живут в кодовой базе.

Поэтому правильный вопрос звучит не так: “какие новые API появятся, чтобы когда-нибудь попробовать их в песочнице?”. Правильный вопрос звучит иначе: какие предпосылки в текущем коде могут помешать нам спокойно жить в мире React 18, и что можно подготовить заранее, не дожидаясь официального релиза? Именно такой взгляд обычно оказывается самым полезным для реальных команд. Он снимает нервозность вокруг будущей версии и переводит разговор из режима “когда-нибудь разберемся” в режим спокойной подготовки.

И это особенно разумно сейчас, потому что React давно уже перестал быть просто библиотекой, которую можно воспринимать как очередной пакет для обновления. Вокруг него строятся крупные продуктовые системы, дизайн-системы, внутренние кабинеты, витрины, сложные административные интерфейсы и огромные кодовые базы с историей. В такой среде выигрывает не тот, кто первым прочитал анонс, а тот, кто заранее понимает, какие инженерные привычки будут совместимы с будущим направлением платформы, а какие уже начинают выглядеть устаревающими.

Главная идея React 18: не один трюк, а новая степень гибкости рендера

Чтобы не запутаться в деталях, полезно сначала схватить общий смысл. React 18 — это не история про одну точечную возможность, которую можно рассматривать в отрыве от остального. Это скорее развитие всего направления, которое уже намечалось раньше: React хочет быть лучше приспособленным к постепенному, управляемому и более интеллектуальному обновлению интерфейса.

Если раньше разработчик чаще думал про обновление состояния как про нечто сравнительно прямолинейное — произошло изменение, React отрендерил новое состояние интерфейса, пользователь увидел результат, — то теперь разговор становится тоньше. Оказывается, не все обновления одинаково срочны. Нажатие клавиши в поле ввода и тяжелое перестроение большого списка по фильтру — это не одно и то же с точки зрения ощущения интерфейса. Пользовательский ввод нужно отразить немедленно. Остальное можно иногда сделать чуть менее агрессивно, если это сохранит отзывчивость.

Вот именно такое мышление и лежит в основе будущих перемен. React хочет лучше различать характер работы. И это очень важная мысль, потому что она влияет не только на новые API, но и на саму дисциплину написания компонентов. Чем больше кодовая база зависит от предположения “любое обновление идет одинаковым путем и одинаково безопасно”, тем болезненнее потом воспринимается переход к более гибкой модели.

Concurrency — не магия и не “все стало параллельным”

Одна из первых вещей, которая путает людей в обсуждении React 18, — само слово concurrent. Оно звучит почти так, будто React внезапно станет работать как нечто полностью параллельное и загадочное. Отсюда рождается лишняя тревога: что теперь будет с компонентами, эффектами, состоянием, порядком обновлений и вообще можно ли будет доверять привычной модели мышления.

Самая вредная реакция на слово concurrent — услышать в нем “теперь все стало параллельным” и решить, что прежняя ментальная модель больше не работает. Полезнее понимать это без лишней драматизации. В практическом смысле concurrent-подход — это прежде всего способность React гибче распоряжаться работой по рендеру, прерывать менее приоритетные задачи, возвращаться к ним позже и тем самым делать интерфейс отзывчивее. Дело не в том, что привычный React внезапно исчезает и вместо него появляется совершенно иная вселенная, а в том, что движок становится умнее в вопросе того, как именно доставлять обновления до экрана.

Почему это важно для кодовой базы уже сейчас? Потому что чем больше ваш интерфейс зависит от побочных эффектов в фазе рендера, от скрытых мутаций, от неявной связи между вызовами и от предположения, что “если функция компонента вызвалась, значит все линейно и без сюрпризов”, тем сильнее такие места будут выглядеть подозрительно в новом мире. Даже если React 18 не требует завтра же переписать все на новый лад, он явно подталкивает к более чистой модели компонентов.

Что значит “готовить кодовую базу”: не переписывать все, а убрать самые хрупкие предпосылки

Когда разработчики слышат о грядущей большой версии, обычно встречаются две крайности. Первая — паника и желание срочно заранее переписать полпроекта. Вторая — полное игнорирование до момента, когда обновление уже нельзя откладывать. Обе стратегии плохи. Куда полезнее смотреть на подготовку как на постепенную очистку кода от вещей, которые и без React 18 были сомнительными, просто теперь становятся еще заметнее.

То есть речь не о том, чтобы уже сегодня искусственно внедрять будущие паттерны во все места подряд. Речь о том, чтобы убрать архитектурные долги, из-за которых переход к более гибкому режиму рендера станет нервным. Если компонент делает слишком много во время рендера — это плохой сигнал уже сейчас. Если логика эффекта зависит от случайного порядка выполнения и от того, что “на самом деле это вызывается ровно один раз” — это плохой сигнал уже сейчас. Если тяжелые вычисления тесно переплетены с непосредственным пользовательским вводом — это плохой сигнал уже сейчас. В этом смысле подготовка к React 18 — это во многом подготовка к более дисциплинированному React вообще.

И это хорошая новость. Потому что означает, что большая часть полезной работы сегодня не пропадет. Даже если конкретный релиз еще впереди, улучшение структуры компонентов, уменьшение побочных эффектов и более честное разделение срочного и несрочного в UI уже сейчас делает приложение лучше.

Первое, что стоит проверить: нет ли побочных эффектов там, где должен быть чистый рендер

Если искать главную зону риска в стареющих React-кодовых базах, то это почти всегда размытая граница между рендером и побочными действиями. Очень многие проекты долго жили с привычкой “немного делать что-то прямо по дороге”. Где-то в теле компонента выполняется скрытая мутация. Где-то вычисление не такое уж чистое и зависит от внешнего изменяемого состояния. Где-то условно дергается логика, которая на самом деле уже ближе к эффекту, чем к вычислению представления.

Такие вещи опасны и в обычном React, но в контексте движения к concurrent-возможностям они особенно нежелательны. Если React получает больше свободы в том, как запускать, прерывать и повторять работу рендера, то любой код, который воспринимал рендер как безопасное место для побочных действий, становится архитектурно хрупким.

Поэтому одна из самых практичных подготовительных работ — пройтись по компонентам и честно спросить: что здесь является чистым вычислением JSX и derived state, а что уже похоже на side effect? Если что-то взаимодействует с внешним миром, меняет состояние вне контролируемого жизненного цикла, императивно запускает то, что не должно происходить просто от самого факта рендера, это стоит вытаскивать из тела компонента в более подходящее место.

Это может звучать как очевидность, но именно такие очевидности сильнее всего влияют на безболезненность будущих обновлений.

Effects нужно воспринимать строже, чем многие привыкли

У React-сообщества уже был опыт того, как новый подход к жизненному циклу меняет реальную дисциплину кода. Hooks упростили множество вещей, но одновременно создали и новую форму беспорядка: разработчики начали складывать в эффекты слишком многое, превращая их в универсальный контейнер для “всего, что не помещается в рендер”. На короткой дистанции это удобно. На длинной — рождает очень хрупкую систему причин и следствий.

План вокруг React 18 делает эту проблему еще заметнее. Чем более гибким становится рендеринг, тем важнее, чтобы эффекты были действительно эффектами, а не скрытым механизмом управления всей логикой приложения. То есть полезно уже сейчас пересматривать useEffect не как место для “сделать что угодно после рендера”, а как инструмент синхронизации с внешним миром или с тем, что действительно должно происходить вне чистого вычисления интерфейса.

Если эффект используется, чтобы компенсировать неясную модель состояния, если внутри него происходит вычисление того, что можно было бы выразить прямо через state и props, если он служит способом латать порядок операций, значит в коде, скорее всего, есть более глубокая проблема. React 18 не создает эту проблему, но будет гораздо менее терпим к такому стилю мышления. И это хороший повод начать разбирать особенно тяжелые эффекты уже сейчас.

Automatic batching — маленькая деталь, которая меняет ожидания

Одна из тех вещей, которые на поверхности могут показаться просто приятной оптимизацией, на деле довольно сильно влияют на ментальную модель — это более широкое автоматическое объединение обновлений. Идея здесь простая: React сможет в большем числе случаев группировать несколько обновлений состояния вместе, чтобы не делать лишнюю работу и вести себя эффективнее.

На бумаге это выглядит почти исключительно как плюс. И в большинстве случаев так и есть. Но полезно заранее подумать о другой стороне: часть старого кода иногда неявно полагалась на очень конкретное поведение обновлений и на то, в какой момент именно что становится доступным. Если логика компонента написана так, будто каждый setState немедленно должен быть наблюдаемым через некоторые побочные конструкции, такие места лучше пересматривать заранее.

Это не значит, что React 18 ломает здравый код. Это значит, что код, в котором порядок наблюдения за промежуточными состояниями уже был скользким, может начать вести себя не так, как автор когда-то случайно привык. Поэтому стоит особенно внимательно посмотреть на места, где несколько связанных обновлений происходят подряд, а логика вокруг них завязана на предположения о пошаговом ходе процесса.

Вообще, чем меньше код зависит от тонких механических деталей обновления и чем больше выражает намерение явно, тем спокойнее он переживает такие изменения. Это еще один пример того, как подготовка к React 18 на самом деле совпадает с подготовкой к более здоровому React-коду.

Transitions: пора учиться различать срочное и несрочное в интерфейсе

Одна из самых интересных идей, связанных с будущим React 18, — это возможность явнее сказать React’у, какие обновления пользовательски критичны, а какие могут быть обработаны как менее срочные. Для обычного разработчика это почти новая полезная оптика на интерфейс. Потому что долгие годы во многих приложениях все обновления попадали в один мысленный мешок: изменилось состояние — обновился экран. Но реальный пользовательский опыт всегда устроен тоньше.

Когда человек вводит текст в поле поиска, само появление символов на экране — это срочное действие. А вот тяжелая перестройка большого списка результатов может быть обработана более гибко, если это сохранит ощущение отзывчивости. Идея transitions как раз про это: дать разработчику способ выразить, что часть изменений не обязана конкурировать с немедленными интеракциями.

Даже если вы еще не внедряете конкретные API, к этой модели уже полезно готовить мышление кодовой базы. Посмотрите на места, где один пользовательский ввод запускает сразу и мгновенное локальное обновление, и тяжелую цепочку пересчетов, фильтраций, загрузок или перестроений большого дерева. Очень часто именно такие места потом и оказываются лучшими кандидатами на более тонкое управление приоритетом.

Иными словами, готовить стоит не только код, но и архитектурный взгляд на UI: какие части интерфейса обязаны быть немедленными, а какие можно считать переходными состояниями.

Подозрительные места: тяжелый derived state и дорогое вычисление прямо в компоненте

Если хочется найти практический список того, что особенно стоит проверить перед эпохой React 18, туда почти наверняка попадут тяжелые вычисления, живущие прямо в компонентах. Особенно если эти вычисления запускаются на каждый ввод, на каждое изменение фильтра, на каждую небольшую интеракцию пользователя. Пока приложение маленькое, это может не раздражать. Но как только объем данных растет, а UI становится плотнее, подобные вещи начинают напрямую влиять на ощущение интерфейса.

React 18 не запрещает вычислять что-то в компоненте. Вопрос не в запрете. Вопрос в том, насколько ясно у вас отделено действительно легкое вычисление представления от дорогой работы, которая конкурирует за время с пользовательским взаимодействием. Если в приложении много таких мест, полезно уже сейчас разбирать их по-честному: что можно мемоизировать, что лучше выносить, что вообще не должно пересчитываться так часто, где стоит пересмотреть структуру данных.

Особенно это относится к экранам с большими списками, таблицами, сложной фильтрацией, сортировкой и зависимой композицией больших деревьев компонентов. Именно там новый взгляд на приоритеты обновлений потом дает наибольшую практическую пользу. А значит, именно там и подготовка окупается сильнее всего.

Suspense начинает выглядеть не как экзотика, а как часть общей траектории

Еще недавно для многих разработчиков Suspense оставался чем-то немного “из будущего”. Интересная идея, красивый концепт, но не всегда понятно, как именно и где это станет повседневным инструментом. На фоне планов вокруг React 18 значение Suspense выглядит гораздо серьезнее. Потому что он уже заметнее встраивается не как отдельный эксперимент, а как часть общей модели того, как React хочет работать с асинхронностью и подготовкой интерфейса.

Это не значит, что всем нужно срочно переписывать получение данных под Suspense прямо сейчас. Но это значит, что кодовая база выигрывает, если в ней уже меньше ручной хаотичной оркестрации состояний загрузки там, где можно держать структуру более чистой и предсказуемой. Чем более запутаны у вас цепочки loading/error/partial-ready через множество уровней компонентов, тем внимательнее стоит смотреть на архитектуру асинхронных сценариев.

React 18 в целом подталкивает к мысли, что асинхронность — не побочное неудобство, а базовая реальность интерфейса. И с этой реальностью полезно работать не через растущий хаос флагов и ручных переключений, а через более ясные структурные решения. Suspense как раз начинает выглядеть частью этой философии.

Streaming и server-side рендеринг: нужно готовить не только клиент, но и ожидания от SSR

Еще одна важная часть плана — развитие server-side rendering в сторону более гибкой, потоковой модели. На уровне общей идеи это очень логично: если React учится лучше работать с постепенной подготовкой интерфейса, то и серверная сторона не должна быть заперта в модель “либо отдали все сразу, либо ждем до конца”. Возможность стримить HTML частями и лучше сочетать это с Suspense выглядит как очень естественный шаг.

Почему это стоит учитывать уже сейчас? Потому что многие кодовые базы с SSR исторически накопили очень жесткие предположения о том, как именно должна собираться страница, когда все данные обязаны быть доступны и как устроена последовательность рендера между сервером и клиентом. Чем больше ваш SSR-слой завязан на грубую синхронную картину мира, тем больше смысла заранее присматриваться к местам, где эта картина уже выглядит слишком негибкой.

Это особенно касается архитектур, где серверная подготовка данных и клиентская гидрация завязаны на сложные вручную поддерживаемые соглашения. Если они слишком хрупкие уже сейчас, то будущая эволюция React в сторону более потокового и асинхронного мышления вряд ли сделает их легче. Поэтому полезно заранее стремиться к более прозрачным границам данных и более честному разделению ответственности между серверной и клиентской частью интерфейса.

Strict Mode стоит воспринимать не как раздражающий режим, а как ранний детектор проблем

Один из самых недооцененных способов подготовки к будущему React — это внимательное отношение к Strict Mode. Очень многие команды включают его, видят “лишние” срабатывания и предупреждения, раздражаются и мысленно относят все это к шуму, который мешает жить. Но если смотреть на происходящее чуть зрелее, становится видно, что Strict Mode довольно честно подсвечивает места, где код уже сейчас завязан на нежелательные предпосылки.

Если компонент болезненно реагирует на повторные вызовы в режиме разработки, если эффекты ведут себя странно, если логика ломается от более строгой проверки, это не столько проблема режима, сколько намек на архитектурную хрупкость самого кода. И в контексте движения к React 18 такие сигналы особенно полезны. Они показывают, где именно ваша кодовая база хуже всего готова к более продвинутой модели рендеринга.

Поэтому один из самых практичных советов — не отключать неудобства мысленно, а использовать их как карту долга. Да, не все придется чинить мгновенно. Но если команда начнет системно убирать особенно проблемные места, будущее обновление перестанет выглядеть как прыжок в неизвестность.

Библиотеки вокруг React тоже имеют значение

Говоря о подготовке кодовой базы, легко сосредоточиться только на собственных компонентах. Но в реальных проектах значительная часть поведения зависит от сторонних библиотек: роутинг, формы, таблицы, state management, асинхронные данные, UI-киты, обертки над запросами. И здесь тоже есть важный вопрос: насколько эти инструменты готовы жить в мире React 18.

Это не значит, что нужно прямо сейчас срочно менять стек. Но это значит, что новые зависимости уже стоит оценивать не только по привычному набору критериев, но и по их общему направлению совместимости с современным React. Насколько библиотека уважает чистоту рендера? Не строится ли она на странных предположениях о синхронности? Не злоупотребляет ли императивными обходными путями? Насколько активно поддерживается?

Иногда подготовка к будущему релизу состоит не в переписывании собственного кода, а в том, чтобы не углублять зависимость от решений, которые уже сегодня выглядят тяжело совместимыми с траекторией React. Для больших кодовых баз это особенно важно: накопление “неудобного окружения” часто потом усложняет апгрейд сильнее, чем состояние самих компонентов.

State management: полезно уменьшать лишнюю связанность уже сейчас

Еще один класс мест, куда стоит посмотреть заранее, — это архитектура состояния. React 18 сам по себе не требует отказаться от привычных подходов, но его направление хорошо сочетается с одной здравой мыслью: интерфейс становится легче развивать, когда обновления состояния описаны ясно, а их влияние на UI предсказуемо.

Если в приложении слишком много неявно связанных кусков глобального состояния, если любое изменение прокатывается через полдерева компонентов, если derived state размазан по разным уровням, а эффекты используются как клей между несогласованными частями модели, то любая новая гибкость рендера будет восприниматься с большей тревогой. Не потому, что React 18 плох, а потому, что сама система состояния уже перегружена.

Поэтому разумная подготовка — это уменьшение ненужной связанности, более четкое разделение локального и глобального, более честное хранение источников истины и отказ от лишних обходных путей. Такие изменения полезны независимо от конкретной версии React, но именно в контексте грядущего релиза становятся особенно стратегическими.

Нужно готовить не только код, но и командную оптику

Есть еще один важный аспект, который обычно недооценивают: React 18 — это не только техническое обновление, но и обновление языка, на котором команда обсуждает интерфейс. Если разработчики по-прежнему мыслят только в категориях “изменили state — все просто перерисовалось”, то новые идеи вроде transitions или более гибкого рендера могут казаться сложными и чужеродными. Но если команда уже учится различать виды обновлений, осознает природу асинхронности и понимает, что отзывчивость интерфейса — это не побочный результат, а часть архитектуры, переход становится куда спокойнее.

Именно поэтому полезно уже сейчас обсуждать производительность и структуру интеракций не только на уровне “подтормаживает/не подтормаживает”, а на уровне приоритетов работы. Что здесь нужно показать мгновенно? Что может догрузиться позже? Что должно оставаться отзывчивым даже при тяжелом пересчете? Где пользователь чувствует задержку сильнее всего? Эти разговоры очень хорошо готовят мышление к тому, что React 18 пытается дать на уровне API и движка.

В итоге лучшая подготовка — это не список заклинаний, а постепенное взросление модели интерфейса внутри команды.

Что не стоит делать уже сейчас

Полезно сказать и о другом: готовиться к React 18 не означает спешно внедрять все, что только напоминает “будущее”. Не нужно переписывать стабильные части системы ради моды на новые слова. Не нужно создавать искусственные абстракции в ожидании неясных сценариев. Не нужно заранее усложнять код только потому, что когда-нибудь появится новый способ тоньше управлять обновлениями.

Самая разумная стратегия сегодня — не форсировать будущее, а убирать то, что уже выглядит сомнительно. Чистить тяжелые эффекты. Убирать побочные действия из рендера. Пересматривать избыточно связанные модели состояния. Искать места, где пользовательский ввод конкурирует с дорогой работой. Улучшать дисциплину вокруг SSR и асинхронных сценариев. Это все реальные улучшения, а не инвестиция в туманную моду.

То есть готовить кодовую базу стоит не через истерику, а через снижение хрупкости. Такой подход почти всегда оказывается самым выгодным, когда большая версия действительно приходит.

Итог

План вокруг React 18 простыми словами выглядит так: React движется к более умному и гибкому способу обновлять интерфейс, лучше различать приоритеты работы, спокойнее жить с асинхронностью и давать разработчику инструменты для более отзывчивого пользовательского опыта. Это не маленькое косметическое изменение и не одна фича для красивого примера. Это развитие всей модели того, как библиотека понимает современный интерфейс.

Поэтому готовить в кодовой базе уже сейчас стоит не “поддержку React 18” в абстрактном смысле, а те качества, которые будут совместимы с этим направлением. Чистый рендер без побочных эффектов. Более строгие и честные эффекты. Меньше скрытых предположений о порядке обновлений. Более ясное разделение срочного и несрочного в UI. Меньше тяжелой работы, тесно спаянной с интеракциями. Более аккуратная асинхронная архитектура. Внимание к Strict Mode и к зрелости библиотечного окружения.

И если сформулировать самый практичный совет совсем коротко, он будет таким: не готовьтесь к React 18 как к очередному списку фич, готовьтесь к нему как к проверке того, насколько ваш React-код уже сегодня чист, предсказуем и честен по отношению к современному интерфейсу. Тогда и сам релиз перестанет выглядеть чем-то тревожным. Он станет просто следующим шагом, к которому кодовая база подошла не в последний момент, а с нормальной инженерной зрелостью.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

Читайте также