Feature-Sliced Design: разумный способ структурировать большой React-проект

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

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

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

Это особенно заметно в тот момент, когда проект перестает быть “просто интерфейсом” и становится полноценной системой: с ролями, сценариями, асинхронностью, несколькими командами, большой поверхностью UI и постоянно растущими бизнес-требованиями. На таком масштабе недостаточно просто иметь аккуратные папки. Нужна структура, которая отражает способ развития продукта, а не только технические категории файлов. И именно здесь Feature-Sliced Design выглядит не как модная схема именования директорий, а как попытка ответить на очень практический вопрос: как сделать так, чтобы большой React-проект можно было понимать, расширять и поддерживать без постоянного ощущения, что любая новая фича рискует расползтись по половине репозитория.

Самая вредная реакция на любой архитектурный подход — услышать слово “методология” и решить, что теперь порядок наведется сам. Сила Feature-Sliced Design не в том, что он магически решает все архитектурные проблемы; таких решений вообще не существует. Его сила в другом: он не привязывает структуру кода ко вкусам конкретного разработчика, к привычкам прошлой команды или к тому, какая библиотека сейчас популярнее, — он привязывает ее к тому, как устроены реальные пользовательские возможности, сущности и сценарии системы.

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

Почему обычная структура React-проекта быстро перестает работать

Почти у каждой команды есть свой исторический способ раскладывать React-код. Кто-то любит делить по техническим сущностям: components, api, models, hooks, constants. Кто-то предпочитает группировку по страницам. Кто-то строит почти библиотечный подход, где все мыслится через набор общих UI-примитивов и модулей данных. Все эти подходы на маленьком и среднем проекте могут выглядеть вполне рабочими. Проблемы начинаются тогда, когда бизнес-логика становится сложнее, чем сама механика рендера компонентов.

Деление по типу файлов удобно до определенного предела. Оно хорошо отвечает на вопрос “что это за сущность технически?”, но плохо отвечает на вопрос “зачем это существует в продукте и кто за это отвечает?”. В папке components могут лежать вещи совершенно разного уровня: от базовой кнопки до сложного блока оформления заказа. В hooks может оказаться и небольшой UI-хук, и полноценный слой сценарной логики. В services начинают жить и запросы к API, и оркестрация пользовательских действий, и иногда даже куски бизнес-правил. Формально все классифицировано. Практически — связи становятся мутными.

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

Главная ценность FSD: структура начинает повторять продукт

Feature-Sliced Design интересен прежде всего тем, что предлагает сменить оптику. Вместо вопроса “в какую техническую папку положить этот файл?” возникает другой вопрос: “какой уровень ответственности у этого кода, к какой части продукта он относится и кто должен иметь право от него зависеть?”. Это гораздо более полезный вопрос для большого проекта.

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

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

Слои как способ задать иерархию ответственности

Одна из самых сильных идей Feature-Sliced Design — мыслить проект через слои. Но важно правильно понимать, что именно здесь дают слои. Это не просто декоративная иерархия и не попытка имитировать академическую многослойность ради солидности. Смысл слоев в том, чтобы задать направление зависимостей и уровень абстракции.

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

Эта схема ценна не тем, что красиво выглядит на диаграмме. Она ценна тем, что делает архитектурный вопрос очень конкретным: может ли один слой зависеть от другого? Что вправе знать страница о фиче? Должна ли сущность знать о виджете? Имеет ли право shared-код тянуть зависимости из бизнес-частей? Как только такие вопросы формализуются, проект становится менее хаотичным.

В обычных React-проектах без явной иерархии зависимостей код часто течет как получится. Компоненты верхнего уровня знают слишком много о деталях. Низкоуровневые части внезапно начинают импортировать бизнес-логику. Общие папки засоряются вещами, которые на самом деле давно уже принадлежат конкретной фиче. Слои в FSD нужны именно для того, чтобы такое размывание не становилось нормой.

Entities: когда предметная область получает собственное место

Очень многие фронтенд-проекты долго страдали от одной и той же проблемы: предметные сущности продукта фактически не имели собственного архитектурного дома. Пользователь, статья, комментарий, товар, заказ, уведомление — все это где-то присутствовало в системе, но не было понятно, где проходит граница их ответственности. Частично данные жили в store, частично типы лежали в types, куски UI размазывались по страницам, а отдельные операции оседали в сервисах и хуках.

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

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

Важный нюанс тут в том, что сущность в FSD — это не “все, что хоть как-то касается объекта”. Это именно базовый уровень предметного представления, а не место для произвольной сценарной логики. И если эту меру выдерживать, архитектура начинает становиться ощутимо чище.

Features: наконец-то логика пользовательских возможностей не прячется по углам

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

Обычно эта логика либо размазывается по страницам, либо живет в неопределенном наборе хуков и сервисов. В какой-то момент разработчики начинают чувствовать, что именно продуктовые действия являются реальной единицей изменения, но структура проекта им этого не подсказывает. FSD делает это явным. Feature — это не просто кусок интерфейса, а завершенный пользовательский сценарий или возможность.

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

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

Widgets и Pages: композиция без сваливания всего на страницу

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

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

Такое разделение очень помогает. Страница перестает быть местом, где лежит вся промежуточная логика мира. Она начинает отвечать за сборку и размещение крупных блоков. А сами блоки получают право быть достаточно самостоятельными, чтобы внутри себя комбинировать более мелкие части. Это делает архитектуру не только чище, но и реалистичнее. Экран ведь почти никогда не состоит из “одной страницы и множества мелких компонентов”. Обычно там действительно есть уровень значимых секций, и FSD это признает.

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

Shared — это не “папка для всего общего”

У любого подхода есть место, которое команды особенно легко портят, и в FSD таким местом почти наверняка станет shared. Потому что как только в проекте появляется слой “общего”, возникает очень сильный соблазн складывать туда все, что пока не хочется осмыслять. Это знакомая болезнь. Папка с общими компонентами, общими утилитами и общими хелперами очень быстро превращается в архив архитектурной нерешительности.

Но в зрелом применении FSD shared не должен быть мусорным контейнером. Это слой действительно низкоуровневых, инфраструктурных и независимых от предметной области вещей. Базовый UI-kit, утилитарные функции, адаптеры окружения, настройки, низкоуровневые API-клиенты, общие типы для инфраструктуры — вот его территория. Если в shared начинают попадать куски, смысл которых связан с конкретным пользователем, заказом, статьей или сценарием продукта, архитектура уже начинает терять дисциплину.

Именно здесь проявляется зрелость команды при работе с FSD. Важно не свалиться в крайность и не решить, что раз слой называется shared, то любая зависимость в нем заведомо безобидна. Подход помогает, но не спасает от соблазна обобщать неправильно. Если shared используется как место для “пока не знаем куда положить”, то через несколько месяцев получится тот же хаос, только с более красивыми названиями слоев.

Сегменты внутри слайсов: порядок на локальном уровне

Сама идея slice в FSD особенно хороша тем, что позволяет держать рядом связанные куски одной ответственности. Но даже внутри slice нужен локальный порядок. И здесь появляется дополнительная полезная дисциплина: сегменты вроде ui, model, api, lib и им подобных. Это уже не глобальное деление всего проекта по техническим папкам, а локальная внутренняя организация конкретного модуля.

Разница принципиальная. Когда весь проект делится на глобальные components и hooks, вы теряете продуктовый контекст. Когда же внутри фичи или сущности есть собственные ui и model, вы сохраняете и контекст, и понятную внутреннюю структуру. Это очень сильная комбинация. Она дает и близость связанных частей, и предсказуемость их устройства.

По сути FSD не отрицает технические категории как таковые. Он лишь говорит, что они должны быть вложены в смысловые границы, а не определять архитектуру целиком. Это и делает подход таким практичным: он не требует отказаться от здравого порядка, а просто ставит его на правильный уровень.

Почему FSD особенно хорош для больших команд

На маленьком проекте многое можно держать в голове. Там даже спорная структура иногда живет удивительно долго просто потому, что один-два разработчика знают весь код почти наизусть. Но когда над приложением работает несколько человек или несколько команд, в игру вступает другой фактор — коллективная понимаемость системы.

Большому проекту недостаточно просто “работать”. Он должен быть устроен так, чтобы новый человек мог сравнительно быстро понять, где что живет, не копаясь неделями в исторических слоях. Ему нужно, чтобы архитектура подсказывала, где искать логику сценария, где находится предметная сущность, где допустимо переиспользование, а где лучше не тянуть зависимость. И вот здесь FSD действительно помогает.

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

Что FSD реально улучшает в повседневной разработке

Архитектурные подходы легко обсуждать слишком абстрактно, как будто их ценность измеряется только красотой принципов. Но у Feature-Sliced Design есть вполне приземленные плюсы. Во-первых, новая фича или изменение старой реже размазываются по случайным местам проекта. Во-вторых, легче локализовать ответственность: если ломается сценарий, связанный с конкретной возможностью, область поиска уже меньше. В-третьих, становится проще решать, куда должен попасть новый код. Не идеально автоматически, конечно, но гораздо понятнее, чем в бесформенном наборе глобальных папок.

Еще один важный плюс — снижение соблазна преждевременного переиспользования. Когда структура ориентирована на срезы и уровни ответственности, легче удержаться от того, чтобы тащить в “общие компоненты” все, что просто дважды встретилось в продукте. Код сначала живет там, где ему принадлежит смысл. И только если становится ясно, что это действительно инфраструктурный или повторяемый примитив, он поднимается выше. Это гораздо здоровее, чем обратный путь.

Наконец, FSD помогает разделять изменение продукта и изменение платформы проекта. Новая пользовательская возможность чаще всего должна проявляться на уровне feature или widget, а не расползаться сразу по shared и глобальным техническим каталогам. Это делает эволюцию системы менее нервной.

Где можно легко перегнуть палку

При всех достоинствах FSD не стоит превращать в религию. Как и любой архитектурный подход, он легко портится, если команда начинает использовать его механически. Самая частая ошибка — создавать слои и слайсы ради самих слоев и слайсов, а не ради реальной структуры ответственности. Тогда проект обрастает красивыми каталогами, но не становится понятнее.

Вторая распространенная ошибка — дробить слишком мелко. Не каждая кнопка — отдельная feature. Не каждый кусок отображения — widget. Не каждый тип объекта заслуживает выделения в самостоятельную entity. Если резать проект без чувства меры, получится не прозрачная архитектура, а бюрократия директорий. Разработчик будет тратить больше сил на выбор “правильного места”, чем на саму задачу.

Третья ошибка — называть слои правильно, но нарушать их смысл. Это особенно коварно. Например, feature внезапно начинает знать слишком много о странице, entity тянет детали UI-оркестрации, shared содержит половину бизнес-логики, а widgets становятся страницами под другим именем. Формально FSD как будто есть. Фактически — архитектурный долг все равно накапливается.

То есть подход требует не слепого следования схеме, а постоянной честности в вопросе: отражает ли текущая структура реальные границы ответственности? Если нет, одних названий папок недостаточно.

Это не silver bullet, а хороший способ задавать правильные вопросы

Самое зрелое отношение к Feature-Sliced Design — видеть в нем не чудодейственный рецепт, а систему хороших архитектурных вопросов. Что здесь является сущностью? Где заканчивается одна пользовательская возможность и начинается другая? Что относится к странице, а что должно быть самостоятельным блоком? Что действительно общее, а что лишь случайно повторилось пару раз? Каким слоям вообще позволено зависеть друг от друга?

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

Почему этот подход набирает вес именно сейчас? Потому что React-проекты к 2021 году уже достаточно выросли, чтобы проблема структуры стала не теоретической, а повседневной. Нужен был не просто очередной набор папок, а способ меньше путать продуктовую логику с технической механикой. Feature-Sliced Design предлагает именно это направление.

Когда такой подход особенно уместен

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

Особенно хорошо FSD чувствует себя там, где команда уже столкнулась с болью “у нас вроде все разложено, но менять тяжело”. Это как раз та ситуация, где нужно не косметическое переименование папок, а другой способ мыслить структуру. И если внедрять его постепенно и без фанатизма, эффект может быть очень практическим.

По сути, Feature-Sliced Design — это один из редких архитектурных подходов, который не пытается выглядеть гениальнее задачи. Он не строит чрезмерных теорий. Он просто довольно здраво говорит: большой фронтенд лучше организовывать вокруг того, как устроен продукт и как развиваются его возможности. Для React-мира, который долго жил между хаотичной свободой и избыточной церемониальностью, это на удивление разумный компромисс.

Итог

Feature-Sliced Design выглядит привлекательным не потому, что предлагает очередную красивую схему директорий, а потому, что помогает вернуть архитектуру фронтенда к реальным единицам смысла. Сущности получают свое место. Пользовательские возможности перестают прятаться по техническим папкам. Страницы разгружаются за счет виджетов. Общий код перестает быть оправданием для бесформенной свалки. А зависимости между частями системы становятся чуть менее случайными.

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

Поэтому разумнее всего воспринимать Feature-Sliced Design как зрелый способ структурировать код там, где приложение уже живет не как набор экранов, а как развивающийся продукт. Не как догму, а как рабочую карту. FSD не делает архитектуру правильной за вас — он лишь делает правильный порядок естественнее, а архитектурный долг заметнее; и для большого React-проекта, где логика иначе расползается тонким слоем по репозиторию, этого уже достаточно, чтобы подход окупался.

Автор

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

Обновлено

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