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

ReactにおけるContext ProviderとZustandのような状態管理ライブラリの適切な使い分け

    Reactアプリケーション開発において、状態管理は常に重要な課題です。特に、プロジェクトが大きくなるにつれて「どの状態管理ツールを使うべきか」という疑問が生じます。今回は、二つの主要な状態管理アプローチであるContext ProviderとZustandの適切な使い分けについて掘り下げていきます。

    状態管理ツールの選択はなぜ重要か

    状態管理ツールの選択は単なる好みの問題ではありません。それは

    • アプリケーションの保守性

    • コードの拡張性

    • UIのパフォーマンス

    に直接影響する重要な決断です。適切なツールを適切な場所で使用することで、長期的なプロジェクトの健全性を確保できます。

    それでは、Context ProviderとZustandの違いを見ていきましょう。

    Context ProviderとZustandの根本的な違い

    Context Providerの本質

    React ContextはReactの公式機能として、コンポーネントツリーを通じて「値」を提供します。その核となる特性は

    • Reactのレンダリングサイクルとの統合: コンテキスト値の変更はReactの再レンダリングを直接トリガーします

    • コンポーネント階層に依存: 提供する側と消費する側の間にコンポーネント関係が必要です

    • シンプルなAPI: 特別なライブラリを必要とせず、React標準機能として利用できます

    // src/providers/ThemeProvider.tsx
    import React, { createContext, useContext, useState } from 'react';
    
    const ThemeContext = createContext(undefined);
    
    export const ThemeProvider = ({ children }) => {
      const [theme, setTheme] = useState('light');
      
      return (
        <ThemeContext.Provider value={{ theme, setTheme }}>
          {children}
        </ThemeContext.Provider>
      );
    };
    
    export const useTheme = () => useContext(ThemeContext);
    

    Zustandの本質

    Zustandは独立した状態管理ライブラリで、Reactコンポーネントツリーの外部に「ストア」を作成します:

    • コンポーネント階層からの独立: どのコンポーネントからでも直接アクセス可能

    • 細粒度のサブスクリプション: 必要な状態の部分のみを購読し、不要な再レンダリングを防止

    • 単純でボイラープレートの少ないAPI: Redux風の状態管理よりもシンプル

    // src/stores/authStore.ts
    import { create } from 'zustand';
    
    export const useAuthStore = create((set) => ({
      user: null,
      isAuthenticated: false,
      login: (userData) => set({ 
        user: userData, 
        isAuthenticated: true 
      }),
      logout: () => set({ 
        user: null, 
        isAuthenticated: false 
      }),
    }));
    

    なぜこれらの違いが重要なのか

    これらの根本的な違いが重要なのは、アプリケーションの異なる種類の状態が異なる要件を持っているからです。

    Context Providerが特に有効なケース

    1. UIに近い状態管理

    UIコンポーネントに密接に関連する状態は、レンダリングサイクルと連動する必要があるため、Context Providerと相性が良いです。

    // src/features/tables/providers/TableProvider.tsx
    
    import React, { createContext, useContext, useState } from 'react';
    
    const TableContext = createContext(undefined);
    
    export const TableProvider = ({ children }) => {
      const [sortColumn, setSortColumn] = useState('name');
      const [sortDirection, setSortDirection] = useState('asc');
      const [pageSize, setPageSize] = useState(10);
      const [currentPage, setCurrentPage] = useState(1);
      
      const sortBy = (column) => {
        if (sortColumn === column) {
          setSortDirection(prev => prev === 'asc' ? 'desc' : 'asc');
        } else {
          setSortColumn(column);
          setSortDirection('asc');
        }
      };
      
      return (
        <TableContext.Provider 
          value={{ 
            sortColumn, 
            sortDirection, 
            pageSize, 
            currentPage, 
            setPageSize, 
            setCurrentPage, 
            sortBy 
          }}
        >
          {children}
        </TableContext.Provider>
      );
    };
    
    export const useTable = () => useContext(TableContext);
    
    1. コンポーネントサブツリーに限定された状態

    特定のコンポーネント群でのみ使用される状態は、Contextで明示的な境界を設定できます。

    // src/features/forms/providers/FormProvider.tsx
    
    import React, { createContext, useContext, useReducer } from 'react';
    
    const FormContext = createContext(undefined);
    
    const formReducer = (state, action) => {
      switch (action.type) {
        case 'SET_FIELD':
          return { ...state, values: { ...state.values, [action.field]: action.value } };
        case 'SET_ERROR':
          return { ...state, errors: { ...state.errors, [action.field]: action.error } };
        case 'RESET':
          return { values: {}, errors: {} };
        default:
          return state;
      }
    };
    
    export const FormProvider = ({ children, initialValues = {} }) => {
      const [state, dispatch] = useReducer(formReducer, {
        values: initialValues,
        errors: {},
      });
      
      return (
        <FormContext.Provider value={{ state, dispatch }}>
          {children}
        </FormContext.Provider>
      );
    };
    
    export const useForm = () => useContext(FormContext);
    
    1. 設定や環境変数の提供

    アプリケーション構成や環境設定など、起動時に設定されほとんど変更されない状態は、Context Providerでアプリ全体に提供するのに適しています。

    // src/providers/ConfigProvider.tsx
    
    import React, { createContext, useContext } from 'react';
    
    const ConfigContext = createContext(undefined);
    
    export const ConfigProvider = ({ children, config }) => {
      return (
        <ConfigContext.Provider value={config}>
          {children}
        </ConfigContext.Provider>
      );
    };
    
    export const useConfig = () => useContext(ConfigContext);
    


    // 使用例 (src/providers/index.tsx)
    
    const AppProviders = ({ children }) => {
      return (
        <ConfigProvider config={{
          apiUrl: process.env.REACT_APP_API_URL,
          maxUploadSize: 10 * 1024 * 1024,
          features: {
            newDashboard: true,
            betaFeatures: false
          }
        }}>
          {/* 他のプロバイダー */}
          {children}
        </ConfigProvider>
      );
    };
    

    Zustandが特に有効なケース

    1. アプリケーション全体で共有される状態

    ユーザー認証情報やグローバル設定など、多くのコンポーネントで共有される状態はZustandで管理すると効果的です。

    // src/stores/authStore.ts
    
    import { create } from 'zustand';
    import { persist } from 'zustand/middleware';
    
    export const useAuthStore = create(
      persist(
        (set) => ({
          user: null,
          token: null,
          isAuthenticated: false,
          login: (user, token) => set({ 
            user, 
            token, 
            isAuthenticated: true 
          }),
          logout: () => set({ 
            user: null, 
            token: null, 
            isAuthenticated: false 
          }),
          updateUser: (userData) => set((state) => ({
            user: { ...state.user, ...userData }
          }))
        }),
        { name: 'auth-storage' }
      )
    );
    
    1. 複雑な状態更新ロジック

    複数の更新パターンや副作用を持つ状態はZustandで整理しやすいです。

    // src/features/cart/stores/cartStore.ts
    
    import { create } from 'zustand';
    
    export const useCartStore = create((set, get) => ({
      items: [],
      addItem: (product, quantity = 1) => set((state) => {
        const existingItem = state.items.find(item => item.id === product.id);
        
        if (existingItem) {
          return {
            items: state.items.map(item => 
              item.id === product.id
                ? { ...item, quantity: item.quantity + quantity }
                : item
            )
          };
        }
        
        return {
          items: [...state.items, { ...product, quantity }]
        };
      }),
      removeItem: (productId) => set((state) => ({
        items: state.items.filter(item => item.id !== productId)
      })),
      updateQuantity: (productId, quantity) => set((state) => ({
        items: state.items.map(item => 
          item.id === productId ? { ...item, quantity } : item
        )
      })),
      clearCart: () => set({ items: [] }),
      getTotal: () => {
        return get().items.reduce(
          (total, item) => total + (item.price * item.quantity), 
          0
        );
      },
      getItemCount: () => {
        return get().items.reduce(
          (count, item) => count + item.quantity, 
          0
        );
      }
    }));
    
    1. 永続化が必要な状態

    ページリロード後も維持する必要がある状態は、Zustandのpersistミドルウェアと相性が良いです。

    // src/stores/settingsStore.ts
    
    import { create } from 'zustand';
    import { persist } from 'zustand/middleware';
    
    export const useSettingsStore = create(
      persist(
        (set) => ({
          theme: 'light',
          fontSize: 'medium',
          notifications: true,
          setTheme: (theme) => set({ theme }),
          setFontSize: (fontSize) => set({ fontSize }),
          toggleNotifications: () => set((state) => ({ 
            notifications: !state.notifications 
          })),
        }),
        { name: 'user-settings' }
      )
    );
    
    1. パフォーマンス最適化が必要な場合

    大きなリストや頻繁に更新される状態など、パフォーマンスが重要な状態はZustandの細粒度選択が有効です。

    // src/features/products/stores/productsStore.ts
    
    import { create } from 'zustand';
    import { getProducts } from '../api/getProducts';
    
    export const useProductsStore = create((set, get) => ({
      products: [],
      isLoading: false,
      error: null,
      filters: {
        category: null,
        minPrice: 0,
        maxPrice: null,
        inStock: false
      },
      
      // 選択的な状態取得のため、個別のセレクタとして実装
      getFilteredProducts: () => {
        const { products, filters } = get();
        return products.filter(product => {
          if (filters.category && product.category !== filters.category) return false;
          if (filters.minPrice && product.price < filters.minPrice) return false;
          if (filters.maxPrice && product.price > filters.maxPrice) return false;
          if (filters.inStock && !product.inStock) return false;
          return true;
        });
      },
      
      fetchProducts: async () => {
        set({ isLoading: true, error: null });
        try {
          const products = await getProducts();
          set({ products, isLoading: false });
        } catch (error) {
          set({ error: error.message, isLoading: false });
        }
      },
      
      setFilter: (key, value) => set((state) => ({
        filters: { ...state.filters, [key]: value }
      })),
      
      resetFilters: () => set({
        filters: {
          category: null,
          minPrice: 0,
          maxPrice: null,
          inStock: false
        }
      })
    }));
    

    なぜ設計時にこれらを考慮すべきなのか

    適切な状態管理選択がアーキテクチャに重要な理由は、それがアプリケーションの保守性、拡張性、パフォーマンスに直接影響するからです。

    保守性への影響

    • 責任の明確な分離: 各状態の管理方法が明確になり、コードの意図が伝わりやすくなる

    • デバッグの容易さ: 問題の原因を特定しやすくなる

    • コード理解の促進: 新しいチームメンバーが「この状態はどこにあるべきか」を直感的に理解できる

    拡張性への影響

    • 新機能の追加容易性: 既存の状態管理パターンに従って新機能を追加できる

    • コンポーネントの再利用性: 状態の依存関係が明確になり、コンポーネントの分離と再利用が容易になる

    • テスト容易性: 状態管理が適切に分離されていると、単体テストが書きやすくなる

    パフォーマンスへの影響

    • 再レンダリングの最適化: 適切なツール選択により不要な再レンダリングを防止

    • メモリ効率: 必要な状態のみを購読することでメモリ使用を最適化

    • 応答性: 効率的な状態更新により、アプリケーションの応答性を向上

    実際のプロジェクトでの併用アプローチ

    実践では、Context ProviderとZustandを排他的ではなく、補完的に使用します

    // src/providers/index.tsx
    
    import React from 'react';
    import { QueryClientProvider, QueryClient } from 'react-query';
    import { ThemeProvider } from './ThemeProvider';
    import { ConfigProvider } from './ConfigProvider';
    import { ToastProvider } from './ToastProvider';
    
    const queryClient = new QueryClient();
    
    export const AppProviders = ({ children }) => {
      // アプリケーション起動時の設定はContext Providerで提供
      return (
        <QueryClientProvider client={queryClient}>
          <ConfigProvider config={{ 
            apiUrl: '/api', 
            maxUploadSize: 5 * 1024 * 1024 
          }}>
            <ThemeProvider>
              <ToastProvider>
                {children}
              </ToastProvider>
            </ThemeProvider>
          </ConfigProvider>
        </QueryClientProvider>
      );
    };
    


    // src/App.tsx
    
    import React from 'react';
    import { AppProviders } from './providers';
    import { Routes } from './routes';
    import { useAuthStore } from './stores/authStore';
    import { useSettingsStore } from './stores/settingsStore';
    
    function App() {
      // グローバル状態はZustandからアクセス
      const isAuthenticated = useAuthStore(state => state.isAuthenticated);
      const theme = useSettingsStore(state => state.theme);
      
      return (
        <AppProviders>
          <div className={`app-container ${theme}`}>
            <Routes isAuthenticated={isAuthenticated} />
          </div>
        </AppProviders>
      );
    }
    

    フレームワーク: 適切な選択のために

    状態管理ツールを選択する際の実践的なフレームワークを紹介します:

    1. 状態の範囲を確認

      • この状態は単一のコンポーネントだけで使われる? → useState/useReducer

      • コンポーネントサブツリー内でのみ使われる? → Context Provider

      • アプリケーション全体/複数機能で使われる? → Zustand

    2. 状態の性質を分析

      • UI表示に密接に関連している? → Context Provider

      • ビジネスロジックやデータモデルに関連している? → Zustand

      • 設定や環境変数のような静的な値? → Context Provider

    3. 状態の複雑さを評価

      • シンプルな値の共有? → Context Provider

      • 複雑な更新ロジックを持つ? → Zustand

      • 頻繁に更新され、パフォーマンスが重要? → Zustand

    4. 永続化の必要性を考慮

      • ページリロード後も維持する必要がある? → Zustand + persist

      • セッション内でのみ必要? → どちらでも可

    結論: バランスが鍵

    状態管理アプローチでは、Context ProviderとZustandの両方を適切に使い分けることが重要です。この使い分けは、理論的な好みや流行ではなく、各ツールの強みと弱みを理解し、状態の性質に合わせて適切な選択をすることに基づいています。

    実践的なルールとして:

    • UIに近い状態はContext Provider で管理

    • アプリケーション全体のビジネスロジックはZustand で管理

    • 設定や環境変数はContext Provider で提供

    • 複雑なロジックや頻繁な更新を伴う状態はZustand で管理

    この明確な使い分けにより、コードは自然と「関心の分離」の原則に従い、各状態が最も適した場所と方法で管理されるようになります。これは短期的な利便性だけでなく、長期的なプロジェクトの健全性を考慮したアプローチです。

     
     

    ぎー

     
     
    Web系のエンジニアをしています。生成AIの活用や業務効率化など役立つ発信をしていきます。

    あなたへのおすすめ