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

So zeigen Sie laufende Hintergrundprogramme in Linux an und beenden sie

Linux-Taskverwaltung - Ausführung und Beendigung ...

Eine Lösung für einen Fehler in IE6 mit jquery-multiselect

Bei der Verwendung von jquery-multiselect (einem ...

So überwachen und löschen Sie abgelaufene Sitzungen in Tomcat

Vorwort Ich habe zufällig entdeckt, dass die halb...

Datenbankübergreifende Assoziationsabfragemethode in MySQL

Geschäftsszenario: Abfragen von Tabellen in versc...

Lassen Sie sich die tiefe Kopie von js verstehen

Inhaltsverzeichnis js tiefe Kopie Methode der Dat...

7 Möglichkeiten, Elemente mit CSS vertikal zu zentrieren

【1】Kennen Sie die Breite und Höhe des zentrierten...

Mehrere Möglichkeiten, die Lesbarkeit von Webseiten zu verbessern

1. Verwenden Sie kontrastierende Farben. Mit Kont...