Нормализация данных в Redux: почему store не должен выглядеть как JSON с бэка

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

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

Одна из самых коварных ловушек в Redux-проекте появляется ровно в тот момент, когда все вроде бы начинает складываться правильно. Есть store, есть actions, reducers, однонаправленный поток данных, понятная схема обновлений. Сервер присылает JSON, клиент его получает, кладет в store и показывает интерфейс. На раннем этапе это выглядит очень естественно. Даже слишком естественно. Кажется, что между ответом бэка и состоянием приложения не должно быть почти никакой дистанции. Раз пришел объект с вложенными сущностями, списками, связями и метаданными, значит, именно так его и стоит хранить. Меньше преобразований, меньше кода, меньше поводов ошибиться.

Самая вредная реакция на эту мысль — услышать «меньше кода» и решить, что прямое отражение ответа в store это и есть простота. На короткой дистанции иллюзия держится крепко. Сервер вернул список постов, внутри каждого поста автор, внутри автора профиль, внутри поста комментарии, внутри комментариев свои авторы, лайки и прочие связанные данные. Мы просто положили это в store и пользуемся. Работает. Но по мере роста приложения эта прямота начинает мстить. Выясняется, что store, устроенный как сырой JSON с бэка, плохо обновляется, трудно читается, провоцирует дублирование данных, усложняет reducers, делает селекторы тяжелее и превращает любое частичное изменение сущности в маленькую операцию с множеством побочных последствий.

Здесь и кроется центральное напряжение всей темы. Дело не в том, что вложенный JSON — это плохой формат. Он отличный формат для передачи данных по сети. Проблема в том, что транспортная форма и клиентская модель — это не одно и то же, а смешивать их ради «простоты» в итоге обходится дороже всего. Эта статья — про спокойное разведение двух ответственностей, а не про модную любовь к нормализации ради нормализации.

Серверный ответ и клиентское состояние решают разные задачи

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

Но клиент живет по другим законам. Его задача — не архивировать ответы API, а поддерживать удобное, устойчивое и обновляемое состояние интерфейса. А значит, у store есть право быть устроенным иначе. Это и есть базовое противопоставление: store — не журнал того, как однажды пришли данные по сети, а рабочая модель того, как с этими данными живет приложение.

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

Нормализация выглядит как лишняя работа только в момент приема ответа

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

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

Дублирование сущностей превращает обновление в гонку за всеми копиями

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

Именно здесь store, похожий на JSON с бэка, начинает подталкивать к хаосу. Reducers становятся сложнее, потому что приходится пробираться по глубоким вложенным структурам. Обновление одного поля неожиданно превращается в прогулку по нескольким веткам состояния. Где-то меняется пользователь внутри списка, где-то — внутри карточки, где-то — внутри комментария. Если вы не обновили одно из этих мест, интерфейс начинает показывать разные версии одной и той же сущности в разных частях приложения. А это уже не просто неудобство архитектуры, а реальная проблема согласованности UI.

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

Глубокая вложенность дорого обходится иммутабельным reducers

Вторая причина, по которой store не должен выглядеть как сырой JSON, связана с глубиной вложенности. Redux, конечно, не запрещает хранить глубокие деревья. Но чем глубже вложено состояние, тем тяжелее и опаснее его обновлять. В иммутабельной модели любое изменение требует аккуратно строить новую версию затронутой ветки. Если состояние неглубокое и разумно организованное, это еще терпимо. Если же у вас в store лежат вложенные ответы API на несколько уровней вниз, reducers начинают обрастать шумом. Нужно копировать родительские объекты, массивы, вложенные элементы, следить, чтобы не мутировать старое состояние, и при этом не потерять общую читаемость. Код становится многословным, а вероятность ошибки растет.

Нормализация делает обновления более плоскими и локальными. Вместо того чтобы менять поле в глубине дерева ответа, вы обновляете конкретную запись в конкретном наборе сущностей. Reducer становится не только короче, но и понятнее по смыслу. Он работает не с «третьим комментарием внутри поста, лежащего внутри определенного ответа», а с сущностью comment по ее id. Это очень важный сдвиг. Store начинает описывать модель данных приложения, а не историю того, как именно сервер однажды прислал вложенный JSON.

Разные экраны не используют один и тот же ответ одинаково

Есть и третья причина, менее очевидная на старте, но очень важная по мере роста проекта: разные экраны приложения почти никогда не используют серверные ответы в их исходном виде одинаково. Одному экрану нужен список id и короткие превью. Другому — развернутая сущность с автором и связанными метками. Третьему — только агрегированные признаки. Четвертому — отдельная детальная страница. Если store повторяет структуру бэкенд-ответов, он оказывается слишком тесно привязан к конкретным запросам. Получается, что клиентское состояние строится вокруг того, как API сгруппировало данные для транспортировки, а не вокруг того, как интерфейс хочет с ними работать. Это делает приложение менее гибким.

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

Очень характерный пример — пагинация, фильтры и разные представления одних и тех же сущностей. Допустим, у вас есть список статей или товаров. Один запрос возвращает первые двадцать элементов в одном порядке. Другой — избранные. Третий — результаты поиска. Четвертый — элементы конкретной категории. Если хранить весь серверный JSON как есть, у вас быстро появляются несколько списков с вложенными копиями одних и тех же сущностей. А если один элемент обновился, нужно либо синхронизировать несколько мест, либо надеяться, что пользователь не заметит расхождение. При нормализации же сами сущности живут отдельно, а разные выборки и представления могут храниться как массивы идентификаторов и сопутствующие метаданные. Это уже заметно ближе к тому, как реальный интерфейс мыслит данными.

Именно здесь становится видно, что store должен отражать не только сами сущности, но и отношения между ними и контексты их получения. Например, сущности пользователей могут храниться в одном месте, а список «видимых пользователей на текущем экране» — в другом, как отдельный набор id. Товары — в словаре товаров, а текущий результат поиска — как список id плюс loading и pagination metadata. Это важная разница. Store перестает быть архивом сырых ответов и становится рабочей моделью приложения, где отделены данные, связи и экранные представления.

Селекторы — это не цена нормализации, а ее естественная вторая половина

Многие разработчики сопротивляются нормализации еще и потому, что боятся: «тогда ведь придется потом собирать данные обратно для UI». Это правда. Интерфейс редко хочет напрямую работать только с плоскими словарями сущностей и списками id. Обычно ему нужна удобная производная форма: пост с автором и комментариями, карточка товара с ценой и флагом доступности, пользователь с ролью и аватаром. Но именно для этого и существуют селекторы. Их задача — читать нормализованное состояние и собирать из него данные в форме, удобной для представления. Это не недостаток архитектуры, а нормальное разделение обязанностей. Store хранит устойчивую модель, селекторы собирают из нее проекции для конкретного UI.

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

Есть и чисто организационная выгода. Нормализованный store помогает лучше увидеть, какие сущности вообще существуют в приложении. Пока все хранится как ответы API, модель данных часто остается расплывчатой. Есть какие-то списки, какие-то вложенные объекты, какие-то поля, и не всегда даже ясно, где проходит граница между сущностью и случайным куском ответа. Нормализация вынуждает назвать вещи своими именами: вот users, вот posts, вот comments, вот orders, вот products. Это дисциплинирует не только хранение, но и мышление о приложении. А в Redux-проекте, где большая часть качества держится на ясности потоков и структур, такая дисциплина очень полезна.

Сущности нормализуют, а экранные флаги и loading-state — нет

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

Это особенно заметно в связке с иммутабельным подходом, который и так подталкивает Redux к более явному управлению изменениями. Глубоко вложенный store в иммутабельной модели почти неизбежно увеличивает шум в reducers. Нормализованный store уменьшает глубину копирования и делает изменение более адресным. В результате reducers становятся проще по смыслу: вместо долгого ручного прохода по вложенным веткам вы обновляете конкретную сущность по id или меняете конкретный список ссылок. Это не только быстрее писать, но и легче проверять глазами.

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

Сервер отдаёт данные порциями, а store хранит их так, как ими живёт интерфейс

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

Если попытаться выразить это совсем просто, store не должен выглядеть как JSON с бэка потому, что у сервера и у клиента разные задачи. Сервер отдает данные порциями в удобной для API форме. Клиент хранит данные в форме, удобной для интерфейса и изменений. Когда эти две ответственности смешиваются, store становится заложником случайной формы ответов. Когда они разведены, приложение получает более ясную модель: сущности живут в одном месте, связи выражены явно, представления собираются через селекторы, обновления происходят локально и предсказуемо.

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

Автор

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

Обновлено

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