不必要な React コンポーネントの再レンダリングを防ぐ方法

効率的でパフォーマンスの高いアプリケーションを構築するには、React Native がコンポーネントをレンダリングする方法を理解することが不可欠です。コンポーネントの状態やプロパティが変更されると、React はそれらの変更を反映するためにユーザー インターフェイス (UI) を自動的に更新します。その結果、React はコンポーネントの render メソッドを再度呼び出して、更新された UI 表現を生成します。

この記事では、3 つの React フックと、React での不要なレンダリングを防ぐ方法について説明します

• メモを使用
• コールバックを使用
• useRef

これらのツールを使用すると、不必要な再レンダリングを回避し、パフォーマンスを向上させ、値を効率的に保存することでコードを最適化できます。

この記事が終わるまでに、これらの便利な React フックを使用して React アプリケーションを高速化し、応答性を高める方法をよりよく理解できるようになります。

ReactのuseMemoの使い方

React では、useMemo を使用して不必要な再レンダリングを防ぎ、パフォーマンスを最適化できます。

useMemo フックを使用して、React コンポーネントでの不必要な再レンダリングをどのように防ぐことができるかを見てみましょう。

関数の結果を記憶し、その依存関係を追跡することにより、useMemo は必要な場合にのみプロセスが再計算されるようにします。

次の例を考えてみましょう:

import { useMemo, useState } from 'react';

    function Page() {
      const [count, setCount] = useState(0);
      const [items] = useState(generateItems(300));

      const selectedItem = useMemo(() => items.find((item) => item.id === count), [
        count,
        items,
      ]);

      function generateItems(count) {
        const items = [];
        for (let i = 0; i < count; i++) {
          items.push({
            id: i,
            isSelected: i === count - 1,
          });
        }
        return items;
      }

      return (
        <div className="tutorial">
          <h1>Count: {count}</h1>
          <h1>Selected Item: {selectedItem?.id}</h1>
          <button onClick={() => setCount(count + 1)}>Increment</button>
        </div>
      );
    }

    export default Page;

上記のコードは、useMemo を使用して selectedItem の計算を最適化する Page という React コンポーネントです。

説明は次のとおりです:

• コンポーネントは、useState フックを使用して状態変数カウントを維持します。
• アイテムの状態は、generateItems 関数の結果を使用して useState フックを使用して初期化されます。
• selectedItem は、items.find 操作の結果を記憶する useMemo を使用して計算されます。カウントまたは項目が変更された場合にのみ再計算されます。
• generateItems 関数は、指定された数に基づいて項目の配列を生成します。
• コンポーネントは、現在の count 値、selectedItem ID、およびカウントを増やすボタンをレンダリングします。

useMemo を使用すると、items.find 操作の結果をメモ化することでパフォーマンスが最適化されます。これにより、依存関係 (数またはアイテム) が変更された場合にのみ selectedItem の計算が実行され、後続のレンダリングでの不必要な再計算が防止されます。

メモ化は、レンダリング プロセスに追加のオーバーヘッドをもたらすため、計算集約型の操作に選択的に使用する必要があります。

ReactのuseCallbackの使用

React の useCallback フックを使用すると、関数のメモ化が可能になり、各コンポーネントのレンダリング中に関数が再作成されるのを防ぎます。 useCallback を利用する。パーツは一度だけ作成され、その依存関係が変更されない限り、後続のレンダリングで再利用されます。

次の例を考えてみましょう:

import React, { useState, useCallback, memo } from 'react';

    const allColors = ['red', 'green', 'blue', 'yellow', 'orange'];

    const shuffle = (array) => {
      const shuffledArray = [...array];
      for (let i = shuffledArray.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [shuffledArray[i], shuffledArray[j]] = [shuffledArray[j], shuffledArray[i]];
      }
      return shuffledArray;
    };

    const Filter = memo(({ onChange }) => {
      console.log('Filter rendered!');

      return (
        <input
          type='text'
          placeholder='Filter colors...'
          onChange={(e) => onChange(e.target.value)}
        />
      );
    });

    function Page() {
      const [colors, setColors] = useState(allColors);
      console.log(colors[0])

      const handleFilter = useCallback((text) => {
        const filteredColors = allColors.filter((color) =>
          color.includes(text.toLowerCase())
        );
        setColors(filteredColors);
      }, [colors]);


      return (
        <div className='tutorial'>
        <div className='align-center mb-2 flex'>
          <button onClick={() => setColors(shuffle(allColors))}>
            Shuffle
          </button>
          <Filter onChange={handleFilter} />
        </div>
        <ul>
          {colors.map((color) => (
            <li key={color}>{color}</li>
          ))}
        </ul>
      </div>
      );
    }

    export default Page;

上記のコードは、React コンポーネントでの単純なカラー フィルタリングとシャッフル機能を示しています。段階的に見てみましょう:

• 色の初期配列は allColors として定義されます。
• シャッフル関数は配列を受け取り、その要素をランダムにシャッフルします。 Fisher-Yates アルゴリズムを使用してシャッフルを実現します。
• Filter コンポーネントは、入力要素をレンダリングするメモ化された機能コンポーネントです。 onChange プロパティを受け取り、入力値が変化したときにコールバック関数をトリガーします。
• ページ コンポーネントは、カラー フィルタリングおよびシャッフル機能をレンダリングする主要なコンポーネントです。
• 状態変数の色は useState フックを使用して初期化され、初期値は allColors に設定されます。これは、フィルタリングされた色のリストを表します。
• handleFilter 関数は useCallback フックを使用して作成されます。テキスト パラメータを受け取り、指定されたテキストに基づいて allColors 配列をフィルタリングします。次に、フィルターされた色は、useState フックの setColors 関数を使用して設定されます。依存関係配列 [colors] により、色の状態が変化した場合にのみ handleFilter 関数が再作成され、不必要な再レンダリングを防ぐことでパフォーマンスが最適化されます。
• ページ コンポーネント内には、色をシャッフルするためのボタンがあります。ボタンをクリックすると、シャッフルされた allColors の配列を使用して setColors 関数が呼び出されます。
• Filter コンポーネントは、handleFilter 関数に設定された onChange プロパティを使用してレンダリングされます。
• 最後に、カラー配列がマッピングされて、カラー項目のリストが
としてレンダリングされます。
• 要素。

useCallback フックは、handleFilter 関数をメモ化するために使用されます。つまり、関数は一度だけ作成され、依存関係 (この場合は色の状態) が同じであれば、その後のレンダリングで再利用されます。

This optimization prevents unnecessary re-renders of child components that receive the handleFilter function as a prop, such as the Filter component.
It ensures that the Filter component is not re-rendered if the colors state hasn't changed, improving performance.

Using React's useRef

Another approach to enhance performance in React applications and avoid unnecessary re-renders is using the useRef hook. Using useRef, we can store a mutable value that persists across renders, effectively preventing unnecessary re-renders.

This technique allows us to maintain a reference to a value without triggering component updates when that value changes. By leveraging the mutability of the reference, we can optimize performance in specific scenarios.

Consider the following example:

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

function App() {
  const [name, setName] = useState('');
  const inputRef = useRef(null);

  function handleClick() {
    inputRef.current.focus();
  }

  return (
    <div>
      <input
        type="text"
        value={name}
        onChange={(e) => setName(e.target.value)}
        ref={inputRef}
      />
      <button onClick={handleClick}>Focus</button>
    </div>
  );
}

The example above has a simple input field and a button. The useRef hook creates a ref called inputRef. As soon as the button is clicked, the handleClick function is called, which focuses on the input element by accessing the current property of the inputRef ref object. As such, it prevents unnecessary rerendering of the component when the input value changes.

To ensure optimal use of useRef, reserve it solely for mutable values that do not impact the component's rendering. If a mutable value influences the component's rendering, it should be stored within its state instead.

Conclusion

Throughout this tutorial, we explored the concept of React re-rendering and its potential impact on the performance of our applications. We delved into the optimization techniques that can help mitigate unnecessary re-renders. React offers a variety of hooks that enable us to enhance the performance of our applications. We can effectively store values and functions between renders by leveraging these hooks, significantly boosting React application performance.

以上が不必要な React コンポーネントの再レンダリングを防ぐ方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。