React Context без фанатизма: где он заменяет Redux, а где только создаёт путаницу

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

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

У фронтенд-сообщества есть одна повторяющаяся привычка: как только появляется новый или заново осмысленный инструмент, вокруг него почти сразу возникает соблазн объявить конец предыдущей эпохи. Так было с React против старых MVC-подходов, так было с Redux как ответом на хаос состояния, и примерно так же сейчас начинают говорить о React Context. После того как в марте этого года вышел React 16.3 с обновлённым, наконец-то официальным Context API, разговор очень быстро сместился от технического «теперь это стало удобнее» к почти идеологическому «может быть, Redux больше не нужен?». Это понятная реакция. Разработчики устали от лишней церемонии, от слоёв абстракции, от actions, reducers, связующих контейнеров и общего ощущения, что простая задача иногда требует слишком много инфраструктуры. И на этом фоне Context выглядит как очень соблазнительное упрощение.

Но именно здесь и требуется то, что вынесено в заголовок: без фанатизма. Самая вредная реакция на новый API — услышать «контекст теперь стабилен» и решить, что Redux отменён. Потому что Context действительно закрывает часть тех задач, ради которых раньше часто брали Redux почти автоматически. Но он совсем не обязательно закрывает их все. Более того, при неосторожном использовании он может породить новый вид путаницы: менее формальный, менее заметный на старте, но вполне реальный по мере роста приложения.

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

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

Context силён не как store, а как механизм композиции данных по дереву

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

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

Передать данные вниз и управлять изменениями состояния — не одно и то же

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

Redux, при всех претензиях к его многословности, был полезен именно тем, что задавал очень строгую форму изменения состояния. Есть action, есть reducer, есть store, есть явный переход от одного состояния к другому. Эта строгость для маленького приложения часто ощущается как избыточность. Но для сложного — она нередко и есть главная ценность. Context же по своей природе намного свободнее. Он прекрасно подходит для распространения значения. Но то, как именно это значение меняется, вы организуете сами. И если приложение уже страдает не от prop drilling, а от хаотичных переходов состояния, Context сам по себе эту боль не снимает. Он просто перемещает её в другое место.

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

Решает не инструмент, а тип состояния, с которым вы имеете дело

Здесь очень полезно смотреть не на инструмент как таковой, а на тип состояния. Не всякое общее состояние одинаково по своей природе. Есть состояние глобального окружения: тема, локаль, авторизация, набор доступов, конфигурация интерфейса, подключённые сервисы. Оно обычно меняется относительно редко, потребляется широко и по смыслу действительно является контекстом для дерева компонентов. Для такого класса задач Context подходит почти идеально.

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

Очень показательный пример — данные приложения, полученные с сервера, и их многократное использование в разных местах UI. Допустим, у вас есть список сущностей, детальный просмотр, фильтрация, редактирование, подгрузка, optimistic updates, разные источники событий и, возможно, несколько экранов, завязанных на одни и те же куски состояния. Теоретически всё это можно держать в Context-провайдере и раздавать вниз через value. Но практически очень быстро возникает вопрос: а где модель изменений? Где граница между действиями и состоянием? Как устроено обновление? Где находится логика асинхронности? Context как механизм передачи значений не отвечает на эти вопросы. Их всё равно придётся решать самостоятельно.

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

Лес провайдеров не убирает сложность, а лишь распределяет её незаметно

Одна из самых частых зон путаницы возникает тогда, когда Context начинают использовать для всего подряд именно потому, что «теперь можно не пробрасывать props». В результате почти любой более или менее важный кусок состояния быстро оказывается поднят в какой-нибудь provider. Появляется ThemeContext, AuthContext, UserContext, AppContext, DataContext, UIContext, FiltersContext, ModalContext и ещё несколько слоёв, которые начинают обрастать логикой. На раннем этапе это может даже выглядеть красиво: всё разбито на аккуратные контексты, никакого Redux, всё локально. Но затем разработчик открывает корень приложения и видит лес провайдеров, а внутри каждого — свои методы, своя логика, свои маленькие правила жизни. То есть формальная централизация исчезла, но когнитивная сложность осталась, просто стала распределённой и менее явной.

Такой проект может оказаться даже труднее для понимания, чем Redux-приложение средней строгости. В Redux хотя бы есть единый язык: action, reducer, store, селектор, dispatch. С Context-слоями каждая команда начинает вырабатывать собственные локальные паттерны. Один контекст обновляется напрямую через setState, другой — через reducer, третий — через набор методов, четвёртый вообще совмещает чтение данных и побочные эффекты в одном provider. Для маленького проекта это не обязательно страшно. Для большого — это уже полноценный риск расползания архитектуры.

Очень важно и то, как Context влияет на производительность мышления, а не только рендера. Часто, когда обсуждают его как замену Redux, разговор быстро смещается к техническим деталям обновления подписчиков. Это важная тема, но не единственная. Не менее важно то, насколько легко разработчику понять, откуда приходит состояние, где оно меняется и кто на него влияет. Redux, опять же, выигрывал не только механизмом хранения, но и предсказуемой картиной изменения. Context такую картину не навязывает. Если команда не выстроила её сама, код начинает звучать менее строго. А в больших интерфейсах именно строгость модели изменений часто и является главным источником спокойствия.

Многим приложениям Redux был не нужен с самого начала

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

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

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

Стоит добавить загрузку и отмену запросов, и provider снова раздувается в центр управления

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

Стоит также помнить, что Context не отменяет ценность хороших границ компонентов. Иногда разработчики начинают использовать его слишком рано просто потому, что prop drilling раздражает психологически. Но не всякая передача props через два-три уровня — это архитектурная проблема. Иногда это честное отражение зависимости. Если промежуточный контейнер действительно организует данные для дочернего слоя, прокидывание props вполне нормально. Преждевременный переход на Context может сделать зависимости менее явными без реального выигрыша. То есть Context полезен не тогда, когда хочется убрать любой неудобный prop, а тогда, когда данные по смыслу действительно принадлежат общему поддереву и при этом не должны определять архитектуру нескольких промежуточных компонентов.

Без командной дисциплины Context перестаёт быть общим языком состояния

Есть и психологический нюанс в командной работе. Redux, при всех его недостатках, был очень легко узнаваемой школой организации состояния. Новый разработчик приходил в проект и быстро понимал, что здесь есть actions, reducers, store, selectors. С Context-ориентированным приложением многое сильнее зависит от того, насколько последовательно команда сама выработала паттерны. Без этого проект рискует стать набором разных локальных решений, формально объединённых словом Context, но по сути отличающихся от feature к feature. А это и есть один из самых типичных источников путаницы: инструмент вроде один, но каждая область приложения использует его по-своему.

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

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

Спрашивайте не «чем заменить Redux», а какая у приложения проблема

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

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

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

Если сформулировать совсем прямо: Context — это решение для prop drilling, а не модель управления состоянием; используйте его там, где он естественен, и не требуйте от него магии там, где нужна не магия, а дисциплина модели изменений.

Автор

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

Обновлено

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