MENU
  1. ホーム
  2. React
  3. ReactのContext APIで大規模アプリケーションのステートを効果的に整理する方法

ReactのContext APIで大規模アプリケーションのステートを効果的に整理する方法

React

Reactを用いた大規模アプリケーションの開発において、ステート管理は重要な課題の一つです。従来の方法では、プロップスの受け渡しが煩雑になり、アプリケーションの複雑さが増すことがよくあります。これを解決するための手法として、ReactのContext APIが注目されています。本記事では、Context APIを活用することで、どのように大規模なアプリケーションのステートを簡潔かつ効果的に整理できるかについて、基礎から応用まで詳しく解説します。Context APIの基本的な使い方や具体的な実装例を通じて、その利点を最大限に引き出す方法を学んでいきましょう。

目次
  1. Context APIとは何か
    1. 基本的な用途
  2. Context APIを選択するメリット
    1. プロップスドリリングの解消
    2. 軽量かつシンプルな導入
    3. コンポーネント間のスムーズなデータ共有
    4. 開発効率の向上
    5. アプリケーションのパフォーマンス向上
  3. Context APIを用いたステート管理の基礎
    1. 1. Contextの作成
    2. 2. Providerの利用
    3. 3. ConsumerまたはuseContextフックの使用
    4. Context APIの基本フロー
  4. Contextの作成とプロバイダーの設定
    1. Contextオブジェクトの作成
    2. Providerの設定
    3. Providerのネストに関する注意点
    4. まとめ
  5. Consumerを使用したデータアクセス方法
    1. Consumerの基本構文
    2. Consumerのメリットと制約
    3. useContextフックとの比較
    4. まとめ
  6. Context APIの制限と課題
    1. 再レンダリングの問題
    2. 過剰なネスト
    3. 非同期データの扱い
    4. デバッグの難しさ
    5. まとめ
  7. Context APIを効率化するための工夫
    1. Contextの分割
    2. 値のメモ化
    3. コンシューマコンポーネントの分離
    4. カスタムフックの利用
    5. 不要な再レンダリングのチェック
    6. まとめ
  8. 応用例：Context APIを用いたテーマ切り替え機能の実装
    1. 1. Contextの作成
    2. 2. プロバイダーの適用
    3. 3. コンポーネントでテーマを使用する
    4. 4. 全体の構造
    5. 5. 動作確認
    6. まとめ
  9. Context APIと他のステート管理ライブラリの比較
    1. Context APIの特徴
    2. Reduxの特徴
    3. MobXの特徴
    4. どれを選ぶべきか
    5. まとめ
  10. 演習問題：Context APIを使った簡易カート機能の構築
    1. 1. Contextの作成
    2. 2. プロバイダーの適用
    3. 3. カート機能の利用
    4. 4. 完成したアプリケーションの構成
    5. 5. 動作確認
    6. まとめ
  11. まとめ

Context APIとは何か


ReactのContext APIは、コンポーネントツリー全体でデータを共有するための仕組みを提供します。従来の「プロップスドリリング」と呼ばれる親子間でのプロップスの受け渡しの煩雑さを解消し、必要なコンポーネントだけが直接データにアクセスできるようにします。

基本的な用途


Context APIは、次のような用途で利用されます。

  • グローバルステート管理: アプリケーション全体で共有されるデータ（例: ユーザー認証情報、テーマ設定）。
  • 設定情報の管理: 言語設定やUIのカスタマイズ情報など。
  • リアルタイムデータ共有: 複数のコンポーネント間でリアルタイムに更新されるデータの共有。

Context APIはReactに組み込まれているため、追加のライブラリをインストールする必要がなく、シンプルで軽量なステート管理が可能です。

Context APIを選択するメリット

大規模アプリケーションにおいて、Context APIを利用することにはいくつかの重要なメリットがあります。これにより、ステート管理の効率性や開発体験が向上します。

プロップスドリリングの解消


Context APIを利用すると、親から子、さらに孫コンポーネントへとプロップスを階層的に渡す必要がなくなります。これにより、コードの見通しが良くなり、メンテナンス性が向上します。

軽量かつシンプルな導入


Context APIはReactに組み込まれており、追加のライブラリや設定が不要です。そのため、ReduxやMobXなどの外部ライブラリを使う場合と比べて、簡単に導入できます。

コンポーネント間のスムーズなデータ共有


Contextを使用すれば、どのコンポーネントでも直接データにアクセスできるため、データの共有や同期が簡単になります。

開発効率の向上


Context APIは、少ないボイラープレートコードで実現できるため、素早く開発を進めることが可能です。また、React開発者にとっては学習コストが低いという利点もあります。

アプリケーションのパフォーマンス向上


適切にContextを分割して使用すれば、再レンダリングの範囲を抑えることができ、アプリケーションのパフォーマンスを向上させることも可能です。

Context APIを採用することで、開発体験の向上と効率化を実現できますが、特定のケースでは他のライブラリとの併用も検討が必要になる場合があります。その点については後の章で詳しく解説します。

Context APIを用いたステート管理の基礎

Context APIを利用してステート管理を行うためには、以下の3つの基本的な要素を理解する必要があります。これらを活用することで、コンポーネント間でデータを効率的に共有できます。

1. Contextの作成


Contextは、React.createContext()関数を使用して作成します。この関数は、共有したいデータの初期値を受け取り、Contextオブジェクトを返します。

import React from 'react';

// Contextの作成
const MyContext = React.createContext(null);

2. Providerの利用


Providerは、Contextに格納された値をコンポーネントツリー内の子コンポーネントに渡す役割を果たします。Providerコンポーネントは、Contextオブジェクトから取得され、valueプロパティを使用して共有するデータを指定します。

import React, { useState } from 'react';

const MyContext = React.createContext();

function App() {
  const [state, setState] = useState("Hello, Context!");

  return (
    <MyContext.Provider value={state}>
      <ChildComponent />
    </MyContext.Provider>
  );
}

3. ConsumerまたはuseContextフックの使用


子コンポーネントは、ConsumerまたはuseContextフックを使用してContextのデータにアクセスします。最近では、簡潔な記述が可能なuseContextフックが一般的に使用されています。

import React, { useContext } from 'react';

const MyContext = React.createContext();

function ChildComponent() {
  const contextValue = useContext(MyContext);

  return <p>{contextValue}</p>;
}

Context APIの基本フロー

  1. Contextを作成する。
  2. Providerを使ってデータを共有する。
  3. 必要なコンポーネントでConsumerまたはuseContextを使ってデータにアクセスする。

このように、Context APIを用いたステート管理は、Reactの基本機能のみで実現できるシンプルな方法です。次の章では、Contextの作成とProviderの設定をさらに詳しく解説します。

Contextの作成とプロバイダーの設定

Context APIを活用するには、まずContextオブジェクトを作成し、それをProviderを通じてアプリケーション全体に共有する必要があります。この章では、Contextの作成からProviderの設定までの具体的な手順を説明します。

Contextオブジェクトの作成


Contextオブジェクトは、React.createContext()を使って作成します。このオブジェクトには、アプリケーション全体で共有したいデータの初期値を設定することができます。

import React from 'react';

// Contextの作成
const UserContext = React.createContext(null);

export default UserContext;

Providerの設定


Providerは、Contextから提供されるコンポーネントで、Contextの値を子コンポーネントに渡します。Providerを使うことで、コンポーネントツリーの任意の深さにある子コンポーネントでデータにアクセス可能になります。

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

function App() {
  const [user, setUser] = useState({ name: "John Doe", age: 30 });

  return (
    <UserContext.Provider value={user}>
      <ChildComponent />
    </UserContext.Provider>
  );
}

ここで、valueプロパティには、Providerを通じて共有したいデータを設定します。このデータは、オブジェクト、配列、または単一の値でも構いません。

Providerのネストに関する注意点


複数のContextを使用する場合、それぞれのProviderをネストすることが一般的です。ただし、ネストが深くなるとコードが煩雑になるため、Contextを分割して必要最小限の範囲で共有することが推奨されます。

<ThemeContext.Provider value={theme}>
  <UserContext.Provider value={user}>
    <App />
  </UserContext.Provider>
</ThemeContext.Provider>

まとめ

  • React.createContextを使ってContextを作成する。
  • Providerを通じてデータをコンポーネントツリーに供給する。
  • valueプロパティでContextの値を設定する。

次の章では、Providerを使用して共有されたデータをConsumerやuseContextフックを使って取得する方法を説明します。

Consumerを使用したデータアクセス方法

Providerで提供されたデータにアクセスする方法として、ConsumerとuseContextフックがあります。この章では、Consumerを使ったデータの取得方法を中心に解説します。また、最近のReactで推奨されるuseContextフックとの違いについても触れます。

Consumerの基本構文


Consumerは、Contextから提供される値を受け取るためのコンポーネントです。Consumerは、子として関数を受け取り、その関数の引数にvalueを渡します。

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

function ChildComponent() {
  return (
    <UserContext.Consumer>
      {value => (
        <div>
          <p>User Name: {value.name}</p>
          <p>User Age: {value.age}</p>
        </div>
      )}
    </UserContext.Consumer>
  );
}

export default ChildComponent;

この例では、UserContext.Consumerを使って値を取得し、valueオブジェクトのプロパティにアクセスしています。

Consumerのメリットと制約

メリット

  • 明示的に値を取得できるため、Contextの仕組みを理解しやすい。

制約

  • コードが冗長になる。
  • ネストが深い場合に複雑さが増す。

useContextフックとの比較


Consumerを使うよりも、useContextフックを使用する方が簡潔で読みやすいコードを実現できます。

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

function ChildComponent() {
  const value = useContext(UserContext);

  return (
    <div>
      <p>User Name: {value.name}</p>
      <p>User Age: {value.age}</p>
    </div>
  );
}

export default ChildComponent;

この例では、useContextフックを使うことで、Consumerの冗長なコードを省略できます。useContextは関数コンポーネントでのみ使用可能です。

まとめ

  • ConsumerはContextの値を明示的に取得する方法を提供するが、コードが冗長になる可能性がある。
  • useContextフックは、簡潔な記述でContextの値を取得するためのモダンな方法である。
  • 最近のReactでは、useContextフックの使用が推奨される。

次の章では、Context APIの制限と課題について掘り下げていきます。

Context APIの制限と課題

Context APIは便利で柔軟なステート管理の仕組みを提供しますが、利用する際にはいくつかの制限や課題があります。これらを理解し、適切な対策を講じることが、効率的な開発の鍵となります。

再レンダリングの問題


Contextの値が変更されると、それを利用しているすべてのコンポーネントが再レンダリングされます。これにより、アプリケーションのパフォーマンスが低下する可能性があります。

例: 再レンダリングの課題


以下の例では、Contextの値が更新されると、ChildComponentが不要に再レンダリングされる可能性があります。

<MyContext.Provider value={someValue}>
  <ChildComponent />
</MyContext.Provider>

対策

  • Contextを複数に分割して、必要なデータだけを提供する。
  • 値をメモ化する（例: useMemoフックを使用）。
const memoizedValue = useMemo(() => someValue, [someValue]);

<MyContext.Provider value={memoizedValue}>
  <ChildComponent />
</MyContext.Provider>

過剰なネスト


Contextを多用すると、Providerがネストされすぎてコードの読みやすさが低下する「Provider Hell」に陥る可能性があります。

対策

  • Contextを必要な範囲で分割して使用する。
  • カスタムフックを作成して、Contextのロジックをカプセル化する。

非同期データの扱い


Context APIは非同期データの取得や更新を直接サポートしていません。非同期処理を含むステート管理には、ReduxやMobXなどの専用ライブラリが適している場合があります。

対策

  • 非同期データを管理するためにuseReducerやカスタムフックを併用する。

デバッグの難しさ


Contextを使用したデータフローは、デバッグがやや困難になる場合があります。どのコンポーネントがContextの値を利用しているのか追跡するのが難しいことがあります。

対策

  • 開発者ツールを活用する（例: React DevTools）。
  • Contextを適切に命名して、役割を明確にする。

まとめ

  • Context APIはシンプルで便利だが、再レンダリングやネストの問題に注意が必要。
  • メモ化やカスタムフックなどの対策を講じることで課題を軽減可能。
  • 非同期データや高度なステート管理が必要な場合は、他のライブラリとの併用も検討する。

次の章では、Context APIを効率的に使用するための具体的な工夫について解説します。

Context APIを効率化するための工夫

Context APIを使用する際には、効率的な実装方法を取り入れることで、パフォーマンスや可読性を向上させることができます。この章では、Context APIの効果的な使用方法とベストプラクティスを紹介します。

Contextの分割


複数の値を単一のContextで管理すると、値の一部が更新された際に、関連のないコンポーネントまで再レンダリングされる可能性があります。この問題を防ぐには、Contextを機能ごとに分割することが有効です。

例: Contextの分割

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

// UserとThemeを別々のContextで管理
<UserContext.Provider value={user}>
  <ThemeContext.Provider value={theme}>
    <App />
  </ThemeContext.Provider>
</UserContext.Provider>

値のメモ化


Contextの値が頻繁に変わる場合、useMemoやuseCallbackを使って値をメモ化することで、再レンダリングの範囲を最小限に抑えます。

例: メモ化された値

const memoizedValue = useMemo(() => computeExpensiveValue(input), [input]);

<SomeContext.Provider value={memoizedValue}>
  <ChildComponent />
</SomeContext.Provider>

コンシューマコンポーネントの分離


Contextの値を必要としない部分と分けてコンポーネントを設計すると、Contextの更新時に不要な部分の再レンダリングを防げます。

例: 分離されたコンシューマコンポーネント

function ParentComponent() {
  return (
    <div>
      <StaticComponent />
      <DynamicComponent />
    </div>
  );
}

function DynamicComponent() {
  const value = useContext(SomeContext);
  return <div>{value}</div>;
}

カスタムフックの利用


Contextのロジックをカスタムフックにまとめると、コードの再利用性が向上し、コンポーネントがシンプルになります。

例: カスタムフック

function useUser() {
  return useContext(UserContext);
}

function UserProfile() {
  const user = useUser();
  return <p>User Name: {user.name}</p>;
}

不要な再レンダリングのチェック


React DevToolsを使ってどのコンポーネントが再レンダリングされているかを確認し、必要に応じて最適化を行いましょう。

まとめ

  • Contextを機能ごとに分割して再レンダリングの影響を最小化する。
  • 値をメモ化してパフォーマンスを向上させる。
  • カスタムフックでコードを簡素化し、再利用性を高める。
  • 再レンダリングを視覚化して最適化ポイントを特定する。

次の章では、Context APIの具体的な応用例として、テーマ切り替え機能の実装を解説します。

応用例：Context APIを用いたテーマ切り替え機能の実装

Context APIを使用して、アプリケーション全体でテーマ（ライトモードとダークモードなど）を切り替える機能を実装する方法を解説します。この例では、Context APIとuseContextフックを活用し、テーマの状態管理を効率的に行います。

1. Contextの作成


テーマの状態を管理するためのContextを作成します。

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

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

// プロバイダーコンポーネント
export function 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;

このコードでは、themeステートを管理し、テーマを切り替えるためのtoggleTheme関数を提供しています。

2. プロバイダーの適用


ThemeProviderをアプリケーション全体で使用できるように設定します。

import React from 'react';
import ReactDOM from 'react-dom';
import { ThemeProvider } from './ThemeContext';
import App from './App';

ReactDOM.render(
  <ThemeProvider>
    <App />
  </ThemeProvider>,
  document.getElementById('root')
);

3. コンポーネントでテーマを使用する


子コンポーネントでuseContextフックを使って、テーマの状態にアクセスします。

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

function ThemedComponent() {
  const { theme, toggleTheme } = useContext(ThemeContext);

  return (
    <div style={{ 
      backgroundColor: theme === 'light' ? '#fff' : '#333', 
      color: theme === 'light' ? '#000' : '#fff', 
      padding: '20px' 
    }}>
      <p>Current Theme: {theme}</p>
      <button onClick={toggleTheme}>Toggle Theme</button>
    </div>
  );
}

export default ThemedComponent;

このコンポーネントでは、themeを基にスタイルを変更し、ボタンをクリックするとテーマを切り替えられるようにしています。

4. 全体の構造


以下が最終的なアプリケーションの構成です。

// index.js
<ThemeProvider>
  <App />
</ThemeProvider>

// App.js
<ThemedComponent />

5. 動作確認


アプリケーションを起動すると、テーマ切り替えボタンをクリックするたびに背景色や文字色が変更されることが確認できます。

まとめ


この応用例では、Context APIを使用してアプリケーション全体でテーマを管理する方法を学びました。useContextフックを活用することで、簡潔で可読性の高いコードが実現でき、テーマの状態管理が効率的に行えます。このようなパターンは、他のグローバルな設定や状態管理にも応用可能です。

次の章では、Context APIと他のステート管理ライブラリの比較を行い、それぞれの適用場面を考察します。

Context APIと他のステート管理ライブラリの比較

Context APIは、Reactが提供する組み込みのステート管理ツールですが、用途によってはReduxやMobXなどの外部ステート管理ライブラリが適している場合もあります。この章では、Context APIと他のステート管理ライブラリの特徴を比較し、それぞれの適用場面を考察します。

Context APIの特徴

  • メリット
  • Reactに組み込まれているため、追加のインストールや設定が不要。
  • 小規模から中規模アプリケーションのグローバルステート管理に適している。
  • シンプルで学習コストが低い。
  • デメリット
  • 再レンダリングの範囲が広くなる可能性がある。
  • 非同期処理や複雑なステートロジックの管理には適していない。

Reduxの特徴

  • メリット
  • 中〜大規模アプリケーションでのステート管理に適している。
  • 非同期処理のためのミドルウェア（Redux Thunk、Redux Saga）を活用できる。
  • ステートの予測可能性が高く、デバッグが容易。
  • デメリット
  • ボイラープレートコードが多くなる。
  • 設定や学習に時間がかかる場合がある。

MobXの特徴

  • メリット
  • リアクティブなプログラミングスタイルでステート管理が直感的。
  • ボイラープレートコードが少ない。
  • パフォーマンスが高く、自動的に必要な部分だけ再レンダリングされる。
  • デメリット
  • ステートの透明性が低く、デバッグが難しい場合がある。
  • Reduxに比べてエコシステムが限定的。

どれを選ぶべきか

  • Context API
  • 小規模なプロジェクト、設定や管理が単純なグローバルステートが必要な場合に最適。
  • Redux
  • 複数の開発者が関わる大規模プロジェクトや、複雑な非同期処理が必要な場合に最適。
  • MobX
  • コードの簡潔さや直感的な開発を重視する場合に適している。

まとめ


Context APIは、シンプルなステート管理には最適なツールですが、複雑な要件を満たすにはReduxやMobXが適している場合があります。プロジェクトの規模や要件に応じて、適切なツールを選択することが重要です。

次の章では、Context APIの理解を深めるために、簡易カート機能を構築する演習問題を紹介します。

演習問題：Context APIを使った簡易カート機能の構築

Context APIを利用して、シンプルなカート機能を構築することで、実践的な使い方を学びます。この演習では、商品の追加、削除、合計金額の計算といった基本的な機能を実装します。

1. Contextの作成


まず、カートの状態を管理するContextを作成します。

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

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

// Providerコンポーネント
export function CartProvider({ children }) {
  const [cart, setCart] = useState([]);

  const addItem = (item) => {
    setCart((prevCart) => [...prevCart, item]);
  };

  const removeItem = (id) => {
    setCart((prevCart) => prevCart.filter((item) => item.id !== id));
  };

  const getTotal = () => {
    return cart.reduce((total, item) => total + item.price, 0);
  };

  return (
    <CartContext.Provider value={{ cart, addItem, removeItem, getTotal }}>
      {children}
    </CartContext.Provider>
  );
}

export default CartContext;

このコードでは、カートの内容を管理し、商品を追加、削除、および合計金額を計算するための関数を提供しています。

2. プロバイダーの適用


アプリケーション全体でカート機能を使用できるように設定します。

import React from 'react';
import ReactDOM from 'react-dom';
import { CartProvider } from './CartContext';
import App from './App';

ReactDOM.render(
  <CartProvider>
    <App />
  </CartProvider>,
  document.getElementById('root')
);

3. カート機能の利用


次に、useContextフックを使用して、カートの状態を管理するコンポーネントを作成します。

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

function Product({ product }) {
  const { addItem } = useContext(CartContext);

  return (
    <div>
      <h3>{product.name}</h3>
      <p>Price: ${product.price}</p>
      <button onClick={() => addItem(product)}>Add to Cart</button>
    </div>
  );
}

function Cart() {
  const { cart, removeItem, getTotal } = useContext(CartContext);

  return (
    <div>
      <h2>Shopping Cart</h2>
      {cart.map((item) => (
        <div key={item.id}>
          <p>{item.name}</p>
          <p>Price: ${item.price}</p>
          <button onClick={() => removeItem(item.id)}>Remove</button>
        </div>
      ))}
      <h3>Total: ${getTotal()}</h3>
    </div>
  );
}

export { Product, Cart };

このコードでは、Productコンポーネントで商品をカートに追加し、Cartコンポーネントでカートの内容を表示・管理しています。

4. 完成したアプリケーションの構成


最終的なアプリケーションの構造は以下のようになります。

// App.js
import React from 'react';
import { Product, Cart } from './CartComponents';

function App() {
  const sampleProduct = { id: 1, name: "Sample Product", price: 20 };

  return (
    <div>
      <Product product={sampleProduct} />
      <Cart />
    </div>
  );
}

export default App;

5. 動作確認


アプリケーションを起動して、商品の追加、削除、合計金額の確認が正しく動作するか確認してください。

まとめ


この演習では、Context APIを使って簡易カート機能を構築しました。Contextを利用したステート管理の基本的な流れを理解し、実用的なアプリケーションで活用するための基礎を学ぶことができます。この例を基に、さらに複雑な機能を追加してスキルを磨いてみてください。

次の章では、この記事の内容をまとめます。

まとめ

本記事では、ReactのContext APIを活用した大規模アプリケーションのステート管理について、基礎から応用までを解説しました。Context APIの基本概念や実装方法、効率的な使い方を学び、テーマ切り替え機能やカート機能といった具体例を通じてその応用力を深めました。

Context APIは、小規模から中規模のアプリケーションで特に効果的に使えるツールですが、再レンダリングやネストの問題といった課題を抱える場合があります。適切な工夫を取り入れることで、これらの制限を克服し、効率的なステート管理が可能です。

この記事を通じて、Context APIを使った柔軟でスケーラブルなReactアプリケーションの構築に自信を持てるようになったのではないでしょうか。次のステップとして、実際のプロジェクトで積極的に活用し、さらにスキルを高めていきましょう。

React
React ステート管理 Context API

コメント

コメントする

目次
  1. Context APIとは何か
    1. 基本的な用途
  2. Context APIを選択するメリット
    1. プロップスドリリングの解消
    2. 軽量かつシンプルな導入
    3. コンポーネント間のスムーズなデータ共有
    4. 開発効率の向上
    5. アプリケーションのパフォーマンス向上
  3. Context APIを用いたステート管理の基礎
    1. 1. Contextの作成
    2. 2. Providerの利用
    3. 3. ConsumerまたはuseContextフックの使用
    4. Context APIの基本フロー
  4. Contextの作成とプロバイダーの設定
    1. Contextオブジェクトの作成
    2. Providerの設定
    3. Providerのネストに関する注意点
    4. まとめ
  5. Consumerを使用したデータアクセス方法
    1. Consumerの基本構文
    2. Consumerのメリットと制約
    3. useContextフックとの比較
    4. まとめ
  6. Context APIの制限と課題
    1. 再レンダリングの問題
    2. 過剰なネスト
    3. 非同期データの扱い
    4. デバッグの難しさ
    5. まとめ
  7. Context APIを効率化するための工夫
    1. Contextの分割
    2. 値のメモ化
    3. コンシューマコンポーネントの分離
    4. カスタムフックの利用
    5. 不要な再レンダリングのチェック
    6. まとめ
  8. 応用例：Context APIを用いたテーマ切り替え機能の実装
    1. 1. Contextの作成
    2. 2. プロバイダーの適用
    3. 3. コンポーネントでテーマを使用する
    4. 4. 全体の構造
    5. 5. 動作確認
    6. まとめ
  9. Context APIと他のステート管理ライブラリの比較
    1. Context APIの特徴
    2. Reduxの特徴
    3. MobXの特徴
    4. どれを選ぶべきか
    5. まとめ
  10. 演習問題：Context APIを使った簡易カート機能の構築
    1. 1. Contextの作成
    2. 2. プロバイダーの適用
    3. 3. カート機能の利用
    4. 4. 完成したアプリケーションの構成
    5. 5. 動作確認
    6. まとめ
  11. まとめ