※本記事には広告(楽天アフィリエイト)リンクが含まれる場合があります。

「Reduxは設定が多すぎて個人開発には重い」「Context APIだとパフォーマンスが心配」「Jotai・Recoilどれを選べばいいのか迷っている」——Reactの状態管理ライブラリ選びで悩んだことはありませんか?

Zustand(ドイツ語で「状態」の意)はその問いに対して明確な答えを持っています。ボイラープレートが最小限、Providerラッパー不要、TypeScript完全対応——これだけの特徴を持ちながら、バンドルサイズはわずか約1KB(gzip)です。2026年現在、npm週間ダウンロード数は1,700万超を記録しており、React状態管理の事実上の標準ライブラリとなっています。

この記事では、Zustandの基本的なストア作成から、persist・immer・devtoolsミドルウェアの活用法、大規模アプリ向けのスライスパターン、Redux/Jotaiとの比較まで徹底解説します。

広告・楽天アフィリエイト

プログラミング技術書

実践寄りの技術書・参考書を探す。

楽天ポイント還元

技術書を楽天で見る →

Zustandとは:なぜ2026年でも選ばれるのか

Zustandはpmndrs(Poimandres)チームが開発・メンテナンスしているReact向け状態管理ライブラリです。同チームはThree.js向けのreact-three-fiberやアニメーションライブラリreact-springなど、パフォーマンス重視のライブラリを多数開発していることで知られています。

Zustandが支持される理由を一言で表すと「シンプルだが機能は十分」です。具体的に見ていきましょう。

Zustandの5つの特徴

  • Providerレス設計:Reduxのように <Provider> でアプリを包む必要がない。ストアをimportするだけで使える
  • 最小限のボイラープレート:actions・reducers・selectors を分離して定義する必要がなく、ストア1ファイルで完結する
  • TypeScript完全対応:型推論が自然に効き、ジェネリクスや型アサーションの乱用が不要
  • バンドルサイズ約1KB:依存ゼロ(React以外)、ランタイムコストが極小
  • React外でも動作:Vanilla JSからも状態を購読・更新でき、テストや外部連携が容易

インストール

npm・yarn・pnpm・bunどれでもインストールできます。

# npm
npm install zustand

# pnpm
pnpm add zustand

# yarn
yarn add zustand

# bun
bun add zustand

Zustand v5系(2025年リリース)では useShallow が本体にバンドルされ、セレクター最適化がさらに使いやすくなっています。

基本的なストアの作成

Zustandの中核は create 関数です。状態(state)とアクション(actions)を1つのオブジェクトとして定義します。

// stores/counterStore.ts
import { create } from 'zustand'

type CounterState = {
  count: number
  increment: () => void
  decrement: () => void
  reset: () => void
}

export const useCounterStore = create<CounterState>()((set) => ({
  count: 0,
  increment: () => set((state) => ({ count: state.count + 1 })),
  decrement: () => set((state) => ({ count: state.count - 1 })),
  reset: () => set({ count: 0 }),
}))

create はカスタムフックを返します。コンポーネント側は useCounterStore を呼ぶだけです。

// components/Counter.tsx
import { useCounterStore } from '@/stores/counterStore'

export function Counter() {
  const { count, increment, decrement, reset } = useCounterStore()

  return (
    <div>
      <p>カウント: {count}</p>
      <button onClick={increment}>+1</button>
      <button onClick={decrement}>-1</button>
      <button onClick={reset}>リセット</button>
    </div>
  )
}

これだけで動作します。Providerも、actionタイプ定義も、dispatchも不要です。

セレクターで不要な再レンダリングを防ぐ

デフォルトでは、ストアの任意の値が変わると全サブスクライバーが再レンダリングされます。パフォーマンスを最適化するには、セレクター関数を渡して必要な値だけを購読します。

// count だけを購読(count が変わったときだけ再レンダリング)
const count = useCounterStore((state) => state.count)

// increment だけを購読(アクションは参照が変わらないので再レンダリングなし)
const increment = useCounterStore((state) => state.increment)

複数の値をまとめてセレクトしたい場合は useShallow を使います(v5から本体同梱)。

import { useShallow } from 'zustand/react/shallow'

// count と decrement だけを購読(どちらかが変わったときだけ再レンダリング)
const { count, decrement } = useCounterStore(
  useShallow((state) => ({ count: state.count, decrement: state.decrement }))
)

派生状態(Computed State)

Zustandには computed/derived state の専用機能はありませんが、いくつかのパターンで実現できます。

パターン1:ストア外でセレクターとして定義する

// stores/cartStore.ts
type CartState = {
  items: { id: string; price: number; qty: number }[]
  addItem: (item: CartState['items'][0]) => void
}

export const useCartStore = create<CartState>()((set) => ({
  items: [],
  addItem: (item) => set((state) => ({ items: [...state.items, item] })),
}))

// セレクターとしてエクスポート
export const selectTotal = (state: CartState) =>
  state.items.reduce((sum, item) => sum + item.price * item.qty, 0)

// コンポーネント側
const total = useCartStore(selectTotal)

パターン2:get() を使ってストア内で計算する

const useStore = create<State>()((set, get) => ({
  items: [],
  // getTotal はアクションとして定義(呼び出し時に計算)
  getTotal: () => get().items.reduce((sum, item) => sum + item.price, 0),
}))

ミドルウェア:persist・immer・devtools

Zustandのミドルウェアは create の中にラップして使います。3つのミドルウェアを組み合わせた典型的な構成を見てみましょう。

devtools:Redux DevToolsと連携する

import { create } from 'zustand'
import { devtools } from 'zustand/middleware'

export const useStore = create<State>()(
  devtools(
    (set) => ({
      count: 0,
      increment: () => set((state) => ({ count: state.count + 1 }), false, 'increment'),
    }),
    { name: 'CounterStore' }
  )
)

set の第3引数にアクション名を渡すと、Redux DevToolsのタイムラインに名前付きで表示されます。開発中のデバッグが格段に楽になります。

persist:ローカルストレージへ永続化する

import { create } from 'zustand'
import { persist, createJSONStorage } from 'zustand/middleware'

type AuthState = {
  token: string | null
  user: { id: string; name: string } | null
  setAuth: (token: string, user: AuthState['user']) => void
  logout: () => void
}

export const useAuthStore = create<AuthState>()(
  persist(
    (set) => ({
      token: null,
      user: null,
      setAuth: (token, user) => set({ token, user }),
      logout: () => set({ token: null, user: null }),
    }),
    {
      name: 'auth-storage',            // localStorageのキー名
      storage: createJSONStorage(() => localStorage),
      partialize: (state) => ({ token: state.token, user: state.user }),
    }
  )
)

partialize を使うと、保存する値を選択できます。アクション関数は保存不要なので除外するのがベストプラクティスです。

immer:イミュータブルな更新をミュータブルに書く

ネストの深いオブジェクトをスプレッド演算子で更新するのは冗長になりがちです。immer ミドルウェアを使うと、直接代入するような書き方でイミュータブルな更新ができます。

import { create } from 'zustand'
import { immer } from 'zustand/middleware/immer'

type TodoState = {
  todos: { id: string; text: string; done: boolean }[]
  toggleTodo: (id: string) => void
}

export const useTodoStore = create<TodoState>()(
  immer((set) => ({
    todos: [],
    toggleTodo: (id) =>
      set((state) => {
        const todo = state.todos.find((t) => t.id === id)
        if (todo) todo.done = !todo.done  // 直接変更してOK(Immerがコピーを作る)
      }),
  }))
)

ミドルウェアを複数組み合わせる

devtools・persist・immerを同時に使う場合はネストして組み合わせます。型推論を正しく効かせるには順序が重要です。

import { create } from 'zustand'
import { devtools, persist } from 'zustand/middleware'
import { immer } from 'zustand/middleware/immer'

export const useStore = create<State>()(
  devtools(
    persist(
      immer((set) => ({
        // ...ストア定義
      })),
      { name: 'my-store' }
    ),
    { name: 'MyStore' }
  )
)

一般的な推奨順序は devtools → persist → immer の外から内です。devtoolsを最外部に置くことでミドルウェアチェーン全体のアクションが可視化されます。

非同期アクション(APIコール)

Zustandはアクションを async 関数として定義できます。ReduxのようにmiddlewareやcreateAsyncThunkは不要です。

type UserState = {
  users: User[]
  loading: boolean
  error: string | null
  fetchUsers: () => Promise<void>
}

export const useUserStore = create<UserState>()((set) => ({
  users: [],
  loading: false,
  error: null,
  fetchUsers: async () => {
    set({ loading: true, error: null })
    try {
      const res = await fetch('/api/users')
      const users = await res.json()
      set({ users, loading: false })
    } catch (err) {
      set({ error: (err as Error).message, loading: false })
    }
  },
}))

注意:非同期処理はZustandよりもTanStack Queryに任せるのが現代的なベストプラクティスです。サーバー状態(APIから取得するデータ)はTanStack Query、クライアント状態(UIの開閉状態・フォームデータ等)はZustandという役割分担が2026年の主流パターンです。

スライスパターン(大規模状態管理)

アプリが大きくなるにつれ、1つのストアファイルが肥大化します。そのときに使うのがスライスパターンです。Redux Toolkitのスライスと同様の発想ですが、設定不要でシンプルに実現できます。

// stores/slices/cartSlice.ts
import { StateCreator } from 'zustand'
import type { StoreState } from '../useStore'

export type CartSlice = {
  cartItems: CartItem[]
  addToCart: (item: CartItem) => void
  clearCart: () => void
}

export const createCartSlice: StateCreator<StoreState, [], [], CartSlice> = (set) => ({
  cartItems: [],
  addToCart: (item) =>
    set((state) => ({ cartItems: [...state.cartItems, item] })),
  clearCart: () => set({ cartItems: [] }),
})

// stores/slices/authSlice.ts
export type AuthSlice = {
  currentUser: User | null
  login: (user: User) => void
  logout: () => void
}

export const createAuthSlice: StateCreator<StoreState, [], [], AuthSlice> = (set) => ({
  currentUser: null,
  login: (user) => set({ currentUser: user }),
  logout: () => set({ currentUser: null }),
})

// stores/useStore.ts
import { create } from 'zustand'
import { createCartSlice, CartSlice } from './slices/cartSlice'
import { createAuthSlice, AuthSlice } from './slices/authSlice'

export type StoreState = CartSlice & AuthSlice

export const useStore = create<StoreState>()((...a) => ({
  ...createCartSlice(...a),
  ...createAuthSlice(...a),
}))

各スライスは独立したファイルで管理でき、テストも単体で書けます。

React外からストアを操作する

Zustandのストアはフックとは独立したオブジェクトとして機能します。.getState() と .setState() を使えばReactコンポーネント外(APIレスポンスのコールバック、WebSocketイベント、テストコードなど)からも状態を操作できます。

// React外からストアにアクセス
const { count, increment } = useCounterStore.getState()
increment()

// WebSocketからの更新
socket.on('user-update', (user) => {
  useAuthStore.setState({ currentUser: user })
})

// テストコード
test('increment increases count', () => {
  useCounterStore.setState({ count: 0 })
  useCounterStore.getState().increment()
  expect(useCounterStore.getState().count).toBe(1)
})

Zustand vs Redux vs Jotai vs Recoil:どれを選ぶか

ライブラリ サイズ パターン 向いている用途
Zustand ~1KB ストア中心 個人開発〜中規模アプリ、シンプルなグローバル状態
Redux Toolkit ~18KB Flux/アクション 大規模チーム開発、엄格な変更履歴管理が必要な場合
Jotai ~13KB アトム中心 細かい単位で状態を分散管理したい場合・React Suspense活用
Recoil ~80KB アトム中心 ※開発縮小傾向。新規採用は非推奨(2026年現在)
Context API 0KB(内蔵) コンテキスト テーマ・ロケールなど低頻度更新のデータ。状態管理には不向き

結論:迷ったらZustandを選んでください。Redux Toolkitは「大規模チームでの엄格な変更管理が必要」という特定のユースケース向けです。Jotaiは「アトム単位の細かい依存関係管理」が必要な場合に検討します。個人開発・スタートアップ・中規模チームではZustandが最も費用対効果の高い選択です。

TypeScript活用のベストプラクティス

型を厳密に定義する

// NG: any を使わない
const useStore = create((set) => ({ count: 0 }))

// OK: 型パラメータを明示
const useStore = create<CounterState>()((set) => ({ count: 0 }))

create<State>() のように型パラメータを渡す際、v4以降は **カリー化記法**(後ろに () を付ける)が必要です。TypeScript の型推論を正しく機能させるための仕様です。

ストア内のアクションと状態を型で分ける

// 状態と操作を型で分離するとメンテナンスしやすい
type State = {
  bears: number
}

type Actions = {
  increase: () => void
  decrease: () => void
}

const useBearStore = create<State & Actions>()((set) => ({
  bears: 0,
  increase: () => set((state) => ({ bears: state.bears + 1 })),
  decrease: () => set((state) => ({ bears: state.bears - 1 })),
}))

テストの書き方

Vitest または Jest でZustandストアをテストする際は、テスト間で状態が引き継がれないよう beforeEach でリセットします。

// stores/__tests__/counterStore.test.ts
import { describe, it, expect, beforeEach } from 'vitest'
import { useCounterStore } from '../counterStore'

describe('CounterStore', () => {
  beforeEach(() => {
    useCounterStore.setState({ count: 0 })
  })

  it('初期値は0', () => {
    expect(useCounterStore.getState().count).toBe(0)
  })

  it('increment で+1される', () => {
    useCounterStore.getState().increment()
    expect(useCounterStore.getState().count).toBe(1)
  })

  it('reset で0に戻る', () => {
    useCounterStore.setState({ count: 10 })
    useCounterStore.getState().reset()
    expect(useCounterStore.getState().count).toBe(0)
  })
})

React コンポーネントのテストには @testing-library/react を使います。フックと同様に renderHook や render で検証できます。

よくあるハマりポイントと解決策

ハマり1:オブジェクトを一括でセレクトすると毎回再レンダリングされる

// NG: オブジェクトを返すセレクターは毎回新しい参照を生成する
const { count, user } = useStore((state) => ({ count: state.count, user: state.user }))

// OK: useShallow でシャロー比較する
import { useShallow } from 'zustand/react/shallow'
const { count, user } = useStore(useShallow((state) => ({ count: state.count, user: state.user })))

ハマり2:persist 使用時に型エラーが発生する

persist ミドルウェアと immer を組み合わせると型推論が崩れることがあります。その場合は StateCreator の型パラメータを明示的に渡します。

import { StateCreator } from 'zustand'
import { PersistOptions } from 'zustand/middleware'

type MyPersist = (
  config: StateCreator<State>,
  options: PersistOptions<State>
) => StateCreator<State>

ハマり3:Next.js App Router で hydration エラーが出る

SSR環境でpersistを使うと、サーバーとクライアントの状態が一致せずhydrationエラーが発生することがあります。

// _hasHydrated フラグでクライアントサイドを待つ
const useStore = create<State & { _hasHydrated: boolean; setHasHydrated: (v: boolean) => void }>()(
  persist(
    (set) => ({
      _hasHydrated: false,
      setHasHydrated: (v) => set({ _hasHydrated: v }),
      // ...状態定義
    }),
    {
      name: 'my-store',
      onRehydrateStorage: () => (state) => {
        state?.setHasHydrated(true)
      },
    }
  )
)

// コンポーネント側
function App() {
  const hasHydrated = useStore((state) => state._hasHydrated)
  if (!hasHydrated) return null  // ハイドレーション完了まで何も描画しない
  // ...
}

まとめ:Zustandを使うべき場面

Zustandは「シンプルかつパワフル」という相反する要求を両立させた稀有なライブラリです。以下のようなケースで特に力を発揮します。

  • ユーザー認証状態・テーマ設定などグローバルなUIの状態を管理したい
  • TanStack Queryと組み合わせてサーバー状態とクライアント状態を分離したい
  • Reduxのような大がかりな設定なしに開発を始めたい個人開発者
  • フォームの一時データやモーダルの開閉など複数コンポーネントをまたぐUI状態を管理したい
  • React Native アプリでも同じ状態管理パターンを使いたい

公式ドキュメントは docs.pmnd.rs/zustand にあり、2026年現在も活発にメンテナンスされています。まずは npm install zustand してシンプルなカウンターから試してみてください。