К содержимому
Войти

Frontend Road Map

🧰 Redux Toolkit

Redux держит состояние приложения в одном сторе вне React и меняет его только через действия, поэтому каждое изменение можно залогировать, отмотать в DevTools и проверить тестом без компонентов. Redux Toolkit (RTK) — официальный способ писать на Redux сейчас: он убрал ручные константы, копирование вложенных объектов и настройку middleware. Redux до сих пор живёт во многих больших проектах, и вопросы по нему повторяются: принципы, Immer, лишние рендеры от useSelector, thunk

🧠 Как это устроено

Три принципа

Документация Redux формулирует их так:

  1. Единый источник истины. Всё глобальное состояние лежит в одном дереве объектов в одном сторе
  2. Состояние только для чтения. Изменить его можно одним способом — отправить действие, объект с описанием того, что произошло: { type: 'todos/added', payload: 'купить молоко' }
  3. Изменения делают чистые функции. Редьюсер получает старое состояние и действие и возвращает новое: (state, action) => newState

Чистота редьюсера держит на себе всю остальную механику. Подписчики понимают, что что-то изменилось, сравнивая ссылки: старый объект !== новый, значит пора пересчитать. Если редьюсер поменял объект на месте, ссылка осталась той же, и компонент не узнает об изменении. Если редьюсер ходит в сеть или читает Date.now(), одно и то же действие даёт разный результат, и отмотка истории в DevTools показывает неправду. Поэтому побочные эффекты живут не в редьюсере, а в middleware

Поток данных

Компонент вызывает dispatch(action). Действие проходит цепочку middleware, затем корневой редьюсер собирает новое состояние из редьюсеров слайсов. Стор оповещает подписчиков, и каждый useSelector заново вычисляет свой селектор. Компонент перерисуется, только если результат селектора изменился по ===

Что убрал Redux Toolkit

Классический ReduxRedux Toolkit
Константы типов, action creators и switch в редьюсере пишутся руками в трёх местахcreateSlice генерирует типы действий и action creators из объекта редьюсеров
Иммутабельное обновление через spread на каждом уровне вложенностиImmer внутри createSlice: пишешь «мутацию» черновика, получаешь новый объект
createStore, combineReducers, applyMiddleware, compose для DevToolsconfigureStore с разумными умолчаниями
Три действия загрузки и thunk пишутся руками для каждого запросаcreateAsyncThunk отправляет pending, fulfilled, rejected сам
Свой слой загрузки и кэша ответовRTK Query, кэш серверных данных поверх того же стора

Актуальные major-версии: @reduxjs/toolkit 2, react-redux 9, redux 5, Immer 11 (идёт зависимостью RTK), Reselect 5. Старый createStore помечен устаревшим ещё с Redux 4.2, и редактор зачеркнёт его, чтобы подтолкнуть к configureStore

Что делает configureStore по умолчанию

  • объединяет объект reducer через combineReducers
  • подключает thunk middleware в любой сборке
  • в dev-сборке добавляет три проверки: immutableCheck ругается на мутацию состояния вне Immer. serializableCheck ловит Date, Map, классы и функции в состоянии и действиях. actionCreatorCheck заметит dispatch(added) вместо dispatch(added()). В продакшен-сборке остаётся только thunk
  • devTools: true — подключение к расширению Redux DevTools

Отключить проверку можно точечно: getDefaultMiddleware({ serializableCheck: false }). Чаще правильнее не отключать, а убрать из стора то, на что она ругается

Как Immer разрешает «мутировать»

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

Работает это только внутри createSlice, createReducer и produce. Та же строка state.items.push(x) в обычном редьюсере или в компоненте — настоящая мутация

🛠️ На практике

Слайс, стор и типизированные хуки. Так выглядит почти любой стор на RTK:

import { configureStore, createSlice, type PayloadAction } from '@reduxjs/toolkit'
import { useDispatch, useSelector } from 'react-redux'

type Todo = { id: string; text: string; done: boolean }

const todosSlice = createSlice({
  name: 'todos',
  initialState: [] as Todo[],
  reducers: {
    added(state, action: PayloadAction<string>) {
      // «мутация» черновика, Immer вернёт новый массив
      state.push({ id: crypto.randomUUID(), text: action.payload, done: false })
    },
    toggled(state, action: PayloadAction<string>) {
      const todo = state.find((t) => t.id === action.payload)
      if (todo) todo.done = !todo.done
    },
    cleared() {
      // целиком новое состояние — только через return
      return []
    },
  },
})

export const { added, toggled, cleared } = todosSlice.actions

export const store = configureStore({ reducer: { todos: todosSlice.reducer } })

export type RootState = ReturnType<typeof store.getState>
export type AppDispatch = typeof store.dispatch
export const useAppSelector = useSelector.withTypes<RootState>()
export const useAppDispatch = useDispatch.withTypes<AppDispatch>()

added('купить молоко') вернёт { type: 'todos/added', payload: 'купить молоко' }: тип собран из name слайса и имени редьюсера. После dispatch массив todos в сторе — новая ссылка, старый остался нетронутым

Мутировать и вернуть одновременно нельзя

Immer ждёт одно из двух: либо меняешь черновик, либо возвращаешь новое значение. Частая ловушка — стрелка без фигурных скобок:

reducers: {
  // push возвращает новую длину массива: и мутация, и return сразу
  broken: (state, action: PayloadAction<Todo>) => state.push(action.payload),
  // так можно: фигурные скобки, функция ничего не возвращает
  fixed: (state, action: PayloadAction<Todo>) => {
    state.push(action.payload)
  },
}

На broken Immer бросает ошибку An immer producer returned a new value *and* modified its draft. Вторая ловушка — state = action.payload: это просто перепривязка локальной переменной, стор не изменится. Заменить состояние целиком можно только через return action.payload

Селекторы и лишние рендеры

useSelector подписан на стор и пересчитывает селектор после каждого действия, а результат сравнивает по ===. Если селектор возвращает новый объект или массив, сравнение всегда ложно, и компонент перерисуется на любое действие в приложении, даже на то, что меняет чужой слайс:

// перерисовка на каждое действие: filter и {} каждый раз дают новую ссылку
const openTodos = useAppSelector((s) => s.todos.filter((t) => !t.done))
const { name, role } = useAppSelector((s) => ({ name: s.user.name, role: s.user.role }))

Чинят тремя способами:

import { createSelector } from '@reduxjs/toolkit'
import { shallowEqual } from 'react-redux'

// 1. Несколько useSelector, каждый возвращает примитив или существующую ссылку
const name = useAppSelector((s) => s.user.name)
const role = useAppSelector((s) => s.user.role)

// 2. shallowEqual сравнивает поля объекта, а не сам объект
const user = useAppSelector((s) => ({ name: s.user.name, role: s.user.role }), shallowEqual)

// 3. Мемоизированный селектор: новый массив только когда изменился s.todos
const selectTodos = (s: RootState) => s.todos
export const selectOpenTodos = createSelector([selectTodos], (todos) =>
  todos.filter((t) => !t.done),
)
const openTodos = useAppSelector(selectOpenTodos)

createSelector из Reselect (RTK реэкспортирует его) запоминает аргументы входных селекторов. Пока s.todos та же ссылка, функция результата не вызывается, и selectOpenTodos(state) === selectOpenTodos(state). Немемоизированный вариант с filter на том же состоянии дважды вернёт разные массивы. В Reselect 5 по умолчанию стоит weakMapMemoize: у селектора с аргументом вроде (state, categoryId) отдельный кэш на каждое значение аргумента, а в Reselect 4 помнился только последний вызов

Мемоизировать простое чтение поля s => s.todos не нужно, ссылка и так стабильна. createSelector нужен, когда селектор делает map, filter, собирает объект или считает что-то дорогое

В dev-режиме useSelector сам подсказывает такие ошибки: проверка stabilityCheck при первом вызове запускает селектор дважды и предупреждает в консоли, если результаты не равны. identityFunctionCheck ругается на useSelector(s => s) — подписку на весь стор

Middleware и thunk

Middleware — функция между dispatch и редьюсером. Она видит каждое действие и может его залогировать, изменить, задержать, не пропустить или отправить вместо него другие. Сигнатура в три вложенные функции:

import type { Middleware } from '@reduxjs/toolkit'

export const logger: Middleware = (api) => (next) => (action) => {
  const result = next(action) // передать дальше по цепочке
  console.log(action, api.getState())
  return result
}

Thunk middleware делает одну вещь: если в dispatch пришла функция, а не объект, он вызывает её с dispatch и getState и не передаёт в редьюсер. Так асинхронная логика живёт рядом со стором, а редьюсеры остаются чистыми

createAsyncThunk поверх этого генерирует три действия и сам их отправляет:

import { createAsyncThunk, createSlice } from '@reduxjs/toolkit'

type User = { id: string; name: string }

export const fetchUser = createAsyncThunk<User, string, { rejectValue: string }>(
  'users/fetchById',
  async (id, { signal, rejectWithValue }) => {
    const res = await fetch(`/api/users/${id}`, { signal })
    if (!res.ok) return rejectWithValue(`HTTP ${res.status}`)
    return (await res.json()) as User
  },
)

const usersSlice = createSlice({
  name: 'users',
  initialState: { user: null as User | null, status: 'idle', error: null as string | null },
  reducers: {},
  extraReducers: (builder) => {
    builder
      .addCase(fetchUser.pending, (state) => {
        state.status = 'loading'
      })
      .addCase(fetchUser.fulfilled, (state, action) => {
        state.status = 'idle'
        state.user = action.payload
      })
      .addCase(fetchUser.rejected, (state, action) => {
        state.status = 'failed'
        state.error = action.payload ?? action.error.message ?? null
      })
  },
})

Отправка dispatch(fetchUser('42')) выдаёт users/fetchById/pending, затем fulfilled или rejected. Промис, который вернул dispatch, не падает даже при ошибке: он разрешается финальным действием. Нужен try/catch в компоненте — вызывай .unwrap(), он вернёт payload или бросит ошибку. У промиса есть .abort(), сигнал приходит в signal внутри функции, и после отмены уходит rejected с meta.aborted

RTK Query коротко

Если половина слайсов — это status, error и данные с сервера, это уже кэш ответов, а не состояние приложения. RTK Query решает эту задачу внутри Redux: описываешь эндпоинты в createApi, получаешь хуки вроде useGetUserQuery, дедупликацию запросов и инвалидацию по тегам. Как устроен такой кэш и чем RTK Query отличается от TanStack Query — на странице «Серверное состояние: TanStack Query»

⚠️ Где ошибаются

  • Селектор собирает объект или массив без мемоизации. Компонент рендерится на каждое действие в приложении, и на большом списке это видно в профайлере сразу. Возвращай примитивы, shallowEqual или createSelector
  • createSelector, который ничего не считает. createSelector([s => s.todos], todos => todos) просто возвращает вход и не экономит ни рендера. Обратная ошибка — входной селектор s => s: он меняется на каждое действие, и кэш не срабатывает никогда
  • Всё подряд в сторе. Значение инпута, открыт ли дропдаун, Date и File в состоянии. Первое даёт отправку действия на каждую букву, второе ломает сериализацию и DevTools. Локальному UI место в useState, датам — строка ISO или число
  • state = newValue в редьюсере слайса. Ничего не происходит, ошибки нет. Новое состояние целиком — только return
  • Отключённый serializableCheck «потому что мешал». Предупреждение было про реальную проблему: несериализуемое значение не переживёт persist, SSR-гидратацию и отмотку в DevTools. Исключение — специальные действия библиотек вроде redux-persist, для них есть ignoredActions

🎯 Вопросы с собеседований

Какие три принципа Redux и зачем редьюсер чистый?

Единый стор как источник истины, состояние только для чтения и меняется лишь через действия, изменения описывают чистые функции-редьюсеры. Чистота нужна, потому что Redux и useSelector узнают об изменении сравнением ссылок: мутация на месте оставит ту же ссылку, и интерфейс не обновится. Без побочных эффектов одно и то же действие на том же состоянии всегда даёт один результат, поэтому работают отмотка истории в DevTools, повтор действий и тесты редьюсера без моков. Эффекты выносятся в middleware: thunk, listener middleware, RTK Query

Что упрощает Redux Toolkit по сравнению с «классическим» Redux?

createSlice генерирует типы действий и action creators из редьюсеров, поэтому нет констант и switch. С Immer внутри обновления пишутся как мутации вместо spread на каждом уровне. configureStore сам собирает редьюсеры, подключает thunk и DevTools, а в dev добавляет проверки мутаций и сериализуемости. createAsyncThunk убирает ручные pending, fulfilled, rejected, а RTK Query — ручную загрузку и кэш серверных данных. Плюс хорошая типизация TypeScript почти без ручных типов

Как createSlice позволяет «мутировать» state и почему это безопасно? Можно ли одновременно мутировать и вернуть новый объект?

Редьюсер получает от Immer черновик — Proxy, который записывает изменения. После выполнения Immer строит новое состояние: копирует изменённые ветки и переиспользует нетронутые по ссылке, а оригинал не трогает. Снаружи это обычное иммутабельное обновление. Мутировать и вернуть одновременно нельзя: Immer бросит ошибку, потому что не знает, какой результат взять. Типичная причина — стрелка без скобок (state, a) => state.push(a.payload), где push возвращает длину массива. Лечится фигурными скобками или void

Почему компонент с useSelector перерендеривается на каждое действие и как это исправить?

useSelector пересчитывает селектор после каждого dispatch и сравнивает результат с прошлым по ===. Если селектор возвращает новый объект или массив (filter, map, литерал {}), ссылки всегда разные, и компонент рендерится на любое действие, даже на чужой слайс. Есть три способа: несколько useSelector с примитивами, второй аргумент shallowEqual для объекта из полей, мемоизированный селектор через createSelector, который возвращает прежнюю ссылку, пока не изменились входы. React.memo тут не поможет: рендер запускает сама подписка, а не родитель

Что такое middleware и как работает thunk / createAsyncThunk?

Middleware — функция вида api => next => action => …, которая стоит между dispatch и редьюсером и видит каждое действие. Thunk проверяет, функция ли пришла: если да, вызывает её с dispatch и getState и в редьюсер не пускает. createAsyncThunk поверх thunk отправляет pending, затем fulfilled с результатом или rejected с ошибкой, а слайс ловит их в extraReducers. Промис из dispatch не отклоняется, для try/catch нужен .unwrap(). Есть rejectWithValue для своей ошибки, condition, чтобы не запускать повторный запрос, и отмена через abort() и signal

Когда Redux не нужен?

Когда глобального клиентского состояния мало: тема, текущий пользователь, пара флагов. Серверные данные лучше держать в кэше запросов, локальный UI — в useState, и после этого стор часто оказывается почти пустым. Redux окупается, когда много экранов читают и меняют одни и те же данные, нужна предсказуемая история изменений, middleware и DevTools, или команда уже живёт на нём

📚 Что почитать

  • Three Principles — три принципа в формулировке авторов, коротко
  • Writing Reducers with Immer — как Immer работает внутри RTK и все ловушки с return, state = и логированием черновика через current
  • getDefaultMiddleware — что входит в цепочку в dev и проде и как настроить каждую проверку
  • Deriving Data with Selectors — когда мемоизировать, а когда нет, и как устроен кэш селекторов с аргументами