メインコンテンツへスキップ
見出し画像

React で複数コンポーネント間の状態を共有する方法(4種)

    はじめに

    仕事でContextを使った実装があったのですが、以前はZustandを使っていたこともあり、それぞれの使い方やメリデメがごちゃごちゃになって混乱してきましたので、本記事を書きました。

    さて本題ですが、複数のコンポーネントから同じ値を参照・更新したい場面はよくあります。React にはいくつもの選択肢がありますが、それぞれ「向いている場面」と「コストの掛かり方」が違います。

    この記事は二部構成です。

    • 前半:4 つの代表的な手法(Context + useState、React Hook Form、Zustand、Redux Toolkit)の基本的な使い方

    • 後半:それぞれで非同期処理(API 通信など)をどう扱うか


    全体像 — どれを選ぶか

    まず結論からです。状況別の推奨はこのようになります。

    • フォームの値を複数コンポーネントで共有したい

      •  React Hook Form の useFormContext。バリデーションやパフォーマンス最適化まで全部含まれているので、フォーム用途ならまずこれを検討します。

    • フォーム以外の汎用的な状態共有(テーマ、認証情報など)

      •  React Context + useState。React 組み込みで追加ライブラリは不要です。

    • アプリ全体の複雑な状態管理

      •  Zustand または Redux Toolkit。スケールしやすく、DevTools などの開発体験も良好です。

    以下、それぞれを順番に見ていきます。


    第 1 部:基本的な使い方

    1. React Context + useState

    React 組み込みの仕組みだけで完結する、最も基本的な方法です。追加ライブラリは不要ですが、設計を間違えると不要な再レンダリングが大量発生するという落とし穴があります。

    実装の 3 ステップ

    ステップ 1:Context とカスタムフックを作る

    Context・Provider・カスタムフックは 1 ファイルにまとめておくと管理しやすくなります。

    // context/UserContext.jsx
    import { createContext, useContext, useState } from 'react';
    
    // ① Context オブジェクトを作る
    const UserContext = createContext(null);
    
    // ② Provider コンポーネント(state はここで管理する)
    export function UserProvider({ children }) {
      const [user, setUser] = useState({ name: '', email: '' });
    
      return (
        <UserContext.Provider value={{ user, setUser }}>
          {children}
        </UserContext.Provider>
      );
    }
    
    // ③ 使いやすいようカスタムフックでラップする
    export function useUser() {
      const context = useContext(UserContext);
      if (!context) throw new Error('UserProvider の外で使われています');
      return context;
    }
    

    ステップ 2:Provider でアプリをラップする

    // App.jsx
    import { UserProvider } from './context/UserContext';
    
    function App() {
      return (
        <UserProvider>  {/* この中ならどこからでもアクセスできる */}
          <Header />
          <ProfileForm />
          <ProfileDisplay />
        </UserProvider>
      );
    }
    

    ステップ 3:各コンポーネントで使う

    // ProfileForm.jsx(更新する側)
    import { useUser } from '../context/UserContext';
    
    function ProfileForm() {
      const { user, setUser } = useUser();
    
      return (
        <input
          value={user.name}
          onChange={e => setUser(prev => ({ ...prev, name: e.target.value }))}
        />
      );
    }
    
    // ProfileDisplay.jsx(読む側)
    import { useUser } from '../context/UserContext';
    
    function ProfileDisplay() {
      const { user } = useUser();
      return <p>こんにちは、{user.name} さん</p>;
    }
    

    設計のポイント

    押さえておきたいのは次の 4 点です。

    • Context・Provider・カスタムフックを 1 ファイルにまとめる

      • インポートがシンプルになり、変更箇所が一箇所で済みます。

    • カスタムフック内に if (!context) チェックを入れる 

      • Provider 外で誤って使われた場合に分かりやすいエラーを出せます。

    • setUser(prev => ...) の関数形式を使う

      • 非同期更新でも安全に前の値を参照できます。

    • Context を用途ごとに細かく分ける

      • 1 つに詰め込むと、関係ない値の変更で再レンダリングが走ってしまいます。

    最後の「Context を細かく分ける」は特に重要です。たとえばユーザー情報とテーマ設定を同じ Context に入れてしまうと、テーマを切り替えただけでユーザー情報を読んでいるコンポーネントまで再レンダリングされます。


    2. React Hook Form の useFormContext

    フォームに特化した解決策です。React Hook Form を既に使っているなら、これが一番スムーズです。register や watch といったフォーム機能をそのまま共有できます。Context をベースにした仕組みなので、親側で FormProvider でラップしておく必要があります。

    // 親コンポーネント
    import { useForm, FormProvider } from 'react-hook-form';
    
    function ParentForm() {
      const methods = useForm();
      return (
        <FormProvider {...methods}>
          <ComponentA />
          <ComponentB />
        </FormProvider>
      );
    }
    
    // 子コンポーネント(どこでも同じフォーム状態にアクセスできる)
    import { useFormContext } from 'react-hook-form';
    
    function ComponentA() {
      const { register } = useFormContext();
      return <input {...register('email')} />;
    }
    
    function ComponentB() {
      const { watch } = useFormContext();
      const email = watch('email');  // ComponentA の値をリアルタイムで参照できる
      return <p>入力中: {email}</p>;
    }
    

    通常の Context との大きな違いは、入力のたびに全体が再レンダリングされない という点です。React Hook Form は内部で subscription を細かく管理しているので、watch('email') を呼んでいるコンポーネントだけが email の変更時に再描画されます。


    3. Zustand — Provider が要らない

    Zustand の特徴は、Provider を一切書かなくていい という点です。

    Provider 不要の理由

    Zustand のストアは React のレンダリングツリーの外、JavaScript モジュールのスコープ に存在します。コンポーネントが useStore() を呼ぶと、内部でそのモジュールの値を直接購読する仕組みです。Context のように「ツリーの上方向に Provider を探しに行く」必要がありません。

    // store.js — モジュールスコープで定義するだけ
    import { create } from 'zustand';
    
    export const useUserStore = create((set) => ({
      name: '',
      email: '',
      setName: (newName) => set({ name: newName }),
    }));
    
    // どのコンポーネントからでも、ただ呼ぶだけ
    function ComponentA() {
      const name = useUserStore((state) => state.name);
      return <p>{name}</p>;
    }
    
    function ComponentB() {
      const name = useUserStore((state) => state.name);
      const setName = useUserStore((state) => state.setName);
      return (
        <input
          value={name}
          onChange={e => setName(e.target.value)}
        />
      );
    }
    

    セレクタによる最適化

    (state) => state.name のような セレクタ関数 を渡すと、name が変わったときだけ再レンダリングされます。関係ない値(たとえば email)が変わっても反応しません。Context だと「Provider の value が変わったら配下が全部再レンダリング」になるので、Zustand の方が標準で効率的です。

    // email が変わってもこのコンポーネントは再レンダリングされない
    const name = useUserStore((state) => state.name);
    

    4. Redux Toolkit — Provider は必要

    Redux も「グローバルなストア」を提供しますが、Provider が必要 です。これは Redux がもともと React 専用ではなく、React に「接続する」ためのアダプタとして react-redux が存在するからです。

    実装の 4 ステップ

    ステップ 1:Slice を定義する

    Redux Toolkit では createSlice を使って「状態 + それを変更する関数(reducer)」をひとまとめに定義します。Toolkit が内部で Immer を使っているので、state.name = 'foo' のように 直接書き換える書き方が許されます(実際には不変更新が行われます)。

    // features/user/userSlice.js
    import { createSlice } from '@reduxjs/toolkit';
    
    const userSlice = createSlice({
      name: 'user',
      initialState: {
        name: '',
        email: '',
      },
      reducers: {
        setName: (state, action) => {
          state.name = action.payload;  // 直接代入してよい(Immer のおかげ)
        },
        setEmail: (state, action) => {
          state.email = action.payload;
        },
        resetUser: (state) => {
          state.name = '';
          state.email = '';
        },
      },
    });
    
    // アクション(コンポーネントから dispatch するもの)
    export const { setName, setEmail, resetUser } = userSlice.actions;
    
    // reducer(store に登録するもの)
    export default userSlice.reducer;
    

    ステップ 2:Store を作る

    configureStore に reducer を登録すれば、それだけで Redux DevTools の連携やデフォルトミドルウェアの設定が済みます。

    // app/store.js
    import { configureStore } from '@reduxjs/toolkit';
    import userReducer from '../features/user/userSlice';
    
    export const store = configureStore({
      reducer: {
        user: userReducer,
        // 機能が増えたらここに追加していく
        // posts: postsReducer,
        // auth: authReducer,
      },
    });
    

    userReducer は、ステップ 1 で書いた export default userSlice.reducer の中身です。デフォルトエクスポートは import 側で自由に名前を付けられるので、慣習として <機能名>Reducer という名前にしています。reducer: { user: userReducer } のキー user は、コンポーネントで useSelector((state) => state.user.name) と書くときの state.user に対応します。

    ステップ 3:Provider でアプリをラップする

    ここは一度書くだけです。

    // main.jsx
    import { Provider } from 'react-redux';
    import { store } from './app/store';
    import App from './App';
    
    <Provider store={store}>
      <App />
    </Provider>
    

    ステップ 4:コンポーネントから使う

    useSelector で読み取り、useDispatch でアクションを送信します。

    // ProfileForm.jsx(更新する側)
    import { useSelector, useDispatch } from 'react-redux';
    import { setName } from './features/user/userSlice';
    
    function ProfileForm() {
      const name = useSelector((state) => state.user.name);
      const dispatch = useDispatch();
    
      return (
        <input
          value={name}
          onChange={(e) => dispatch(setName(e.target.value))}
        />
      );
    }
    
    // ProfileDisplay.jsx(読む側)
    import { useSelector } from 'react-redux';
    
    function ProfileDisplay() {
      const name = useSelector((state) => state.user.name);
      return <p>こんにちは、{name} さん</p>;
    }
    

    Redux Toolkit のメリット

    ルートに Provider を 1 度書くだけなので普段はほぼ意識しません。Redux の真価は次のような点にあります。

    • Redux DevTools による時系列デバッグ

      • どのアクションでどう状態が変わったか全履歴を追える

    • ミドルウェアによる副作用管理

      • API 通信や非同期処理を createAsyncThunk で整理できる(詳しくは後半で)

    • 大規模チームでの規約の作りやすさ

      • Slice 単位でファイルが分かれるので責務が明確

    小〜中規模なら Zustand の方が記述量が圧倒的に少なくて済みますが、チームでガチガチに規約を敷きたい場合や、複雑な副作用を扱う場合は Redux が選ばれることが多いです。


    第 1 部のまとめ

    4 つの手法を Provider の必要性・記述量・再レンダリング制御・向いている場面で整理すると、こうなります。

    • Context + useState は Provider が必須で、記述量は少なめ。再レンダリング制御は手動で工夫が必要です。小規模なアプリや、テーマ・認証情報など変更頻度が低い値の共有に向いています。

    • RHF の useFormContext も Provider が必須ですが、記述量は少なく、再レンダリングはライブラリが自動で最適化してくれます。フォームの値共有が主用途です。

    • Zustand は Provider 不要、記述量はこの中で最も少なく、セレクタで再レンダリングが自動的に絞られます。中〜大規模のアプリで記述をシンプルに保ちたいときに向いています。

    • Redux Toolkit は Provider が必須(ただし 1 回だけ)、記述量はやや多めですが、セレクタで再レンダリングが自動最適化されます。大規模チーム、DevTools での時系列追跡、副作用が複雑なケースに向いています。


    第 2 部:非同期処理の扱い

    ここからは「API 通信のような非同期処理を、各手法でどう扱うか」を見ていきます。どの手法を使っても非同期処理自体は書けますが、ライブラリが面倒を見てくれる範囲 が違うので、考慮すべきポイントが変わってきます。

    1. Context + useState の非同期処理

    非同期処理のサポートは ゼロ です。ローディング状態やエラー状態は自分で useState を増やして管理する必要があります。

    import { createContext, useContext, useState } from 'react';
    
    const UserContext = createContext(null);
    
    export function UserProvider({ children }) {
      // 第 1 部と同じフィールド
      const [user, setUser] = useState({ name: '', email: '' });
    
      // 非同期処理のために追加
      const [status, setStatus] = useState('idle');
      const [error, setError] = useState(null);
    
      const fetchUser = async (id) => {
        setStatus('loading');
        setError(null);
        try {
          const res = await fetch(`/api/users/${id}`);
          if (!res.ok) throw new Error('取得失敗');
          const data = await res.json();
          setUser({ name: data.name, email: data.email });
          setStatus('succeeded');
        } catch (err) {
          setError(err.message);
          setStatus('failed');
        }
      };
    
      return (
        <UserContext.Provider value={{ user, status, error, fetchUser }}>
          {children}
        </UserContext.Provider>
      );
    }
    
    // 第 1 部と同じカスタムフック(Provider 外チェック付き)
    export function useUser() {
      const context = useContext(UserContext);
      if (!context) throw new Error('UserProvider の外で使われています');
      return context;
    }
    

    コンポーネント側からは useUser を介して fetchUser と状態を取り出します。

    import { useEffect } from 'react';
    import { useUser } from '../context/UserContext';
    
    function UserProfile({ userId }) {
      const { user, status, error, fetchUser } = useUser();
    
      useEffect(() => {
        fetchUser(userId);
      }, [userId]);
    
      if (status === 'loading') return <p>読み込み中...</p>;
      if (status === 'failed') return <p>エラー: {error}</p>;
      return <p>{user.name}</p>;
    }
    

    考慮すべき点:

    • 状態が増えるたびに Provider が肥大化する

    • status / error の管理パターンを毎回書くことになる(共通化しないとファイルごとにバラバラになる)

    • Provider の value が変わるたびに配下が再レンダリングされやすい

    • 競合状態(古いリクエストの結果が後から届く問題)の対策も自前で必要

    2. React Hook Form の非同期処理

    フォーム送信時の非同期処理は 組み込みでサポート されています。handleSubmit に async 関数を渡せば、isSubmitting で送信中状態を自動管理してくれます。

    import { useForm } from 'react-hook-form';
    
    function ProfileForm() {
      const { register, handleSubmit, formState: { isSubmitting } } = useForm();
    
      const onSubmit = async (data) => {
        const res = await fetch('/api/users', {
          method: 'POST',
          body: JSON.stringify(data),
        });
        if (!res.ok) throw new Error('送信失敗');
      };
    
      return (
        <form onSubmit={handleSubmit(onSubmit)}>
          <input {...register('name')} />
          <button disabled={isSubmitting}>
            {isSubmitting ? '送信中...' : '送信'}
          </button>
        </form>
      );
    }
    

    useFormContext でも同じことができる

    第 1 部で紹介した FormProvider + useFormContext の構成でも、非同期送信は同じように書けます。handleSubmit や isSubmitting は親の useForm() が返す methods に含まれているので、子コンポーネントからも useFormContext() 経由で取り出せます。

    // 親:form タグと送信ハンドラを置く
    import { useForm, FormProvider } from 'react-hook-form';
    
    function ParentForm() {
      const methods = useForm();
    
      const onSubmit = async (data) => {
        const res = await fetch('/api/users', {
          method: 'POST',
          body: JSON.stringify(data),
        });
        if (!res.ok) throw new Error('送信失敗');
      };
    
      return (
        <FormProvider {...methods}>
          <form onSubmit={methods.handleSubmit(onSubmit)}>
            <NameField />
            <SubmitButton />
          </form>
        </FormProvider>
      );
    }
    
    // 子:入力フィールドは register をもらうだけ
    import { useFormContext } from 'react-hook-form';
    
    function NameField() {
      const { register } = useFormContext();
      return <input {...register('name')} />;
    }
    
    // 子:送信ボタンも別コンポーネントから isSubmitting を参照できる
    function SubmitButton() {
      const { formState: { isSubmitting } } = useFormContext();
      return (
        <button disabled={isSubmitting}>
          {isSubmitting ? '送信中...' : '送信'}
        </button>
      );
    }
    

    ポイントは、onSubmit は親に置いたまま にする点です。子コンポーネントは入力や表示の責務だけを持ち、API 通信のロジックは親に集約されるので、フォーム全体の見通しが良くなります。

    考慮すべき点: フォーム送信に関しては基本的に困りません。ただしフォーム外の非同期処理(初期データの取得など)は別途仕組みが必要です。

    3. Zustand の非同期処理

    非同期処理は アクション内に普通の async 関数を書くだけ で動きます。Redux Toolkit のように Thunk という概念を持ち出さなくていいのが特徴です。

    第 1 部の基本サンプルに、API 取得用のアクションと状態を足した形にするとこうなります。

    import { create } from 'zustand';
    
    export const useUserStore = create((set) => ({
      // 第 1 部と同じフィールド
      name: '',
      email: '',
      setName: (newName) => set({ name: newName }),
    
      // 非同期処理のために追加
      status: 'idle',
      error: null,
    
      fetchUser: async (id) => {
        set({ status: 'loading', error: null });
        try {
          const res = await fetch(`/api/users/${id}`);
          if (!res.ok) throw new Error('取得失敗');
          const user = await res.json();
          set({ name: user.name, email: user.email, status: 'succeeded' });
        } catch (err) {
          set({ status: 'failed', error: err.message });
        }
      },
    }));
    

    コンポーネント側ではセレクタで必要な値だけを購読します。useUserStore() を引数なしで呼ぶとストア全体を購読してしまい、関係ない値の変更でも再レンダリングが走るので、用途ごとに分けて取り出すのがおすすめです。

    import { useEffect } from 'react';
    
    function UserProfile({ userId }) {
      const name = useUserStore((state) => state.name);
      const status = useUserStore((state) => state.status);
      const fetchUser = useUserStore((state) => state.fetchUser);
    
      useEffect(() => {
        fetchUser(userId);
      }, [fetchUser, userId]);
    
      if (status === 'loading') return <p>読み込み中...</p>;
      return <p>{name}</p>;
    }
    

    考慮すべき点:

    • 書きやすさはこの中で一番

    • ただし createAsyncThunk のような「pending / fulfilled / rejected が自動生成される」便利機能はない

    • ローディング状態の管理パターンは自分で決める必要がある(プロジェクト内で統一を意識)

    • DevTools 連携は別途プラグインで対応可能

    4. Redux Toolkit の非同期処理(createAsyncThunk)

    Redux はそのままでは「同期的に状態を更新する」ことしかできません。API 通信のような非同期処理を扱うには ミドルウェア という仕組みが必要になります。ミドルウェアは dispatch されたアクションが reducer に届く前に割り込んで、副作用(API 通信、ログ出力、ルーティングなど)を処理できる層です。

    Redux Toolkit には Thunk ミドルウェアがデフォルトで組み込まれており、configureStore を使った時点で自動的に有効になっています。そのおかげで、非同期処理を「アクションのように」扱えるのが Redux の大きな強みです。具体的には次のようなメリットがあります。

    • ローディング・成功・失敗の状態が Slice 内に集約される

      • コンポーネント側に散らばらない

    • DevTools で非同期処理の流れも追える

      • どのリクエストがいつ走り、いつ完了したかが履歴で見える

    • 副作用の再利用がしやすい

      • 同じ API 呼び出しを複数コンポーネントから dispatch するだけで使い回せる

    その仕組みを最も簡単に使えるのが createAsyncThunk です。これは「非同期関数 + 自動生成されるアクション(pending / fulfilled / rejected)」をワンセットで作ってくれるユーティリティです。

    Thunk と Slice の定義

    // features/user/userSlice.js
    import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
    
    // ① 非同期処理を定義する
    // 第 1 引数:アクションのタイプ名
    // 第 2 引数:実際の非同期処理(payload を受け取り、結果を返す)
    export const fetchUser = createAsyncThunk(
      'user/fetchUser',
      async (userId, { rejectWithValue }) => {
        try {
          const res = await fetch(`/api/users/${userId}`);
          if (!res.ok) throw new Error('ユーザー取得に失敗しました');
          return await res.json();  // 成功時:fulfilled の payload になる
        } catch (err) {
          return rejectWithValue(err.message);  // 失敗時:rejected の payload になる
        }
      }
    );
    
    const userSlice = createSlice({
      name: 'user',
      initialState: {
        name: '',
        email: '',
        // 非同期処理のために追加
        status: 'idle',  // 'idle' | 'loading' | 'succeeded' | 'failed'
        error: null,
      },
      reducers: {
        // 同期的な reducer はここに(簡潔さのため setName のみ記載。
        // setEmail / resetUser もここに置く想定)
        setName: (state, action) => { state.name = action.payload; },
      },
      // ② 非同期アクションは extraReducers で扱う
      extraReducers: (builder) => {
        builder
          .addCase(fetchUser.pending, (state) => {
            state.status = 'loading';
            state.error = null;
          })
          .addCase(fetchUser.fulfilled, (state, action) => {
            state.status = 'succeeded';
            state.name = action.payload.name;
            state.email = action.payload.email;
          })
          .addCase(fetchUser.rejected, (state, action) => {
            state.status = 'failed';
            state.error = action.payload;  // rejectWithValue で渡した値
          });
      },
    });
    
    export const { setName } = userSlice.actions;
    export default userSlice.reducer;
    

    ポイントは 3 つのライフサイクルアクション(pending / fulfilled / rejected)が自動で生成されることです。自分で「ローディング開始」「成功」「失敗」のアクションを書き分ける必要がなくなります。なお rejectWithValue を使うとエラー情報を action.payload として渡せます(普通に throw した場合は action.error.message 側に入ります)。

    コンポーネントから使う

    dispatch する側は通常のアクションとほぼ同じです。返り値が Promise なので await や .unwrap() で結果を待てます。

    // UserProfile.jsx
    import { useEffect } from 'react';
    import { useSelector, useDispatch } from 'react-redux';
    import { fetchUser } from './features/user/userSlice';
    
    function UserProfile({ userId }) {
      const dispatch = useDispatch();
      const { name, email, status, error } = useSelector((state) => state.user);
    
      useEffect(() => {
        dispatch(fetchUser(userId));
      }, [dispatch, userId]);
    
      if (status === 'loading') return <p>読み込み中...</p>;
      if (status === 'failed') return <p>エラー: {error}</p>;
    
      return (
        <div>
          <p>名前: {name}</p>
          <p>メール: {email}</p>
        </div>
      );
    }
    

    成功・失敗をコンポーネント側でハンドリングしたい場合は .unwrap() を使うと try-catch で書けます。

    async function handleSubmit() {
      try {
        const user = await dispatch(fetchUser(userId)).unwrap();
        console.log('取得成功:', user);
        // 成功時の追加処理(画面遷移など)
      } catch (err) {
        console.error('取得失敗:', err);
        // 失敗時の追加処理(トースト表示など)
      }
    }
    

    .unwrap() を付けないと dispatch の返り値は「常に成功する Promise(中に fulfilled か rejected のアクションが入っている)」になるため、エラーを catch したい場合は .unwrap() が必要になります。


    第 2 部のまとめ

    非同期処理のサポート範囲を 4 つの手法で比べると、こうなります。

    • Context + useState は非同期サポートがゼロで、ローディングやエラーは自前で useState を増やして管理する必要があります。副作用の追跡もできません。

    • React Hook Form はフォーム送信時の非同期処理だけ自動でサポートされており、isSubmitting などで送信中状態が管理されます。フォーム外の副作用追跡はできません。

    • Zustand はアクション内に async 関数を書くだけで動きますが、ローディング・エラーの管理パターンは自前で決める必要があります。副作用の追跡はプラグインで対応可能です。

    • Redux Toolkit は createAsyncThunk で非同期処理が構造化され、pending / fulfilled / rejected が自動生成されます。副作用は DevTools で完全に追跡できます。

    もう一つの選択肢:サーバー状態は専用ツールに任せる

    最近のトレンドでは、サーバーから取得するデータ(API 通信)はそもそも状態管理ライブラリで扱わない という考え方が主流になりつつあります。代わりに TanStack Query(旧 React Query) や SWR を使います。

    import { useQuery } from '@tanstack/react-query';
    
    function UserProfile({ userId }) {
      const { data, isLoading, error } = useQuery({
        queryKey: ['user', userId],
        queryFn: () => fetch(`/api/users/${userId}`).then(r => r.json()),
      });
    
      if (isLoading) return <p>読み込み中...</p>;
      if (error) return <p>エラー: {error.message}</p>;
      return <p>{data.name}</p>;
    }
    

    これだけでキャッシュ、再フェッチ、競合状態の解決、ローディング・エラー管理が全部入っています。役割分担としてはこうなります。

    • クライアント状態(UI の開閉、フォーム入力、テーマなど)

      •  Context / Zustand / Redux

    • サーバー状態(API から取得するデータ)

      •  TanStack Query / SWR

    この分け方をすると、Zustand や Context は「軽くて十分」になり、Redux Toolkit を入れる必要性自体が下がります。


    最終まとめ

    選択の指針はシンプルです。

    • フォームならまず React Hook Form を検討する。FormProvider + useFormContext だけで多くの要求が満たせます。

    • フォーム以外で、共有する値が少なく変更頻度も低いなら Context + useState で十分。追加ライブラリの依存も増えません。

    • アプリ全体の状態を扱うなら Zustand がバランスが良いです。Provider 不要・記述シンプル・セレクタで最適化と、デメリットが少ない。

    • チーム規模が大きく、厳格なフロー制御や DevTools での時系列追跡が必要なら Redux Toolkit。

    • API 通信のような「サーバー状態」を扱うなら、TanStack Query や SWR を併用する のが現代的なアプローチ。

    「最初は Context、複雑になってきたら Zustand に移行する」というステップでも問題ありません。重要なのは、共有する値の 変更頻度 と 読み取るコンポーネントの数、そして クライアント状態かサーバー状態か を見て、適切なツールを組み合わせることです。


    あなたへのおすすめ