Ausführliche Erläuterung zur Leistungsoptimierung von React-Komponenten

Dieser Artikel stellt hauptsächlich die Leistungsoptimierung von React-Komponenten vor. Jetzt teile ich ihn mit Ihnen und gebe Ihnen eine Referenz.

Kardner: „Wir sollten vergessen, kleine Leistungsoptimierungen zu ignorieren. Man kann sagen, dass in 97 % der Fälle eine vorzeitige Optimierung die Wurzel allen Übels ist, und wir sollten uns um die anderen drei kritischsten Auswirkungen kümmern.“ Leistung. % des Codes. „

Verschwenden Sie keine Energie zur Leistungsoptimierung für Code, der die Gesamtleistung nicht verbessert. Es ist noch nicht zu früh, die Teile zu optimieren, die einen entscheidenden Einfluss auf die Leistung haben. Denn der kritischste Teil, der sich auf die Leistung auswirkt, betrifft oft den Kern der Lösung und bestimmt die Gesamtarchitektur, die noch stärker involviert sein wird, wenn sie in Zukunft geändert werden muss.

1. Leistungsoptimierung einer einzelnen React-Komponente

React verwendet Virtual DOM, um die Rendering-Leistung zu verbessern, obwohl jede Seitenaktualisierung ein erneutes Rendering der Komponente erfordert Die meisten Komponenten bedeuten jedoch nicht, dass alle vorherigen Rendering-Inhalte aufgegeben und von vorne begonnen werden müssen. Mit Hilfe von Virtual DOM kann React die minimale Änderung am DOM-Baum standardmäßig sehr schnell berechnen >

Obwohl Virtual DOM den Umfang jeder DOM-Operation auf ein Minimum reduzieren kann, ist die Berechnung und der Vergleich von Virtual DOM immer noch ein komplizierter Prozess

Natürlich, wenn das Rendering beurteilt werden kann Bevor Sie mit der Berechnung des virtuellen DOM beginnen, ändert sich das Ergebnis nicht, sodass keine Berechnung und kein Vergleich des virtuellen DOM erforderlich ist und die Geschwindigkeit höher ist.

2. Die Standardimplementierung von ShouldComponentUpdate

Da es möglich ist, vor dem Start festzustellen, dass sich das Rendering-Ergebnis der Komponente nicht ändert Berechnen Sie das virtuelle DOM. Um das Rendern zu verhindern und dadurch die Leistung zu verbessern, denken wir natürlich an die Verwendung von ShouldComponentUpdate(nextProp,nextState)

Die Funktion ShouldComponentUpdate wird vor der Renderfunktion aufgerufen, um zu bestimmen, „wann kein Bedarf besteht“. zum erneuten Rendern";

Gibt einen booleschen Wert zurück, um zu bestimmen, ob die Aktualisierung fortgesetzt wird. Der Standardwert gibt true zurück. Wenn false zurückgegeben wird, wird die Aktualisierung unterbrochen;

shouldComponentUpdate(nextProp,nextState){
  return (nextProp.completed !== this.props.completed) ||
    (nextProp.text !== this.props.text)
}

wobei nextProps Für die für dieses Update übergebenen Requisiten sind die einzigen Requisiten, die sich auf den gerenderten Inhalt auswirken, abgeschlossen und text Solange sich diese beiden Requisiten nicht geändert haben, sollteComponentUpdate kann false zurückgeben, um unnötige Aktualisierungen zu verhindern

Der obige Vergleich ist jedoch nur ein „oberflächlicher Vergleich“. Wenn der Typ ein Basistyp ist, solange die Werte gleich sind „flacher Vergleich“

betrachtet die beiden auch als gleich:

Was ist dann, wenn es sich bei der Art der Requisite um ein komplexes Objekt handelt?

Bei komplexen Objekten prüft die Methode „flacher Vergleich“ nur, ob es sich bei den beiden Requisiten um Referenzen auf dasselbe Objekt handelt. Wenn nicht, sind die Inhalte der Objekte identisch als unterschiedlich angesehen. Verwenden Sie dann einen „tiefen Vergleich“: Die Struktur des Objekts ist jedoch unvorhersehbar. Wenn Sie für jedes Feld einen „tiefen Vergleich“ durchführen, wird der Code nicht nur komplexer, sondern kann auch zu Leistungsproblemen führen.

Wenn Sie also feststellen möchten, dass die Requisiten der Objekttypen davor und danach gleich sind, müssen Sie sicherstellen, dass die Requisiten auf dasselbe JavaScript-Objekt verweisen:

<Foo styleProp = {{color: "red"}}>

Um die Verwendung der oben genannten Eingabemethode zu vermeiden, wird das Objekt {color: „red“} für jedes Rendering neu erstellt und die Referenzadresse ist jedes Mal anders , was dazu führt, dass styleProp jedes Mal anders ist.

const footStyle = {color: "red"};//确保这个初始化只执行一次，不要放在render函数中
<Foo styleProp = {footStyle}>

Verwenden Sie den „Singleton-Modus“, um sicherzustellen, dass das eingehende styleProp auf dasselbe Objekt zeigt

Was wäre, wenn? ist eine Funktion?

<Foo onToggle={() => onToggleTodo(item.id)}/>

Sie sollten die Verwendung des oben genannten Funktionsübertragungsmodus vermeiden, da der hier zugewiesene Wert eine anonyme Funktion ist und während der Zuweisung generiert wird. und das heißt, jedes Rendern erzeugt eine neue Funktion, und das ist das Problem.

Was ist, wenn viele Requisiten weitergegeben werden müssen?

Nun~~Wenn Sie React-Redux verwenden, gibt es eine Standardimplementierung von ShouldComponentUpdate.

3. Leistungsoptimierung mehrerer React-Komponenten

Wenn eine React-Komponente geladen, aktualisiert und entladen wird, wird eine Folge von Komponenten-Lebenszyklusfunktionen ausgeführt aufgerufen werden. Diese Lebenszyklusfunktionen gelten jedoch für eine bestimmte React-Komponentenfunktion. In einer Anwendung sind viele React-Komponenten von oben nach unten kombiniert, und der Rendervorgang zwischen ihnen ist komplizierter.

Der Rendering-Prozess derselben Komponente muss auch drei Prozesse berücksichtigen: Ladephase, Aktualisierungsphase und Entladephase

Für die Ladephase muss die Komponente sein Auf jeden Fall müssen alle Unterkomponenten ab dieser React-Komponente gleichzeitig den Ladelebenszyklus der React-Komponente durchlaufen, sodass nicht viel Optimierung erforderlich ist.

Für die Deinstallationsphase gibt es nur eine Lebenszyklusfunktion „componentWillUnmount“. Diese Funktion bereinigt nur die durch „componentDidMount“ hinzugefügte Ereignisverarbeitung und andere Abschlussarbeiten, sodass kein Raum für Optimierung besteht 🎜>

4. Abstimmungsprozess in der React-Update-Phase

Während des Komponentenaktualisierungsprozesses wird ein aktualisiertes virtuelles DOM erstellt und mit dem vorherigen verglichen Virtuelles DOM, um den Unterschied zu finden und mit minimaler DOM-Manipulation zu aktualisieren

调和过程：即React更新中对Virtual DOM找不同的过程，通常对比两个N个节点的树形结构的算法，时间复杂度是O(n*3),如果直接

使用默认对比，节点过多的话，需要操作的数量太多，而React不可能采用这种算法；

React实际采用的算法时间复杂度是O(N)(时间复杂度只是对一个算法最好和最差情况下需要的指令操作数量级的估量)

React的Reconciliation算法并不复杂，首先检查两个树形的根节点的类型是否相同，根据相同或者不同有不同的处理方式：

节点类型不同的情况

如果树形节点的类型不相同，那就意味着改动很大，直接认为原来的那个树形结构已经没用，可以扔掉，需要从新构建DOM树，原有的树形上的React组件便会经历“卸载”的生命周期；

也就是说，对于Virtual DOM树这是一个“更新”过程，但是却可能引发这个树结构上某些组件的“装载”和“卸载”过程
如：

更新前

 <p>
  <Todos />
 </p>

我们想要更新成这样：

 <span>
   <Todos />
 </span>

>1. 那么在作比较的时候，一看根节点原来是p，新的是span，类型就不一样了，那么这个算法就废弃之前的p包括里面的所有子节点，从新构建一个span节点和子节点；

>2. 很明显因为根节点不同就将所有的子节点从新构建，这很浪费，但是为了避免O(N*3)的时间复杂度，React这能选择这种比较简单、快捷的方法；

>3. 所以，作为开发者，我们一定要避免上面的浪费的情景出现

节点类型相同的情况

如果两个节点类型相同时，对于DOM元素，React会保留节点对应的DOM元素，只对其节点的属性和内容做对比，然后只修改更新的部分；

节点类型相同时，对于React组件类型，React做得是根据新节点的props去更新节点的组件实例，引发组件的更新过程；

在处理完根节点对比后，React的算法会对根节点的每一个子节点重复一样的操作

多个相同子组件的情况

如果最初组件状态为：

<ul>
  <TodoItem text = "First" />
  <TodoItem text = "Second" />

</ul>

更新后为：

<ul>
  <TodoItem text = "First" />
  <TodoItem text = "Second" />
  <TodoItem text = "Third" />
</ul>

那么React会创建一个新的TodoItem组件实例，而前两个则进行正常的更新过程但是，如果更新后为：

<ul>
  <TodoItem text = "Zero" />
  <TodoItem text = "First" />
  <TodoItem text = "Second" />

</ul>

（这将暴露一个问题）理想处理方式是，创建一个新的TodoItem组件实例放在第一位，后两个进入自然更新过程
但是要让react按照这种方式，就必须找两个子组件的不同之处，而现有计算两个序列差异的算法时间是O(N*2),显然则
不适合对性能要求很高的场景，所以React选择了一个看起来很傻的办法，即挨个比较每个子组件；

React首先认为把text为First的组件的text改为Zero,Second的改为First，最后创建一个text为Second的组件，这样便会破原有的两个组件完成一个更新过程，并创建一个text为Second的新组件

这显然是一个浪费，React也意到，并提供了方克服，不过需要开发人员提供一点帮助，这就是key

Key的使用

key属性可以明确的告诉React每个组件的唯一标识

如果最初组件状态为：

<ul>
  <TodoItem key={1} text = "First" />
  <TodoItem key={2} text = "Second" />

</ul>

更新后为：

<ul>
  <TodoItem key={0} text = "Zero" />
  <TodoItem key={1} text = "First" />
  <TodoItem key={2} text = "Second" />
</ul>

因为有唯一标识key,React可以根据key值，知道现在的第二和第三个组件就是之前的第一和第二个，便用原来的props启动更新过程，这样shouldComponentUpdate就会发生作用，避免无谓的更新；

注意：因为作为组件的唯一标识，所以key必须唯一，且不可变

下面的代码是错误的例子：

<ul>
  todos.map((item,index) => {
      <TodoItem
        key={index}
        text={item.text}
      />
    })
</ul>

使用数组下标作为key值，看起来唯一，但不稳定，因为随着todos数组值的不同，同样一个组件实例在不同的更新过程中数组的下标完全可能不同，把下标当做可以就会让React乱套，记住key不仅要唯一还要确保稳定不可变

需要注意：虽然key是一个prop，但是接受key的组件不能读取key的值，因为key和ref是React保留的两个特殊prop，并没有预期让组将直接访问。

上面是我整理给大家的，希望今后会对大家有帮助。

相关文章：

如何关闭Vue计算属性自带的缓存功能，具体步骤有哪些？

Welche spezifischen Methoden gibt es für die Verwendung von Compass in Vue?

Verwenden der Swiper-Komponente in vue2.0 zur Implementierung eines Karussells (ausführliches Tutorial)

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung zur Leistungsoptimierung von React-Komponenten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!