Einer der Schlüssel zum Erstellen leistungsfähiger React-Anwendungen ist die Vermeidung unnötiger erneuter Renderings. Die Rendering-Engine von React ist effizient, aber es ist dennoch wichtig, erneute Renderings dort zu verhindern, wo sie nicht benötigt werden. In diesem Beitrag besprechen wir häufige Fehler und wie man sie vermeidet.

1. Komponenten mit React.memo auswendig lernen

Memoization hilft Ihnen, erneute Renderings zu überspringen, wenn sich die Requisiten der Komponente nicht geändert haben. Es ist jedoch leicht, React.memo zu missbrauchen, indem keine benutzerdefinierte Vergleichsfunktion implementiert wird.

Falsche Verwendung:

const MemoizedComponent = React.memo(MyComponent);

Hiermit wird nur überprüft, ob sich die Requisitenreferenz geändert hat, was möglicherweise nicht immer ausreicht.

Richtige Verwendung:

const MemoizedComponent = React.memo(MyComponent, (prevProps, nextProps) => {
  return prevProps.itemId === nextProps.itemId;
});

Hier verwenden wir eine benutzerdefinierte Vergleichsfunktion, die nur dann ein erneutes Rendern auslöst, wenn sich die itemId-Requisite ändert.

2. Vermeiden Sie den übermäßigen Einsatz von Inline-Funktionen

Die Verwendung von Inline-Funktionen in JSX kann zu unnötigen erneuten Renderings führen, da React bei jedem Rendering eine neue Funktion als neue Requisite behandelt.

Falsche Verwendung:

function ButtonComponent() {
  return  handleClick()}>Click me;
}

Dies führt dazu, dass handleClick bei jedem Rendern neu erstellt wird, was zu unnötigen Neurendern führt.

Richtige Verwendung:

import { useCallback } from 'react';

function ButtonComponent() {
  const handleClick = useCallback(() => {
    // Handle click logic
  }, []);

  return Click me;
}

Durch die Verwendung von useCallback merken wir uns die handleClick-Funktion und verhindern so eine unnötige Neuerstellung bei jedem Rendern.

3. Nutzung von PureComponent

Bei der Arbeit mit Klassenkomponenten stellt die Verwendung von React.PureComponent sicher, dass die Komponente nur dann erneut gerendert wird, wenn sich ihre Requisiten oder ihr Status ändern. Wenn Sie React.Component verwenden, kann es zu unnötigen erneuten Renderings kommen.

Falsche Verwendung:

class CardComponent extends React.Component {
  // Component logic
}

Richtige Verwendung:

class CardComponent extends React.PureComponent {
  // Component logic
}

Durch die Erweiterung von React.PureComponent vergleicht React Requisiten und Status oberflächlich und vermeidet so unnötige erneute Renderings.

4. UseSelector in Funktionskomponenten optimieren

Bei Verwendung von useSelector aus React-Redux ist es wichtig, nur den erforderlichen Teil des Zustands auszuwählen.

Falsche Verwendung:

import { useSelector } from 'react-redux';

const DataComponent = () => {
  const globalState = useSelector((state) => state);
  // Render logic
};

Dies führt dazu, dass die Komponente jedes Mal neu gerendert wird, wenn sich ein Teil des Status ändert.

Richtige Verwendung:

import { useSelector } from 'react-redux';

const DataComponent = () => {
  const selectedData = useSelector((state) => state.specificSlice);
  // Render logic based on specific slice
};

Indem Sie nur den notwendigen Teil des Zustands auswählen, minimieren Sie erneute Renderings.

5. Implementieren von ShouldComponentUpdate in Klassenkomponenten

Für Klassenkomponenten, die PureComponent nicht erweitern, ermöglicht die manuelle Implementierung von ShouldComponentUpdate eine detailliertere Kontrolle darüber, wann die Komponente erneut gerendert wird.

Falsche Verwendung:

class ListItem extends React.Component {
  // Component logic
}

Dies wird jedes Mal neu gerendert, wenn die übergeordnete Komponente gerendert wird, auch wenn sich die Requisiten und der Status nicht geändert haben.

Richtige Verwendung:

class ListItem extends React.Component {
  shouldComponentUpdate(nextProps, nextState) {
    return this.props.itemId !== nextProps.itemId || this.state.value !== nextState.value;
  }

  // Component logic
}

Durch die Anpassung von ShouldComponentUpdate stellen wir sicher, dass die Komponente nur dann neu gerendert wird, wenn sich die itemId-Requisite oder der Wertstatus ändert.

Abschluss

Durch den Einsatz dieser Techniken können Sie unnötige Neu-Renderings in Ihren React-Anwendungen erheblich reduzieren, was zu einer besseren Leistung führt. Die Implementierung der Memoisierung mit React.memo, die Nutzung von PureComponent und die Feinabstimmung von ShouldComponentUpdate sind wichtige Strategien zur Optimierung Ihrer React-Komponenten.

Wenn Sie verstehen, wann und wie das Rendering optimiert werden muss, können Sie die Benutzererfahrung erheblich verbessern, indem Sie schnellere und reaktionsfähigere Anwendungen bereitstellen.

Referenzen:

1. GeeksforGeeks. (2023). Was ist Memoisierung in React?
2. Syncfusion. (2024). Auswendiglernen in React
3. Hygraph. (2024). Was ist React Memo und wie wird es verwendet?
4. Refine.dev. (2024). React-Memo-Leitfaden mit Beispielen

Wenn Sie diesen Leitfaden nützlich fanden, denken Sie bitte darüber nach, ihn mit anderen zu teilen! ?

Dieser Blog bietet einen aktualisierten und umfassenden Überblick über die Vermeidung unnötiger erneuter Renderings in React-Anwendungen bei gleichzeitiger Integration von Best Practices und der Änderung von Variablennamen für Klarheit und Relevanz in modernen Webentwicklungspraktiken.

Zitate:
[1] https://www.geeksforgeeks.org/what-is-memoization-in-react/
[2] https://stackoverflow.com/questions/74013864/why-arent-all-react-components-wrapped-with-react-memo-by-default
[3] https://www.syncfusion.com/blogs/post/what-is-memoization-in-react
[4] https://hygraph.com/blog/react-memo
[5] https://refine.dev/blog/react-memo-guide/
[6] https://dmitripavlutin.com/use-react-memo-wisely/
[7] https://www.topcoder.com/thrive/articles/memoization-in-react-js
[8] https://react.dev/reference/react/memo