Роутинг в React-приложении: как проектировать экранную навигацию, а не набор ссылок

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

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

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

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

Именно поэтому о роутинге в React уже полезно говорить не как о технической настройке, а как о проектировании экранной навигации. Клиентские приложения становятся все крупнее, а React все чаще используется не для отдельных виджетов на странице, а для полноценных интерфейсов с несколькими разделами, вложенными состояниями, фильтрами, авторизацией, данными с сервера и достаточно долгими пользовательскими сценариями. В такой среде адрес перестает быть только строкой в браузере. Он начинает выражать состояние экрана, место пользователя в приложении и его путь через систему.

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

Сначала экраны, потом ссылки — а не наоборот

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

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

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

React дает свободу композиции, но возвращает ответственность за границы экранов

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

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

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

Маршрут — это не единица рендера, а навигационный смысл

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

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

Граница между состоянием экрана и состоянием приложения проходит через адрес

Особенно болезненной темой становятся фильтры, сортировка, поиск и другие параметры списка. Как только в приложении появляется хоть сколько-нибудь сложный список, возникает вопрос: должны ли эти параметры отражаться в URL? С точки зрения набора ссылок ответ часто случайный. Где-то отражаются, где-то нет, в зависимости от того, как было удобнее написать. Но если смотреть на приложение как на систему экранной навигации, вопрос звучит яснее: является ли текущее состояние списка самостоятельным состоянием экрана, которое пользователь может захотеть сохранить, отправить другому человеку, восстановить после обновления страницы или вернуть по кнопке «назад»? Если да, параметры логично выносить в маршрут или адресные параметры. Если нет, возможно, это локальное состояние интерфейса, которому не нужен собственный URL.

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

История браузера — это тоже предмет проектирования, а не побочный эффект

Еще один важный момент — работа с историей браузера. В обычном многостраничном сайте это поведение во многом складывается само собой: переход открыл новую страницу, браузер добавил запись в историю. В клиентском React-приложении вам нужно гораздо внимательнее думать о том, какие действия должны восприниматься как реальные переходы между экранными состояниями, а какие нет. Если каждый незначительный сдвиг интерфейса начинает создавать новую точку в истории, кнопка «назад» превращается в источник раздражения. Если, наоборот, значимые переходы не попадают в историю, пользователь теряет ощущение маршрута через приложение. Проектировать навигацию — значит в том числе проектировать и поведение истории, а не только набор доступных URL.

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

Роутинг связан с данными не меньше, чем с компонентами

В крупных React-приложениях все заметнее, что роутинг тесно связан не только с компонентами, но и с данными. Переход на новый экран почти всегда означает необходимость получить другой набор данных, показать загрузку, возможно, сбросить часть предыдущего состояния или, наоборот, сохранить его для возврата. Если маршруты спроектированы как случайный список адресов, эти переходы начинают сопровождаться хаотичной логикой загрузки и очистки. Если же роутинг продуман как система экранных состояний, гораздо проще понять, какие данные принадлежат конкретному экрану, когда они должны загружаться и что именно должно происходить при входе и выходе из контекста.

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

Адреса должны быть концептуально устойчивыми, а не отражать структуру кода

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

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

Не все состояния заслуживают адреса — зрелость в отборе

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

Отдельно стоит сказать о модальных и промежуточных состояниях, потому что в React-приложениях они встречаются очень часто. Открытие превью, редактирование поверх списка, просмотр детали в диалоге, подтверждение действия — все это создает соблазн либо полностью игнорировать URL, либо, наоборот, немедленно привязать к маршруту любой модальный шаг. Здесь снова помогает вопрос о навигационном смысле. Если модальное состояние достаточно значимо, чтобы им делиться, возвращаться к нему по истории и считать его частью экранного сценария, возможно, ему стоит иметь отражение в адресе. Если это чисто временное вспомогательное окно, не стоит перегружать им роутинг. Главное — принимать это решение осознанно, а не по случайному удобству реализации.

Layout-уровни превращают навигацию из прыжков в плавное изменение состояний

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

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

Предсказуемость перехода важнее, чем сам факт перехода

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

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

Итог

В React-проекте роутинг особенно выигрывает от того, что его можно обсуждать вместе с дизайном экранов еще до финальной реализации. Это важное изменение по сравнению с эпохой, когда маршрутизация часто воспринималась как техническая проблема веб-сервера или шаблонной системы. Теперь навигация — часть клиентской архитектуры, а значит, ее можно и нужно проектировать как часть UX. Не обязательно рисовать огромные схемы, но полезно понимать карту экранов, основные переходы, точки возврата, глубину вложенности и отношение URL к состояниям интерфейса.

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

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

Автор

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

Обновлено

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