🐻 Zustand и атомарные сторы
Zustand, Jotai, Effector и сигналы решают одну задачу: держать общее состояние клиента так, чтобы компонент перерисовывался только от того, что он читает. У Zustand один стор, из которого компонент берёт кусок селектором. У атомов много маленьких независимых ячеек. У сигналов реактивное значение само знает, кто его читает. На собеседовании это спрашивают в паре с Redux Toolkit: почему выбрали одно, а не другое, и как библиотека избегает лишних рендеров
🧠 Как это устроено
Zustand: стор вне React и подписка через селектор
Стор Zustand живёт вне дерева React. Внутри это замыкание с текущим состоянием и Set слушателей. Наружу торчат четыре функции: getState, setState, subscribe и getInitialState. setState сравнивает новое значение со старым через Object.is, если оно изменилось, сливает объект со старым на один уровень и вызывает всех слушателей
Хук, который возвращает create, связывает этот внешний стор с React через встроенный useSyncExternalStore. На каждое изменение стора React вызывает селектор и сравнивает результат с прошлым через Object.is. Совпал, и компонент не рендерится. Отсюда главное правило: компонент перерисовывается, только когда меняется то, что вернул его селектор. Провайдер не нужен, потому что стор и так один на модуль
Бейдж с селектором (s) => s.items.length получает число и пропускает смену промокода. Компонент с useCart() без селектора получает весь стейт и перерисуется от любого set
Объект из селектора в Zustand 5
Селектор, который собирает объект (s) => ({ items: s.items, add: s.add }), на каждый вызов создаёт новую ссылку. В Zustand 4 у create была своя функция сравнения, и такой код просто лишний раз рендерил компонент. В Zustand 5 create работает как обычный useSyncExternalStore, а React требует, чтобы снимок состояния был стабильным. React сначала пишет в консоль The result of getSnapshot should be cached to avoid an infinite loop, а потом падает с Maximum update depth exceeded
Лечится это обёрткой useShallow. Она запоминает прошлый результат и, если новый объект поверхностно равен старому (те же ключи, значения равны по Object.is), возвращает старую ссылку. Нужно старое поведение целиком, тогда есть createWithEqualityFn из zustand/traditional, но ему нужен пакет use-sync-external-store как peer-зависимость
Атомы: Jotai и Effector
Атомарный подход переворачивает картину. Вместо одного объекта со всеми полями есть много маленьких ячеек, и производные ячейки строятся из других. Компонент подписан ровно на те атомы, которые прочитал, поэтому селекторы и useShallow не нужны
В Jotai atom(0) не хранит значение. Это конфиг, ключ, а значение лежит в сторе, который по умолчанию общий, а через Provider свой для поддерева. Производный атом atom((get) => get(itemsAtom).length) сам отслеживает зависимости: каждый get подписывает его на атом, и пересчёт идёт, только когда тот изменился
Effector устроен иначе, хотя его тоже относят к атомарным. Состояние лежит во многих сторах (createStore, по соглашению с $ в начале имени), но менять их напрямую нельзя: нет setState. Меняют через события (createEvent) и эффекты (createEffect для запросов). Связи между ними задаются декларативно, через .on, .map и sample. Стор не обновляется, если новое значение строго равно старому или равно undefined. React только читает сторы и вызывает события через useUnit. Effector спрашивают на собеседованиях в некоторых компаниях, например в Т-Банке, так что базовые термины стоит знать
Сигналы
Сигнал — значение с подпиской внутри. В Preact Signals signal(0) читается и пишется через .value, computed пересчитывается лениво от своих сигналов, effect перезапускается, когда меняется прочитанное. Зависимости собираются автоматически: что прочитал, на то и подписался
Разница с моделью React в том, где живёт реакция на изменение. В React компонент — функция от состояния: изменилось состояние, функция вызывается заново, React сравнивает результат и правит DOM. У сигналов реагирует конкретное место, которое прочитало значение. Если отдать сигнал в JSX Preact прямо текстом, обновится текстовый узел, а сам компонент не перерисуется. MobX работает на той же идее: компонент-observer подписывается на поля observable, прочитанные при рендере. В обычном React сигналы подключают отдельным пакетом @preact/signals-react, и он работает в обход привычной модели React
| Один стор (Zustand, Redux) | Атомы (Jotai, Effector) | Сигналы (Preact Signals, MobX) | |
|---|---|---|---|
| Где состояние | Один объект вне React | Много ячеек, граф зависимостей | Реактивные значения и объекты |
| Как компонент подписывается | Селектором, вручную | Читает атом, подписка сама | Читает .value или поле, подписка сама |
| Что перерисовывается | Компонент, у которого изменился результат селектора | Компонент, прочитавший изменённый атом | Место, прочитавшее значение, иногда без рендера компонента |
| Производные значения | Селекторы, мемоизация вручную | Производные атомы | computed |
🛠️ На практике
Стор корзины. В TypeScript create вызывают с пустыми скобками перед функцией: так тип стейта выводится и для set
import { create } from 'zustand'
import { useShallow } from 'zustand/react/shallow'
type CartState = {
items: string[]
promo: string
add: (id: string) => void
setPromo: (promo: string) => void
}
export const useCart = create<CartState>()((set) => ({
items: [],
promo: '',
add: (id) => set((s) => ({ items: [...s.items, id] })),
setPromo: (promo) => set({ promo }),
}))
function CartBadge() {
// число: смена промокода этот компонент не трогает
const count = useCart((s) => s.items.length)
return <span>{count}</span>
}
function CartList() {
// объект из селектора в Zustand 5 только через useShallow
const { items, add } = useCart(useShallow((s) => ({ items: s.items, add: s.add })))
return <ul>{items.map((id) => <li key={id}>{id}</li>)}</ul>
}Вне React стор тоже доступен: useCart.getState().add('sku-1') из обработчика WebSocket или теста, useCart.subscribe(listener) для логирования
Сохранить стор между перезагрузками
Middleware persist пишет стор в хранилище и читает его при создании. Обязателен только name, ключ в хранилище. По умолчанию хранилище localStorage через createJSONStorage. partialize выбирает, что сохранять, version и migrate переводят старые данные на новую схему
import { create } from 'zustand'
import { persist } from 'zustand/middleware'
type Prefs = { theme: 'light' | 'dark'; draft: string; setTheme: (t: Prefs['theme']) => void }
export const usePrefs = create<Prefs>()(
persist(
(set) => ({ theme: 'light', draft: '', setTheme: (theme) => set({ theme }) }),
{
name: 'prefs',
version: 1,
partialize: (s) => ({ theme: s.theme }), // черновик не сохраняем
skipHydration: true, // читаем хранилище сами, после монтирования
},
),
)
// в клиентском компоненте, который рендерится один раз на приложение
useEffect(() => {
void usePrefs.persist.rehydrate()
}, [])После setTheme('dark') в localStorage по имени prefs лежит {"state":{"theme":"dark"},"version":1}. Сразу после создания стора там пусто: в Zustand 5 persist больше не записывает начальное состояние, пока не было первого set
Где это ломается:
- SSR и гидратация. На сервере нет
localStorage, и сервер рисует тему по умолчанию. На клиенте с синхронным хранилищем стор читаетlocalStorageпрямо при создании, первый рендер уже с тёмной темой, и React ругается на расхождение разметки. ОтсюдаskipHydrationиrehydrate()в эффекте: первый клиентский рендер совпадает с серверным, сохранённое значение приходит следом - Асинхронное хранилище (AsyncStorage, IndexedDB) отдаёт данные позже, и приложение успевает отрисоваться со значениями по умолчанию. Рендер ждут по флагу:
usePrefs.persist.hasHydrated()и подпискаonFinishHydration. СамhasHydrated()не реактивный, рендер он не вызовет - Смена схемы. Переименовал поле и не поднял
version, и у части пользователей в сторе осталось старое поле, а нового нет. Поднялversionбезmigrate, и сохранённое значение просто выбрасывается - Вложенные поля. По умолчанию сохранённое состояние сливается с начальным поверхностно. Новое поле во вложенном объекте у старых пользователей пропадёт, потому что объект целиком придёт из хранилища. Здесь нужен свой
merge
Секреты и токены в persist не кладут: localStorage читает любой скрипт на странице. Подробно про хранилища и cookie есть на странице «Cookie и хранилища»
Атомы и события в коде
Та же корзина на Jotai и на Effector:
// Jotai
import { atom, useAtomValue, useSetAtom } from 'jotai'
const itemsAtom = atom<string[]>([])
const countAtom = atom((get) => get(itemsAtom).length) // производный
const addAtom = atom(null, (get, set, id: string) => set(itemsAtom, [...get(itemsAtom), id]))
function CartBadge() {
const count = useAtomValue(countAtom)
const add = useSetAtom(addAtom)
return <button onClick={() => add('sku-1')}>{count}</button>
}// Effector
import { createEvent, createStore } from 'effector'
import { useUnit } from 'effector-react'
const itemAdded = createEvent<string>()
const $items = createStore<string[]>([]).on(itemAdded, (items, id) => [...items, id])
const $count = $items.map((items) => items.length)
function CartBadge() {
const [count, add] = useUnit([$count, itemAdded])
return <button onClick={() => add('sku-1')}>{count}</button>
}В Jotai логика лежит в атомах, и их легко держать рядом с компонентом. В Effector событие itemAdded — отдельная сущность: на него можно повесить запрос, аналитику и сброс формы, не трогая компонент
Как выбрать
Ответы с сервера в этот выбор не входят: кэш запросов держит TanStack Query или RTK Query, об этом соседняя страница «Серверное состояние: TanStack Query»
| Что | Когда брать | Чем платишь |
|---|---|---|
| Context | Редко меняющееся: тема, локаль, текущий пользователь. Маленький проект без отдельной библиотеки | Все потребители перерисовываются при смене значения |
| Zustand | Небольшая или средняя команда, несколько общих сторов: корзина, фильтры, состояние плеера. Нужен доступ к стору вне React | Мало правил из коробки, структуру сторов команда договаривается держать сама |
| Redux Toolkit | Большая команда и долгоживущий проект, где важны единые соглашения, DevTools с историей действий, middleware. Уже есть RTK Query | Больше кода и понятий, чем у Zustand |
| Jotai | Много мелких независимых значений и производных от них: редактор, конструктор, сложная форма-мастер | Граф атомов сложнее охватить взглядом, чем один стор |
| Effector | Много бизнес-логики, которую хочется держать вне компонентов и тестировать отдельно. Команда готова учить его модель | Свой словарь (события, эффекты, sample), меньше людей на рынке его знают |
Разумный ответ на собеседовании начинается не с библиотеки, а с вопроса, какое состояние осталось после серверного кэша, URL и локального useState. Часто его так мало, что хватает контекста или одного стора Zustand
⚠️ Где ошибаются
- Берут весь стор без селектора.
const { items } = useCart()выглядит аккуратно, но компонент подписан на всё и перерисуется от любогоset, даже от поля, которого он не видит. Бери поле селектором, несколько полей черезuseShallow - Возвращают новый объект или массив из селектора в Zustand 5.
(s) => s.items.filter(...)и(s) => ({ a: s.a, b: s.b })дают бесконечный цикл иMaximum update depth exceeded. Для набора полейuseShallow, для отфильтрованного спискаuseMemoв компоненте от исходного массива - Ждут глубокого слияния от
set.set({ user: { name } })заменитuserцеликом: Zustand сливает стейт только на один уровень. Вложенное обновляй через спредset((s) => ({ user: { ...s.user, name } }))или подключи middlewareimmer - Делают глобальный стор в Next.js на сервере. Модульный стор на сервере один на все запросы, и данные одного пользователя могут попасть в ответ другому. В SSR создают стор на запрос через
createStoreизzustand/vanillaи отдают через контекст - Создают атом Jotai внутри компонента.
atom(0)в теле функции на каждый рендер даёт новый ключ, и значение теряется. Атомы объявляют на уровне модуля, а если без компонента не обойтись, оборачивают вuseMemo
🎯 Вопросы с собеседований
Redux Toolkit vs Zustand vs атомарные стейт-менеджеры: что выбрать и почему?
Сначала убираю из выбора серверные данные, их держит TanStack Query или RTK Query, и состояние в URL. Если осталось немного редко меняющегося, хватает контекста. Для нескольких общих сторов в небольшой команде беру Zustand: мало кода, нет провайдера, стор доступен вне React. Redux Toolkit выигрывает в большой команде, где нужны жёсткие соглашения, DevTools с историей действий и middleware. Атомы, Jotai или Effector, подходят, когда состояние распадается на много мелких независимых частей с производными значениями или когда бизнес-логику хочется вынести из компонентов в граф событий
Как Zustand избегает лишних перерендеров?
Стор живёт вне React, а хук подключается к нему через useSyncExternalStore. На каждое изменение React вызывает селектор компонента и сравнивает результат с прошлым через Object.is. Если результат тот же, компонент не рендерится. Поэтому селектор должен возвращать примитив или существующую ссылку. Если нужно несколько полей объектом, селектор оборачивают в useShallow, который сравнивает поверхностно и возвращает прошлую ссылку. В Zustand 5 без этого селектор с новым объектом даёт бесконечный цикл
Что такое атомарное состояние и чем оно отличается от единого стора?
Вместо одного объекта со всеми полями состояние разбито на маленькие ячейки, атомы, а производные значения строятся из других атомов. Компонент подписывается ровно на прочитанные атомы, поэтому селекторы и сравнение не нужны: изменился атом, пересчитались его зависимые и перерисовались его читатели. Единый стор проще охватить взглядом и отладить, всё в одном месте. Атомы удобнее, когда кусков много и они независимы, но граф зависимостей сложнее увидеть целиком
Что такое сигналы и чем их модель отличается от модели React?
Сигнал — реактивное значение, которое помнит, кто его прочитал, и уведомляет только их. В React компонент — функция от состояния: изменилось состояние, функция вызывается целиком, React сравнивает виртуальное дерево и правит DOM. Сигналы обновляют точечно: в Preact сигнал прямо в JSX правит текстовый узел без рендера компонента. Цена в том, что поток данных становится неявным, и в обычном React это обходит его собственную модель
Как сохранить стор между перезагрузками и что может пойти не так?
В Zustand оборачиваю стор в persist с ключом name, по умолчанию он пишет в localStorage. Через partialize сохраняю только нужное, через version и migrate переживаю смену схемы. В SSR сервер не видит localStorage и рисует значения по умолчанию, а клиент читает хранилище сразу и рисует сохранённое, отсюда ошибка гидратации. Лечу через skipHydration: true и persist.rehydrate() в эффекте. С асинхронным хранилищем приложение может отрисоваться до чтения данных, поэтому рендер ждёт флага hasHydrated или подписки onFinishHydration. Токены туда не кладу
📚 Что почитать
- Migrating to v5 — что сломалось в пятой версии: селекторы с новым объектом,
persist, требования к React - Persisting store data — все опции
persistи рецепты для гидратации в SSR и асинхронных хранилищ - Jotai: atom — чем атом-конфиг отличается от значения и как устроены производные атомы
- Effector: core concepts — сторы, события, эффекты и
sampleна одной странице - Preact Signals —
signal,computed,effectи почему сигнал в JSX не перерисовывает компонент