MENU
  1. ホーム
  2. React
  3. Reactのライフサイクルメソッドを活用してパフォーマンスを向上させる方法

Reactのライフサイクルメソッドを活用してパフォーマンスを向上させる方法

React

Reactは、コンポーネントベースのUI開発を可能にする強力なライブラリであり、多くのWebアプリケーションで採用されています。しかし、高度なアプリケーションでは、パフォーマンスが問題になることも少なくありません。Reactのライフサイクルメソッドは、この課題を解決するための鍵となります。本記事では、ライフサイクルメソッドを活用して、効率的かつ最適にコンポーネントを操作し、アプリケーションのパフォーマンスを向上させる具体的な方法を解説します。初学者から中級者まで役立つ内容を取り揃え、リアルワールドの例も交えながら、そのメリットを最大限に引き出すためのガイドを提供します。

目次
  1. Reactのライフサイクルメソッドとは
    1. ライフサイクルメソッドの役割
    2. ライフサイクルメソッドの基本構造
  2. ライフサイクルのフェーズと主なメソッド
    1. 1. マウント（Mount）
    2. 2. 更新（Update）
    3. 3. アンマウント（Unmount）
    4. React 18以降の注意点
  3. shouldComponentUpdateを使った再レンダリングの制御
    1. shouldComponentUpdateの役割
    2. 使用例
    3. shouldComponentUpdateの注意点
    4. React.memoとの比較
  4. componentDidMountでの初期データ取得
    1. componentDidMountの役割
    2. 使用例
    3. ベストプラクティス
    4. React Hooksを使用する場合
    5. まとめ
  5. componentWillUnmountでのリソース解放
    1. componentWillUnmountの役割
    2. 使用例
    3. イベントリスナーの解除
    4. React Hooksを使用する場合
    5. ベストプラクティス
    6. まとめ
  6. React 18の変更点とライフサイクルへの影響
    1. React 18の主要な変更点
    2. ライフサイクルメソッドへの影響
    3. React 18での推奨アプローチ
    4. ベストプラクティス
    5. まとめ
  7. ライフサイクルメソッドを使った実践的な最適化例
    1. 例1: APIリクエストの最適化
    2. 例2: タイマー管理の効率化
    3. 例3: 外部ライブラリの管理
    4. 例4: エラーバウンドリによるエラーハンドリング
    5. 実践的なヒント
    6. まとめ
  8. エラー処理とエラーバウンドリの活用
    1. エラーバウンドリとは
    2. エラーバウンドリの実装
    3. エラーバウンドリの利用シーン
    4. エラーバウンドリの限界
    5. React Hooksを使用する場合のエラー処理
    6. ベストプラクティス
    7. まとめ
  9. まとめ

Reactのライフサイクルメソッドとは


Reactのライフサイクルメソッドとは、コンポーネントの生成から終了までの一連の過程を管理するための特定のメソッド群を指します。これらのメソッドを活用することで、コンポーネントの動作を細かく制御し、効率的なリソース管理や動的なUIの実現が可能になります。

ライフサイクルメソッドの役割


ライフサイクルメソッドは以下のような場面で役立ちます。

  • 初期化：コンポーネントの初期状態を設定し、外部リソースを読み込む。
  • 更新：状態やプロパティの変更に応じて適切な処理を実行する。
  • 終了：不要になったリソースを解放し、メモリリークを防ぐ。

ライフサイクルメソッドの基本構造


Reactのライフサイクルは大きく分けて以下の3つのフェーズに分類されます。

  1. マウント（Mount）：コンポーネントが初めてDOMに追加される段階。
  2. 更新（Update）：状態（state）やプロパティ（props）が変更された際の段階。
  3. アンマウント（Unmount）：コンポーネントがDOMから削除される段階。

これらのフェーズを通じて、Reactコンポーネントのライフサイクル全体を管理できます。ライフサイクルメソッドを正しく活用することで、アプリケーションのパフォーマンス向上や、予期しない動作の防止に役立ちます。

ライフサイクルのフェーズと主なメソッド


Reactのライフサイクルは、コンポーネントがDOMとやり取りする過程を制御するために3つのフェーズに分類されます。それぞれのフェーズに特定の役割を持つメソッドがあります。

1. マウント（Mount）


コンポーネントが初めてDOMに挿入されるフェーズです。ここでは、初期化や外部データの取得が主な目的です。

  • constructor: 初期化処理（stateの設定やクラス内変数の初期化など）を行います。
  • componentDidMount: DOMがレンダリングされた後に呼び出され、APIリクエストや外部リソースの読み込みなどに使用されます。

2. 更新（Update）


propsやstateが変更され、再レンダリングが必要なときに実行されるフェーズです。パフォーマンス最適化が重要なポイントになります。

  • shouldComponentUpdate: 再レンダリングを行うべきかを判断します。効率化のために使用します。
  • componentDidUpdate: 更新後の状態を操作するために利用されます。例えば、新しいデータの取得やDOM操作が可能です。

3. アンマウント（Unmount）


コンポーネントがDOMから削除される際に実行されるフェーズです。このフェーズではリソースの解放を行います。

  • componentWillUnmount: イベントリスナーの解除やタイマーのクリアなど、クリーンアップ処理に使用されます。

React 18以降の注意点


React 18ではライフサイクルメソッドにいくつかの変更が加えられました。たとえば、クラスコンポーネントでの使用が主だったメソッドの一部は非推奨となり、関数コンポーネントでのHooks使用が推奨されています。これらの変更点を理解し、最新のReactバージョンに適応することが重要です。

Reactのライフサイクルを正確に理解し、適切に活用することで、効率的なコンポーネント設計が可能になります。

shouldComponentUpdateを使った再レンダリングの制御


Reactアプリケーションのパフォーマンスを最適化するために、不要な再レンダリングを防ぐことは重要です。そのために利用されるのが、shouldComponentUpdateメソッドです。このメソッドを活用することで、再レンダリングの条件を明確に制御できます。

shouldComponentUpdateの役割


shouldComponentUpdateは、クラスコンポーネントで使用されるライフサイクルメソッドの一つで、コンポーネントが再レンダリングされるべきかどうかを判断します。
デフォルトでは、Reactはすべてのstateやpropsの変更で再レンダリングを実行しますが、このメソッドをオーバーライドすることで、再レンダリングの条件をカスタマイズできます。

使用例


以下の例では、stateやpropsが特定の条件を満たす場合のみ再レンダリングを実行するように設定しています。

class MyComponent extends React.Component {
  shouldComponentUpdate(nextProps, nextState) {
    // 再レンダリングする条件を設定
    if (this.props.value !== nextProps.value) {
      return true; // 再レンダリングを許可
    }
    return false; // 再レンダリングを防止
  }

  render() {
    return <div>{this.props.value}</div>;
  }
}

shouldComponentUpdateの注意点

  • パフォーマンスのメリット
    再レンダリングを必要最低限に抑えることで、複雑なコンポーネントツリーにおいてパフォーマンスの向上が期待できます。
  • コストとバランス
    高頻度で変更されるコンポーネントでは、このメソッドの計算コストがかえってパフォーマンスを悪化させる場合があります。そのため、適用箇所を慎重に選ぶことが重要です。

React.memoとの比較


React 16.6以降では、関数コンポーネントにおいて似た役割を果たすReact.memoが利用可能です。これを使うと、propsが変更された場合のみ再レンダリングを行うことができます。以下はその例です。

const MyComponent = React.memo(function MyComponent(props) {
  return <div>{props.value}</div>;
});

shouldComponentUpdateはクラスコンポーネントに特化したメソッドであり、関数コンポーネントではReact.memoやHooksを活用するのがモダンなアプローチです。プロジェクトの要件に合わせて適切な方法を選択することが重要です。

componentDidMountでの初期データ取得


componentDidMountは、コンポーネントが初めてDOMに追加された直後に実行されるライフサイクルメソッドです。このメソッドは、外部データの取得や初期設定が必要な処理を実行するための最適な場所として利用されます。

componentDidMountの役割

  • 初期データの取得
    APIからデータを取得し、stateを初期化します。これにより、コンポーネントのレンダリングが外部リソースと同期します。
  • サードパーティライブラリの初期化
    チャートや地図などのライブラリの初期設定を行います。
  • イベントリスナーの登録
    ウィンドウサイズの変更やスクロールイベントなど、リスナーを設定します。

使用例


以下の例では、APIからデータを取得してコンポーネントに表示しています。

class MyComponent extends React.Component {
  state = {
    data: null,
  };

  componentDidMount() {
    // APIからデータを取得
    fetch("https://api.example.com/data")
      .then((response) => response.json())
      .then((data) => this.setState({ data }));
  }

  render() {
    const { data } = this.state;
    if (!data) {
      return <div>Loading...</div>;
    }
    return <div>Data: {data.name}</div>;
  }
}

ベストプラクティス

  • ローディング状態の表示
    データ取得中はローディング画面を表示してユーザー体験を向上させます。
  • エラーハンドリング
    データ取得に失敗した場合の処理を追加します。
componentDidMount() {
  fetch("https://api.example.com/data")
    .then((response) => response.json())
    .then((data) => this.setState({ data }))
    .catch((error) => console.error("Error fetching data:", error));
}

React Hooksを使用する場合


関数コンポーネントでは、useEffectフックがcomponentDidMountの代替として使用されます。

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

function MyComponent() {
  const [data, setData] = useState(null);

  useEffect(() => {
    fetch("https://api.example.com/data")
      .then((response) => response.json())
      .then((data) => setData(data));
  }, []); // 空の依存配列でcomponentDidMountと同じ動作

  if (!data) {
    return <div>Loading...</div>;
  }
  return <div>Data: {data.name}</div>;
}

まとめ


componentDidMountは、初期データ取得やリソースの初期化に不可欠なメソッドです。クラスコンポーネントではこのメソッドを活用し、関数コンポーネントではuseEffectを使用することで、同様の結果が得られます。これにより、ユーザーにスムーズな体験を提供しつつ、効率的なリソース管理を実現できます。

componentWillUnmountでのリソース解放


componentWillUnmountは、ReactコンポーネントがDOMから削除される直前に実行されるライフサイクルメソッドです。このメソッドは、リソースのクリーンアップやイベントリスナーの解除など、メモリリークを防ぐために使用されます。

componentWillUnmountの役割

  • リソースの解放
    タイマー、WebSocket接続、外部ライブラリのリソースなどを解放します。
  • イベントリスナーの解除
    ウィンドウサイズ変更やスクロールなどのイベントリスナーを解除します。
  • メモリリークの防止
    不要な参照やリソースを削除することで、メモリリークを防ぎます。

使用例


以下の例では、コンポーネントで設定したタイマーをクリーンアップしています。

class TimerComponent extends React.Component {
  componentDidMount() {
    this.timerID = setInterval(() => console.log("Tick"), 1000);
  }

  componentWillUnmount() {
    clearInterval(this.timerID); // タイマーを停止
  }

  render() {
    return <div>Timer is running...</div>;
  }
}

イベントリスナーの解除


イベントリスナーを登録した場合は、componentWillUnmountで必ず解除を行う必要があります。

class ScrollComponent extends React.Component {
  componentDidMount() {
    window.addEventListener("scroll", this.handleScroll);
  }

  componentWillUnmount() {
    window.removeEventListener("scroll", this.handleScroll); // イベントリスナーを解除
  }

  handleScroll = () => {
    console.log("Scrolling...");
  };

  render() {
    return <div>Scroll to see the effect</div>;
  }
}

React Hooksを使用する場合


関数コンポーネントでは、useEffectフックのクリーンアップ関数を利用して同様の処理を行います。

import React, { useEffect } from "react";

function TimerComponent() {
  useEffect(() => {
    const timerID = setInterval(() => console.log("Tick"), 1000);

    // クリーンアップ関数
    return () => {
      clearInterval(timerID); // タイマーを停止
    };
  }, []); // 空の依存配列でcomponentDidMountとcomponentWillUnmountの動作を模倣

  return <div>Timer is running...</div>;
}

ベストプラクティス

  1. クリーンアップの徹底
    すべてのリソースを確実に解放することで、メモリリークやパフォーマンス低下を防止します。
  2. 登録と解除の一貫性
    コンポーネント内で登録したすべてのリソースやイベントリスナーは、必ず解除を行います。

まとめ


componentWillUnmountは、リソース管理を最適化するための重要なメソッドです。クラスコンポーネントではこのメソッドを活用し、関数コンポーネントではuseEffectのクリーンアップ関数を用いることで、効率的なリソース管理を実現できます。これにより、アプリケーションの安定性とパフォーマンスが向上します。

React 18の変更点とライフサイクルへの影響


React 18では、新しい機能とパフォーマンス最適化を目的とした変更が導入され、ライフサイクルメソッドにもいくつかの影響が及びました。これらの変更を理解することは、最新のReactバージョンに対応するために重要です。

React 18の主要な変更点

  • コンカレントモード（Concurrent Mode）の導入
    React 18では、コンポーネントのレンダリングを中断・再開する新しいレンダリングモデルが導入されました。これにより、ユーザーインターフェイスの応答性が向上します。
  • useTransitionやstartTransitionの追加
    時間のかかる状態更新を遅延させることで、スムーズなUI更新を実現します。
  • 自動バッチ処理の改善
    状態更新が自動的にグループ化され、レンダリング回数が削減されます。

ライフサイクルメソッドへの影響


React 18の変更点により、従来のライフサイクルメソッドに次のような影響が生じています。

1. componentWillMount, componentWillUpdate, componentWillReceivePropsの非推奨


これらのメソッドはReact 16.3以降で非推奨となり、React 18でも引き続き使用が推奨されていません。代わりに、以下のメソッドを使用します。

  • getDerivedStateFromProps
  • componentDidUpdate

2. componentDidMountとコンカレントモード


componentDidMountは引き続き使用可能ですが、コンカレントモードではレンダリングが複数回行われる可能性があるため、慎重に設計する必要があります。たとえば、外部リソースのリクエストが二重に行われないようにする工夫が必要です。

3. componentWillUnmountとリソース管理


コンカレントモードでは、コンポーネントが途中でアンマウントされる可能性があります。これにより、componentWillUnmountの使用がより重要になります。特に、未使用のリソースやイベントリスナーを確実に解放する設計が必要です。

React 18での推奨アプローチ


最新のReact機能を活用することで、ライフサイクルメソッドの課題を克服できます。

関数コンポーネントとHooksの活用


クラスコンポーネントから関数コンポーネントに移行することで、React 18の変更により柔軟に対応できます。以下は、主なHooksの代替方法です。

  • useEffect: componentDidMount, componentDidUpdate, componentWillUnmountを統合した代替フック。
  • useMemo, useCallback: 計算コストの高い処理やコールバック関数のメモ化。

startTransitionの使用例


状態更新の優先度を調整することで、パフォーマンスを向上させます。

import { useState, startTransition } from "react";

function MyComponent() {
  const [value, setValue] = useState("");

  const handleChange = (event) => {
    const newValue = event.target.value;
    startTransition(() => {
      setValue(newValue); // 優先度の低い状態更新
    });
  };

  return <input onChange={handleChange} value={value} />;
}

ベストプラクティス

  1. 最新のReact機能を活用
    関数コンポーネントとHooksを使い、クラスコンポーネントの課題を回避します。
  2. 非推奨メソッドを避ける
    React 18以降で非推奨のライフサイクルメソッドを使用しない設計を心がけます。
  3. テストと検証の徹底
    コンカレントモードに対応したアプリケーションのテストを十分に行います。

まとめ


React 18の新機能と変更点を理解し、ライフサイクルメソッドを適切に活用することで、より効率的で柔軟なアプリケーション設計が可能になります。最新バージョンに対応した設計を採用し、ユーザー体験の向上を目指しましょう。

ライフサイクルメソッドを使った実践的な最適化例


Reactのライフサイクルメソッドを適切に活用することで、パフォーマンスの向上とリソースの効率的な利用を実現できます。本節では、ライフサイクルメソッドを利用した具体的な最適化例を紹介します。

例1: APIリクエストの最適化


componentDidMountでデータを取得し、状態を初期化します。同時に、shouldComponentUpdateを利用して、必要のない再レンダリングを防ぎます。

class OptimizedComponent extends React.Component {
  state = {
    data: null,
    loading: true,
  };

  componentDidMount() {
    fetch("https://api.example.com/data")
      .then((response) => response.json())
      .then((data) => this.setState({ data, loading: false }));
  }

  shouldComponentUpdate(nextProps, nextState) {
    // 状態が変化した場合のみ再レンダリング
    return this.state.data !== nextState.data || this.state.loading !== nextState.loading;
  }

  render() {
    if (this.state.loading) {
      return <div>Loading...</div>;
    }
    return <div>Data: {this.state.data.name}</div>;
  }
}

例2: タイマー管理の効率化


componentDidMountでタイマーを設定し、componentWillUnmountでタイマーを解除することで、不要なリソース消費を防ぎます。

class TimerComponent extends React.Component {
  state = { count: 0 };

  componentDidMount() {
    this.timerID = setInterval(() => {
      this.setState((prevState) => ({ count: prevState.count + 1 }));
    }, 1000);
  }

  componentWillUnmount() {
    clearInterval(this.timerID); // タイマーのクリーンアップ
  }

  render() {
    return <div>Count: {this.state.count}</div>;
  }
}

例3: 外部ライブラリの管理


componentDidMountで外部ライブラリを初期化し、componentWillUnmountでリソースを解放します。

import Chart from "chart.js/auto";

class ChartComponent extends React.Component {
  componentDidMount() {
    this.chart = new Chart(this.canvasRef, {
      type: "bar",
      data: {
        labels: ["Red", "Blue", "Yellow"],
        datasets: [
          {
            label: "Votes",
            data: [12, 19, 3],
          },
        ],
      },
    });
  }

  componentWillUnmount() {
    this.chart.destroy(); // チャートインスタンスの解放
  }

  render() {
    return <canvas ref={(ref) => (this.canvasRef = ref)} />;
  }
}

例4: エラーバウンドリによるエラーハンドリング


componentDidCatchを活用して、予期しないエラーをキャッチし、UIを保護します。

class ErrorBoundary extends React.Component {
  state = { hasError: false };

  componentDidCatch(error, info) {
    console.error("Error caught in boundary:", error, info);
    this.setState({ hasError: true });
  }

  render() {
    if (this.state.hasError) {
      return <div>Something went wrong.</div>;
    }
    return this.props.children;
  }
}

// 使用例
<ErrorBoundary>
  <ChildComponent />
</ErrorBoundary>

実践的なヒント

  1. 再レンダリングの最適化
    shouldComponentUpdateやReact.memoを活用して、パフォーマンスを向上させます。
  2. クリーンアップの徹底
    リソースリークを防ぐために、必ず不要なリソースを解放します。
  3. エラーハンドリングの実装
    componentDidCatchを利用して、エラー発生時のユーザー体験を向上させます。

まとめ


ライフサイクルメソッドを活用したこれらの実践例を通じて、Reactアプリケーションの効率性と安定性を向上させることができます。これらのテクニックをプロジェクトに取り入れることで、より洗練されたReact開発を行えるようになります。

エラー処理とエラーバウンドリの活用


Reactアプリケーションでは、予期しないエラーが発生する可能性があります。これに対応するために、エラーバウンドリを活用することで、エラーがUI全体に影響を及ぼさないように制御できます。本節では、エラー処理の基本とエラーバウンドリの実装方法を解説します。

エラーバウンドリとは


エラーバウンドリとは、Reactで発生したエラーをキャッチし、影響範囲を特定のコンポーネントに限定する仕組みです。エラーバウンドリは、クラスコンポーネントで次の2つのライフサイクルメソッドを使用して実装されます。

  • componentDidCatch(error, info): エラーをキャッチして処理する。
  • getDerivedStateFromError(error): エラー発生時にstateを更新する。

エラーバウンドリは、レンダリング中、ライフサイクルメソッド中、または子コンポーネント内で発生したエラーをキャッチします。

エラーバウンドリの実装


以下は、エラーバウンドリを実装した例です。

class ErrorBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = { hasError: false };
  }

  static getDerivedStateFromError(error) {
    // エラー発生時にstateを更新
    return { hasError: true };
  }

  componentDidCatch(error, info) {
    // エラーログを送信するなどの処理を実行
    console.error("Error caught by ErrorBoundary:", error, info);
  }

  render() {
    if (this.state.hasError) {
      return <h1>Something went wrong.</h1>; // エラーメッセージを表示
    }
    return this.props.children; // 子コンポーネントを描画
  }
}

// 使用例
<ErrorBoundary>
  <SomeComponent />
</ErrorBoundary>

エラーバウンドリの利用シーン

  1. 複雑なコンポーネントの保護
    特定のコンポーネントやセクションでエラーが発生しても、アプリ全体のクラッシュを防ぎます。
  2. ログとモニタリング
    エラー発生時にログを外部サービスに送信することで、問題を早期に発見できます。

エラーバウンドリの限界

  • 非同期エラーには対応しない
    Promise内部で発生したエラーはキャッチされません。非同期エラーにはtry-catchやグローバルエラーハンドリングを活用する必要があります。
// 非同期エラーのハンドリング例
async function fetchData() {
  try {
    const response = await fetch("https://api.example.com/data");
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error("Async error caught:", error);
  }
}

React Hooksを使用する場合のエラー処理


関数コンポーネントでは、React Hooksとカスタムフックを組み合わせることでエラー処理を実現できます。

import React, { useState } from "react";

function ErrorWrapper({ children }) {
  const [hasError, setHasError] = useState(false);

  try {
    return children;
  } catch (error) {
    setHasError(true);
    console.error("Error caught in wrapper:", error);
    return <h1>Something went wrong.</h1>;
  }
}

// 使用例
<ErrorWrapper>
  <SomeComponent />
</ErrorWrapper>

ベストプラクティス

  1. エラーハンドリングを統一する
    グローバルなエラー監視とローカルなエラーバウンドリの組み合わせで、エラー対応の信頼性を高めます。
  2. ユーザーへの適切なフィードバック
    エラー発生時には、適切なエラーメッセージを表示してユーザー体験を損ねないようにします。
  3. ログの収集と解析
    エラーを詳細に記録し、問題の根本原因を特定します。

まとめ


エラーバウンドリを活用することで、Reactアプリケーションの堅牢性が向上し、エラーによる影響を最小限に抑えることができます。エラーハンドリングはUIの安定性と信頼性を高める重要な要素です。設計段階から適切なエラーハンドリングを組み込み、ユーザー体験を向上させましょう。

まとめ


本記事では、Reactのライフサイクルメソッドを活用してパフォーマンスを向上させる方法について解説しました。ライフサイクルの各フェーズとそれに対応するメソッドの役割、再レンダリングの制御やリソース管理、エラーハンドリングなど、具体的な最適化手法を紹介しました。さらに、React 18の新機能や変更点に触れ、モダンなReactアプリケーションに適した設計についても説明しました。

ライフサイクルメソッドを正しく理解し、適切に活用することで、Reactアプリケーションの効率性、安定性、ユーザー体験を大幅に向上させることができます。これを参考に、より高品質なReactプロジェクトを実現してください。

React
パフォーマンス最適化 React ライフサイクルメソッド

コメント

コメントする

目次
  1. Reactのライフサイクルメソッドとは
    1. ライフサイクルメソッドの役割
    2. ライフサイクルメソッドの基本構造
  2. ライフサイクルのフェーズと主なメソッド
    1. 1. マウント（Mount）
    2. 2. 更新（Update）
    3. 3. アンマウント（Unmount）
    4. React 18以降の注意点
  3. shouldComponentUpdateを使った再レンダリングの制御
    1. shouldComponentUpdateの役割
    2. 使用例
    3. shouldComponentUpdateの注意点
    4. React.memoとの比較
  4. componentDidMountでの初期データ取得
    1. componentDidMountの役割
    2. 使用例
    3. ベストプラクティス
    4. React Hooksを使用する場合
    5. まとめ
  5. componentWillUnmountでのリソース解放
    1. componentWillUnmountの役割
    2. 使用例
    3. イベントリスナーの解除
    4. React Hooksを使用する場合
    5. ベストプラクティス
    6. まとめ
  6. React 18の変更点とライフサイクルへの影響
    1. React 18の主要な変更点
    2. ライフサイクルメソッドへの影響
    3. React 18での推奨アプローチ
    4. ベストプラクティス
    5. まとめ
  7. ライフサイクルメソッドを使った実践的な最適化例
    1. 例1: APIリクエストの最適化
    2. 例2: タイマー管理の効率化
    3. 例3: 外部ライブラリの管理
    4. 例4: エラーバウンドリによるエラーハンドリング
    5. 実践的なヒント
    6. まとめ
  8. エラー処理とエラーバウンドリの活用
    1. エラーバウンドリとは
    2. エラーバウンドリの実装
    3. エラーバウンドリの利用シーン
    4. エラーバウンドリの限界
    5. React Hooksを使用する場合のエラー処理
    6. ベストプラクティス
    7. まとめ
  9. まとめ