Anwendungsszenarien für React useMemo und useCallback

Anwendungsszenarien für React useMemo und useCallback

verwendenMemo

Wir wissen, dass beim erneuten Rendern einer übergeordneten Komponente alle ihre Zustände, lokalen Variablen usw. neu sind. Sobald eine untergeordnete Komponente von einer Objektvariable einer übergeordneten Komponente abhängt, erhält die untergeordnete Komponente ein neues Objekt, unabhängig davon, ob sich das Objekt ändert. Dadurch wird der der untergeordneten Komponente entsprechende Diff ungültig und die Logik erneut ausgeführt. Im folgenden Beispiel enthält unsere Nebeneffektabhängigkeit den von der übergeordneten Komponente übergebenen Objektparameter, und jedes Mal, wenn die übergeordnete Komponente aktualisiert wird, wird eine Datenanforderung ausgelöst.

Funktion Info({
  Stil,
}) {
  console.log('Info-Rendering erfolgt');

  useEffect(() => {
    console.log('Daten neu laden'); // Die Daten werden bei jedem erneuten Rendern neu geladen}, [style]);

  zurückkehren (
    <p Stil={Stil}>
      Dies ist der Text in Info</p>
  );
}

Funktion Seite() {
  console.log('Seitendarstellung');

  const [Anzahl, Anzahl festlegen] = useState(0);
  const Stil = { Farbe: "rot" };

  // Wenn der Zähler +1 ist, wird die Seite neu gerendert, was wiederum das erneute Rendern der Info-Rückgabe auslöst (
    <div>
      <h4>Zählwert: {count}</h4>
      <button onClick={() => setCount(Anzahl + 1)}> +1 </button>
      <Infostil={Stil} />
    </div>
  );
}

React Hooks bietet uns eine Lösung. useMemo ermöglicht es uns, die übergebenen Objekte zwischenzuspeichern und die entsprechenden Objekte nur dann neu zu berechnen und zu aktualisieren, wenn sich die Abhängigkeiten ändern.

Funktion Seite() {
  console.log('Seitendarstellung');

  const [Farbe] = useState('rot');
  const [Anzahl, Anzahl festlegen] = useState(0);
  const style = useMemo(() => ({ color }), [color]); // der Stil ändert sich nur, wenn sich die Farbe deutlich ändert // Wenn der Zähler +1 ist, wird ein erneutes Rendern der Seite ausgelöst, was wiederum ein erneutes Rendern der Informationen auslöst // Da der Stil jedoch zwischengespeichert wird, wird dies kein erneutes Laden der Daten in der Informationen-Rückgabe auslösen (
    <div>
      <h4>Zählwert: {count}</h4>
      <button onClick={() => setCount(Anzahl + 1)}> +1 </button>
      <Infostil={Stil} />
    </div>
  );
}

useCallback

React Hooks bringt zwei Änderungen am Datenfluss mit sich: Erstens unterstützt es eine benutzerfreundlichere Kontextverwendung für die Statusverwaltung und vermeidet die Übertragung irrelevanter Parameter an die mittlere Ebene, wenn zu viele Ebenen vorhanden sind. Zweitens ermöglicht es Funktionen, am Datenfluss teilzunehmen, und vermeidet die Übertragung redundanter Parameter an Komponenten auf niedrigerer Ebene.

Als eines der Kernmodule von Hooks kann useContext den aktuellen Wert des übergebenen Kontexts abrufen, um eine schichtübergreifende Kommunikation zu erreichen. Auf der offiziellen Website von React finden Sie eine ausführliche Einführung. Zu beachten ist, dass alle Komponenten, die den Kontext verwenden, neu gerendert werden, sobald sich der Kontextwert ändert. Um das Neuzeichnen irrelevanter Komponenten zu vermeiden, müssen wir den Kontext sinnvoll konstruieren. Ausgehend von der im ersten Abschnitt erwähnten neuen Denkweise können wir beispielsweise den Kontext entsprechend der Relevanz des Status organisieren und verwandte Zustände im selben Kontext speichern.

Wenn in der Vergangenheit die übergeordneten und untergeordneten Komponenten dieselbe Datenanforderungsmethode getData verwendeten und diese Methode vom von der oberen Ebene übergebenen Abfragewert abhängig war, mussten die Methoden Abfrage und getData normalerweise zusammen an die untergeordnete Komponente übergeben werden. Die untergeordnete Komponente entschied anhand des Abfragewerts, ob getData erneut ausgeführt werden sollte.

Klasse Parent erweitert React.Component {
   Zustand = {
    Abfrage: 'Schlüsselwort',
  }

  getData() {
    const url = `https://mocks.alibaba-inc.com/mock/fO87jdfKqX/demo/queryData.json?query=${this.state.query}`;
    // Daten anfordern...
    console.log(`Anforderungspfad: ${url}`);
  }

  rendern() {
    zurückkehren (
      // Übergeben eines Abfragewerts, den eine untergeordnete Komponente nicht rendert <Child getData={this.getData} query={this.state.query} />
    );
  }
}

Klasse Child erweitert React.Component {
  componentDidMount() {
    dies.props.getData();
  }

  componentDidUpdate(vorherigeProps) {
    // if (prevProps.getData !== this.props.getData) { // Diese Bedingung ist immer wahr
    // diese.props.getData();
    // }
    if (prevProps.query !== this.props.query) { // Kann nur den Abfragewert zur Beurteilung verwenden this.props.getData();
    }
  }

  rendern() {
    zurückkehren (
      // ...
    );
  }
}

In React Hooks können wir mit useCallback eine Funktion zwischenspeichern und sie nur aktualisieren, wenn sich ihre Abhängigkeiten ändern. Dadurch können wir useEffect in untergeordneten Komponenten verwenden, um ein Laden nach Bedarf zu erreichen. Durch die Zusammenarbeit von Hooks ist eine Funktion nicht mehr nur eine Methode, sondern kann als Wert am Datenfluss der Anwendung teilnehmen.

Funktion Übergeordnet() {
  const [Anzahl, Anzahl festlegen] = useState(0);
  const [Abfrage, setQuery] = useState('Schlüsselwort');

  const getData = useCallback(() => {
    const url = `https://mocks.alibaba-inc.com/mock/fO87jdfKqX/demo/queryData.json?query=${query}`;
    // Daten anfordern...
    console.log(`Anforderungspfad: ${url}`);
  }, [Abfrage]); // getData wird nur aktualisiert, wenn sich die Abfrage ändert // Änderungen im Zählwert führen nicht dazu, dass Child die Datenrückgabe erneut anfordert (
    <>
      <h4>Zählwert: {count}</h4>
      <button onClick={() => setCount(Anzahl + 1)}> +1 </button>
      <input onChange={(e) => {setQuery(e.target.value)}} />
      <Untergeordnetes getData={getData} />
    </>
  );
}

Funktion Kind({
  Daten abrufen
}) {
  useEffect(() => {
    getData();
  }, [getData]); // Funktionen können am Datenfluss teilnehmen, da Abhängigkeiten zurückkehren (
    // ...
  );
}

Oben finden Sie detaillierte Informationen zu den Verwendungsszenarien von React useMemo und useCallback. Weitere Informationen zur Verwendung von React useMemo und useCallback finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!

Das könnte Sie auch interessieren:
  • Detaillierte Erklärung zur Verwendung von React.memo() zur Optimierung der Leistung von Funktionskomponenten
  • Erinnern Sie sich an einen durch React.memo verursachten Fehler

<<:  Detaillierte Erklärung und Zusammenfassung der URL zur Datenbankverbindung

>>:  Containerisierungstransformation für Docker-Großprojekte

Artikel empfehlen

Vollständiger Schrittbericht zur Vue-Kapselung allgemeiner Tabellenkomponenten

Inhaltsverzeichnis Vorwort Warum müssen wir die T...

So konfigurieren Sie einen Pfadalias für das React-Scaffolding

Die React-Version beim Schreiben dieses Artikels ...

Zusammenfassung der zwölf Methoden der Vue-Wertübertragung

Inhaltsverzeichnis 1. Vom Vater zum Sohn 2. Vom S...

Verwenden von JavaScript zum Implementieren von Karusselleffekten

In diesem Artikel wird der spezifische Code für J...

Tatsächlicher Datensatz zur Wiederherstellung der MySQL-Datenbank nach Zeitpunkt

Einführung: MySQL-Datenbankwiederherstellung nach...

Beispiel für die Verwendung von rem zum Ersetzen von px in einem Vue-Projekt

Inhaltsverzeichnis Werkzeug Installieren Sie das ...

Eine umfassende Analyse der Möglichkeiten von Nginx

Vorwort Dieser Artikel konzentriert sich nur dara...

Fallstudie: Ajax responseText analysiert JSON-Daten

Lösen Sie das Problem, dass der vom Server nach d...

Beispielcode zur Installation von Jenkins mit Docker

Zwei Probleme, die bei der Installation von Docke...