Архитектура больших React приложений: Feature-Sliced Design

18 ноября 2026
Автор

Антон Ларичев

Что такое Feature-Sliced Design

Feature-Sliced Design (FSD) — это архитектурная методология для фронтенд-приложений. Она решает главную проблему роста кодовой базы: когда приложение перестаёт помещаться в голове одного разработчика и изменения в одном месте ломают несвязанные части.

FSD строит приложение из трёх понятий: слои (layers), слайсы (slices) и сегменты (segments). Каждый слой имеет строго определённую ответственность, а зависимости между ними идут только сверху вниз.

Курс по теме

Пройти курс React и Redux Toolkit

40 000+ студентов · рейтинг 4.8 · гарантия возврата 30 дней

Структура слоёв

Все слои располагаются в корне src/ и образуют иерархию от общего к конкретному:

src/
  app/
  pages/
  widgets/
  features/
  entities/
  shared/

Правило одно: слой может импортировать только из слоёв, которые находятся ниже него. features может использовать entities и shared, но никак не pages или widgets.

shared

Самый нижний слой — переиспользуемые элементы без привязки к бизнес-логике. Здесь живут UI-компоненты, утилиты, конфигурация API, типы.

shared/
  ui/
    Button/
    Input/
    Modal/
  api/
    instance.ts
  lib/
    formatDate.ts
    formatPrice.ts
  config/
    routes.ts
  types/
    pagination.ts

Компоненты в shared/ui не знают о бизнес-сущностях. Button — это просто кнопка, без знания о том, что она будет добавлять товар в корзину.

// shared/ui/Button/Button.tsx
import { ButtonHTMLAttributes, FC, ReactNode } from 'react';

interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
  variant?: 'primary' | 'secondary' | 'ghost';
  size?: 'sm' | 'md' | 'lg';
  children: ReactNode;
}

export const Button: FC<ButtonProps> = ({
  variant = 'primary',
  size = 'md',
  children,
  ...props
}) => {
  return (
    <button
      className={`btn btn-${variant} btn-${size}`}
      {...props}
    >
      {children}
    </button>
  );
};

entities

Слой бизнес-сущностей — объекты предметной области: User, Product, Order, Cart. Каждая сущность — отдельный слайс со своими компонентами, хуками и моделью данных.

entities/
  product/
    ui/
      ProductCard/
      ProductRating/
    model/
      types.ts
      store.ts
    api/
      productApi.ts
    index.ts
  user/
    ...
  cart/
    ...

Пример сущности product:

// entities/product/model/types.ts
export interface Product {
  id: string;
  title: string;
  price: number;
  rating: number;
  imageUrl: string;
  category: string;
}

// entities/product/ui/ProductCard/ProductCard.tsx
import { FC } from 'react';
import { Product } from '../../model/types';

interface ProductCardProps {
  product: Product;
  actions?: React.ReactNode;
}

export const ProductCard: FC<ProductCardProps> = ({ product, actions }) => {
  return (
    <div className="product-card">
      <img src={product.imageUrl} alt={product.title} />
      <h3>{product.title}</h3>
      <span>{product.price} ₽</span>
      {actions && <div className="product-card__actions">{actions}</div>}
    </div>
  );
};

Обратите внимание на actions — слот для дополнительных действий. Это позволяет вышестоящим слоям добавлять кнопки (например, «Добавить в корзину») без того, чтобы ProductCard знала о фиче добавления.

features

Пользовательские сценарии и действия: AddToCart, AuthByEmail, FilterProducts, WriteReview. Фичи используют сущности и описывают, что пользователь может делать с ними.

features/
  add-to-cart/
    ui/
      AddToCartButton/
    model/
      addToCart.ts
    index.ts
  auth-by-email/
    ui/
      LoginForm/
    model/
      authModel.ts
    api/
      authApi.ts
    index.ts
// features/add-to-cart/ui/AddToCartButton/AddToCartButton.tsx
import { FC } from 'react';
import { Button } from '@/shared/ui/Button';
import { useCart } from '@/entities/cart';
import { Product } from '@/entities/product';

interface AddToCartButtonProps {
  product: Product;
}

export const AddToCartButton: FC<AddToCartButtonProps> = ({ product }) => {
  const { addItem, isInCart } = useCart();

  if (isInCart(product.id)) {
    return <Button variant="secondary">В корзине</Button>;
  }

  return (
    <Button onClick={() => addItem(product)}>
      Добавить в корзину
    </Button>
  );
};

widgets

Композиционный слой — крупные самодостаточные блоки интерфейса, которые объединяют несколько фич и сущностей: Header, ProductCatalog, CartSidebar, UserProfile.

widgets/
  header/
    ui/
      Header/
    index.ts
  product-catalog/
    ui/
      ProductCatalog/
      ProductGrid/
    index.ts
  cart-sidebar/
    ...
// widgets/product-catalog/ui/ProductCatalog/ProductCatalog.tsx
import { FC } from 'react';
import { ProductCard } from '@/entities/product';
import { AddToCartButton } from '@/features/add-to-cart';
import { FilterProducts } from '@/features/filter-products';
import { useProducts } from '../../model/useProducts';

export const ProductCatalog: FC = () => {
  const { products, filters, setFilters } = useProducts();

  return (
    <section>
      <FilterProducts value={filters} onChange={setFilters} />
      <div className="product-grid">
        {products.map((product) => (
          <ProductCard
            key={product.id}
            product={product}
            actions={<AddToCartButton product={product} />}
          />
        ))}
      </div>
    </section>
  );
};

pages

Страницы приложения. Они только компонуют виджеты и передают им параметры маршрута. Никакой бизнес-логики здесь нет — только сборка.

pages/
  home/
    ui/
      HomePage/
    index.ts
  product/
    ui/
      ProductPage/
    index.ts
  cart/
    ...
// pages/home/ui/HomePage/HomePage.tsx
import { FC } from 'react';
import { ProductCatalog } from '@/widgets/product-catalog';
import { Banner } from '@/widgets/banner';

export const HomePage: FC = () => {
  return (
    <main>
      <Banner />
      <ProductCatalog />
    </main>
  );
};

app

Верхний слой инициализации: провайдеры, глобальные стили, конфигурация роутера, инициализация сторов.

app/
  providers/
    RouterProvider/
    ThemeProvider/
    StoreProvider/
  styles/
    global.css
    reset.css
  App.tsx
  index.ts
// app/App.tsx
import { RouterProvider } from './providers/RouterProvider';
import { ThemeProvider } from './providers/ThemeProvider';
import { StoreProvider } from './providers/StoreProvider';
import './styles/global.css';

export const App = () => {
  return (
    <StoreProvider>
      <ThemeProvider>
        <RouterProvider />
      </ThemeProvider>
    </StoreProvider>
  );
};

Публичный API слайсов

Каждый слайс экспортирует только то, что должно быть видно снаружи — через файл index.ts. Это одно из ключевых правил FSD.

// entities/product/index.ts
export { ProductCard } from './ui/ProductCard';
export { ProductRating } from './ui/ProductRating';
export type { Product } from './model/types';
export { useProduct } from './model/useProduct';
// внутренние детали реализации НЕ экспортируются

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

// ПРАВИЛЬНО
import { ProductCard, Product } from '@/entities/product';

// НЕПРАВИЛЬНО — нарушает изоляцию слайса
import { ProductCard } from '@/entities/product/ui/ProductCard/ProductCard';

Правило изоляции слайсов

Слайсы одного слоя не могут импортировать друг друга. features/add-to-cart не может импортировать из features/filter-products. Это защищает от циклических зависимостей и неявных связей между фичами.

Если нужна общая логика между двумя слайсами — она переносится на слой ниже: в entities или shared.

// НЕПРАВИЛЬНО — features импортирует из features
import { useFilters } from '@/features/filter-products';

// ПРАВИЛЬНО — общая логика вынесена в entities
import { useProductFilters } from '@/entities/product';

Настройка алиасов

Для удобства работы с абсолютными путями настройте алиасы в tsconfig.json и сборщике:

// tsconfig.json
{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"]
    }
  }
}
// vite.config.ts
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import path from 'path';

export default defineConfig({
  plugins: [react()],
  resolve: {
    alias: {
      '@': path.resolve(__dirname, './src'),
    },
  },
});

Типичные ошибки при внедрении

Слишком ранняя разбивка на слайсы. Не нужно создавать слайс для каждой мелочи. Если фича из трёх строк — держите её в странице до тех пор, пока не появится реальная причина выносить.

Бизнес-логика в shared. Shared — только для универсальных вещей. useUserPermissions — это не shared, это entities/user.

Прямые импорты из внутренних путей. Всегда через index.ts. Иначе теряется смысл публичного API.

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

Инструменты для проверки архитектуры

Есть линтер специально для FSD — @feature-sliced/eslint-config. Он проверяет направление зависимостей на уровне ESLint:

npm install --save-dev @feature-sliced/eslint-config
// .eslintrc.json
{
  "extends": ["@feature-sliced"]
}

Линтер автоматически запретит импорт pages из features и подобные нарушения иерархии.

Когда FSD оправдан

FSD добавляет структурный оверхед. Для небольших приложений (до 10 страниц, 1–2 разработчика) он может быть излишним. Методология раскрывается там, где:

  • Над проектом работает команда от трёх человек
  • Приложение активно растёт и сложность модулей увеличивается
  • Есть чёткое разделение на бизнес-домены
  • Важна независимость отдельных частей для тестирования и замены

Для небольших проектов часто достаточно трёх слоёв: pages, features, shared — и добавлять остальные по мере роста.

Итог

Feature-Sliced Design даёт ответ на вопрос «куда положить этот код», который работает при любом масштабе команды. Шесть слоёв с однонаправленными зависимостями, изолированные слайсы и явный публичный API через index.ts — этих трёх правил достаточно, чтобы большое приложение оставалось управляемым.

Чтобы научиться строить масштабируемые React приложения с нуля и освоить современные паттерны разработки, записывайтесь на курс по React на PurpleSchool: https://purpleschool.ru/course/react?utm_source=knowledgebase&utm_medium=text&utm_campaign=feature-sliced-design-architecture

Стрелочка влевоHOC в React: мастерство композиции компонентовError Boundaries: создаем надежные React-приложенияСтрелочка вправо

Постройте личный план изучения React до уровня Middle — бесплатно!

React — часть карты развития Frontend

  • step100+ шагов развития
  • lessons30 бесплатных лекций
  • lessons300 бонусных рублей на счет

Бесплатные лекции

Все гайды по React

Zustand: продвинутые паттерны, persist middleware и slicesБезопасность в React: защита от XSS, CSRF и утечек данныхUncontrolled Components: когда DOM управляет даннымиRender Props: гибкое управление рендерингом в ReactРефакторинг React-кода: техники и лучшие практикиReact с WebSocket — реалтайм в компонентахReact Native New Architecture: Fabric и JSIReact Native приложение с нуля до публикации в сторахПрофилирование React: как найти и устранить узкие местаЧастичное применение: как создавать компоненты без лишнего кодаИменование компонентов в React: соглашения и лучшие практикиЛенивая загрузка: как ускорить React-приложение в разыОшибки гидратации в React и способы их устраненияHOC в React: мастерство композиции компонентовАрхитектура больших React приложений: Feature-Sliced DesignError Boundaries: создаем надежные React-приложенияuseMemo: как спасти производительность от тяжелых вычисленийКонтролируемые компоненты в React: полный контроль над формамиCompound Components в React: создаем гибкие компоненты с мощным APIДокументирование компонентов в React: Storybook, JSDoc и READMEКомпозиция компонентов в React: строим гибкие интерфейсыКомментирование кода в React: когда и как писать комментарииCode Splitting в React: как уменьшить бандл и ускорить загрузку приложенияАсинхронные компоненты в React: новый стандарт работы с даннымиДоступность (a11y) в React: ARIA, семантика и клавиатурная навигация
Zustand — управление состоянием в ReactZod - валидация с TypeScriptYup - валидация схемXState - конечные автоматыТемизация в ReactТестирование хуковTailwind CSS с ReactSWR - библиотека для запросовStyled Components — стилизация через JSSnapshots тестированиеStorybook - документация компонентовRTK Query - работа с APIRedux Toolkit - современный ReduxRecoil — библиотека управления состоянием от FacebookВиртуализация списков с react-window: как отображать тысячи элементов без лаговReact Testing LibraryReact Toastify - уведомления в ReactСоздание таблиц в React гайд по react-tableReact Spring - анимацииReact Query (TanStack Query) - работа с серверомРабота с формами и селектами в ReactПлагины в React что это и как их использоватьReact PDF - работа с PDF файламиОбзор популярных библиотек для ReactReact Icons - библиотека иконок для ReactReact Hook Form — валидация форм в ReactReact Dropzone — загрузка файловПодключение Bootstrap к React-приложениюReact Beautiful DnD - перетаскивание элементовАнимация при монтировании компонентов в ReactМокирование APIMobX — реактивное управление состоянием в ReactМикрофронтенды с React (micro-frontends)Загрузка и индикаторыАнимация списков в ReactJotai - атомарное состояниеБесконечная прокруткаFramer Motion - библиотека анимацийFormik — библиотека для форм в ReactEmotion — библиотека CSS-in-JSДинамические стили в ReactE2E тестирование с CypressCSSTransition - переходыCSS-in-JS — плюсы и минусыКонтекст vs Redux — когда что использоватьТестирование асинхронных компонентовAxios с ReactОбработка ошибок APIИспользование Chart.js в React
Что такое Vite и как запускать проекты React через негоReact Router v6 - основыКак использовать Next.js вместе с ReactКак подключить Tailwind к ReactНастройка маршрутизации в React с React RouterРабота с Redux в React-приложенииИспользование API в React-приложенияхИспользование Expo для разработки на ReactПрограммная навигация в React — переходы из кодаДинамические маршруты в Next.jsЗащищённые маршруты (Protected Routes)Использование React вместе с GoИнтеграция Express и ReactДинамические маршруты
Valtio: атомарный state management в ReactuseState в React что это и как использоватьuseTransition - плавные переходы между состояниямиuseSyncExternalStore — работа с внешними сторамиuseRef в React — создание ссылок на DOM и значенияuseOptimistic — оптимистичные обновления UIuseLayoutEffect в React — эффект до отрисовкиuseInsertionEffect — внедрение стилей до мутаций DOMuseImperativeHandle в React — настройка ref дочернего компонентаuseId — генерация уникальных идентификаторовuseFormStatus - отслеживание статуса отправки формыuseDeferredValue — отложенное обновление состоянияuseDebugValue — отладка кастомных хуковuseCallback в React — мемоизация функцийuseReducer — альтернатива useState для сложной логикиuseMemo в React: как и когда оптимизировать тяжелые вычисленияХук use() в React 19useEffect в React что это и как использоватьuseContext — работа с контекстом в ReactuseCallback в React — мемоизация функций и оптимизация ре-рендеровuseActionState в React 19React Stale Closures — устаревшие замыкания в хукахОптимизация рендеринга в React: от теории к глубокой практикеЧто такое useRef и как его применять в ReactКак и зачем использовать React HooksУправление состоянием в React через ContextНовые возможности React 19Как предотвратить лишние ре-рендеры в React: полное руководствоuseMemo vs useCallback: подробное руководство по мемоизации в ReactПравила хуков — правила использованияflushSync — синхронные обновления состояния в ReactuseEffect vs useLayoutEffect: в чём разница и какой хук выбрать?Кастомные хуки в React — создание собственных хуковuseState продвинутое использование в React
Server Components vs Client Components: когда использоватьRemotion: создание видео на ReactReact 19: ref как проп без forwardRefВизуализация данных в React с RechartsReact Three Fiber — 3D-графика в ReactReact Native Skia для графикиReact Native Maps: работа с картами в мобильных приложенияхReact Native Gesture Handler: обработка жестов в мобильных приложенияхReact key — как React использует ключи для согласованияRadix UI: компоненты без стилейАнимации в React с GSAPLayout-анимации в React с Framer MotionReact forwardRef — передача рефов дочерним компонентам
React Suspense — приостановка рендераTransition API — плавные обновления интерфейса в ReactStrictMode в React — как находить ошибки на этапе разработкиСерверные компоненты React (RSC) — подробный разбор и практикаКак работает рендеринг в ReactЧто такое props в React и как их правильно использоватьКак работает JSX связка React и HTMLЧто такое React.js и как его использоватьКак использовать элементы в ReactКак использовать React DOM в проектеЧто такое компоненты в React и как их применятьРабота с children в ReactПорталы в React: рендер компонентов вне иерархии DOMFragment в React: группировка элементов без лишних узлов DOMCSS Modules в ReactConcurrent Mode — конкурентный режим в React
Открыть базу знаний

Лучшие курсы по теме

изображение курса

React и Redux Toolkit

Антон Ларичев
AI-тренажерыAI-тренажеры
Практика в студииПрактика в студии
Гарантия
Бонусы
иконка звёздочки рейтинга4.8
3 999 ₽ 6 990 ₽
Подробнее
изображение курса

TypeScript с нуля

Антон Ларичев
AI-тренажерыAI-тренажеры
Практика в студииПрактика в студии
Гарантия
Бонусы
иконка звёздочки рейтинга4.8
3 999 ₽ 6 990 ₽
Подробнее
изображение курса

Next.js - с нуля

Антон Ларичев
AI-тренажерыAI-тренажеры
Практика в студииПрактика в студии
Гарантия
Бонусы
иконка звёздочки рейтинга4.7
3 999 ₽ 6 990 ₽
Подробнее

Отправить комментарий