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