Как организовать Redux-store без хаоса: reducers, actions и папки без боли

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

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

Когда Redux только появляется в проекте, он почти всегда производит приятное впечатление. После хаотичного набора обработчиков, неочевидных связей между компонентами и состояния, которое меняется в разных местах по разным поводам, идея выглядит соблазнительно. Есть единый store, есть actions, есть reducers, есть однонаправленный поток данных. Все кажется аккуратным, почти математически чистым. Но проходит немного времени, приложение растет, и вместе с ним растет другой вопрос: как все это организовать так, чтобы Redux не превратился в новый вид беспорядка?

Самая вредная реакция на этот вопрос — услышать слово «Redux» и решить, что архитектура уже наведена. Это не так. Сам по себе store не гарантирует порядка, он лишь задает рамку. А то, как внутри этой рамки разложены reducers, actions, константы, селекторы и папки, зависит не от библиотеки, а от команды и от дисциплины. Здесь многие впервые сталкиваются с парадоксом: формально Redux призван уменьшить хаос, а на практике очень легко порождает хаос другого типа — бесконечные списки action type-констант, разбросанные по папкам reducers, огромные switch-блоки, дублирующуюся логику, файлы с именами вродеcommon.js и utils.js, в которых постепенно оказывается половина проекта, и споры о том, куда положить очередной кусок кода. Сам store остается единым, но код вокруг него начинает расползаться.

Проблема здесь не в Redux как таковом, а в том, что инструмент дает простую модель данных, но не навязывает одну-единственную структуру проекта. Для сообщества это, с одной стороны, хорошо: организацию можно подстроить под нужды команды. С другой — отсутствие единственного правильного ответа создает тревогу. Хочется знать, как именно «правильно» хранить reducers, где держать actions, делить ли все по типам сущностей или по функциям интерфейса, когда выносить константы отдельно, а когда не плодить лишние уровни. И самое неприятное: почти любой проект сначала выглядит простым, поэтому организационные решения принимаются слишком беспечно — а расплачиваться за них приходится через полгода.

Зафиксируем сразу главную мысль, к которой все сведется. Порядок в Redux — это не про идеальную схему папок, а про уважение к ролям и про близость кода к предметной области. Папки важны, но они вторичны. Дальше разберем это по слоям: с чего начинать, как делить reducers, как именовать actions, как раскладывать код, что делать с константами, селекторами, вложенностью и асинхронностью — и чем за всё это приходится платить.

Порядок начинается не с папок, а с модели приложения

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

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

Reducers стоит делить по срезам состояния, а не по любви к маленьким файлам

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

Разумная стратегия выглядит так: reducer выделяют под осмысленный срез состояния, который может жить как относительно самостоятельная единица. Не под каждое отдельное поле, но и не под весь мир сразу.usersReducer, authReducer, notificationsReducer,filtersReducer — вполне естественные сущности. А вот отдельный formFlagsReducerради двух булевых значений рядом с unrelatedDataReducer уже выглядит как искусственное дробление. Структура reducers должна помогать понимать приложение, а не соответствовать абстрактной эстетике мелких модулей.

Action — это описание события, а не команда для reducer

С actions беспорядок приходит еще быстрее, потому что действия в Redux очень дешевы в создании. Добавить новый type, новый action creator и новый case в reducer несложно. Поэтому в проекте начинает расти слой мелких и плохо продуманных действий. Особенно опасно, когда actions отражают не бизнес-события и не понятные переходы состояния, а буквально каждое шевеление интерфейса без всякой системы. В итоге появляются трудноразличимые имена, дублирующие действия, размытые намерения и ощущение, что store обновляется по поводу и без повода.

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

Раскладка по feature-областям устойчивее раскладки по типам файлов

Отсюда следует и рекомендация по файловой организации: не стоит думать об actions как о безликой общей куче. Папка actions, куда складывается все подряд, на раннем этапе кажется удобной, а потом быстро превращается в свалку. Если проект живет на нескольких крупных областях состояния, полезнее группировать actions рядом с той областью, которой они реально принадлежат. Не потому, что это модно, а потому, что reducer, action creators и связанные части логики читаются вместе. Если user-related actions лежат в одном конце проекта, а user reducer — в другом, приходится постоянно держать карту в голове.

Здесь и появляется главный организационный спор: раскладывать Redux-код по техническим типам или по функциональным областям? То есть держать ли все reducers в одной папке, все actions в другой, всеconstants в третьей — или собирать код по feature-модулям, где рядом живут reducer, actions и, возможно, компоненты одной конкретной части приложения. Универсального ответа нет. Но если цель — меньше боли по мере роста, то раскладка по смысловым областям часто оказывается устойчивее.

Структура по техническим типам логична на маленьком проекте: в папке reducers лежат reducers, в папке actions — actions. Но у нее скрытый недостаток. Она хорошо отвечает на вопрос «что это за тип файла?» и плохо — на вопрос «к какой части приложения это относится?». Когда приложение растет, второй вопрос становится важнее первого. Разработчику чаще нужно понять, где живет логика списка заказов, авторизации или поиска, чем знать, что он открыл именно reducer, а не action creator. Поэтому feature-ориентированная организация выигрывает в практичности: у каждой области своя папка, внутри — связанные куски Redux-логики.

Критерий — не название схемы, а сколько папок нужно держать в голове ради одного action

Важно не свалиться в другую крайность и не переносить немедленно вообще все в полностью модульную структуру. Иногда удобна гибридная схема: общая инфраструктура store и корневая сборка reducers живут централизованно, а большая часть прикладной логики — рядом с конкретными областями. Важно не название подхода, а то, уменьшает ли он когнитивную нагрузку. Если, чтобы добавить новый action для поиска, нужно помнить о трех разных папках в разных концах проекта, структура недружелюбна. Если вся логика поиска собрана рядом, работать легче. Это критерий, а не идеология.

Константы и селекторы дают порядок только при умеренности

Много боли приносит вопрос констант. Знакомясь с Redux, многие быстро привыкают выносить action types в отдельные constants-файлы. Шаг разумный: уменьшается риск опечаток, появляется единообразие, имена можно импортировать в reducers и action creators. Но и здесь есть цена механического применения. Если в проекте заводится одна глобальная папка constants с длинным перечнем строк для всего на свете, она начинает жить собственной тяжеловесной жизнью. Константы перестают помогать ориентироваться и превращаются в обязательный промежуточный слой.

Спокойнее держать action types ближе к тому модулю, где они используются. Если есть users-модуль, нет нужды отправлять его constants в центральное хранилище всех констант проекта — локальность дает больше ясности. Исключение составляют действительно общие вещи с кросс-модульным смыслом, но таких случаев, как правило, меньше, чем кажется в начале.

Отдельная и часто недооцененная часть порядка — селекторы. Когда компонентам нужны данные из store, соблазнительно каждый раз доставать их напрямую из вложенного state-дерева в mapStateToPropsили рядом. На короткой дистанции это безобидно. На длинной — знание о внутренней структуре store расползается по всему приложению, и стоит поменять форму данных, как приходится искать десятки мест, где они читаются напрямую.

Селектор — это маленький слой абстракции над состоянием. Он позволяет сказать: вот так приложение получает список видимых пользователей, вот так — текущего пользователя, вот так — активные фильтры. Тогда компоненты зависят не от конкретной формы state-дерева, а от понятного интерфейса доступа к данным. Это упрощает рефакторинг store и держит логику вычисления производных данных вне компонентов. В итоге роли расходятся спокойно: reducers отвечают за изменение состояния, actions — за события, селекторы — за чтение и подготовку данных для представления.

Большая часть хаоса начинается со смешения слоев

Одна из главных причин беспорядка в Redux-проектах — смешение слоев. Reducer начинает делать работу селектора. Action creator внезапно знает слишком много о структуре хранилища. Компонент берет на себя трансформацию данных, которая уже живет где-то еще. Или наоборот, в reducer пытаются затолкать побочные эффекты и асинхронную логику, потому что «нужно же где-то это обработать». Как только границы размываются, store перестает быть опорной архитектурой и превращается в набор привычных компромиссов под новым названием.

Поэтому порядок в Redux — это не столько про папки, сколько про уважение к ролям. Reducer — чистая функция, которая меняет свой срез состояния в ответ на действие. Action описывает событие. Action creator помогает собрать это описание. Селектор читает и подготавливает данные. Компонент показывает интерфейс. Чем яснее роли, тем меньше соблазна засунуть «временно вот сюда» еще немного случайной логики. А большинство хаоса начинается именно с этих временных решений, к которым потом никто не возвращается.

Преждевременная универсальность дороже сегодняшней ясности

Есть и обратная ловушка: желание заранее построить идеально универсальную структуру store на годы вперед. Это приводит к переусложнению с первого дня. Команда проектирует не под текущие потребности, а под гипотетическое грандиозное будущее: лишние уровни абстракции, слишком общие базовые модули, папки «на вырост», которые пока пустуют, и много красивой архитектурной лексики при малой прикладной пользе. Redux особенно располагает к избыточному проектированию, потому что сама идея единого store провоцирует мыслить крупными блоками. Полезнее идти от сегодняшнего устройства приложения и закладывать ясность, а не архитектурную торжественность.

Это не призыв игнорировать будущее. Просто устойчивость структуры рождается не из максимальной общности, а из хороших локальных решений. Если у каждого feature-модуля понятный reducer, ясные action names, локальные constants, удобные селекторы и внятные границы ответственности, проект масштабируется лучше, чем тот, что с самого начала оформлен как учебник по абстракциям. Redux любит простоту, и об этом легко забыть именно тогда, когда хочется сделать все «по-взрослому».

Именование и плоское состояние снимают боль дешевле рефакторинга

Много боли снимает простое соглашение по именованию. Это кажется мелочью, но в Redux имена держат читаемость потока событий. Хорошо, когда action types последовательно отражают область и событие, reducers называются по смысловым срезам состояния, а не по внутренней механике, а папки не носят туманных имен вроде core, misc, common2 или temp. Чем яснее имя, тем меньше времени уходит на навигацию. Для store-ориентированной архитектуры это особенно важно: значительная часть работы разработчика — мысленно проследить, как событие проходит через систему.

Стоит сказать и о вложенности состояния. Глубокое дерево в store почти всегда увеличивает боль. Формально запрета нет: Redux спокойно работает с вложенными структурами. Но чем сложнее форма state, тем больше усилий требует ее обновление, тем больше копирования в reducers, тем труднее читаются селекторы и тем выше вероятность случайных ошибок. Если структура store напоминает матрешку из нескольких уровней, стоит спросить: эти уровни отражают смысловые сущности или это следствие случайного накопления данных? Плоские и ясные структуры состояния сопровождать проще, чем глубоко вложенные.

Асинхронность требует не изящества, а повторяемого ритма

Сильно влияет на ощущение порядка отношение к асинхронности. Многие Redux-проекты уже используют middleware-подходы для работы с асинхронными действиями, и здесь легко потерять ясность. Если код запроса, обработки успеха, обработки ошибки, обновления индикаторов загрузки и нормализации данных размазан по случайным местам, store быстро превращается в поле недописанных решений. Поэтому даже если конкретная техника асинхронной работы в проекте различается, важно держать единый ритм: где начинается запрос, какие actions сопровождают его жизненный цикл, какой reducer за это отвечает, где хранитсяloading/error-состояние. Повторяемость паттерна здесь важнее изящества.

Итог

Ощущение «без хаоса» в Redux приходит тогда, когда разработчик быстро отвечает на четыре вопроса. Что хранится в store? Где меняется конкретный кусок состояния? Какое событие это запустило? И как компонент получает нужные данные? Если ответить можно без долгой археологии по проекту, архитектура работает. Если же каждый шаг требует вспоминать расположение десятка файлов, разгадывать смысл action names и искать, кто вычисляет нужные данные, store уже начал обрастать болью.

Хорошая новость в том, что для наведения порядка редко нужен большой рефакторинг. Чаще достаточно нескольких принципов, соблюдаемых последовательно: делить reducers по реальным областям состояния; давать actions имена событий, а не технических операций; группировать Redux-логику рядом с feature-областями, а не только по типам файлов; держать селекторы как официальный способ чтения данных; не плодить глобальные constants без причины; не делать состояние глубже, чем нужно; не смешивать роли reducers, action creators, селекторов и компонентов. Правила звучат буднично, но именно из такой будничной дисциплины и складывается проект без боли.

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

Если сформулировать совсем прямо: организовать Redux-store без хаоса — это не выстроить идеальную схему ради схемы, а сделать так, чтобы reducers, actions и селекторы держались близко к предметным областям и не смешивали роли; именно близость к домену и чистота ролей, а не количество папок, и превращают store в спокойную, читаемую и развиваемую архитектуру.

Автор

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

Обновлено

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