MENU
  1. ホーム
  2. React
  3. React Context APIで実現するルート間データ共有の方法と実践

React Context APIで実現するルート間データ共有の方法と実践

React

Reactにおいて、複数のコンポーネント間でデータを共有することは、アプリケーションの状態管理において重要な課題です。通常、Reactでは親コンポーネントから子コンポーネントにpropsを使ってデータを渡しますが、この手法はネストが深い場合に煩雑になります。こうした課題を解決するために、Context APIが提供されています。本記事では、Context APIを使ったルート間のデータ共有方法について、初心者でも分かりやすく解説します。このガイドを通じて、Context APIの基本的な使い方から実践例までを学び、効率的な状態管理を習得しましょう。

目次
  1. Context APIとは
    1. Context APIの基本的な仕組み
    2. Context APIの主な用途
    3. Context APIを選択する理由
  2. Contextの作成方法
    1. Contextの作成ステップ
    2. Contextを作成する実践例
    3. Contextを作成する際のポイント
  3. プロバイダーの使用方法
    1. プロバイダーの基本的な使用法
    2. プロバイダーのネスト
    3. プロバイダーのスコープ
    4. プロバイダーの実践例
    5. プロバイダー使用時の注意点
  4. コンシューマーによるデータアクセス
    1. 1. Consumerコンポーネントを使用した方法
    2. 2. `useContext`フックを使用した方法
    3. コンシューマーを使用した実践例
    4. 注意点とベストプラクティス
  5. Context APIを使用したデータの更新
    1. データを更新する仕組み
    2. 実装例
    3. ポイント解説
    4. 注意点
  6. Context APIのベストプラクティス
    1. 1. Contextの役割を明確化する
    2. 2. 必要に応じてContextを分割する
    3. 3. 再レンダリングを最小限に抑える
    4. 4. Contextの使用範囲を限定する
    5. 5. デバッグを簡単にする工夫
    6. 6. 他の状態管理ツールとの併用を検討する
    7. 7. エラーハンドリングの追加
    8. まとめ
  7. Context APIと他のステート管理ツールの比較
    1. 1. Context APIの特徴
    2. 2. Reduxとの比較
    3. 3. Recoilとの比較
    4. 4. Zustandとの比較
    5. 5. Context APIを選択する際のポイント
    6. まとめ
  8. 実践例：TodoアプリでのContext API利用
    1. アプリの構成
    2. Step 1: Contextの作成
    3. Step 2: Providerの利用
    4. Step 3: Todoリストの表示
    5. Step 4: 新しいタスクの追加
    6. Step 5: 動作確認
    7. コード全体の構成
    8. まとめ
  9. まとめ

Context APIとは


ReactのContext APIは、コンポーネントツリー全体でデータを共有するための機能です。従来のpropsを用いたデータの「引き渡し」に比べて、Context APIは「直接アクセス」を可能にし、ネストが深いコンポーネント間でのデータ共有を簡単にします。

Context APIの基本的な仕組み


Contextは、React.createContext()を使って作成されます。このContextを通じてデータを提供する役割を担うのが「Provider」であり、データを受け取るコンポーネントは「Consumer」またはReact Hooks（useContext）を用いてデータにアクセスします。

Context APIの主な用途


Context APIは、以下のようなシナリオで特に有用です。

  • テーマ設定：ライトモードやダークモードの切り替え。
  • ユーザー認証情報：ログイン情報やユーザーデータの共有。
  • アプリ全体の状態管理：設定情報や選択項目の共有。

Context APIを選択する理由


Context APIは、props drilling（不要なpropsの受け渡し）の問題を解消し、コードの可読性を向上させます。また、Reduxなどの外部ライブラリに比べて、シンプルかつ軽量で、セットアップが容易です。そのため、小中規模のアプリケーションや特定の機能において、適切な選択肢となります。

Contextの作成方法

Context APIを利用するためには、まずContextを作成する必要があります。ReactではReact.createContext()を使用してContextを作成します。このセクションでは、Contextを作成する基本的な手順を解説します。

Contextの作成ステップ

  1. Contextの生成
    新しいContextを作成するには、React.createContext()を呼び出します。以下はその基本構文です。
   import React from 'react';

   const MyContext = React.createContext();

これにより、MyContextという名前のContextオブジェクトが作成されます。このオブジェクトには、データを提供するProviderコンポーネントと、データを取得するConsumerコンポーネントが含まれます。

  1. デフォルト値の設定（オプション）
    Contextを作成する際に、デフォルト値を設定することが可能です。デフォルト値は、Providerで値を指定しない場合に使用されます。
   const MyContext = React.createContext('デフォルト値');

Contextを作成する実践例

以下に、テーマを切り替えるためのContextを作成する例を示します。

import React from 'react';

// Contextの作成
const ThemeContext = React.createContext('light');

// デフォルト値として'light'を設定
export default ThemeContext;

Contextを作成する際のポイント

  • Context名は、用途を明確にするために具体的な名前を付けることが推奨されます（例: UserContext, ThemeContext）。
  • 複数のContextを使用する場合、整理するために専用のファイル（例: contextディレクトリ）を作成すると便利です。

以上で、Contextの作成が完了です。次のステップでは、このContextを用いてデータを提供する方法を解説します。

プロバイダーの使用方法

Contextを作成した後、Providerを利用してデータをコンポーネントツリーに提供します。ProviderはContext APIの一部で、コンポーネントツリー全体または一部にデータを共有する役割を担います。

プロバイダーの基本的な使用法

Providerは作成したContextオブジェクトの一部として提供されます。Providerにデータを設定し、それをコンポーネントツリーに渡します。

import React from 'react';
import ThemeContext from './ThemeContext';

const App = () => {
    return (
        <ThemeContext.Provider value="dark">
            <MyComponent />
        </ThemeContext.Provider>
    );
};
  • value属性
    value属性を使用して、共有したいデータをProviderに渡します。この値は、コンシューマー（ConsumerやuseContext）がアクセスできます。

プロバイダーのネスト

複数のContextを使用する場合、Providerをネストしてデータを提供できます。

import React from 'react';
import ThemeContext from './ThemeContext';
import UserContext from './UserContext';

const App = () => {
    return (
        <ThemeContext.Provider value="dark">
            <UserContext.Provider value={{ name: 'John', role: 'admin' }}>
                <MyComponent />
            </UserContext.Provider>
        </ThemeContext.Provider>
    );
};

プロバイダーのスコープ

  • Providerは、その配下のコンポーネントにのみデータを共有します。
  • 必要な部分にのみProviderを配置することで、スコープを制限できます。

プロバイダーの実践例

以下は、テーマ（ライトモード/ダークモード）を切り替えるデータをProviderで提供する例です。

import React, { useState } from 'react';
import ThemeContext from './ThemeContext';
import MyComponent from './MyComponent';

const App = () => {
    const [theme, setTheme] = useState('light');

    return (
        <ThemeContext.Provider value={{ theme, setTheme }}>
            <MyComponent />
        </ThemeContext.Provider>
    );
};

export default App;

プロバイダー使用時の注意点

  1. 再レンダリングの最小化
    valueが更新されるたびに配下のコンポーネントが再レンダリングされます。値が頻繁に更新される場合は、Memo化を検討してください。
   const providerValue = React.useMemo(() => ({ theme, setTheme }), [theme]);
  1. 不要なネストの回避
    過剰なProviderのネストは可読性を損ないます。必要に応じて、Contextをまとめるなどの工夫を行いましょう。

以上で、Providerを使用してContextを通じてデータを提供する方法を理解できました。次は、提供されたデータを利用する方法について解説します。

コンシューマーによるデータアクセス

Providerで提供されたデータは、コンシューマー（ConsumerまたはuseContextフック）を利用してコンポーネント内で取得できます。このセクションでは、それぞれの方法について詳しく解説します。

1. Consumerコンポーネントを使用した方法

Consumerは、Context APIに含まれるコンポーネントで、プロバイダーから提供されたデータにアクセスします。以下はその基本的な使用方法です。

import React from 'react';
import ThemeContext from './ThemeContext';

const MyComponent = () => {
    return (
        <ThemeContext.Consumer>
            {value => <div>現在のテーマ: {value}</div>}
        </ThemeContext.Consumer>
    );
};

export default MyComponent;
  • valueの取得
    ThemeContext.Consumerは関数として子要素を受け取り、valueを引数として渡します。このvalueはProviderのvalue属性に設定したデータです。

2. `useContext`フックを使用した方法

関数コンポーネントでは、useContextフックを利用することで、より簡潔にContextデータを取得できます。

import React, { useContext } from 'react';
import ThemeContext from './ThemeContext';

const MyComponent = () => {
    const theme = useContext(ThemeContext);

    return <div>現在のテーマ: {theme}</div>;
};

export default MyComponent;
  • メリット
  • コードがシンプルで読みやすい。
  • Consumerに比べてネストを避けられる。

コンシューマーを使用した実践例

以下は、テーマ（ライトモード/ダークモード）をContextから取得し、スタイルを変更する例です。

import React, { useContext } from 'react';
import ThemeContext from './ThemeContext';

const MyComponent = () => {
    const { theme, setTheme } = useContext(ThemeContext);

    const toggleTheme = () => {
        setTheme(theme === 'light' ? 'dark' : 'light');
    };

    return (
        <div style={{ background: theme === 'light' ? '#fff' : '#333', color: theme === 'light' ? '#000' : '#fff' }}>
            <p>現在のテーマ: {theme}</p>
            <button onClick={toggleTheme}>テーマを切り替える</button>
        </div>
    );
};

export default MyComponent;

注意点とベストプラクティス

  1. 適切なフックの利用
    関数コンポーネントを使用している場合、useContextを優先的に使用します。クラスコンポーネントの場合はConsumerが必須です。
  2. パフォーマンスの最適化
    useContextやConsumerを使用しているコンポーネントは、Providerのvalueが更新されるたびに再レンダリングされます。不要な再レンダリングを避けるために、値をMemo化するか、必要に応じてデータを分割することを検討してください。
   const providerValue = React.useMemo(() => ({ theme, setTheme }), [theme]);

以上で、Contextのデータを取得する方法について理解できました。次のステップでは、Context APIを使ったデータの動的更新方法について説明します。

Context APIを使用したデータの更新

Context APIでは、Providerのvalueに関数を含めることで、データを動的に更新することが可能です。このセクションでは、Contextデータを動的に変更する方法について解説します。

データを更新する仕組み

データ更新のためには、以下の手順を実行します：

  1. 更新関数を用意する
    データを操作するための関数をProvider内で定義します。
  2. 更新関数をContextで共有する
    更新関数をvalueに含めて、下位のコンポーネントからアクセスできるようにします。
  3. useContextやConsumerを使用してデータを操作する
    下位コンポーネントで更新関数を呼び出してデータを変更します。

実装例

以下に、テーマ（ライトモード/ダークモード）を切り替える例を示します。

Step 1: Contextの作成

import React, { createContext, useState } from 'react';

const ThemeContext = createContext();

export const ThemeProvider = ({ children }) => {
    const [theme, setTheme] = useState('light');

    const toggleTheme = () => {
        setTheme(prevTheme => (prevTheme === 'light' ? 'dark' : 'light'));
    };

    return (
        <ThemeContext.Provider value={{ theme, toggleTheme }}>
            {children}
        </ThemeContext.Provider>
    );
};

export default ThemeContext;

Step 2: Providerの利用

import React from 'react';
import { ThemeProvider } from './ThemeContext';
import MyComponent from './MyComponent';

const App = () => {
    return (
        <ThemeProvider>
            <MyComponent />
        </ThemeProvider>
    );
};

export default App;

Step 3: データの更新
下位コンポーネントでContextを利用し、テーマを切り替えます。

import React, { useContext } from 'react';
import ThemeContext from './ThemeContext';

const MyComponent = () => {
    const { theme, toggleTheme } = useContext(ThemeContext);

    return (
        <div style={{ background: theme === 'light' ? '#fff' : '#333', color: theme === 'light' ? '#000' : '#fff' }}>
            <p>現在のテーマ: {theme}</p>
            <button onClick={toggleTheme}>テーマを切り替える</button>
        </div>
    );
};

export default MyComponent;

ポイント解説

  • データと関数をセットで共有
    Providerのvalueには、データと更新関数をセットで渡すことで、下位コンポーネントからデータを取得し、操作できるようになります。
  • 関数のMemo化
    大規模なアプリケーションでは、Providerのvalueが更新されるたびに再レンダリングが発生するため、React.useMemoを使用して関数をMemo化するのがベストプラクティスです。
  const providerValue = React.useMemo(() => ({ theme, toggleTheme }), [theme]);

注意点

  1. 頻繁なデータ更新に注意
    Contextは、グローバルな状態管理に適していますが、頻繁に更新されるデータ（例: リアルタイムデータ）はパフォーマンスに影響を与える可能性があります。必要に応じて他の状態管理ツール（ReduxやRecoilなど）を検討してください。
  2. 過剰な依存の回避
    Contextに多くのロジックやデータを詰め込みすぎると、複雑になり管理が困難になります。必要に応じてContextを分割しましょう。

これで、Context APIを使用したデータの動的更新方法を習得できました。次は、Context APIのベストプラクティスについて説明します。

Context APIのベストプラクティス

Context APIは便利で強力なツールですが、正しく使用しなければパフォーマンスやコードの可読性に問題が生じる可能性があります。このセクションでは、Context APIを使用する際に押さえておきたいベストプラクティスを解説します。

1. Contextの役割を明確化する

  • Contextはグローバルな状態に適用
    Contextは、アプリケーション全体で共有されるデータ（テーマ設定、認証情報など）に使用します。頻繁に更新されるデータや特定のコンポーネントのみが使用するデータには適していません。

適切な用途の例

  • アプリ全体のテーマ設定（ライト/ダークモード）
  • ログインユーザー情報（ユーザー名、ロールなど）
  • 設定や構成データ（アプリの言語設定など）

2. 必要に応じてContextを分割する

一つのContextに多くのデータやロジックを詰め込むと、管理が煩雑になり、再レンダリングの範囲が広がります。役割ごとにContextを分割することで、再レンダリングの影響を最小限に抑えられます。

例: 分割されたContext

const ThemeContext = React.createContext();
const AuthContext = React.createContext();

3. 再レンダリングを最小限に抑える

  • valueのMemo化
    Contextのvalueが頻繁に変わる場合、React.useMemoを使用して値をMemo化します。
  const providerValue = React.useMemo(() => ({ theme, toggleTheme }), [theme]);
  • 不要なネストを避ける
    Providerのネストが深くなると、再レンダリングが連鎖的に発生する可能性があります。必要に応じてコンポーネントの階層を簡素化します。

4. Contextの使用範囲を限定する

Contextはツリー全体に影響を与えるため、スコープを明確に制限することが重要です。必要な部分だけにProviderを配置することで、アプリケーション全体への影響を抑えることができます。

5. デバッグを簡単にする工夫

  • デフォルト値を設定する
    Contextの初期値を設定することで、未設定時のエラーを防ぎ、デバッグが容易になります。
  const ThemeContext = React.createContext({ theme: 'light', toggleTheme: () => {} });
  • カスタムフックの導入
    Contextを扱うカスタムフックを作成することで、データ取得や操作を簡素化できます。
  const useTheme = () => React.useContext(ThemeContext);

6. 他の状態管理ツールとの併用を検討する

Context APIは、グローバルな状態管理には便利ですが、大規模なアプリケーションではReduxやRecoilなどのツールが適している場合があります。データの規模や更新頻度に応じて適切なツールを選択しましょう。

7. エラーハンドリングの追加

Contextを使用するコンポーネントで、適切にProviderが配置されていない場合に備え、エラーチェックを実装します。

例: エラーチェック

const useTheme = () => {
    const context = React.useContext(ThemeContext);
    if (!context) {
        throw new Error('useTheme must be used within a ThemeProvider');
    }
    return context;
};

まとめ

Context APIは、Reactアプリケーションで状態を共有するための簡潔な手法を提供します。しかし、適切に使用しなければパフォーマンスや可読性に影響を及ぼします。役割の明確化やMemo化、スコープの制限などを意識し、より効率的なContextの運用を心がけましょう。次は、Context APIと他の状態管理ツールの比較について解説します。

Context APIと他のステート管理ツールの比較

Context APIはReactの組み込み機能として、グローバルな状態管理を手軽に実現します。しかし、ReduxやRecoilといった他の状態管理ツールも選択肢として存在します。このセクションでは、それぞれの特徴を比較し、Context APIを選択する際の判断基準を提供します。

1. Context APIの特徴

  • メリット
  • Reactに組み込まれているため、追加のライブラリが不要。
  • 小中規模アプリケーションに適している。
  • 設定が簡単で学習コストが低い。
  • デメリット
  • 頻繁に更新されるデータに対してはパフォーマンスが低下する場合がある（再レンダリングの問題）。
  • 非同期操作や複雑なロジックの管理には不向き。

2. Reduxとの比較

Reduxは、状態管理のための最も広く利用されるライブラリの一つです。

  • メリット
  • 大規模アプリケーションにおいて、状態管理を一元化しやすい。
  • 中間処理（ミドルウェア）を利用することで、非同期処理やデバッグが容易。
  • Redux DevToolsによる高度なデバッグ機能。
  • デメリット
  • ボイラープレートコードが多く、学習コストが高い。
  • 小規模プロジェクトでは過剰な設計になりがち。
  • Context APIとの使い分け
  • Reduxは、大規模で複雑な状態を管理する必要がある場合に有利。
  • Context APIは、単純なグローバル状態（テーマや認証情報など）を共有する際に適している。

3. Recoilとの比較

Recoilは、Reactアプリケーション向けに設計された新しい状態管理ツールです。

  • メリット
  • コンポーネント間で状態を共有しやすいアトム（状態の最小単位）モデル。
  • 非同期データ（リモートデータの取得など）の管理が簡単。
  • パフォーマンスが良く、最小限の再レンダリングで済む。
  • デメリット
  • 比較的新しいため、エコシステムが未成熟。
  • Context APIやReduxに比べて採用実績が少ない。
  • Context APIとの使い分け
  • Recoilは、状態の依存関係や非同期データの処理が多い場合に適している。
  • Context APIは、シンプルなデータ共有で十分な場合に便利。

4. Zustandとの比較

Zustandは軽量な状態管理ライブラリとして人気があります。

  • メリット
  • 設定が非常に簡単で、柔軟性が高い。
  • Context APIと比較して、パフォーマンスの問題を解決できる。
  • フックベースのAPIで直感的に使用可能。
  • デメリット
  • 公式なサポートが少なく、ReduxやContext APIほど情報が多くない。
  • Context APIとの使い分け
  • Zustandは、Context APIのように簡単な設定を求めつつ、パフォーマンスを重視したい場合に有効。

5. Context APIを選択する際のポイント

Context APIを選択するべきケース：

  • 状態が少なく、構造が単純な場合（例: テーマ切り替えや認証状態の共有）。
  • アプリの規模が小中規模で、外部ライブラリを追加したくない場合。
  • 学習コストを最小限に抑えたい場合。

外部ライブラリを検討するべきケース：

  • アプリケーションが大規模で、状態の依存関係が複雑な場合。
  • 頻繁な状態更新や非同期処理が必要な場合。
  • Redux DevToolsなどの高度なデバッグ機能が必要な場合。

まとめ

Context APIは、小中規模アプリケーションや単純なグローバル状態の共有に非常に適しています。一方で、複雑な状態管理や頻繁な更新が必要なアプリケーションでは、ReduxやRecoilのような外部ツールを検討すべきです。アプリケーションの規模や要件に応じて適切なツールを選択することが、効率的な開発への第一歩となります。次は、具体的な実践例について解説します。

実践例：TodoアプリでのContext API利用

ここでは、Context APIを用いて、シンプルなTodoアプリを構築する方法を解説します。この例では、アプリ全体でTodoリストを管理し、新しいタスクの追加やタスクの削除ができる仕組みを実装します。

アプリの構成

  • TodoProvider: Todoリストの状態を管理し、アプリ全体に共有するProvider。
  • TodoList: 現在のTodoリストを表示するコンポーネント。
  • AddTodo: 新しいタスクを追加するフォーム。

Step 1: Contextの作成

まず、Todoリスト用のContextを作成します。

import React, { createContext, useState, useMemo } from 'react';

// Contextの作成
const TodoContext = createContext();

export const TodoProvider = ({ children }) => {
    const [todos, setTodos] = useState([]);

    const addTodo = (text) => {
        setTodos((prev) => [...prev, { id: Date.now(), text }]);
    };

    const removeTodo = (id) => {
        setTodos((prev) => prev.filter((todo) => todo.id !== id));
    };

    const providerValue = useMemo(() => ({ todos, addTodo, removeTodo }), [todos]);

    return <TodoContext.Provider value={providerValue}>{children}</TodoContext.Provider>;
};

export default TodoContext;

Step 2: Providerの利用

アプリ全体にTodoリストの状態を共有するために、TodoProviderでラップします。

import React from 'react';
import { TodoProvider } from './TodoContext';
import TodoList from './TodoList';
import AddTodo from './AddTodo';

const App = () => {
    return (
        <TodoProvider>
            <h1>Todoアプリ</h1>
            <AddTodo />
            <TodoList />
        </TodoProvider>
    );
};

export default App;

Step 3: Todoリストの表示

Todoリストを表示するコンポーネントTodoListを作成します。

import React, { useContext } from 'react';
import TodoContext from './TodoContext';

const TodoList = () => {
    const { todos, removeTodo } = useContext(TodoContext);

    return (
        <ul>
            {todos.map((todo) => (
                <li key={todo.id}>
                    {todo.text}
                    <button onClick={() => removeTodo(todo.id)}>削除</button>
                </li>
            ))}
        </ul>
    );
};

export default TodoList;

Step 4: 新しいタスクの追加

新しいタスクを追加するフォームAddTodoを作成します。

import React, { useState, useContext } from 'react';
import TodoContext from './TodoContext';

const AddTodo = () => {
    const [text, setText] = useState('');
    const { addTodo } = useContext(TodoContext);

    const handleSubmit = (e) => {
        e.preventDefault();
        if (text.trim()) {
            addTodo(text);
            setText('');
        }
    };

    return (
        <form onSubmit={handleSubmit}>
            <input
                type="text"
                value={text}
                onChange={(e) => setText(e.target.value)}
                placeholder="新しいタスクを入力"
            />
            <button type="submit">追加</button>
        </form>
    );
};

export default AddTodo;

Step 5: 動作確認

  1. アプリを起動すると、タスクを追加するフォームと現在のTodoリストが表示されます。
  2. フォームにタスクを入力して「追加」ボタンをクリックすると、タスクがリストに追加されます。
  3. リストの各タスクには「削除」ボタンがあり、クリックするとそのタスクが削除されます。

コード全体の構成

  1. TodoContext.js: ContextとProviderを定義。
  2. TodoList.js: タスクの表示と削除を実装。
  3. AddTodo.js: タスクの追加を実装。
  4. App.js: アプリ全体を構築。

まとめ

この実践例を通じて、Context APIを利用した状態管理の基礎を学べたかと思います。Todoリストという単純な例ではありますが、これを応用すれば、より複雑なアプリケーションの状態管理にも対応できます。次はこの記事全体のまとめに進みます。

まとめ

本記事では、ReactのContext APIを使用してルート間でデータを共有する方法について解説しました。Context APIの基本概念から、プロバイダーでデータを提供し、コンシューマーでデータを取得する手順、さらにデータの動的更新やベストプラクティスを学びました。また、Todoアプリを題材に、実際のコードを通してContext APIの活用方法を確認しました。

Context APIは、シンプルなグローバル状態管理を必要とする小中規模アプリケーションに非常に有用です。ただし、大規模な状態管理や非同期処理が多い場合は、ReduxやRecoilなどのツールも検討すると良いでしょう。

この知識を活かして、より効率的で保守性の高いReactアプリケーションを構築してください！

React
React データ共有 Context API

コメント

コメントする

目次
  1. Context APIとは
    1. Context APIの基本的な仕組み
    2. Context APIの主な用途
    3. Context APIを選択する理由
  2. Contextの作成方法
    1. Contextの作成ステップ
    2. Contextを作成する実践例
    3. Contextを作成する際のポイント
  3. プロバイダーの使用方法
    1. プロバイダーの基本的な使用法
    2. プロバイダーのネスト
    3. プロバイダーのスコープ
    4. プロバイダーの実践例
    5. プロバイダー使用時の注意点
  4. コンシューマーによるデータアクセス
    1. 1. Consumerコンポーネントを使用した方法
    2. 2. `useContext`フックを使用した方法
    3. コンシューマーを使用した実践例
    4. 注意点とベストプラクティス
  5. Context APIを使用したデータの更新
    1. データを更新する仕組み
    2. 実装例
    3. ポイント解説
    4. 注意点
  6. Context APIのベストプラクティス
    1. 1. Contextの役割を明確化する
    2. 2. 必要に応じてContextを分割する
    3. 3. 再レンダリングを最小限に抑える
    4. 4. Contextの使用範囲を限定する
    5. 5. デバッグを簡単にする工夫
    6. 6. 他の状態管理ツールとの併用を検討する
    7. 7. エラーハンドリングの追加
    8. まとめ
  7. Context APIと他のステート管理ツールの比較
    1. 1. Context APIの特徴
    2. 2. Reduxとの比較
    3. 3. Recoilとの比較
    4. 4. Zustandとの比較
    5. 5. Context APIを選択する際のポイント
    6. まとめ
  8. 実践例：TodoアプリでのContext API利用
    1. アプリの構成
    2. Step 1: Contextの作成
    3. Step 2: Providerの利用
    4. Step 3: Todoリストの表示
    5. Step 4: 新しいタスクの追加
    6. Step 5: 動作確認
    7. コード全体の構成
    8. まとめ
  9. まとめ