React для галереи: как спроектировать UI, где много карточек, фильтров и превью
Текст написан с позиции июня 2015 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Когда речь заходит о галерее изображений, многие представляют себе что-то простое: сетка миниатюр, клик по картинке, открытие увеличенной версии. Но на практике интерфейс галереи почти никогда не ограничивается только этим. Очень быстро появляются фильтры, сортировка, категории, состояние загрузки, переключение размеров карточек, выделение выбранных элементов, блок с подробным просмотром, пагинация или бесконечная подгрузка. И как только все это собирается на одной странице, структура интерфейса начинает расползаться.
Самая вредная реакция на такую задачу — решить, что галерея «по сути простая» и разберется по ходу дела. Не разберется. В этот момент важно выбрать подход, который позволит держать разметку, состояние и пользовательские действия в порядке, а не превращать страницу в клубок обработчиков. Именно здесь React оказывается уместным инструментом — но уместным не потому, что он модный, а потому, что он навязывает дисциплину там, где ее легче всего потерять.
React к этому моменту уже перестал быть исключительно внутренней экзотикой Facebook и вошел в круг инструментов, которые обсуждают серьезно. Его ценят не за магию и не за обещание меньшего кода любой ценой, а за очень практичную вещь: интерфейс разбивается на небольшие самостоятельные компоненты, каждый из которых отвечает за свою часть поведения и отображения. Для галереи это почти идеальный сценарий. Здесь есть повторяющиеся элементы, есть состояние, которое должно влиять на разные зоны экрана, и есть множество мелких взаимодействий, которые сложно поддерживать, если все написано в одном большом шаблоне с ручной манипуляцией DOM.
Зафиксируем сразу мысль, к которой все дальнейшее будет сводиться: хороший UI галереи строится не от карточки, а от модели поведения. Это не вопрос вкуса в верстке, а вопрос того, во что превратится страница через полгода, когда фильтров станет вдвое больше, а к сетке добавятся еще два режима просмотра.
Начинать нужно не с карточки, а со сценариев пользователя
Если проектировать такой UI с позиции React, главное — не начинать с карточек. Это первая ошибка, которую часто допускают. Кажется, что раз на странице много изображений, значит, центральный элемент архитектуры — карточка. На деле карточка является лишь конечным представлением данных. Начинать нужно со сценариев пользователя и с общей композиции экрана. Пользователь приходит не смотреть на карточку как таковую, а искать нужный материал, отсеивать лишнее, сравнивать, открывать превью и быстро перемещаться по коллекции. Значит, структура интерфейса должна отражать именно эти действия.
Полезно сначала мысленно разделить экран на несколько зон. Обычно это панель фильтров, область списка или сетки, зона превью либо модальное окно, а также элементы служебной навигации: переключатели вида, сортировка, счетчик найденных элементов, иногда строка поиска. После этого уже можно переходить к компонентам. В React естественно собирать страницу как дерево: верхний контейнер галереи, внутри него панель управления, список карточек, отдельный блок превью и, при необходимости, компоненты статусов. Такой подход дает важное преимущество: мы можем провести довольно четкую границу между данными и тем, как они рисуются.
Состояние галереи поднимается наверх, а не размазывается по DOM
Самый верхний компонент обычно берет на себя текущее состояние галереи. Например, выбранную категорию, активные фильтры, порядок сортировки, текущую страницу, элемент, открытый в превью, и флаг загрузки. Не потому, что React требует держать все в одном месте, а потому, что эти данные влияют сразу на несколько дочерних частей интерфейса. Если фильтр изменился, обновиться должен и список карточек, и счетчик результатов, и иногда состояние пустой выдачи. Если пользователь щелкнул по миниатюре, об этом должен узнать блок превью. В классическом подходе без четкой компонентной структуры такие зависимости быстро превращаются в набор событий, обратных вызовов и селекторов DOM, которые со временем становятся хрупкими. В React же состояние можно поднимать на уровень выше и передавать вниз через свойства.
При этом не стоит понимать это слишком буквально и пытаться засунуть всю логику в один огромный корневой компонент. Важно не свалиться в другую крайность: чрезмерно толстый контейнер быстро становится таким же неудобным, как большой файл с jQuery-кодом. Хороший признак — если у каждого компонента есть ясная роль. Панель фильтров отображает доступные фильтры и сообщает наверх о выборе. Список карточек отвечает за раскладку и обход массива элементов. Карточка отвечает только за представление одного объекта: миниатюра, заголовок, подпись, метка, возможно кнопка действия. Компонент превью показывает подробности выбранного элемента. Если в коде эти обязанности размазаны, масштабирование интерфейса будет болезненным.
Данные галереи и параметры представления — это два разных пласта
Отдельный вопрос — как именно мыслить данными галереи. Самая устойчивая модель — считать, что есть исходный набор элементов и есть набор параметров представления. То есть сами изображения, подписи, категории, размеры, авторы или даты — это один пласт данных. А выбранные фильтры, режим сортировки, активный элемент, способ отображения — другой. Такой разрез помогает избежать путаницы. Мы не меняем сами карточки каждый раз, когда включается фильтр, мы лишь получаем новый список для отображения. Это очень хорошо сочетается с подходом React, где интерфейс получается как функция текущего состояния.
Почему это так важно? Потому что именно смешение этих двух пластов рождает большинство трудноуловимых багов в галереях. Когда фильтр начинает мутировать сами данные, а сортировка переставляет элементы в исходном массиве, восстановить исходное состояние становится почти невозможно. Разделение же дает простое правило: исходные данные неизменны, а представление — производная от них и от параметров. Любое действие пользователя меняет параметры, а не данные.
Карточка должна быть дисциплинированной, а не умной
Когда элементов много, сразу возникает вопрос производительности. Но до разговоров об оптимизации стоит сделать один шаг назад и проверить, нет ли архитектурной ошибки. Очень часто проблемы начинаются не из-за React, а из-за слишком тяжелой карточки. Если каждая миниатюра тянет за собой лишнюю логику, дополнительные вычисления и вложенные компоненты без реальной необходимости, сетка начинает тормозить уже на сравнительно небольшом количестве объектов. Поэтому карточка должна быть предельно дисциплинированной. Она должна получать уже подготовленные данные и не заниматься сложной работой при каждом рендере. Форматирование, фильтрацию и сортировку лучше делать на уровне списка или контейнера, а не внутри каждого элемента.
Есть и другая крайность — желание сделать карточку слишком универсальной, чтобы один и тот же компонент подходил вообще для всего: и для галереи фотографий, и для товаров, и для списка документов, и для избранного. На бумаге это выглядит красиво, но на практике универсальность часто оборачивается десятками условий, флагов и разросшимся набором свойств. Для галереи лучше исходить из реального сценария страницы. Да, компонент стоит проектировать с расчетом на повторное использование, но не в ущерб читаемости. Если вам уже приходится передавать в карточку полтора десятка свойств и ветвить разметку в нескольких местах, вероятно, логичнее выделить разные варианты представления, чем продолжать наращивать один универсальный блок.
Панель фильтров — это навигация, а не набор кнопок
Панель фильтров в галерее заслуживает особого внимания. Это не просто набор кнопок или выпадающих списков, а один из главных инструментов навигации. Значит, ее структура должна быть понятной, а изменения — предсказуемыми. В React удобно описать фильтры как отдельные компоненты: список категорий, переключатель типа сортировки, поле поиска, чекбоксы или теги. Главное, чтобы у них был единый контракт с родительским компонентом. Каждый фильтр не обязан знать о существовании остальных. Он должен только показать текущие значения и сообщить наверх, что пользователь изменил состояние. Тогда композиция остается чистой: контейнер галереи владеет актуальным набором активных фильтров, а дочерние компоненты лишь отображают его и инициируют изменения.
Это особенно полезно, когда фильтры начинают влиять друг на друга. Например, одна категория ограничивает набор доступных тегов, а строка поиска работает только внутри уже отфильтрованного списка. Если нет единого источника актуального состояния, подобные связи быстро превращаются в хаос. В React проще выстроить более понятную модель: любое действие пользователя приводит к изменению состояния на верхнем уровне, затем интерфейс полностью пересчитывается и получает новый вид. Такой ход сначала может показаться избыточным тем, кто привык обновлять только маленький кусочек DOM, но на практике он часто делает код яснее.
Превью — это не отдельный режим, а одно поле состояния
Следующий крупный кусок интерфейса — превью. Здесь есть два распространенных подхода. Первый: превью встроено в страницу как боковая панель или область над сеткой. Второй: превью открывается поверх интерфейса в модальном окне. В обоих случаях React помогает тем, что поведение можно описать через одно и то же состояние — выбранный элемент. Если он отсутствует, превью скрыто. Если выбран объект, соответствующий компонент получает данные и отображает их. Это избавляет от ручного открытия, закрытия, переноса контента и чистки старой разметки. Более того, становится проще поддерживать переходы между элементами, например кнопки «следующий» и «предыдущий» внутри режима просмотра.
Для модального превью, однако, важно не увлечься только визуальной частью. Хороший интерфейс должен учитывать и клавиатурное управление, и понятный способ закрытия окна, и то, как ведет себя фон страницы. React не решает эти вопросы автоматически, но помогает удерживать логику в одном месте. Модальное окно можно оформить как отдельный компонент, который появляется по условию и получает выбранный элемент через свойства. Тогда любые изменения в его содержимом происходят декларативно, без ручных вставок HTML и поиска нужных узлов по документу.
Состояния загрузки нужно закладывать в архитектуру с самого начала
Нельзя обойти стороной и вопрос загрузки данных. Если галерея живет на реальных данных, а не на заранее вшитом массиве, интерфейс должен внятно показывать промежуточные состояния. Загрузка, ошибка, пустой результат, частично подгруженный список — все это должно быть частью архитектуры с самого начала, а не добавляться потом в виде нескольких случайных условий. В React такие состояния удобно выражать прямо в рендере контейнера. Пока идет загрузка, показывается один компонент. Если пришла ошибка — другой. Если данные есть, отображается список. Если список после фильтрации пуст, пользователь видит сообщение, а не белый экран. Такой подход полезен еще и потому, что заставляет мыслить интерфейс как набор явных состояний, а не как одну счастливую ветку.
И здесь важно не обманываться: React не избавляет от необходимости продумать все эти состояния, он лишь делает их видимыми. Если о пустой выдаче или об ошибке не подумали заранее, никакой компонентный подход сам по себе их не нарисует. Зато он не дает забыть про них тихо: каждое состояние становится явной веткой в коде, а не неуправляемым побочным эффектом.
Сетка отвечает за обход элементов, а не за их данные
При проектировании сетки карточек важно не только то, что показывается внутри каждой карточки, но и то, как вся коллекция ведет себя в пространстве. Сейчас многие интерфейсы галерей строятся либо на плавающих блоках, либо на inline-block, иногда с более сложными решениями под masonry-подобную раскладку. React не диктует конкретный способ верстки, но он помогает удерживать структуру списка чистой. Список должен отвечать за обход элементов и генерацию карточек, а не за данные карточек как таковых. Особенно важно не забывать про корректные ключи для элементов списка. Это одна из тех вещей, которые кажутся технической мелочью, но сильно влияют на предсказуемость обновлений, особенно когда пользователь часто меняет фильтры или порядок сортировки.
Если галерея большая, со временем почти неизбежно встает вопрос: что делать с бесконечной лентой или пагинацией? Здесь не существует единственного правильного ответа. Пагинация проще для понимания и стабильнее с точки зрения контроля над данными. Бесконечная прокрутка выглядит современно и уменьшает число явных действий, но часто усложняет интерфейс, особенно если пользователь хочет вернуться к определенному месту, а фильтры и сортировка постоянно меняют состав выдачи. В контексте React хорошо то, что оба варианта могут укладываться в одну архитектуру состояния. Разница лишь в том, что в одном случае меняется номер страницы, а в другом — постепенно расширяется массив отображаемых элементов. Главное — заранее определить модель поведения, а не пытаться смешать обе схемы без необходимости.
Читаемое состояние важнее богатого интерфейса
Очень важная тема для галереи — управляемость. Чем богаче интерфейс, тем выше риск получить страницу, в которой пользователь не понимает, почему он видит именно этот набор карточек. Поэтому стоит делать состояние максимально читаемым. Если фильтры активны, это должно быть заметно. Если найдено мало элементов, это нужно объяснять не только числом, но и контекстом. Если выбрана сортировка по дате, заголовок или контрол должны явно об этом говорить. React помогает здесь тем, что представление строится из текущего состояния. То есть вместо набора разрозненных манипуляций можно думать так: вот объект состояния, а вот логичное его отображение в интерфейсе. Чем последовательнее этот принцип соблюдается, тем спокойнее развивается проект.
Нередко в галерее появляется требование к нескольким режимам просмотра. Например, компактные карточки для быстрого просмотра, крупные карточки для редакционного контента или список вместо сетки. В традиционной верстке добавление таких режимов нередко сопровождается копированием шаблонов и условной логикой в разных местах. В React можно подойти к этому аккуратнее. Либо список получает флаг режима и выбирает нужный компонент карточки, либо сама карточка умеет рендерить несколько вариантов представления. Что выбрать — зависит от того, насколько эти режимы похожи. Если различия поверхностные, разумен один компонент. Если режимы действительно разные по структуре, лучше выделить разные компоненты и не мучить один универсальный.
Чем больше состояния выносишь в props, тем труднее читать компонент
На этом месте появляется соблазн перенести всю логику в свойства и сделать интерфейс полностью управляемым извне. Это иногда оправдано, особенно если галерея должна встраиваться в разные части приложения. Но и здесь нужна мера. Слишком большое количество свойств часто делает компонент трудным для понимания. Полезно различать то, что действительно является внешней конфигурацией, и то, что относится к внутренней механике. Например, список доступных фильтров, исходные данные и стартовый режим отображения вполне могут задаваться извне. А вот локальное состояние наведения, временное раскрытие подсказки или состояние анимации не обязаны вытаскиваться наружу без необходимости.
Отдельно стоит сказать о маршрутизации состояния. Даже если галерея находится на одной странице, пользователю бывает полезно иметь возможность поделиться ссылкой на результат: с определенной категорией, поисковым запросом или открытым превью. Привычка рассматривать UI как нечто полностью временное, живущее только в памяти страницы, постепенно уходит — уже ясно, что часть состояния полезно отражать в адресной строке. Это делает интерфейс понятнее и устойчивее. React сам по себе не отвечает за роутинг, но благодаря четкому разделению состояния интегрировать такую возможность значительно проще. Если фильтры и выбранные сущности представлены явно, их можно синхронизировать с URL без полного переписывания приложения.
Эффекты добавляются последними, а не первыми
Еще одна практическая рекомендация — не смешивать визуальные эффекты с основной логикой. Галерея почти всегда стремится быть эффектной: плавные появления, затемнения, анимации открытия превью, переходы между состояниями. Но если сначала писать интерфейс как набор анимаций, а потом пытаться навесить на него структуру данных, получится ломкая конструкция. Гораздо устойчивее сначала собрать рабочую модель без декоративных зависимостей: есть фильтры, список, выбор элемента, загрузка, ошибки. И только потом постепенно добавлять эффекты. В таком случае React выступает не как средство сделать все красивым мгновенно, а как дисциплинирующий слой, который удерживает интерфейс от распада.
Многие опасаются JSX, особенно если привыкли жестко разделять шаблоны и JavaScript. Но именно в интерфейсе галереи преимущество такого подхода становится заметным. Разметка карточки тесно связана с данными и условиями отображения. Когда логика выбора классов, подписей, статусов и действий находится рядом с разметкой компонента, ее легче сопровождать. Конечно, при плохой дисциплине JSX тоже можно превратить в кашу. Но если компоненты небольшие и роли распределены правильно, код получается понятнее, чем набор разрозненных шаблонов и обработчиков. Для галереи, где повторяющихся и условных элементов особенно много, это ощутимый плюс.
Итог
Хороший UI для галереи в React строится не от миниатюры и не от модного инструмента, а от ясной модели поведения. Нужно понимать, какие части состояния действительно важны, какие компоненты владеют логикой, а какие только отображают данные, где проходит граница между контейнерами и представлением, и каким образом пользователь перемещается по коллекции. Как только эта модель появляется, интерфейс с карточками, фильтрами и превью перестает казаться хаотичным набором блоков. Он становится системой, которую можно развивать: добавлять новые типы фильтров, режимы просмотра, источники данных, состояния загрузки и даже новые страницы, не ломая уже написанное.
Важно не перепутать причину и следствие. React сам по себе не делает галерею хорошей и не решает за вас ни один из перечисленных вопросов автоматически. Его ценность не в обещании меньшего кода, а в том, что он заставляет проектировать UI как иерархию компонентов с явными данными и понятным потоком изменений. Для галереи, где повторяемость элементов сочетается с богатым взаимодействием, это, пожалуй, самое важное качество. Если начать с правильной структуры, даже большая коллекция карточек, фильтров и превью перестает быть пугающей и превращается в просто хорошо организованный интерфейс.
Если сформулировать совсем прямо: проектируйте галерею не от карточки, а от состояния — решите, какие данные владеют интерфейсом и кто их держит, и тогда фильтры, превью и сетка соберутся как функция этого состояния, а не как набор взаимозависимых обработчиков, которые придется чинить через полгода.