Redux сегодня: в каких задачах он всё ещё лучший выбор

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

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

С Redux произошла довольно редкая для фронтенд-инструментов вещь: он успел побыть и символом зрелой архитектуры, и мишенью для усталого скепсиса, и предметом почти обязательного пересмотра. Был период, когда без него многие команды просто не представляли себе более или менее серьезное React-приложение. Потом началась обратная волна: hooks, Context, более удобные решения для server state, локальные сторы, новые архитектурные подходы — и на этом фоне Redux все чаще стали обсуждать не как инструмент по умолчанию, а как что-то слишком тяжелое, чересчур церемониальное и исторически перегруженное репутацией старого enterprise-решения.

Такое маятниковое движение понятно. Фронтенд вообще любит сначала возводить инструмент в ранг универсальной добродетели, а потом с таким же удовольствием разочаровываться в нем, когда обнаруживается, что универсальной добродетели не существует. Но с Redux эта история особенно показательная, потому что на фоне общей усталости от избыточной архитектуры стало легко забыть одну важную вещь: проблема многих проектов была не в самом Redux, а в том, как и где его пытались применять. Очень много боли, которую вспоминают при разговоре о нем, возникло не из-за базовой идеи централизованного предсказуемого состояния, а из-за переусложненных паттернов, ручного бойлерплейта, попытки складывать в глобальный store все подряд и привычки строить вокруг него архитектуру даже там, где продукт этого не просил.

Поэтому к концу 2022 года разумнее говорить не в категориях “Redux умер” или “Redux по-прежнему обязателен”, а в гораздо более практической плоскости: в каких задачах он до сих пор дает такую форму порядка и предсказуемости, которую другие подходы либо дают хуже, либо не дают вовсе. И если смотреть на вопрос так, картина оказывается довольно спокойной. Redux не является универсальным ответом на state management. Но и пережитком, который стоит выкинуть из инженерного словаря, он тоже не стал. Он просто перестал быть инструментом “для всего” и зато яснее проявил те классы задач, где его сильные стороны действительно ценны.

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

Почему разговор о Redux приходится очищать от прошлого шума

Чтобы оценить его сегодняшнее место трезво, сначала надо убрать лишний исторический багаж. Для многих разработчиков Redux ассоциируется с эпохой, когда под любое малейшее изменение интерфейса приходилось писать action types, action creators, reducers, селекторы, middleware и сопровождать все это довольно тяжелой типизацией. Эта память реальна, и отмахиваться от нее бессмысленно. Но она описывает не столько сущность Redux, сколько конкретный стиль его использования, который действительно был слишком обременителен в массе прикладных задач.

С тех пор ситуация заметно изменилась. Прежде всего стало яснее, что далеко не любое состояние заслуживает глобального хранилища. Команды стали лучше различать UI state, server state, derived state, локальные временные значения и действительно общую прикладную правду. Параллельно изменилась и сама культура работы с Redux: Redux Toolkit снял огромную часть ритуального кода, уменьшил трение при работе с reducers и асинхронными сценариями, а типизация стала существенно спокойнее. Все это означает, что разговор о Redux в 2022 году нельзя честно вести так, будто перед нами все еще тот же набор боли из середины прошлого цикла фронтенда.

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

Главный вопрос: проблема действительно в состоянии приложения или в чем-то другом

Одна из самых частых причин неправильного выбора Redux — попытка решить им проблему, которая на самом деле не является проблемой глобального состояния. Если приложение страдает из-за плохой работы с серверными данными, кэшем запросов, инвалидацией, синхронизацией данных из API и фоновых обновлений, то далеко не всегда правильный ответ — централизованный store. Во многих случаях это уже территория специализированных решений для server state, а не классического Redux.

Если приложение страдает из-за тяжелых локальных компонентов, хаотичного props drilling, плохо проведенных границ между контейнерами и представлением, то Redux тоже может оказаться не лекарством, а просто более дорогим способом хранить тот же беспорядок. И если UI разваливается из-за отсутствия нормальной архитектуры модулей, централизованный store не подменит проектирование.

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

Redux по-прежнему хорош там, где нужна единая модель сложных переходов состояния

Есть класс приложений, в которых главная сложность не в том, чтобы просто “иметь данные”, а в том, чтобы управлять их состоянием как системой переходов. Допустим, интерфейс содержит последовательные шаги мастера, отложенные изменения, optimistic updates, откаты, подтверждения, составные сценарии с чередой действий пользователя и серверных реакций, а разные части UI должны видеть согласованную картину этих переходов. В таких местах локальный state, рассыпанный по компонентам, довольно быстро начинает проигрывать.

Именно здесь сила Redux раскрывается очень честно. Он позволяет мыслить не просто наборами значений, а последовательностью событий и переходов, происходящих в централизованной модели. Это особенно полезно там, где состояние должно быть не только доступным, но и объяснимым. То есть когда важно понять не просто “что сейчас лежит в store”, а “как система пришла к этому состоянию и какие действия привели к нему”.

В небольших интерфейсах эта потребность может быть неочевидной. Но в крупных приложениях, особенно внутренних продуктах, административных системах, редакторах, workflow-интерфейсах, конфигураторах и сложных пошаговых сценариях, именно такая объяснимость часто и становится критически важной. Redux в этих случаях хорош не потому, что он глобальный store сам по себе, а потому, что он хорошо подходит для явного моделирования переходов.

Сложные редакторы и конфигураторы — одна из самых естественных территорий Redux

Если искать область, где Redux все еще выглядит почти родным инструментом, это всевозможные сложные редакторы и конфигураторы. Не текстовый input и не простая форма обратной связи, а действительно богатые интерфейсы, в которых пользователь собирает, изменяет, откатывает, комбинирует и сравнивает состояние большого объекта. Это могут быть визуальные билдеры, конструкторы документов, интерфейсы настройки сложных сущностей, редакторы дашбордов, системные панели администрирования, CMS-подобные продукты, редакторы шаблонов, workflow-builder’ы.

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

Redux в таких интерфейсах хорош тем, что позволяет хранить сложную модель как одну управляемую систему, где изменение любого фрагмента может быть прозрачно отражено во всех частях UI. Плюс ко всему именно здесь особенно ценны time-travel, журналирование, воспроизводимость действий и возможность строить undo/redo на понятных событиях. А это уже территория, где альтернативы часто либо оказываются более разрозненными, либо требуют самостоятельного создания слоя, который по сути будет выполнять ту же работу.

Undo/redo и история действий — сильный аргумент в пользу Redux

Есть одна очень практическая особенность, про которую легко забывают в общих спорах о state management: не все приложения живут только в настоящем моменте. В некоторых из них важно не только текущее состояние, но и история его изменений. Как только появляется требование отката, повторного применения действия, сравнения промежуточных шагов, сериализации сессии пользователя или воспроизведения последовательности изменений, ценность action-oriented модели начинает резко расти.

Это не означает, что undo/redo невозможно построить без Redux. Конечно, возможно. Но во многих случаях Redux предоставляет для этого гораздо более естественную почву. Когда действия уже являются явными событиями, а состояние изменяется через централизованную систему переходов, история становится не побочным логом, а продолжением модели. Это очень удобно в редакторах, конфигураторах, системах с drafts, в сложных формах с черновиками, в интерфейсах коллективной работы и везде, где пользователю важно иметь ощущение контролируемого шага назад.

Если в проекте история действий является не декоративной опцией, а частью основного UX, Redux часто начинает выглядеть гораздо убедительнее, чем в среднестатистическом приложении “со списками и карточками”. Потому что там его архитектурная строгость дает не абстрактную “предсказуемость”, а конкретную пользовательскую ценность.

Redux силен там, где разнесенные части интерфейса должны жить в одной реальности

Очень многие state management решения хороши до тех пор, пока зависимые куски UI находятся близко друг к другу. Как только система начинает состоять из множества удаленных, но связанных областей — верхней панели, сайдбара, рабочей области, модалок, всплывающих уведомлений, нескольких вкладок контента и фоновых синхронизаций — локальные подходы начинают испытывать напряжение. Либо приходится поднимать состояние слишком высоко, либо появляется несколько источников правды, либо синхронизация превращается в сетку эффектов и контекстов.

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

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

Корпоративные интерфейсы и административные панели часто все еще хорошо чувствуют себя с Redux

Во фронтенд-дискуссиях иногда забывают, что значительная часть реальной разработки — это не публичные лендинги и не маленькие витрины, а большие внутренние интерфейсы. Корпоративные кабинеты, административные панели, CRM-подобные продукты, интерфейсы обработки сущностей, логистические и финансовые панели — все это довольно специфическая среда. Там не всегда важна ультралегкость state management по ощущениям новичка. Зато очень важны стабильность долгоживущей модели, предсказуемость эффектов, отслеживаемость изменений, понятное тестирование и возможность расширять систему не только быстро, но и без накапливающегося хаоса.

В таких системах Redux довольно часто чувствует себя уместно до сих пор. Особенно если приложение уже перешагнуло границу, где “несколько контекстов и пара локальных хранилищ” перестают быть достаточно ясными. Здесь Redux дает не столько модный DX, сколько институциональную форму. Команда получает единый язык для изменения состояния, понятные точки интеграции middleware, прозрачные селекторы, наблюдаемость и более высокий шанс, что система через год останется объяснимой для новых разработчиков.

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

Redux особенно полезен, когда нужна сильная наблюдаемость

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

Redux здесь по-прежнему очень силен. Его action-based модель и инструменты наблюдения дают системе то, чего часто не хватает более легким решениям: ясную трассу событий. Это важно не только для дебага. Это важно и для аналитики, и для инструментирования, и для понимания пользовательских сценариев, и для воспроизводимости багов. Там, где продукт долго живет, а инциденты стоят дорого, наблюдаемость перестает быть nice-to-have и становится частью архитектурной стоимости.

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

Redux хорош там, где middleware — не экзотика, а важная часть модели

Вокруг Redux всегда жила идея middleware, и долгое время для многих она была абстрактной красотой, которой пользовались от силы ради thunk’ов. Но есть целый класс приложений, где промежуточный слой обработки действий — это не второстепенный бонус, а действительно важная архитектурная зона. Аудит, логирование, orchestration, сложные асинхронные цепочки, нормализация, интеграция с внешними системами, обработка доменных событий на уровне фронтенда, реакция на классы действий с перекрестным эффектом — все это делает middleware действительно ценным.

Многие альтернативные state management подходы умеют что-то похожее, но не всегда дают для этого столь явную и зрелую модель. Redux хорош именно тем, что middleware не выглядит в нем чужим расширением. Это органичная часть того, как система может реагировать на изменения. И если приложение действительно выигрывает от такого промежуточного слоя, Redux начинает давать форму, которую сложно заменить чем-то совсем уж “проще” без потери прозрачности.

Разумеется, это не оправдание использовать middleware везде. Но там, где приложение уже по-настоящему событийное и реактивное по своей архитектуре, Redux выглядит удивительно современно именно за счет этого старого, но очень сильного качества.

Server-state и локальный UI — зоны, где Redux чаще проигрывает

Чтобы разговор был честным, нужно сразу обозначить и обратную сторону. Redux точно не выигрывает по умолчанию в приложениях, где основная сложность сидит в server state: загрузка, кэширование, фоновые обновления, синхронизация запросов, повторные fetch’и, инвалидация и подобные вещи. Там специализированные инструменты для работы с удаленными данными во многих случаях естественнее и удобнее.

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

То есть сильная сторона Redux как раз в том, что его теперь гораздо проще не использовать там, где он не нужен. И это не ослабляет его ценность, а, наоборот, делает ее яснее.

Redux Toolkit многое изменил в его практической пригодности

Невозможно честно обсуждать Redux конца 2022 года, игнорируя Redux Toolkit. Потому что он снял очень большую часть того, что раньше делало Redux не только строгим, но и мучительно многословным. Слайсы, более естественное описание reducers, удобная работа с асинхронными сценариями, встроенные практики по умолчанию — все это резко изменило соотношение между архитектурной пользой и ценой бойлерплейта.

Это важно не в смысле “теперь Redux стал модным снова”, а в гораздо более практическом. Те области, где Redux действительно силен, теперь обходятся меньшим количеством ритуала. Значит, решение использовать его в подходящей задаче стало менее болезненным. А это, в свою очередь, означает, что можно оценивать его не по памяти о прошлых страданиях, а по текущей реальной стоимости.

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

Сильный сигнал в пользу Redux: когда без него вы строите самодельный Redux

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

Это происходит не потому, что Redux “обязателен”. А потому, что некоторые приложения действительно требуют event-driven, централизованной, наблюдаемой модели состояния. И если такая потребность есть, отказ от готового инструмента не убирает ее, а лишь переносит в менее формализованную форму. Иногда это оправдано. Но часто выходит дороже, чем казалось в момент отказа.

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

Redux остается сильным там, где состояние — это часть продукта, а не только механика UI

Есть очень важное различие, которое хорошо помогает понять современное место Redux. В одних приложениях состояние — это в основном техническая механика интерфейса. Какой таб открыт, какая секция развернута, какой фильтр выбран, что лежит в локальной форме, какие данные мы сейчас отрисовываем. В других приложениях состояние становится уже почти частью самой предметной модели продукта. Это не просто UI-настройка. Это рабочий контекст пользователя, набор отложенных изменений, схема документа, процесс редактирования, последовательность шагов, оркестрация действий и бизнес-значимые переходы.

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

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

Итог

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

Особенно убедительно он чувствует себя в сложных редакторах, конфигураторах, workflow-интерфейсах, административных системах, корпоративных кабинетах, интерфейсах с undo/redo, в приложениях с богатыми сценариями оркестрации действий и там, где разнесенные части UI должны жить в одной общей реальности. В этих задачах его action-based природа, прозрачность переходов, middleware-модель и наблюдаемость остаются не историческим наследием, а практическим преимуществом.

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

Автор

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

Обновлено

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