MENU
  1. ホーム
  2. React
  3. React再レンダリングを防ぐ！キー（key）の正しい使い方

React再レンダリングを防ぐ！キー（key）の正しい使い方

React

Reactでの効率的なUIレンダリングには、「キー（key）」の正しい使い方が不可欠です。Reactは仮想DOMを用いて高速なUI更新を実現しますが、不適切なキーの使用は、予期しない再レンダリングやパフォーマンス低下の原因となります。本記事では、Reactでキーがどのように機能し、どのように使うべきかを分かりやすく解説します。これにより、開発中に発生しがちな再レンダリングの問題を回避し、効率的なコーディングを実現できるようになります。

目次
  1. Reactにおけるキー（key）の役割とは
    1. キーの基本的な仕組み
    2. キーがない場合の問題
    3. Reactが期待する「一意性」
  2. 再レンダリングの仕組みと問題点
    1. 再レンダリングの発生タイミング
    2. 仮想DOMによる差分検出
    3. 再レンダリングがもたらす問題
  3. 適切なキーの選び方
    1. キーに設定すべき値
    2. 避けるべきキーの例
    3. キー選びのポイント
    4. 良いキーの例
    5. 避けるべきキーの例
  4. インデックスをキーにする際の注意点
    1. インデックスをキーにすると起こる問題
    2. インデックスをキーにするべきケース
    3. インデックスキーを避ける解決策
    4. まとめ
  5. パフォーマンス最適化の実例
    1. 1. キーを使ったリスト要素の効率的な更新
    2. 2. 大量データの効率的なレンダリング
    3. 3. コンポーネントのメモ化との組み合わせ
    4. 4. 再レンダリングのトラブルシューティング
    5. まとめ
  6. キーの使い方におけるベストプラクティス
    1. 1. ユニークな値をキーに設定する
    2. 2. 配列のインデックスは避ける
    3. 3. コンポーネントの分割と再利用性の向上
    4. 4. ユニークな値がない場合の対応
    5. 5. キーをデバッグの手がかりとして活用
    6. 6. 動的データに対するキー管理の考慮
    7. まとめ
  7. 再レンダリング問題を防ぐための演習問題
    1. 演習1: キーを適切に設定する
    2. 演習2: ユニークなキーを用いたリスト表示
    3. 演習3: 再レンダリングの問題を特定する
    4. 演習4: 大量データでの仮想スクロール対応
    5. まとめ
  8. よくある誤解とその解消法
    1. 誤解1: キーをユニークにする必要がない
    2. 誤解2: インデックスをキーに使っても問題ない
    3. 誤解3: 親コンポーネントでのキー設定は不要
    4. 誤解4: キーはデバッグには関係ない
    5. まとめ
  9. まとめ

Reactにおけるキー（key）の役割とは


Reactで「キー（key）」は、仮想DOM（Virtual DOM）を効率的に比較・更新するための重要な識別子です。仮想DOMは、Reactがレンダリング結果を追跡し、最小限の変更で実際のDOMを更新するための仕組みです。この過程で、各要素に一意のキーが設定されていると、Reactは変更点を迅速に特定し、無駄な更新を防ぐことができます。

キーの基本的な仕組み


キーは、配列内の要素やリスト要素の間で、Reactが変更を追跡するために利用されます。リスト内の要素が追加、削除、または並べ替えられる際に、Reactはキーを基準に変更箇所を特定します。

キーがない場合の問題


キーが設定されていない、または重複している場合、Reactは要素全体を再作成する可能性があります。これにより、以下のような問題が発生します：

  • パフォーマンス低下：変更が不要な箇所も更新されるため、処理が重くなる。
  • 状態のリセット：フォームの入力状態など、ユーザーが保持している状態が失われることがある。

Reactが期待する「一意性」


キーはリスト内で「一意」である必要がありますが、必ずしも全体で一意である必要はありません。同じコンポーネント内の各リストで一意のキーが設定されていれば、Reactは正しく動作します。

適切なキーを使用することで、Reactは変更箇所を効率的に認識し、最小限の更新で最高のパフォーマンスを発揮します。

再レンダリングの仕組みと問題点

Reactでは、仮想DOMを利用してUIを効率的に更新します。しかし、再レンダリングが不要な箇所でも発生すると、パフォーマンスの低下や予期しない挙動につながることがあります。このセクションでは、再レンダリングの基本的な仕組みと、それが引き起こす問題について解説します。

再レンダリングの発生タイミング


Reactコンポーネントが再レンダリングされる主な条件は以下の通りです：

  • 親コンポーネントが再レンダリングされたとき：子コンポーネントも再レンダリングされることが多い。
  • 状態（state）が更新されたとき：そのコンポーネントと子孫コンポーネントが再描画される。
  • プロパティ（props）が変更されたとき：親コンポーネントから新しいプロパティが渡された場合。

仮想DOMによる差分検出


仮想DOMでは、新しい仮想DOMツリーと古いツリーを比較し、実際のDOMを最小限に更新します。このプロセスを「差分検出（diffing）」と呼びます。差分検出を効率的に行うためには、各要素に一意のキーが必要です。

再レンダリングがもたらす問題


不適切なキーや過剰な再レンダリングは以下の問題を引き起こします：

  1. パフォーマンスの低下
  • 変更が不要な部分でも再描画が行われ、処理が重くなる。特に、リストや大量のデータを扱う場合に顕著です。
  1. UIの予期しない変更
  • フォーム入力やアニメーションなど、ユーザーの操作がリセットされることがある。
  1. デバッグの困難
  • 再レンダリングの原因が分かりにくくなり、問題の特定に時間がかかる。

再レンダリングの仕組みを正しく理解し、適切に制御することは、Reactアプリケーションのパフォーマンスと信頼性を向上させる鍵となります。次に、キーの選び方について詳しく見ていきます。

適切なキーの選び方

キー（key）はReactの仮想DOMが要素を正しく識別し、効率的に更新を行うための重要な要素です。しかし、キーが適切でないと、再レンダリングの際に予期しない問題が発生することがあります。ここでは、適切なキーを選ぶための方法と避けるべき例を解説します。

キーに設定すべき値


キーは、リスト内で各要素を一意に識別できる値である必要があります。以下は、キーとして適切な値の例です：

  • ユニークなID：データベースやAPIから取得した一意の識別子。
  • 特定のプロパティ：オブジェクトが持つ一意なプロパティ（例: user.email）。
  • 生成したUUID：一意性を保証するためにUUIDを生成して使用する。

避けるべきキーの例


一見便利に思える値でも、キーとして使用すると問題を引き起こす場合があります：

  • 配列のインデックス
    配列のインデックスをキーに設定すると、要素の並び順や数が変更された際に誤った再レンダリングが発生する可能性があります。
  • 例: 要素が追加されると、すべてのキーが変化し、不要なDOM操作が行われる。
  • 非ユニークな値
    重複する値をキーとして使用すると、Reactが正確な差分を検出できなくなります。

キー選びのポイント

  • 要素が一意に識別可能か確認する：リスト内で同じキーを使用しないよう注意。
  • データソースを活用する：外部データがユニークな識別子を持っている場合は、それを活用する。
  • 意味を持たせる：キーはデバッグ時にも役立つため、できるだけ直感的な値を設定する。

良いキーの例


以下のコードは、ユニークなキーを使用した正しい実装例です：

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 3, name: 'Charlie' }
];

return (
  <ul>
    {users.map(user => (
      <li key={user.id}>{user.name}</li>
    ))}
  </ul>
);

避けるべきキーの例


インデックスをキーに使った場合の問題点を示した例です：

return (
  <ul>
    {users.map((user, index) => (
      <li key={index}>{user.name}</li>
    ))}
  </ul>
);

この場合、ユーザーの追加や削除が発生すると、誤った要素の再レンダリングが行われることがあります。

適切なキーを選ぶことで、Reactアプリケーションの効率と信頼性を向上させることができます。次に、インデックスをキーに使用する場合の具体的な注意点について詳しく見ていきます。

インデックスをキーにする際の注意点

配列のインデックスをキーに設定するのは簡単で便利に思えますが、これにはいくつかのリスクが伴います。インデックスをキーに使用することで発生する問題と、その解決策について詳しく説明します。

インデックスをキーにすると起こる問題


配列のインデックスをキーとして使用すると、リストの変更時にReactが誤った要素を更新することがあります。以下のような問題が代表的です：

1. 要素の並び替えや削除による誤動作

  • リストの要素が並び替えられたり、新しい要素が追加されたりすると、キーがずれてしまい、Reactが正しく差分を検出できなくなります。
  • 結果として、要素の状態がリセットされる、または意図しない箇所が再レンダリングされることがあります。

2. ユーザー入力やUI状態のリセット

  • フォーム入力やアニメーションなどの要素がインデックスキーによって再生成されることで、ユーザーが入力した内容やUIの状態がリセットされてしまう可能性があります。
  • 例えば、チェックボックスの状態が勝手にリセットされるなどの問題が発生します。

3. デバッグの困難

  • インデックスキーはデータの意味を反映していないため、エラーが発生した際にデバッグが困難になります。特にリストが動的に変化する場合、問題箇所を特定するのに時間がかかることがあります。

インデックスをキーにするべきケース


インデックスキーはすべての場面で不適切というわけではありません。以下の場合には使用しても問題ないことがあります：

  • リストが固定で、並び替えや削除が発生しない場合。
  • 単純なリスト表示で、キーに利用できるユニークな値が存在しない場合。

インデックスキーを避ける解決策


インデックスキーによる問題を防ぐためには、以下の方法を検討してください：

1. ユニークなIDを使用


データベースやAPIから取得したユニークな識別子をキーとして使用することで、Reactが正確に差分を検出できるようにします。

const items = [
  { id: 'a1', value: 'Item 1' },
  { id: 'b2', value: 'Item 2' },
  { id: 'c3', value: 'Item 3' }
];

return (
  <ul>
    {items.map(item => (
      <li key={item.id}>{item.value}</li>
    ))}
  </ul>
);

2. UUIDを生成


一意な識別子が用意できない場合は、ランダムなUUIDを生成してキーとして利用することも検討できます。ただし、リストの再描画が頻繁に行われる場合には不向きです。

まとめ


インデックスをキーに使用すると、再レンダリングや状態管理に問題が生じる場合があります。できるだけユニークな識別子を使用するか、リストの性質に応じた適切なキーを選ぶことで、Reactアプリケーションの安定性とパフォーマンスを向上させましょう。次は、キーを活用した具体的なパフォーマンス最適化の実例を解説します。

パフォーマンス最適化の実例

Reactでキー（key）を活用したパフォーマンス最適化は、再レンダリングの負担を軽減し、スムーズなUI体験を提供するために非常に重要です。このセクションでは、キーを活用してパフォーマンスを向上させる具体的なコード例を示します。

1. キーを使ったリスト要素の効率的な更新


リスト表示を更新する際、Reactが無駄な再レンダリングを避けるために正しいキーが必要です。以下は、適切なキーを使用した例です：

const tasks = [
  { id: 1, name: "Task 1", completed: false },
  { id: 2, name: "Task 2", completed: true },
  { id: 3, name: "Task 3", completed: false }
];

return (
  <ul>
    {tasks.map(task => (
      <li key={task.id}>
        <input
          type="checkbox"
          checked={task.completed}
          onChange={() => toggleTask(task.id)}
        />
        {task.name}
      </li>
    ))}
  </ul>
);

この例では、task.idをキーとして使用することで、Reactが正確にどの項目が更新されたかを判断できます。

2. 大量データの効率的なレンダリング


大量のリストを扱う場合、キーを正しく設定することはパフォーマンス最適化の鍵です。以下に、仮想スクロール（Virtual Scrolling）を活用した例を示します：

import { FixedSizeList as List } from "react-window";

const rows = Array(10000).fill().map((_, index) => `Row ${index}`);

function Row({ index, style }) {
  return (
    <div style={style} key={index}>
      {rows[index]}
    </div>
  );
}

return (
  <List
    height={500}
    itemCount={rows.length}
    itemSize={35}
    width={300}
  >
    {Row}
  </List>
);

このコードでは、react-windowライブラリを使用して仮想スクロールを実現し、キーをインデックスではなくリスト内のデータに基づいて動的に設定しています。

3. コンポーネントのメモ化との組み合わせ


キーを正しく使用することで、React.memoやuseMemoによるコンポーネントのメモ化がさらに効果を発揮します。以下はその実例です：

const TaskItem = React.memo(({ task, onToggle }) => {
  return (
    <li key={task.id}>
      <input
        type="checkbox"
        checked={task.completed}
        onChange={() => onToggle(task.id)}
      />
      {task.name}
    </li>
  );
});

const TaskList = ({ tasks, toggleTask }) => {
  return (
    <ul>
      {tasks.map(task => (
        <TaskItem key={task.id} task={task} onToggle={toggleTask} />
      ))}
    </ul>
  );
};

このように、TaskItemコンポーネントをReact.memoでラップすることで、キーが同一の項目に対する無駄な再レンダリングを防ぐことができます。

4. 再レンダリングのトラブルシューティング


キーが正しく設定されていない場合、再レンダリングの原因を特定するためにReact開発者ツール（React Developer Tools）を活用しましょう。これにより、どのコンポーネントが余計に再レンダリングされているかを視覚的に確認できます。

まとめ


キーを適切に設定することで、Reactアプリケーションの効率が向上し、大規模なデータや複雑なUIにもスムーズに対応可能になります。次は、キーの使い方におけるベストプラクティスについて掘り下げていきます。

キーの使い方におけるベストプラクティス

Reactでの「キー（key）」の正しい使い方は、アプリケーションのパフォーマンスや信頼性に大きく影響します。ここでは、キーを使用する際のベストプラクティスをまとめ、効率的な開発をサポートする方法を紹介します。

1. ユニークな値をキーに設定する


キーには、リスト内の各要素を一意に識別できる値を設定する必要があります。以下の点を守ることで、再レンダリングの効率を向上させることができます：

  • データベースやAPIから取得したユニークなIDを使用する。
  • 動的なリストでも一意性が保たれるようにする。

例：正しいキーの設定

const users = [
  { id: "u1", name: "Alice" },
  { id: "u2", name: "Bob" },
  { id: "u3", name: "Charlie" }
];

return (
  <ul>
    {users.map(user => (
      <li key={user.id}>{user.name}</li>
    ))}
  </ul>
);

2. 配列のインデックスは避ける


インデックスをキーに使用すると、リストの変更時に意図しない挙動を引き起こす可能性があります。特にリストの並び替えや要素の追加・削除が頻繁に発生する場合には、インデックスキーは避けるべきです。

避けるべき例

return (
  <ul>
    {users.map((user, index) => (
      <li key={index}>{user.name}</li>
    ))}
  </ul>
);

3. コンポーネントの分割と再利用性の向上


リスト要素ごとに独立したコンポーネントを作成し、各コンポーネントに適切なキーを設定することで、再利用性が向上します。また、各コンポーネントの責務が明確になり、コードの可読性も高まります。

例：リストアイテムのコンポーネント化

const UserItem = ({ user }) => {
  return <li key={user.id}>{user.name}</li>;
};

const UserList = ({ users }) => {
  return (
    <ul>
      {users.map(user => (
        <UserItem key={user.id} user={user} />
      ))}
    </ul>
  );
};

4. ユニークな値がない場合の対応


リスト要素に一意の識別子が存在しない場合は、UUIDなどのライブラリを使用してランダムなユニークIDを生成します。ただし、これは一時的な対応策として使用し、可能であればデータモデルを見直して一意の値を持つプロパティを追加することを推奨します。

5. キーをデバッグの手がかりとして活用


キーは開発時のデバッグにも役立ちます。リスト内でユニークな値を設定しておくと、どの要素に問題が発生しているかを迅速に特定できます。

6. 動的データに対するキー管理の考慮


動的に生成されるデータを扱う場合、キーの一貫性を保つことが重要です。データが変更されてもキーが再利用されないように設計しましょう。

まとめ


Reactでのキーの使い方は、パフォーマンスと正確な動作のための重要な要素です。ユニークな値を設定し、インデックスキーを避けるなどのベストプラクティスを守ることで、効率的かつ安定したアプリケーションを構築できます。次に、再レンダリング問題を防ぐための実践的な演習問題を紹介します。

再レンダリング問題を防ぐための演習問題

Reactのキー（key）の正しい使い方を実践するために、以下の演習問題を通じて学習内容を確認しましょう。これらの問題では、再レンダリングの課題を解決しながら、キーを使ったパフォーマンス最適化を実感できます。

演習1: キーを適切に設定する


以下のコードでは、配列のインデックスをキーに使用しています。適切なキーを設定して、不要な再レンダリングを防ぎましょう。

初期コード

const items = ["Apple", "Banana", "Cherry"];

function ItemList() {
  return (
    <ul>
      {items.map((item, index) => (
        <li key={index}>{item}</li>
      ))}
    </ul>
  );
}

修正後のコード（ヒント）

  • キーにはアイテムの内容そのもの（item）を使用するか、一意のIDを持つオブジェクトに変更してください。

演習2: ユニークなキーを用いたリスト表示


次のコードでは、リストのアイテムにキーが設定されていません。適切なキーを追加し、並び替えや削除時に問題が発生しないようにしてください。

初期コード

const users = [
  { name: "Alice", age: 25 },
  { name: "Bob", age: 30 },
  { name: "Charlie", age: 35 }
];

function UserList() {
  return (
    <ul>
      {users.map(user => (
        <li>{user.name} ({user.age})</li>
      ))}
    </ul>
  );
}

修正後のコード（ヒント）

  • users配列に一意の識別子（ID）を追加し、それをキーとして使用してください。

演習3: 再レンダリングの問題を特定する


以下のコードを実行し、React Developer Toolsを使用して、どの部分が不要に再レンダリングされているかを確認してください。その後、キーの設定を修正して問題を解決してください。

初期コード

const tasks = [
  { id: 1, title: "Task 1", completed: false },
  { id: 2, title: "Task 2", completed: true },
  { id: 3, title: "Task 3", completed: false }
];

function TaskList() {
  return (
    <ul>
      {tasks.map((task, index) => (
        <li key={index}>
          <input type="checkbox" checked={task.completed} />
          {task.title}
        </li>
      ))}
    </ul>
  );
}

修正後のポイント

  • インデックスではなくtask.idをキーとして使用するよう修正してください。

演習4: 大量データでの仮想スクロール対応


大規模なリストをレンダリングする際にパフォーマンスを向上させるために、react-windowなどの仮想スクロールライブラリを使用してキーを適切に設定しましょう。

初期コード（仮想スクロールなし）

const rows = Array.from({ length: 10000 }, (_, i) => `Row ${i + 1}`);

function RowList() {
  return (
    <ul>
      {rows.map((row, index) => (
        <li key={index}>{row}</li>
      ))}
    </ul>
  );
}

修正後のポイント

  • react-windowライブラリを使用して効率的にリストをレンダリングし、適切なキーを設定してください。

まとめ


これらの演習問題を通じて、Reactにおけるキーの重要性とその実用的な使い方を学びました。適切なキーの設定は、再レンダリングの問題を防ぎ、アプリケーションのパフォーマンスを最適化するための重要なスキルです。次は、キーに関するよくある誤解とその解消法を解説します。

よくある誤解とその解消法

Reactのキー（key）の使い方については、多くの開発者が誤解しがちなポイントがあります。これらの誤解を解消することで、再レンダリングの問題を防ぎ、効率的な開発を進められます。このセクションでは、よくある誤解を取り上げ、それを防ぐための具体例を示します。

誤解1: キーをユニークにする必要がない


誤解内容
「キーは必ずしもユニークである必要はない。配列内で適当に設定しても動く。」
解消法
Reactはキーを用いて要素を識別するため、リスト内で一意性を持たないキーは、予期しない再レンダリングを引き起こします。一意の識別子（例: ID）を必ずキーに設定しましょう。

誤った例

const items = ["Apple", "Banana", "Cherry"];
return (
  <ul>
    {items.map(item => (
      <li key="fruit">{item}</li> // 同じキーが繰り返されている
    ))}
  </ul>
);

正しい例

return (
  <ul>
    {items.map((item, index) => (
      <li key={item}>{item}</li> // 各アイテムが一意のキーを持つ
    ))}
  </ul>
);

誤解2: インデックスをキーに使っても問題ない


誤解内容
「リストの順番が変わらないなら、インデックスをキーにしても大丈夫。」
解消法
リストの順序や内容が変わらない場合でも、Reactはデータ構造の整合性を保つためにキーを活用します。配列の要素が動的に変化する場合は、インデックスキーは不適切です。

誤った例

const items = ["Apple", "Banana", "Cherry"];
return (
  <ul>
    {items.map((item, index) => (
      <li key={index}>{item}</li> // インデックスをキーに使用
    ))}
  </ul>
);

正しい例

return (
  <ul>
    {items.map(item => (
      <li key={item}>{item}</li> // 各アイテムがユニークなキーを持つ
    ))}
  </ul>
);

誤解3: 親コンポーネントでのキー設定は不要


誤解内容
「キーはリスト要素にのみ必要で、親コンポーネントには関係ない。」
解消法
キーはリスト内の要素を正確に識別するために必要ですが、リストそのものがコンポーネント化される場合でも適切なキーを設定する必要があります。親レベルでの誤ったキー設定は、再レンダリングの問題を引き起こします。

誤った例

const UserList = ({ users }) => (
  <div>
    {users.map(user => (
      <UserItem user={user} /> // 親レベルでキーが設定されていない
    ))}
  </div>
);

正しい例

const UserList = ({ users }) => (
  <div>
    {users.map(user => (
      <UserItem key={user.id} user={user} /> // 親レベルで適切なキーを設定
    ))}
  </div>
);

誤解4: キーはデバッグには関係ない


誤解内容
「キーは内部処理用であり、デバッグには役立たない。」
解消法
キーはReactの開発ツールでデバッグの際にも利用されます。適切なキーを設定しておくと、問題発生時にどの要素が影響を受けているか特定しやすくなります。

例
リスト要素にキーが設定されていない場合、Reactはコンソールに警告を表示します。
「Each child in a list should have a unique “key” prop」と表示される場合は、キーの設定を見直してください。

まとめ


キーはReactアプリケーションの効率的な更新と正確な動作に直結します。これらの誤解を避けることで、Reactでの開発がスムーズになり、再レンダリングの問題を効果的に解消できます。次は、本記事の内容をまとめて振り返ります。

まとめ

本記事では、Reactにおけるキー（key）の役割とその適切な使い方について解説しました。キーは仮想DOMの効率的な差分検出に不可欠であり、不適切なキー設定は再レンダリングの問題やパフォーマンス低下を引き起こします。

適切なキーの選び方、インデックスキーのリスク、パフォーマンス最適化の実例、ベストプラクティス、さらに誤解を解消するための具体例を通じて、実用的な知識を提供しました。

Reactでのキー設定は、コードの信頼性を高め、ユーザー体験を向上させる重要なスキルです。正しい使い方をマスターして、効率的かつ安定したアプリケーション開発に役立ててください。

React
パフォーマンス React 再レンダリング

コメント

コメントする

目次
  1. Reactにおけるキー（key）の役割とは
    1. キーの基本的な仕組み
    2. キーがない場合の問題
    3. Reactが期待する「一意性」
  2. 再レンダリングの仕組みと問題点
    1. 再レンダリングの発生タイミング
    2. 仮想DOMによる差分検出
    3. 再レンダリングがもたらす問題
  3. 適切なキーの選び方
    1. キーに設定すべき値
    2. 避けるべきキーの例
    3. キー選びのポイント
    4. 良いキーの例
    5. 避けるべきキーの例
  4. インデックスをキーにする際の注意点
    1. インデックスをキーにすると起こる問題
    2. インデックスをキーにするべきケース
    3. インデックスキーを避ける解決策
    4. まとめ
  5. パフォーマンス最適化の実例
    1. 1. キーを使ったリスト要素の効率的な更新
    2. 2. 大量データの効率的なレンダリング
    3. 3. コンポーネントのメモ化との組み合わせ
    4. 4. 再レンダリングのトラブルシューティング
    5. まとめ
  6. キーの使い方におけるベストプラクティス
    1. 1. ユニークな値をキーに設定する
    2. 2. 配列のインデックスは避ける
    3. 3. コンポーネントの分割と再利用性の向上
    4. 4. ユニークな値がない場合の対応
    5. 5. キーをデバッグの手がかりとして活用
    6. 6. 動的データに対するキー管理の考慮
    7. まとめ
  7. 再レンダリング問題を防ぐための演習問題
    1. 演習1: キーを適切に設定する
    2. 演習2: ユニークなキーを用いたリスト表示
    3. 演習3: 再レンダリングの問題を特定する
    4. 演習4: 大量データでの仮想スクロール対応
    5. まとめ
  8. よくある誤解とその解消法
    1. 誤解1: キーをユニークにする必要がない
    2. 誤解2: インデックスをキーに使っても問題ない
    3. 誤解3: 親コンポーネントでのキー設定は不要
    4. 誤解4: キーはデバッグには関係ない
    5. まとめ
  9. まとめ