Redux: зачем ещё один слой абстракции и почему про него все говорят
Текст написан с позиции сентября 2015 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Если последние месяцы вы следите за тем, что происходит вокруг React, Flux и клиентских приложений на JavaScript, то наверняка уже заметили слово, которое все чаще всплывает в обсуждениях: Redux. Кто-то называет его очень элегантной реализацией идей однонаправленного потока данных, кто-то — слишком умной конструкцией ради не самой большой проблемы, а кто-то осторожно присматривается и пытается понять, зачем вообще нужен еще один слой абстракции, если до этого мы уже пережили и MVC-подходы, и собственные Flux-архитектуры, и массу локальных решений для хранения состояния.
Скепсис здесь понятен. JavaScript-сообщество умеет плодить инструменты с такой скоростью, что иногда создается впечатление, будто новый проект появляется просто потому, что автору не понравилось, как названа переменная в предыдущем. Поэтому естественный вопрос звучит так: Redux действительно решает реальную проблему — или просто предлагает еще один красивый словарь терминов поверх уже известных идей?
Зафиксируем сразу честную рамку. Redux — это не революция и не магическая новинка, которая делает фронтенд проще. Это сдвиг в том, как мы думаем о состоянии приложения. И как у любого сдвига, у него есть цена: больше явного кода, новый стиль мышления, дисциплина неизменяемости. Чтобы понять, окупается ли эта цена, начинать нужно не с самого Redux, а со среды, в которой он стал обсуждаться.
Современный фронтенд все меньше похож на набор статических страниц с отдельными эффектами и все больше — на полноценный интерфейс приложения. У нас есть сложные формы с проверкой, списки с фильтрацией, асинхронная загрузка данных, состояние авторизации, модальные окна, клиентская навигация, редакторы, панели управления, уведомления, а иногда и целые экраны, где одновременно живут десятки независимых, но связанных между собой состояний. Именно здесь и возникает настоящий вопрос — не про разметку, а про жизнь данных.
Проблема не в рендеринге, а в том, как организована жизнь данных
На раннем этапе почти любой интерфейс кажется управляемым. Достаточно завести несколько переменных, пару обработчиков событий, сохранить состояние в компоненте или прямо в объектах модели — и приложение выглядит рабочим. Но затем наступает знакомый момент: одно изменение в форме влияет на другой блок, завершение запроса должно обновить три части страницы, переключение маршрута требует сбросить часть состояния, а видимость модального окна внезапно зависит от результата действий в совершенно другом месте.
И вот тут выясняется главное: проблема не в разметке и не в рендеринге, а в том, как вообще организована жизнь данных в приложении. Поверхностная реакция на такую боль — добавить еще обработчиков и аккуратнее их связать. Но это лечение симптома. Источник в другом: состояние размазано по компонентам и объектам, меняется из множества мест, и никто уже не может уверенно сказать, почему интерфейс оказался именно в этом виде.
Flux навел порядок, но заплатил церемонией
Именно на этом фоне набрали популярность идеи Flux. Их главная ценность была не в конкретной библиотеке, а в попытке навести порядок там, где раньше слишком часто царили двусторонние связи и неочевидные зависимости. Вместо хаотичных обновлений всего отовсюду предлагался прямой маршрут: есть действие, есть диспетчер, есть хранилища, есть представление, и данные двигаются в одном направлении. Для больших интерфейсов это оказалось полезной дисциплиной.
Но у Flux быстро проявилась и другая сторона. Формально схема была понятной, однако конкретные реализации нередко получались многословными. Появлялись диспетчеры, константы, несколько хранилищ, события изменения, шаблоны подписки — и во всем этом было немало церемонии. Многие соглашались с направлением мысли, но хотели более компактной и ясной модели. И здесь важно не перепутать: проблемой был не сам Flux, а то, что каждая команда заново изобретала его инфраструктуру, и каждый такой неконтролируемый слой стоил дорого.
Redux не отрицает Flux — он радикально упрощает его подачу
Redux оказался в очень удачной позиции. Он не пришел отрицать идеи Flux. Скорее наоборот: он предложил упростить их до предела. Вместо множества хранилищ — одно дерево состояния. Вместо объектов, которые сами меняют свои данные и рассылают события, — чистые функции, которые получают предыдущее состояние и действие, а возвращают новое. Вместо сложной инфраструктуры вокруг обновлений — предельно прямой поток: вы отправляете действие, система вычисляет следующее состояние, представление получает обновленные данные.
На бумаге это выглядит почти слишком просто. Именно поэтому первая реакция на Redux у многих звучит так: «И ради этого столько разговоров?» Но в этой простоте и заключается главная мысль. Redux добивается предсказуемости не за счет увеличения числа сущностей, а за счет ограничения свободы. Вы не меняете состояние как попало. Вы не разбрасываете обновления по нескольким местам. Вы не заставляете объекты тайно менять самих себя. Вы описываете, что произошло, и получаете новое состояние как результат явного вычисления.
Главное в Redux — не хранение данных, а предсказуемость
Это важный сдвиг в мышлении. В обычном клиентском коде разработчик мыслит категориями «возьми этот объект и обнови ему поле», «если пришли данные, допиши их сюда», «если нажали кнопку, открой этот блок». Все просто, пока приложение небольшое. Но чем больше таких ручных шагов, тем сложнее ответить на базовые вопросы: почему интерфейс в этом состоянии, кто изменил этот фрагмент данных, в какой последовательности пришли обновления, можно ли воспроизвести ошибку пользователя после серии действий.
Redux переводит разговор в другую форму: не «кто и что поменял внутри», а «какое действие произошло и как оно преобразовало предыдущее состояние». Если сформулировать совсем прямо, Redux ценят не за то, что он умеет хранить данные — это умеют почти все. Его ценят за предсказуемость поведения. Когда все значимые изменения проходят через явные действия, а само состояние меняется в одном понятном процессе, приложение становится легче понимать. Не обязательно маленьким. Не обязательно магически более быстрым. Но заметно более обозримым.
React отвечает за отображение, Redux — за данные приложения
Особенно это чувствуется в приложениях на React. React хорошо решает задачу отображения интерфейса как функции состояния: компоненты получают данные и рисуют соответствующее представление. Но сам по себе React не диктует, где и как жить данным приложения. Локальное состояние компонента прекрасно подходит для отдельных вещей — открыт ли выпадающий блок, какое значение введено в поле до отправки, активна ли вкладка внутри маленького виджета. Проблема начинается, когда данные используются в нескольких местах сразу.
Вот почему Redux так часто обсуждают рядом с React. Он не заменяет компонентную модель и не делает интерфейс за вас. Он отвечает именно на вопрос о данных приложения, причем ответ довольно строгий. Состояние находится в одном хранилище. Компоненты не меняют его напрямую — они инициируют действия. Дальше редьюсеры, то есть функции преобразования, определяют следующее состояние. После этого React получает повод обновить интерфейс. Такая схема многим кажется логичной почти сразу, потому что хорошо согласуется с идеей однонаправленного потока.
Маленькому приложению Redux не нужен — и это нормально
Но зачем нужен еще один слой абстракции, если можно написать все это вручную? Теоретически — можно. Более того, в действительно небольшом приложении, возможно, и нужно. Не стоит превращать Redux в обязательный ритуал. Если у вас два экрана, один список и один фильтр, отдельный глобальный механизм хранения состояния почти наверняка не успеет окупиться. Здесь важно не свалиться в другую крайность и не тащить тяжелую архитектуру туда, где ее цена выше пользы.
Проблема в том, что приложения редко остаются маленькими надолго. Когда в кодовой базе начинает накапливаться разрозненная логика обновлений, становится ясно: отсутствие явной модели — это тоже архитектурное решение, только обычно не самое удачное. Redux привлекает тем, что дает общую дисциплину раньше, чем проект окончательно потеряет форму. Если завтра в нем возникнет ошибка, вы хотя бы будете понимать, где искать цепочку изменений; если понадобится добавить функциональность — будете знать, куда вписать ее в поток данных.
Редьюсер пугает названием, но устроен предельно просто
Слово «редьюсер» поначалу отпугивает. Оно звучит так, будто речь о чем-то математическом и ненужном обычной веб-разработке. На деле идея проста: редьюсер берет текущее состояние и действие, после чего возвращает новое состояние. Не модифицирует старое, не рассылает события, не обращается к DOM — просто вычисляет результат. Такая форма оказывается на удивление удобной.
Во-первых, ее легко тестировать: на входе данные, на выходе данные, никаких скрытых зависимостей. Во-вторых, она вынуждает отделять чистую логику преобразования от побочных эффектов и интерфейсного шума. В-третьих, несколько маленьких редьюсеров понять легче, чем один большой объект, который хранит состояние и одновременно знает, как себя менять. В этом и состоит суть подхода: не объект, который тайно изменяет себя, а функция, которая явно вычисляет следующий шаг.
Понятность модели и есть причина шума
Во фронтенде немало инструментов, которые решают проблему ценой собственной внутренней сложности. Пользоваться ими можно, но объяснить их другому человеку трудно. С Redux ситуация обратная: после короткого знакомства модель пересказывается буквально в нескольких фразах. Есть состояние. Есть действия. Есть функция, которая из старого состояния и действия получает новое. Есть представление, подписанное на изменения. Такая компактность заразительна — люди любят идеи, которые можно быстро понять и сразу примерить на свой проект.
Отсюда же растет и мода. Когда сообщество находит удачную формулировку старой боли, вокруг нее немедленно возникает шум выше среднего. Кто-то начинает применять Redux везде подряд, включая задачи, где он явно не нужен. Кто-то пишет статьи с ощущением, будто без него уже нельзя строить ни одно приложение. К этому стоит относиться спокойно: почти любой заметный инструмент проходит фазу переоценки. Важно отделять полезную идею от ажиотажа вокруг нее.
Честные возражения против Redux — и риск завести его формально
Есть и вполне разумные возражения. Кому-то не нравится идея единственного хранилища — кажется искусственной или слишком централизованной. Кто-то считает, что для реальной жизни удобнее объекты с методами, а не функции преобразования. Кто-то не готов постоянно следить за неизменяемостью данных и считает это дисциплиной, которая не всегда оправдана. Эти сомнения не надуманны: Redux требует определенного стиля мышления и не обязан подходить всем проектам одинаково.
Более того, есть риск использовать Redux формально и не получить почти никакой пользы. Можно завести действия и редьюсеры, но продолжать думать о приложении как о наборе случайных обработчиков. Можно сделать одно гигантское состояние без структуры и получить новую форму хаоса — только уже под правильными названиями. Можно механически выносить туда все подряд, включая чисто локальные детали интерфейса, и тем самым утяжелить архитектуру. Redux не спасает от плохих решений автоматически. Он лишь дает рамку, внутри которой хорошие решения принимать проще. И здесь важно не обманываться: инструмент не отменяет дисциплину, а только делает ее возможной.
Популярность Redux — признак взросления фронтенда
Если смотреть шире, шум вокруг Redux говорит о зрелости фронтенда как профессии. Совсем недавно основная энергия уходила на то, чтобы вообще научиться собирать сложные интерфейсы в браузере. Теперь внимание смещается на следующий уровень: как сделать эти интерфейсы поддерживаемыми, понятными и устойчивыми. Именно поэтому так активно говорят о потоках данных, состоянии приложения, детерминированности обновлений, тестируемости и композиции. Это не упрощение фронтенда, а его взросление.
Для команд это особенно важно. Пока код пишет один человек, он еще удерживает систему в голове, опираясь на привычки и память. Но когда над интерфейсом работают несколько разработчиков, неявные правила перестают работать. Нужна общая модель, которую можно быстро объяснить новому участнику. Нужны понятные места, куда добавляются изменения. Нужна возможность разбирать ошибки без археологических раскопок по всем обработчикам событий. Redux привлекателен не только как техническое решение, но и как договоренность о структуре проекта — а это и есть то, что определяет жизнь команды через полгода.
Строгая модель не мешает собирать логику из маленьких частей
Несмотря на внешнюю строгость, Redux позволяет строить логику из маленьких частей. Состояние можно делить по доменам, редьюсеры — объединять, действия — группировать по смыслу. Это хорошо согласуется с модульным устройством приложения. Архитектура не обязана превращаться в монолитный центр управления всем. Наоборот, при аккуратном подходе получается чистое разложение по областям ответственности, где каждая часть знает только про свой фрагмент состояния и свой набор действий.
Нельзя недооценивать и образовательный эффект. Даже если через год ваше приложение будет использовать не Redux в чистом виде, а что-то другое, опыт работы с ним полезен уже тем, что заставляет всерьез задуматься о природе состояния. Многие проблемы в клиентской разработке маскируются под «сложную верстку» или «капризный интерфейс», хотя их источник — неясная модель данных и переходов между состояниями. Redux делает эту тему видимой. Он буквально вынуждает формулировать, что хранится в приложении, какие события возможны и как одно преобразуется в другое.
Вывод
Так зачем нужен еще один слой абстракции? Затем, что иногда хороший слой не скрывает реальность, а делает ее яснее. Redux не добавляет сущности ради статуса — он сокращает число способов, которыми приложение может прийти в неожиданное состояние. Он не отменяет необходимость думать, но помогает думать в более строгих категориях. А почему про него все говорят? Потому что сообщество давно искало достаточно простой язык для разговора о сложных приложениях, и Redux дал этот язык вовремя, объединив однонаправленный поток данных, функциональное преобразование состояния и предсказуемую структуру в форму, которую легко объяснить, попробовать и обсудить.
Если ваш интерфейс уже напоминает не страницу, а живую систему со множеством связанных состояний, относитесь к Redux не как к модному ярлыку и не как к обязательному ритуалу, а как к инструменту дисциплины: внедряйте его тогда, когда стоимость хаоса в данных начинает превышать стоимость явных действий и редьюсеров, но не раньше.