MENU
  1. ホーム
  2. React
  3. Reactで状態が多すぎる場合の整理・分割テクニック徹底解説

Reactで状態が多すぎる場合の整理・分割テクニック徹底解説

React

React開発において、状態管理はアプリケーションの動作を制御する重要な要素です。しかし、アプリが成長するにつれて状態が増えすぎると、コードが複雑化し、エラーやメンテナンス性の低下を招くことがあります。特に、大規模なコンポーネントツリーや複数の状態管理手法を併用するプロジェクトでは、状態の適切な整理と分割が必要不可欠です。本記事では、Reactアプリケーションにおける状態が多すぎる場合の具体的な課題を明らかにし、それを解消するための効果的な整理・分割テクニックを詳しく解説します。

目次
  1. 状態が多すぎるときの問題点とは
    1. コードの複雑化
    2. 再レンダリングの増加
    3. デバッグの困難さ
    4. 状態のスコープが不明確
    5. 依存性の増大
  2. 状態を分割する基本的なアプローチ
    1. 単一責任の原則を適用する
    2. グローバル状態とローカル状態を明確に分ける
    3. 状態のスコープを最小限に保つ
    4. UIと状態管理を分離する
    5. 状態の種類ごとに分類する
  3. コンポーネントのローカル状態管理
    1. ローカル状態とは
    2. useStateを使ったローカル状態の実装
    3. useReducerを使った複雑な状態管理
    4. ローカル状態のメリット
  4. コンテキストAPIを活用した整理術
    1. Context APIとは
    2. Contextの作成と使用方法
    3. Context APIを使うメリット
    4. 注意点とベストプラクティス
  5. 状態管理ライブラリの適切な利用
    1. 状態管理ライブラリが必要なケース
    2. 主な状態管理ライブラリの特徴
    3. 状態管理ライブラリの基本的な使い方
    4. 選択の基準と実践のポイント
  6. カスタムフックによる状態の再利用
    1. カスタムフックとは
    2. カスタムフックの基本例
    3. カスタムフックの活用シナリオ
    4. カスタムフックのメリット
    5. 注意点
  7. 状態のスコープ設計と最適化のポイント
    1. 状態のスコープとは
    2. スコープ設計のベストプラクティス
    3. 再レンダリングの最適化
    4. 具体例：リスト状態の最適化
    5. 状態のスコープ設計で得られるメリット
  8. 状態の分割によるパフォーマンス改善
    1. 状態分割の基本概念
    2. パフォーマンス最適化の手法
    3. パフォーマンス改善の効果
    4. 注意点
  9. まとめ

状態が多すぎるときの問題点とは


Reactアプリケーションで状態が多くなると、以下のような問題が発生します。

コードの複雑化


状態が増えると、どのコンポーネントがどの状態を管理しているのか把握しづらくなります。また、依存関係が複雑化し、メンテナンスが困難になる場合があります。

再レンダリングの増加


多くの状態が1つのコンポーネントやコンテキストで管理されている場合、些細な変更でも多くの部分が再レンダリングされ、パフォーマンスの低下を引き起こします。

デバッグの困難さ


状態がどこで変更されたのか追跡するのが難しくなり、バグの特定に時間がかかるようになります。特にグローバルな状態管理では、どのアクションがどの状態を変更したのかを把握するのが大変です。

状態のスコープが不明確


ローカルで扱うべき状態をグローバルに管理したり、逆にグローバルで扱うべき状態をローカルに閉じ込めたりすると、他のコンポーネントでの再利用が難しくなります。

依存性の増大


状態を適切に分割していない場合、一部のコンポーネントが過剰に多くの他のコンポーネントに依存するようになり、リファクタリングが難しくなります。

こうした問題を未然に防ぐためには、適切な状態管理の設計が欠かせません。次のセクションでは、そのための基本的なアプローチを紹介します。

状態を分割する基本的なアプローチ

Reactアプリケーションにおける状態管理の効率化には、状態を適切に分割することが重要です。以下に、状態を分割する基本的なアプローチを解説します。

単一責任の原則を適用する


コンポーネントごとに、その責務に応じた状態だけを管理するようにします。例えば、フォーム入力の状態はフォームコンポーネント内に閉じ込め、全体的なアプリ状態は上位コンポーネントやグローバル状態管理に委ねます。

グローバル状態とローカル状態を明確に分ける

  • ローカル状態: あるコンポーネントやその子コンポーネントだけが必要とする情報。useStateやuseReducerを使用して管理します。
  • グローバル状態: アプリケーション全体で共有される情報。Context APIや状態管理ライブラリを使用して管理します。

状態のスコープを最小限に保つ


状態を必要とするコンポーネントにだけ渡すようにします。Propsの「ドリリング」が発生する場合は、コンテキストやカスタムフックを利用してスコープを適切に制限します。

UIと状態管理を分離する


状態管理ロジックをUIから切り離すことで、再利用性とテストの容易さが向上します。この分離には、カスタムフックや状態管理ライブラリの導入が役立ちます。

状態の種類ごとに分類する


状態を以下のように分類すると、管理がしやすくなります：

  • UI状態: モーダルの開閉やタブの切り替えなど。
  • データ状態: APIから取得したデータやそのキャッシュ。
  • セッション状態: ユーザー情報や認証トークンなど。

このように状態を整理し、必要に応じて分割することで、コードの可読性とメンテナンス性が向上します。次のセクションでは、状態のローカル管理について詳しく解説します。

コンポーネントのローカル状態管理

Reactでは、コンポーネントごとにローカルな状態を管理することで、コードの簡潔さとパフォーマンスの向上を図ることができます。ここでは、ローカル状態管理の基本とベストプラクティスを解説します。

ローカル状態とは


ローカル状態とは、特定のコンポーネントとその子コンポーネント内だけで使用される状態を指します。たとえば、次のようなケースで利用します：

  • フォームの入力値
  • モーダルの開閉状態
  • ボタンのアクティブ状態

useStateを使ったローカル状態の実装


useStateフックを使用して、コンポーネント内で簡単にローカル状態を管理できます。以下は例です：

import React, { useState } from "react";

function Counter() {
  const [count, setCount] = useState(0);

  const increment = () => setCount(count + 1);

  return (
    <div>
      <p>Current count: {count}</p>
      <button onClick={increment}>Increment</button>
    </div>
  );
}

export default Counter;

この例では、カウンターの状態がコンポーネント内に閉じ込められています。

useReducerを使った複雑な状態管理


ローカルで複雑な状態管理が必要な場合は、useReducerを使用するのが効果的です。たとえば、フォームの状態管理に利用できます：

import React, { useReducer } from "react";

function formReducer(state, action) {
  switch (action.type) {
    case "SET_NAME":
      return { ...state, name: action.payload };
    case "SET_EMAIL":
      return { ...state, email: action.payload };
    default:
      return state;
  }
}

function Form() {
  const [state, dispatch] = useReducer(formReducer, { name: "", email: "" });

  return (
    <div>
      <input
        type="text"
        placeholder="Name"
        value={state.name}
        onChange={(e) => dispatch({ type: "SET_NAME", payload: e.target.value })}
      />
      <input
        type="email"
        placeholder="Email"
        value={state.email}
        onChange={(e) => dispatch({ type: "SET_EMAIL", payload: e.target.value })}
      />
      <p>Name: {state.name}</p>
      <p>Email: {state.email}</p>
    </div>
  );
}

export default Form;

このように、ローカルで必要な範囲の状態管理を適切に行うことで、グローバルな状態の肥大化を防ぐことができます。

ローカル状態のメリット

  • 簡単で直感的: 状態がコンポーネントに限定されるため、理解しやすい。
  • 再レンダリングの抑制: グローバル状態管理と異なり、他の部分に影響を及ぼしにくい。
  • スコープの明確化: 必要な状態を必要なコンポーネント内に閉じ込めることで、管理が容易になる。

ローカル状態管理は、特定の用途に限定した状態を効率的に扱うための重要な手段です。次は、グローバルな状態を扱うContext APIについて説明します。

コンテキストAPIを活用した整理術

ReactのContext APIは、グローバルな状態を管理するための強力なツールです。特に、状態を複数のコンポーネント間で共有する場合に役立ちます。ここでは、Context APIを使用した状態整理の方法を解説します。

Context APIとは


Context APIは、Reactが提供するネイティブな状態管理の仕組みで、以下のようなケースで有用です：

  • ユーザー情報や認証トークンの管理
  • アプリ全体のテーマ設定（ダークモード、ライトモードなど）
  • 多数の子コンポーネントが共有する設定値

Context APIを利用することで、Propsの「ドリリング」（深いネスト構造の中で、いくつものコンポーネントにデータを渡すこと）を防ぐことができます。

Contextの作成と使用方法


以下は、Context APIを使用してテーマ設定を管理する例です：

import React, { createContext, useState, useContext } from "react";

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

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>
  );
}

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

  return (
    <button
      onClick={toggleTheme}
      style={{
        backgroundColor: theme === "light" ? "#fff" : "#333",
        color: theme === "light" ? "#000" : "#fff",
      }}
    >
      Toggle Theme
    </button>
  );
}

function App() {
  return (
    <ThemeProvider>
      <ThemedButton />
    </ThemeProvider>
  );
}

export default App;

Context APIを使うメリット

  • Propsドリリングの削減: 深くネストしたコンポーネントにデータを渡す必要がなくなります。
  • シンプルなグローバル状態管理: 状態管理ライブラリを使うまでもない簡単なユースケースに最適です。
  • 柔軟な設計: 必要に応じて複数のContextを作成して使い分けることができます。

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

  • 過剰な使用を避ける: Contextを多用するとコンポーネントの再レンダリングが増え、パフォーマンスに影響を及ぼす場合があります。状態を細かく分割するか、useMemoやuseCallbackを活用して最適化しましょう。
  • 読み取り専用Contextの活用: 一部の状態が変更されない場合、読み取り専用のContextを作成してパフォーマンスを向上させます。

Context APIは、手軽で効果的なグローバル状態管理の手段です。ただし、適切にスコープを分けて使用することが、効率的なアプリケーション設計の鍵となります。次は、状態管理ライブラリの選び方と活用法について詳しく解説します。

状態管理ライブラリの適切な利用

ReactのContext APIでは対応しきれない大規模な状態管理や複雑なアプリケーションには、ReduxやZustandなどの外部ライブラリを利用することが効果的です。ここでは、状態管理ライブラリの選び方と活用方法を解説します。

状態管理ライブラリが必要なケース


以下のような場合には、状態管理ライブラリの利用を検討すると良いでしょう：

  • アプリケーション全体で多くの状態を共有する必要がある。
  • 非同期データの管理（API通信やキャッシュ）が多い。
  • 状態の追跡やデバッグが複雑化している。

主な状態管理ライブラリの特徴

Redux

  • 特徴: 状態の一元管理を可能にする定番ライブラリ。厳格なフロー（アクション、リデューサー、ストア）で構造化された状態管理を提供します。
  • 利点: デバッグツール（Redux DevTools）が強力で、大規模プロジェクトに適しています。
  • 課題: 初期設定やボイラープレートコードが多い。

Zustand

  • 特徴: シンプルで軽量な状態管理ライブラリ。Context APIの簡易版に近い使用感です。
  • 利点: 学習コストが低く、ボイラープレートも少ない。小規模〜中規模プロジェクトに適しています。
  • 課題: 大規模なプロジェクトには不向きな場合があります。

Recoil

  • 特徴: Reactに特化した状態管理ライブラリ。細かい状態の分離が可能で、コンポーネント単位で効率的に再レンダリングを制御できます。
  • 利点: 細分化された状態管理で、Reactの考え方に沿っています。
  • 課題: 他のライブラリほど汎用性がない場合があります。

状態管理ライブラリの基本的な使い方

以下は、Reduxを使用した基本的な例です：

import { createStore } from "redux";
import { Provider, useSelector, useDispatch } from "react-redux";

// リデューサー
const counterReducer = (state = { count: 0 }, action) => {
  switch (action.type) {
    case "INCREMENT":
      return { count: state.count + 1 };
    case "DECREMENT":
      return { count: state.count - 1 };
    default:
      return state;
  }
};

// ストアの作成
const store = createStore(counterReducer);

function Counter() {
  const count = useSelector((state) => state.count);
  const dispatch = useDispatch();

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => dispatch({ type: "INCREMENT" })}>+</button>
      <button onClick={() => dispatch({ type: "DECREMENT" })}>-</button>
    </div>
  );
}

function App() {
  return (
    <Provider store={store}>
      <Counter />
    </Provider>
  );
}

export default App;

選択の基準と実践のポイント

  • プロジェクトの規模に応じて選ぶ: Reduxは大規模プロジェクト、Zustandは中小規模プロジェクトに向いています。
  • 将来的なメンテナンスを考慮: 状態の構造化や拡張性が必要な場合は、厳格なフローを持つライブラリが適しています。
  • 非同期処理を考慮: Reduxではredux-thunkやredux-sagaを組み合わせることで非同期処理を容易に管理できます。

状態管理ライブラリを適切に選び、活用することで、複雑なアプリケーションでもスムーズな開発と運用が可能になります。次は、カスタムフックによる状態の再利用について解説します。

カスタムフックによる状態の再利用

Reactでは、カスタムフックを利用することで、状態管理やロジックを簡単に再利用可能にできます。カスタムフックは特定の状態や動作を抽象化し、複数のコンポーネント間で共有できるため、コードの簡潔化とメンテナンス性の向上につながります。

カスタムフックとは


カスタムフックは、useStateやuseEffectなどのReactフックを組み合わせて作成される関数です。これにより、状態管理や副作用の処理を1か所にまとめ、コンポーネント間で使い回すことができます。

カスタムフックの基本例


以下は、ウィンドウサイズを取得するカスタムフックの例です：

import { useState, useEffect } from "react";

function useWindowSize() {
  const [size, setSize] = useState({
    width: window.innerWidth,
    height: window.innerHeight,
  });

  useEffect(() => {
    const handleResize = () => {
      setSize({ width: window.innerWidth, height: window.innerHeight });
    };

    window.addEventListener("resize", handleResize);

    return () => {
      window.removeEventListener("resize", handleResize);
    };
  }, []);

  return size;
}

export default useWindowSize;

このフックを使用するコンポーネント：

import React from "react";
import useWindowSize from "./useWindowSize";

function App() {
  const { width, height } = useWindowSize();

  return (
    <div>
      <p>Window width: {width}px</p>
      <p>Window height: {height}px</p>
    </div>
  );
}

export default App;

カスタムフックの活用シナリオ

データフェッチング


APIからのデータ取得やエラーハンドリングをカスタムフックにまとめます：

import { useState, useEffect } from "react";

function useFetch(url) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    fetch(url)
      .then((response) => response.json())
      .then((data) => {
        setData(data);
        setLoading(false);
      })
      .catch((error) => {
        setError(error);
        setLoading(false);
      });
  }, [url]);

  return { data, loading, error };
}

export default useFetch;

フォーム状態の管理


フォームの入力値やバリデーションロジックをカスタムフックに集約します。

認証状態の共有


ログイン状態や認証トークンをカスタムフックで管理することで、関連するコンポーネント間で共有できます。

カスタムフックのメリット

  • 再利用性: 同じロジックを複数のコンポーネントで使い回せます。
  • コードの簡潔化: 共通ロジックを切り出すことで、コンポーネントがシンプルになります。
  • テストの容易さ: カスタムフックは関数単位でテストできるため、ユニットテストが簡単です。

注意点

  • グローバル状態には適さない: カスタムフックは主にローカルな再利用を目的としており、グローバルな状態には状態管理ライブラリを使用する方が適切です。
  • 副作用の管理: フック内部での副作用（例：useEffect）が複雑になる場合は、注意が必要です。

カスタムフックを活用することで、状態管理の効率化とコードの保守性向上が期待できます。次は、状態のスコープ設計と最適化について詳しく解説します。

状態のスコープ設計と最適化のポイント

Reactアプリケーションの状態管理では、状態のスコープ（有効範囲）を適切に設計することが重要です。これにより、再レンダリングの抑制やパフォーマンスの向上、コードの見通しの良さが得られます。ここでは、状態のスコープ設計と最適化の具体的なポイントを解説します。

状態のスコープとは


状態のスコープとは、その状態が影響を及ぼす範囲を指します。状態を適切にスコープ分けすることで、必要以上に影響を広げずに済みます。

ローカルスコープ

  • 特定のコンポーネント内で完結する状態。
  • 例: 入力フォームの入力値、モーダルの開閉状態。

グローバルスコープ

  • アプリ全体や複数のコンポーネントで共有する必要がある状態。
  • 例: 認証状態、アプリテーマ、ユーザープロファイル情報。

スコープ設計のベストプラクティス

状態を最小限に保つ


不要な状態を持たないように設計します。状態を持つべきかを判断する際には以下の基準を考慮します：

  • 状態が計算可能であれば計算結果を使用する（例: 総数やフィルタリング後のリスト）。
  • UIを直接制御しない場合は状態を削除する。

状態の「所有権」を明確にする


状態を「どのコンポーネントが管理すべきか」を明確にします。たとえば、フォーム入力値はフォームコンポーネントが管理し、リストのソート順はリストを表示するコンポーネントが管理します。

依存関係を減らす


状態を持つコンポーネントが他のコンポーネントに依存しすぎると、設計が複雑になります。状態を可能な限り独立させ、再利用可能な形に設計しましょう。

再レンダリングの最適化

状態を適切な粒度で分割する


状態を分割することで、不要な再レンダリングを防ぎます。たとえば、次のように分割します：

  • リスト全体の状態と個々のリストアイテムの状態を分ける。
  • フォーム全体の状態と個々の入力フィールドの状態を分ける。

メモ化を活用する

  • React.memo: コンポーネントが受け取るPropsに変更がない場合、再レンダリングを防ぎます。
  • useMemo: 計算コストの高い値をメモ化して再計算を避けます。
  • useCallback: コールバック関数をメモ化して、再生成を防ぎます。

非同期処理を最適化する


API呼び出しやデータ取得などの非同期処理は、以下の方法で効率化できます：

  • データフェッチを必要なタイミングでのみ行う。
  • キャッシュを活用して、同じデータを繰り返し取得しない。

具体例：リスト状態の最適化


以下はリスト状態をスコープ分割して再レンダリングを最適化する例です：

import React, { useState, memo } from "react";

const ListItem = memo(({ item }) => {
  console.log(`Rendering item: ${item.name}`);
  return <li>{item.name}</li>;
});

function App() {
  const [list, setList] = useState([{ id: 1, name: "Item 1" }, { id: 2, name: "Item 2" }]);
  const [filter, setFilter] = useState("");

  const filteredList = list.filter((item) => item.name.includes(filter));

  return (
    <div>
      <input
        type="text"
        placeholder="Filter items"
        value={filter}
        onChange={(e) => setFilter(e.target.value)}
      />
      <ul>
        {filteredList.map((item) => (
          <ListItem key={item.id} item={item} />
        ))}
      </ul>
    </div>
  );
}

export default App;

この例では、ListItemをReact.memoでラップすることで、フィルタ入力時にリストアイテムの不要な再レンダリングを防いでいます。

状態のスコープ設計で得られるメリット

  • パフォーマンス向上: 必要なコンポーネントだけが再レンダリングされる。
  • コードの簡潔化: 状態が独立し、ロジックが分かりやすくなる。
  • 保守性の向上: 状態管理が整理され、バグの追跡や修正が容易になる。

状態のスコープを適切に設計し、必要に応じて最適化を施すことで、Reactアプリケーションを効率的に管理できます。次は、状態分割がアプリケーションのパフォーマンスに与える影響について詳しく解説します。

状態の分割によるパフォーマンス改善

Reactアプリケーションのパフォーマンスを向上させるためには、状態を適切に分割することが重要です。状態を分割することで、再レンダリングの範囲を限定し、アプリケーション全体の効率を高めることができます。

状態分割の基本概念


Reactでは、状態の変更が発生すると、その状態を管理しているコンポーネントとその子孫コンポーネントが再レンダリングされます。状態を適切に分割すると、再レンダリングの影響を必要最低限に抑えることが可能です。

状態分割の具体例


リストと選択中のアイテムを個別に管理する場合を考えます。

import React, { useState } from "react";

function App() {
  const [items] = useState(["Item 1", "Item 2", "Item 3"]);
  const [selectedItem, setSelectedItem] = useState(null);

  const selectItem = (item) => {
    setSelectedItem(item);
  };

  return (
    <div>
      <ul>
        {items.map((item) => (
          <li key={item} onClick={() => selectItem(item)}>
            {item}
          </li>
        ))}
      </ul>
      <div>
        <h2>Selected Item:</h2>
        <p>{selectedItem}</p>
      </div>
    </div>
  );
}

export default App;

この例では、リスト全体と選択中のアイテムの状態を分割して管理することで、選択アクションがリスト全体の再レンダリングを引き起こさないようにしています。

パフォーマンス最適化の手法

状態を局所化する


グローバルに管理する必要のない状態はローカルに閉じ込めることで、再レンダリングの範囲を制限します。

React.memoによる再レンダリング抑制


React.memoを使用して、Propsが変更されない限り再レンダリングを抑制します。

const ListItem = React.memo(({ item, onClick }) => {
  console.log(`Rendering: ${item}`);
  return <li onClick={() => onClick(item)}>{item}</li>;
});

このようにすることで、状態の変更が他のリストアイテムの再レンダリングに影響を与えなくなります。

計算コストの高い処理をメモ化する


計算コストの高い処理が頻繁に行われる場合、useMemoを活用して値をメモ化します。

const filteredItems = useMemo(() => {
  return items.filter((item) => item.includes(searchQuery));
}, [items, searchQuery]);

非同期処理を分離する


非同期データのフェッチやAPIコールの状態をグローバル状態と分離することで、UIの応答性を高めます。

パフォーマンス改善の効果

  • 再レンダリングの最小化: 必要な部分だけが更新され、全体の描画負荷が軽減されます。
  • メモリ使用量の削減: 状態を効率的に管理することで、無駄なメモリ消費を防ぎます。
  • ユーザー体験の向上: 高速でスムーズな操作が可能になり、ユーザー満足度が向上します。

注意点

  • 状態の分割が過剰になると、コードの複雑性が増すため、適切なバランスを保つことが重要です。
  • 状態の分割とグローバル状態の管理を併用して、シンプルかつ効率的な設計を目指しましょう。

状態の分割と適切な最適化を行うことで、Reactアプリケーションのパフォーマンスを大幅に向上させることができます。次は、本記事のまとめです。

まとめ

本記事では、Reactアプリケーションにおいて状態が多すぎる場合の整理と分割の方法について解説しました。状態が増えることで発生する問題点を理解し、状態のスコープ設計やローカル状態の活用、Context APIや状態管理ライブラリ、カスタムフックの導入といった解決策を具体例とともに紹介しました。

状態を適切に分割することで、コードの可読性が向上し、再レンダリングの最小化やパフォーマンスの最適化が実現できます。また、カスタムフックやライブラリの活用により、複雑なアプリケーションでも効率的な開発が可能になります。

これらのテクニックを活用して、状態管理を整理し、スケーラブルで保守性の高いReactアプリケーションを構築しましょう。

React
React 状態管理 フロントエンド開発

コメント

コメントする

目次
  1. 状態が多すぎるときの問題点とは
    1. コードの複雑化
    2. 再レンダリングの増加
    3. デバッグの困難さ
    4. 状態のスコープが不明確
    5. 依存性の増大
  2. 状態を分割する基本的なアプローチ
    1. 単一責任の原則を適用する
    2. グローバル状態とローカル状態を明確に分ける
    3. 状態のスコープを最小限に保つ
    4. UIと状態管理を分離する
    5. 状態の種類ごとに分類する
  3. コンポーネントのローカル状態管理
    1. ローカル状態とは
    2. useStateを使ったローカル状態の実装
    3. useReducerを使った複雑な状態管理
    4. ローカル状態のメリット
  4. コンテキストAPIを活用した整理術
    1. Context APIとは
    2. Contextの作成と使用方法
    3. Context APIを使うメリット
    4. 注意点とベストプラクティス
  5. 状態管理ライブラリの適切な利用
    1. 状態管理ライブラリが必要なケース
    2. 主な状態管理ライブラリの特徴
    3. 状態管理ライブラリの基本的な使い方
    4. 選択の基準と実践のポイント
  6. カスタムフックによる状態の再利用
    1. カスタムフックとは
    2. カスタムフックの基本例
    3. カスタムフックの活用シナリオ
    4. カスタムフックのメリット
    5. 注意点
  7. 状態のスコープ設計と最適化のポイント
    1. 状態のスコープとは
    2. スコープ設計のベストプラクティス
    3. 再レンダリングの最適化
    4. 具体例：リスト状態の最適化
    5. 状態のスコープ設計で得られるメリット
  8. 状態の分割によるパフォーマンス改善
    1. 状態分割の基本概念
    2. パフォーマンス最適化の手法
    3. パフォーマンス改善の効果
    4. 注意点
  9. まとめ