Inhaltsverzeichnis
Instanzierungsphase
存在期
销毁
React v.16生命周期
Heim Web-Frontend js-Tutorial Umfassendes Verständnis des Reaktionslebenszyklus (mit Code)

Umfassendes Verständnis des Reaktionslebenszyklus (mit Code)

Apr 03, 2019 am 10:05 AM
javascript react.js

Dieser Artikel vermittelt Ihnen ein umfassendes Verständnis des Reaktionslebenszyklus (mit Code). Freunde in Not können sich darauf beziehen.

Der Lebenszyklus einer React-Komponente ist in drei Teile unterteilt: Instanziierung, Existenz und Zerstörung.

Instanzierungsphase

Beim Rendern auf der Clientseite wird Folgendes nacheinander aufgerufen

  • getDefaultProps( )
  • getInitialState()
  • componentWillMount()
  • render()
  • componentDidMount()

Server -seitiges Rendern

  • getDefaultProps()
  • getInitialState()
  • componentWillMount()
  • render()

Hinweis: ComponentDidMount() wird nicht auf der Serverseite gerendert.

getDefaultProps

Für jede Komponenteninstanz wird diese Methode nur einmal aufgerufen. und die Komponentenklasse In allen nachfolgenden Anwendungen wird getDefaultPops nicht erneut aufgerufen und das zurückgegebene Objekt kann zum Festlegen von Standard-Requisitenwerten verwendet werden.

var Hello = React.creatClass({
    getDefaultProps: function(){
        return {
            name: 'pomy',
            git: 'dwqs'
        }
    },
    
    render: function(){
        return (
            <p>Hello,{this.props.name},git username is {this.props.dwqs}</p>
        )
    }
});

ReactDOM.render(<Hello />, document.body);
Nach dem Login kopieren

Sie können beim Montieren der Komponente auch Requisiten festlegen.

var data = [{title: 'Hello'}];
<Hello data={data} />
Nach dem Login kopieren

Oder rufen Sie setProps auf (im Allgemeinen ist kein Aufruf erforderlich), um seine Requisiten festzulegen

var data = [{title: 'Hello'}];
var Hello = React.render(<Demo />, document.body);
Hello.setProps({data:data});
Nach dem Login kopieren

Aber setProps kann nur für untergeordnete Komponenten oder Komponentenbäume aufgerufen werden. Rufen Sie this.setProps nicht auf und ändern Sie this.props nicht direkt. Behandeln Sie es als schreibgeschützte Daten.

React bietet eine Möglichkeit, Requisiten über propTypes zu überprüfen. propTypes ist ein Konfigurationsobjekt, das zum Definieren von Eigenschaftstypen verwendet wird:

var survey = React.createClass({
    propTypes: {
        survey: React.PropTypes.shape({
            id: React.PropTypes.number.isRequired
        }).isRequired,
        onClick: React.PropTypes.func,
        name: React.PropTypes.string,
        score: React.PropTypes.array
        ...
    },
    
    //...
})
Nach dem Login kopieren

oder

import React, { Component } from 'react'
import PropTypes from 'prop-types'

class BetterImage extends Component{...}

BetterImage.PropTypes={
  src: PropTypes.string,
  center: PropTypes.bool,
  loadingImage: PropTypes.string,
  defaultImage: PropTypes.string,
  onLoad: PropTypes.func,
  onError: PropTypes.func,
  onComplete: PropTypes.func
}
BetterImage.defaultProps={
  ....
}
Nach dem Login kopieren

getInitialState

Für jede Instanz der Komponente wird diese Methode einmal und nur einmal aufgerufen, um den Status jeder Instanz zu initialisieren. Mit dieser Methode können Sie auf die Requisiten der Komponente zugreifen. Jede React-Komponente hat ihren eigenen Status, der sich von Props dadurch unterscheidet, dass der Status nur innerhalb der Komponente existiert, während Props von allen Instanzen gemeinsam genutzt werden.

Es gibt einen Unterschied zwischen den Aufrufen von getInitialState und getDefaultPops. GetDefaultPops wird nur einmal für die Komponentenklasse aufgerufen, und nachfolgende Anwendungen dieser Klasse werden nicht aufgerufen, während getInitialState für jede Komponenteninstanz aufgerufen wird nur einmal einstellen.

var LikeButton = React.createClass({
  //初始化State
  getInitialState: function() {
    return {liked: false};
  },
  
  handleClick: function(event) {
    //设置修改State
    this.setState({liked: !this.state.liked});
  },

  render: function() {
    var text = this.state.liked ? 'like' : 'haven\'t liked';
    return (
      <p onClick={this.handleClick}>
        You {text} this. Click to toggle.
      </p>
    );
  }
});

ReactDOM.render(
  <LikeButton />,
  document.getElementById('example')
);
Nach dem Login kopieren

Jedes Mal, wenn der Status geändert wird, wird die Komponente neu gerendert. Nach der Instanziierung wird die Komponente über den Status aktualisiert und die folgenden Methoden werden nacheinander aufgerufen:

1、shouldComponentUpdate
2、componentWillUpdate
3、render
4、componentDidUpdate
Nach dem Login kopieren
  • componentWillMount

wird vor dem Rendern aufgerufen, sowohl auf dem Client als auch auf dem Server. React hat die offiziell veröffentlichte Version v16.3. In diesem Update werden zusätzlich zu der neuen Kontext-API, die vor einiger Zeit heiß diskutiert wurde, zwei neu eingeführte Lebenszyklusfunktionen getDerivedStateFromProps und getSnapshotBeforeUpdate sowie drei Lebenszyklusfunktionen ComponentWillMount in der zukünftigen Version 17.0 entfernt, ComponentWillReceiveProps und ComponentWillUpdate.

In diesem Lebenszyklus werden Sie auf die folgenden Probleme stoßen:

a. Keine Daten auf dem ersten Bildschirm führen zu einem weißen Bildschirm
In React-Anwendungen vermeiden viele Entwickler den weißen Bildschirm Da beim ersten Rendern der Seite keine asynchronen Daten abgerufen werden, wird der Code für den Datenanforderungsteil in ComponentWillMount platziert, in der Hoffnung, den weißen Bildschirm zu vermeiden und die Sendezeit asynchroner Anforderungen zu verlängern. Tatsächlich hat jedoch nach der Ausführung von „componentWillMount“ das erste Rendern bereits begonnen. Wenn also bei der Ausführung von „componentWillMount“ keine asynchronen Daten abgerufen wurden, befindet sich die Seite beim ersten Rendern immer noch in einem Zustand ohne asynchrone Daten. Mit anderen Worten: Die Komponente befindet sich beim ersten Rendern immer in einem Zustand ohne asynchrone Daten. Daher gibt es keine direkte Lösung für dieses Problem, unabhängig davon, wohin die Datenanforderung gesendet wird. Im Hinblick auf das frühzeitige Senden von Datenanfragen empfehlen die Behörden außerdem, den Datenanfrageteil des Codes im Konstruktor der Komponente statt in „componentWillMount“ zu platzieren.
Wenn es zwei Lösungen gibt, die zur Verbesserung der Benutzererfahrung verwendet wurden:

Methode 1: Komponenten asynchron anfordern, verwenden Sie nprogress, um eine Ladeanimation hinzuzufügen

import React, { Component } from 'react'
import NProgress from 'nprogress'
import 'nprogress/nprogress.css'
import './customNprogress.styl'

NProgress.configure({ showSpinner: false })

export default function asyncComponent(importComponent) {
  class AsyncComponent extends Component {
    state = {
      component: null
    }

    async componentDidMount() {
      NProgress.start()
      const { default: component } = await importComponent()
      NProgress.done()

      this.setState({ component })
    }

    render() {
      const C = this.state.component

      return C ? <C {...this.props} /> : null
    }
  }

  return AsyncComponent
}

const AsyncNotFound = asyncComponent(() => import(/* webpackChunkName: "NotFound" */ '@/routes/NotFound'))
Nach dem Login kopieren

Methode 2: Verwenden Sie onreadystatechange Hören Sie sich readyState an und laden Sie eine statische Seite mit nur einem Frame, bevor das Laden der Ressource abgeschlossen ist. Die Seite fordert keine Daten an. Wenn die Datenanforderung abgeschlossen ist, wird die Route auf die echte Homepage umgeschaltet.

  function listen () {
    if (document.readyState == 'complete') { // 资源加载完成
        ReactDom.render(
            <Provider store={store}>
                <Router>
                    <Route path="/" component={Index}/>
                </Router>
            </Provider>,
            document.getElementById('root')
        )
    } else { // 资源加载中
        ReactDom.render(
            <Provider store={store}>
                <Router>
                    <Route path="/" component={FirstScreen}/>
                </Router>
            </Provider>,
            document.getElementById('root')
        )
    }
}

document.onreadystatechange = listen
Nach dem Login kopieren

Weitere Informationen finden Sie unter „Lösung des React First Screen Loading White Screen-Problems“

b. Abonnement von Ereignissen

Ein weiterer häufiger Anwendungsfall ist das Abonnieren von Ereignissen in „componentWillMount“. und in ComponentWillUnmount Kündigen Sie das entsprechende Ereignisabonnement. Tatsächlich kann React jedoch nicht garantieren, dass nach dem Aufruf von „componentWillMount“ auch „componentWillUnmount“ derselben Komponente aufgerufen wird. Ein Beispiel für die aktuelle Version ist, dass beim Rendern auf der Serverseite „componentWillUnmount“ nicht auf der Serverseite aufgerufen wird, sodass das Abonnieren von Ereignissen in „componentWillMount“ direkt zu einem Speicherverlust auf der Serverseite führt. Andererseits ist es wahrscheinlich, dass das Rendern der Komponente durch andere Transaktionen unterbrochen wird, nachdem React in Zukunft den asynchronen Rendering-Modus aktiviert hat, nachdem „componentWillMount“ aufgerufen wurde, was dazu führt, dass „componentWillUnmount“ nicht aufgerufen wird. **Bei „componentDidMount“ tritt dieses Problem nicht auf. Nach dem Aufruf von „componentDidMount“ wird anschließend „componentWillUnmount“ aufgerufen und die in der Komponente vorhandenen Ereignisabonnements werden gemäß dem spezifischen Code gelöscht. **

Rendering

该方法会创建一个虚拟DOM,用来表示组件的输出。对于一个组件来讲,render方法是唯一一个必需的方法。render方法需要满足下面几点:

  • 只能通过 this.props 和 this.state 访问数据(不能修改)
  • 可以返回 null,false(这种场景下,react渲染一个
  • 只能出现一个顶级组件,不能返回一组元素
  • 不能改变组件的状态
  • 不能修改DOM的输出

render方法返回的结果并不是真正的DOM元素,而是一个虚拟的表现,类似于一个DOM tree的结构的对象。react之所以效率高,就是这个原因。

render执行情况如下:

1. 首次加载
2. setState改变组件内部state。
   注意: 此处是说通过setState方法改变。
3. 接受到新的props

注意:因为数据是异步的情况,会导致组件重复渲染

componentDidMount

该方法不会在服务端被渲染的过程中调用。该方法被调用时,已经渲染出真实的 DOM,可以再该方法中通过 this.getDOMNode() 访问到真实的 DOM(推荐使用 ReactDOM.findDOMNode())。

var data = [..];
var comp = React.createClass({
    render: function(){
        return <imput .. />
    },
    componentDidMount: function(){
        $(this.getDOMNode()).autoComplete({
            src: data
        })
    }
})
Nach dem Login kopieren

由于组件并不是真实的 DOM 节点,而是存在于内存之中的一种数据结构,叫做虚拟 DOM (virtual DOM)。只有当它插入文档以后,才会变成真实的 DOM 。有时需要从组件获取真实 DOM 的节点,这时就要用到 ref 属性:

var Area = React.createClass({
    render: function(){
        this.getDOMNode(); //render调用时,组件未挂载,这里将报错
        
        return <canvas ref=&#39;mainCanvas&#39;>
    },
    componentDidMount: function(){
        var canvas = this.refs.mainCanvas.getDOMNode();
        //这是有效的,可以访问到 Canvas 节点
    }
})
Nach dem Login kopieren

需要注意的是,由于 this.refs.[refName] 属性获取的是真实 DOM ,所以必须等到虚拟 DOM 插入文档以后,才能使用这个属性,否则会报错。如果ref回调函数以inline函数的方式来指定,那么在组件更新的时候ref回调会被调用2次。第一次回调的时候传入的参数是null,而第二次的时候才真正的传入DOM节点

更多了解ref使用
从React官方文档看 refs 的使用和未来
获取真实dom,并获取dom css 三种方法

存在期

此时组件已经渲染好并且用户可以与它进行交互,比如鼠标点击,手指点按,或者其它的一些事件,导致应用状态的改变,你将会看到下面的方法依次被调用;

  1. componentWillReceiveProps()
  2. shouldComponentUpdate()
  3. componentWillUpdate()
  4. render()
  5. componentDidUpdate()

componentWillReceiveProps

当props发生变化时执行,初始化render时不执行,在这个回调函数里面,你可以根据属性的变化,通过调用this.setState()来更新你的组件状态,旧的属性还是可以通过this.props来获取,这里调用更新状态是安全的,并不会触发额外的render调用。

componentWillReceiveProps: function(nextProps){
    if(nextProps.checked !== undefined){
        this.setState({
            checked: nextProps.checked
        })
    }
}
Nach dem Login kopieren

了解更多点击此处

shouldComponentUpdate

shouldComponentUpdate函数是重渲染时render()函数调用前被调用的函数,它接受两个参数:nextProps和nextState,分别表示下一个props和下一个state的值。并且,当函数返回false时候,阻止接下来的render()函数及后面的 componentWillUpdate,componentDidUpdate 方法的调用,阻止组件重渲染,而返回true时,组件照常重渲染。

了解更多点击此处--真的讲的好

componentWillUpdate

这个方法和 componentWillMount 类似,在组件接收到了新的 props 或者 state 即将进行重新渲染前,componentWillUpdate(object nextProps, object nextState) 会被调用,注意不要在此方面里再去更新 props 或者 state。

componentDidUpdate

这个方法和 componentDidMount 类似,在组件重新被渲染之后,componentDidUpdate(object prevProps, object prevState) 会被调用。可以在这里访问并修改 DOM。

销毁

componentWillUnmount

每当React使用完一个组件,这个组件必须从 DOM 中卸载后被销毁,此时 componentWillUnmout 会被执行,完成所有的清理和销毁工作,在 componentDidMount 中添加的任务都需要再该方法中撤销,如创建的定时器或事件监听器。

当再次装载组件时,以下方法会被依次调用:

1、getInitialState
2、componentWillMount
3、render
4、componentDidMount

React v.16生命周期

constructor(props) // 初始化参数

componentWillMount()

render() // 第一次渲染 

componentDidMount()

**当父组件向子组件传入props发生改变后,依次调用**

componentWillReceiveProps(nextProps)

shouldComponentUpdate(nextProps, nextState) 

componentWillUpdate()

render() //子组件更新渲染

componentDidUpdate()

**当组件自身state发生变化后**

componentWillUpdate()

render() //组件再次更新渲染

componentDidUpdate()


当组件卸载

componentWillUnmount()
Nach dem Login kopieren

与低于React16版本的比较

  1. Der neue Lebenszyklus von React16 veraltet „componentWillMount“, „componentWillReceiveProps“, „componentWillUpdate“
  2. „getDerivedStateFromProps“, „getSnapshotBeforeUpdate“ hinzugefügt, um die drei veralteten Hook-Funktionen (componentWillMount, „componentWillReceivePorps“, „componentWillUpdate“) zu ersetzen
  3. 16 haben es getan Löschen Sie diese drei Hook-Funktionen nicht, sie können jedoch nicht mit den neuen Hook-Funktionen gemischt werden (getDerivedStateFromProps, getSnapshotBeforeUpdate). React17 löscht ComponentWillMount, ComponentWillReceivePorps und ComponentWillUpdate.
  4. hat ein neues Paar zur Fehlerbehandlung hinzugefügt (ComponentDidCatch).

[Verwandte Empfehlungen:

Video-Tutorial reagieren]

Das obige ist der detaillierte Inhalt vonUmfassendes Verständnis des Reaktionslebenszyklus (mit Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn

Heiße KI -Werkzeuge

Undresser.AI Undress

Undresser.AI Undress

KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover

AI Clothes Remover

Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool

Undress AI Tool

Ausziehbilder kostenlos

Clothoff.io

Clothoff.io

KI-Kleiderentferner

Video Face Swap

Video Face Swap

Tauschen Sie Gesichter in jedem Video mühelos mit unserem völlig kostenlosen KI-Gesichtstausch-Tool aus!

Heiße Werkzeuge

Notepad++7.3.1

Notepad++7.3.1

Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version

SublimeText3 chinesische Version

Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1

Senden Sie Studio 13.0.1

Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6

Dreamweaver CS6

Visuelle Webentwicklungstools

SublimeText3 Mac-Version

SublimeText3 Mac-Version

Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen

Java-Tutorial
1663
14
PHP-Tutorial
1263
29
C#-Tutorial
1236
24
So implementieren Sie ein Online-Spracherkennungssystem mit WebSocket und JavaScript So implementieren Sie ein Online-Spracherkennungssystem mit WebSocket und JavaScript Dec 17, 2023 pm 02:54 PM

So implementieren Sie mit WebSocket und JavaScript ein Online-Spracherkennungssystem. Einführung: Mit der kontinuierlichen Weiterentwicklung der Technologie ist die Spracherkennungstechnologie zu einem wichtigen Bestandteil des Bereichs der künstlichen Intelligenz geworden. Das auf WebSocket und JavaScript basierende Online-Spracherkennungssystem zeichnet sich durch geringe Latenz, Echtzeit und plattformübergreifende Eigenschaften aus und hat sich zu einer weit verbreiteten Lösung entwickelt. In diesem Artikel wird erläutert, wie Sie mit WebSocket und JavaScript ein Online-Spracherkennungssystem implementieren.

WebSocket und JavaScript: Schlüsseltechnologien zur Implementierung von Echtzeitüberwachungssystemen WebSocket und JavaScript: Schlüsseltechnologien zur Implementierung von Echtzeitüberwachungssystemen Dec 17, 2023 pm 05:30 PM

WebSocket und JavaScript: Schlüsseltechnologien zur Realisierung von Echtzeit-Überwachungssystemen Einführung: Mit der rasanten Entwicklung der Internet-Technologie wurden Echtzeit-Überwachungssysteme in verschiedenen Bereichen weit verbreitet eingesetzt. Eine der Schlüsseltechnologien zur Erzielung einer Echtzeitüberwachung ist die Kombination von WebSocket und JavaScript. In diesem Artikel wird die Anwendung von WebSocket und JavaScript in Echtzeitüberwachungssystemen vorgestellt, Codebeispiele gegeben und deren Implementierungsprinzipien ausführlich erläutert. 1. WebSocket-Technologie

Verwendung von JavaScript und WebSocket zur Implementierung eines Echtzeit-Online-Bestellsystems Verwendung von JavaScript und WebSocket zur Implementierung eines Echtzeit-Online-Bestellsystems Dec 17, 2023 pm 12:09 PM

Einführung in die Verwendung von JavaScript und WebSocket zur Implementierung eines Online-Bestellsystems in Echtzeit: Mit der Popularität des Internets und dem Fortschritt der Technologie haben immer mehr Restaurants damit begonnen, Online-Bestelldienste anzubieten. Um ein Echtzeit-Online-Bestellsystem zu implementieren, können wir JavaScript und WebSocket-Technologie verwenden. WebSocket ist ein Vollduplex-Kommunikationsprotokoll, das auf dem TCP-Protokoll basiert und eine bidirektionale Kommunikation zwischen Client und Server in Echtzeit realisieren kann. Im Echtzeit-Online-Bestellsystem, wenn der Benutzer Gerichte auswählt und eine Bestellung aufgibt

So implementieren Sie ein Online-Reservierungssystem mit WebSocket und JavaScript So implementieren Sie ein Online-Reservierungssystem mit WebSocket und JavaScript Dec 17, 2023 am 09:39 AM

So implementieren Sie ein Online-Reservierungssystem mit WebSocket und JavaScript. Im heutigen digitalen Zeitalter müssen immer mehr Unternehmen und Dienste Online-Reservierungsfunktionen bereitstellen. Es ist von entscheidender Bedeutung, ein effizientes Online-Reservierungssystem in Echtzeit zu implementieren. In diesem Artikel wird erläutert, wie Sie mit WebSocket und JavaScript ein Online-Reservierungssystem implementieren, und es werden spezifische Codebeispiele bereitgestellt. 1. Was ist WebSocket? WebSocket ist eine Vollduplex-Methode für eine einzelne TCP-Verbindung.

JavaScript und WebSocket: Aufbau eines effizienten Echtzeit-Wettervorhersagesystems JavaScript und WebSocket: Aufbau eines effizienten Echtzeit-Wettervorhersagesystems Dec 17, 2023 pm 05:13 PM

JavaScript und WebSocket: Aufbau eines effizienten Echtzeit-Wettervorhersagesystems Einführung: Heutzutage ist die Genauigkeit von Wettervorhersagen für das tägliche Leben und die Entscheidungsfindung von großer Bedeutung. Mit der Weiterentwicklung der Technologie können wir genauere und zuverlässigere Wettervorhersagen liefern, indem wir Wetterdaten in Echtzeit erhalten. In diesem Artikel erfahren Sie, wie Sie mit JavaScript und WebSocket-Technologie ein effizientes Echtzeit-Wettervorhersagesystem aufbauen. In diesem Artikel wird der Implementierungsprozess anhand spezifischer Codebeispiele demonstriert. Wir

Einfaches JavaScript-Tutorial: So erhalten Sie den HTTP-Statuscode Einfaches JavaScript-Tutorial: So erhalten Sie den HTTP-Statuscode Jan 05, 2024 pm 06:08 PM

JavaScript-Tutorial: So erhalten Sie HTTP-Statuscode. Es sind spezifische Codebeispiele erforderlich. Vorwort: Bei der Webentwicklung ist häufig die Dateninteraktion mit dem Server erforderlich. Bei der Kommunikation mit dem Server müssen wir häufig den zurückgegebenen HTTP-Statuscode abrufen, um festzustellen, ob der Vorgang erfolgreich ist, und die entsprechende Verarbeitung basierend auf verschiedenen Statuscodes durchführen. In diesem Artikel erfahren Sie, wie Sie mit JavaScript HTTP-Statuscodes abrufen und einige praktische Codebeispiele bereitstellen. Verwenden von XMLHttpRequest

So verwenden Sie insertBefore in Javascript So verwenden Sie insertBefore in Javascript Nov 24, 2023 am 11:56 AM

Verwendung: In JavaScript wird die Methode insertBefore() verwendet, um einen neuen Knoten in den DOM-Baum einzufügen. Diese Methode erfordert zwei Parameter: den neuen Knoten, der eingefügt werden soll, und den Referenzknoten (d. h. den Knoten, an dem der neue Knoten eingefügt wird).

JavaScript und WebSocket: Aufbau eines effizienten Echtzeit-Bildverarbeitungssystems JavaScript und WebSocket: Aufbau eines effizienten Echtzeit-Bildverarbeitungssystems Dec 17, 2023 am 08:41 AM

JavaScript ist eine in der Webentwicklung weit verbreitete Programmiersprache, während WebSocket ein Netzwerkprotokoll für die Echtzeitkommunikation ist. Durch die Kombination der leistungsstarken Funktionen beider können wir ein effizientes Echtzeit-Bildverarbeitungssystem erstellen. In diesem Artikel wird erläutert, wie dieses System mithilfe von JavaScript und WebSocket implementiert wird, und es werden spezifische Codebeispiele bereitgestellt. Zunächst müssen wir die Anforderungen und Ziele des Echtzeit-Bildverarbeitungssystems klären. Angenommen, wir haben ein Kameragerät, das Bilddaten in Echtzeit sammeln kann

See all articles