🧰 Redux Toolkit
Redux держит состояние приложения в одном сторе вне React и меняет его только через действия, поэтому каждое изменение можно залогировать, отмотать в DevTools и проверить тестом без компонентов. Redux Toolkit (RTK) — официальный способ писать на Redux сейчас: он убрал ручные константы, копирование вложенных объектов и настройку middleware. Redux до сих пор живёт во многих больших проектах, и вопросы по нему повторяются: принципы, Immer, лишние рендеры от useSelector, thunk
🧠 Как это устроено
Три принципа
Документация Redux формулирует их так:
- Единый источник истины. Всё глобальное состояние лежит в одном дереве объектов в одном сторе
- Состояние только для чтения. Изменить его можно одним способом — отправить действие, объект с описанием того, что произошло:
{ type: 'todos/added', payload: 'купить молоко' } - Изменения делают чистые функции. Редьюсер получает старое состояние и действие и возвращает новое:
(state, action) => newState
Чистота редьюсера держит на себе всю остальную механику. Подписчики понимают, что что-то изменилось, сравнивая ссылки: старый объект !== новый, значит пора пересчитать. Если редьюсер поменял объект на месте, ссылка осталась той же, и компонент не узнает об изменении. Если редьюсер ходит в сеть или читает Date.now(), одно и то же действие даёт разный результат, и отмотка истории в DevTools показывает неправду. Поэтому побочные эффекты живут не в редьюсере, а в middleware
Поток данных
Компонент вызывает dispatch(action). Действие проходит цепочку middleware, затем корневой редьюсер собирает новое состояние из редьюсеров слайсов. Стор оповещает подписчиков, и каждый useSelector заново вычисляет свой селектор. Компонент перерисуется, только если результат селектора изменился по ===
Что убрал Redux Toolkit
| Классический Redux | Redux Toolkit |
|---|---|
Константы типов, action creators и switch в редьюсере пишутся руками в трёх местах | createSlice генерирует типы действий и action creators из объекта редьюсеров |
| Иммутабельное обновление через spread на каждом уровне вложенности | Immer внутри createSlice: пишешь «мутацию» черновика, получаешь новый объект |
createStore, combineReducers, applyMiddleware, compose для DevTools | configureStore с разумными умолчаниями |
| Три действия загрузки и 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 — когда мемоизировать, а когда нет, и как устроен кэш селекторов с аргументами