구성 요소의 생명주기에 반응하는 방법--그것들은 무엇입니까?

소개하다.👋


React의 각 어셈블리에는 고유의 라이프 사이클이 있습니다.하지만 깊이 연구하기 전에🤔 우리는 React 구성 요소의 생명 주기가 도대체 무엇인지 알아야 한다. 왜 나는 그것을 알아야 합니까?

라이프 사이클은 구성 요소가 존재하는 다양한 단계에서 실행되는 일련의 방법일 뿐입니다.모든react 구성 요소에는 몇 가지 "생명주기 방법"이 있습니다.프로세스에서 특정 시간에 특정 코드를 실행할 때 덮어쓸 수 있도록 이 방법들을 이해해야 한다.

🌱 반응 성분의 상


구성 요소는 4단계로 구성됩니다.

  • 마운트: 이 단계에서 구성 요소가 초기화되고 DOM에 삽입됩니다.

  • 업데이트: 이미 하나의 구성 요소가 DOM에 나타나면, 모든 업데이트는 업데이트 단계의 일부분으로 이 구성 요소에 진행됩니다.

  • 오류 처리: 이 단계는 라이프스케일 방법, 구조 함수 또는 다른 하위 구성 요소에서 발생할 때 발생하는 오류를 처리합니다.

  • 제거: 이 단계에서 DOM에서 구성 요소를 제거하고 정리 활동을 완료합니다.

  • 🧬 라이프 사이클 방법


    이제 React 구성 요소의 다양한 단계를 알았습니다. 단계별로 호출되는 라이프 사이클 방법에 대해 알아보겠습니다.

    1🐇 설치 단계:


    이 단계에서 구성 요소는 구조 함수에서 초기화된 도구와 상태로 만들어집니다.도구와 상태가 준비되면 구성 요소는 DOM에 마운트되어 웹 페이지에 처음 나타납니다.
    설치 단계는 다음과 같습니다.

    1. 구조 함수():

  • 이것은 모든 구성 요소를 호출하는 첫 번째 방법입니다.
  • 구조 함수의 주요 목적은 도구와 상태를 초기화하는 것이다.이외에도 이벤트를'this'(즉 실례)와 귀속시킨다.
  • 구조 함수는 슈퍼()에 대한 호출과 이 함수의 초기화를 포함한다.주 정부.
  • 기억해야 할 것은 상태의 초기화도 구조 함수 () 방법 없이 완성할 수 있고 작업 원리가 같다는 것이다.
  •   import React from 'react';
    
      class AppComp extends React.Component {
            constructor(props) {
                    super(props);
                    this.state = {
                            title : 'Lifecycle Methods'
                    }
                    console.log('Inside React Component 
      Constructor');
              }
      }
    

    2.getDerivedStateFromProps()

  • DOM에서 구성 요소를 보여주기 전에 getDerivedStateFromProps 방법을 호출합니다.
  • 구성 요소의 상태가 도구에 달려 있을 때 이 방법을 사용합니다.
  • 기본적으로 이런 방법은 구성 요소가 도구에 어떠한 변화가 발생할 때 그 상태를 바꿀 수 있도록 허용한다.
  • 이런 방법은 매우 드물지만 실행 순서를 이해하는 것이 매우 중요하다. 왜냐하면 이런 방법은 설치 단계와 업데이트 단계에서 모두 호출되기 때문이다.
  • 위 코드 세그먼트를 계속합니다.
      import React from 'react';
    
      class AppComp extends React.Component {
            constructor(props) {
                    super(props);
                    this.state = {
                            title : 'Lifecycle Methods'
                    }
                    console.log('Inside React Component 
      Constructor');
              }
    
            static getDerivedStateFromProps(props, state) {
                    console.log('Inside React Component
                            getDerivedStateFromProps');
              }
      }
    

    3. 구현()

  • 우리는 이 방법에서 JSX 코드를 작성했는데 이 코드는 DOM에 나타날 것이다.
  • React에서 어셈블리를 생성할 때 필요한 유일한 방법입니다.
  • 이 방법은 상태를 수정하지 않고 호출할 때마다 같은 결과만 되돌려줍니다.
  • render () 방법은props와state 값을 관찰하고 다음 값 중 하나를 되돌려줍니다.
  • 반응소자
  • 어레이
  • 세그먼트
  • 문자열, 숫자, 부울 값 또는 null
  •   import React from 'react';
    
      class AppComp extends React.Component {
            constructor(props) {
                    super(props);
                    this.state = {
                            title : 'Lifecycle Methods'
                    }
                    console.log('Inside React Component 
      Constructor');
              }
    
            static getDerivedStateFromProps(props, state) {
                    console.log('Inside React Component
                            getDerivedStateFromProps');
              }
    
            render() {
                    console.log('Inside render method');
                    return <div> This is the App Component </div>
            }          
      }
    

    4. 구성 요소 설치()

  • 구성 요소가 DOM 트리를 불러오거나 삽입하면 이 방법이 호출됩니다.
  • render()와 달리 이 방법은 한 번만 호출되며 설치 단계에서도 한 번 호출됩니다.이것은 이 방법을 원격 단점에서 데이터를 불러오거나 네트워크 요청을 보내는 데 가장 적합한 위치로 만들었다.
  • 우리는 심지어 이 방법에서 set State () 방법을 호출하여 상태를 수정하고, 최종적으로render () 를 호출해서DOM의 내용을 업데이트할 수 있다.
  • 이 방법은 렌더 () 방법이 두 번 호출되었음에도 불구하고 사용자가 중간 상태를 보지 못하도록 합니다.
  •   import React from 'react';
    
      class AppComp extends React.Component {
            constructor(props) {
                    super(props);
                    this.state = {
                            title : 'Lifecycle Methods'
                    }
                    console.log('Inside React Component 
      Constructor');
              }
    
            static getDerivedStateFromProps(props, state) {
                    console.log('Inside React Component
                            getDerivedStateFromProps');
              }
    
            componentDidMount(){  
                      console.log("Inside componentDidMount");
             }
    
            render() {
                    console.log('Inside render method');
                    return <div> This is the App Component </div>
            }          
      }
    

    Console Output for the above code:


    아직도 나랑 있어?잠깐 기다리다

    이제 구성 요소의 생명주기 2단계를 살펴보자.

    2👨‍💻 업데이트 단계:

  • 구성 요소의 상태가 변하면 구성 요소의 생명 주기는 업데이트 단계에 들어간다.
  • 설치 및 업데이트 단계에서 흔히 볼 수 있는 방법은 이 단계에서 같은 방법을 다시 사용하기 때문이다.이러한 방법은 다음과 같습니다.

  • getDerivedStateFromProps() 및
  • render()
  • 이러한 방법을 포함하여 갱신 단계에는 모두 5가지 방법이 있다.하나씩 보자
  • 1. 정적 getDerivedStateFromProps()

  • 구성 요소의 업데이트 단계에서 구성 요소가 새로운 도구를 받을 때마다, setState () 방법으로 기존 상태를 업데이트할 때마다 이 방법을 사용합니다.
  • 여기서 확보해야 할 점은 이런 방법에서 HTTP 요청이나 Ajax 호출 등이 있어서는 안 된다는 것이다.
  • 2.shouldComponentUpdate()

  • 상태가 변하면 이 방법을 사용합니다.
  • 새로운 도구나 상태를 받았을 때 구성 요소를 다시 보여줄지 여부를 결정합니다.render () 방법 이전에 그것을 호출하는 것과 같습니다.
  • 기존 상태가 변할 때만 호출되기 때문에 이 방법은 설치 단계에 존재하지 않습니다.
  • nextProps와nextState를 함수 매개 변수로 받아들인다.
  • shouldComponentUpdate(nextProps, nextState)

  • 이 방법이false로 되돌아오면 React에서 업데이트를 건너뛸 수 있음을 알립니다.
  • 3. 구현()

  • render () 방법은 업데이트 단계의 기능과 설치 단계의 기능이 같다.
  • 4.getSnapshotBeforeUpdate()

  • 가상 DOM에서 실제 DOM의 변경 사항을 업데이트하기 전에 이 방법을 호출합니다.
  • DOM에서 정보를 캡처하는 데 사용됩니다.예: 스크롤 위치 등 관찰
  • 이것은 마지막 호출로 이전의 상태/아이템 검사 데이터를 사용하는 데 사용됩니다.
  • 이 방법은 값이나null을 되돌려줍니다.반환 값이 무엇이든지 간에 그것은 세 번째 매개 변수로 다음 방법에 전달될 것이다.
  • 5. 어셈블리 업데이트()

  • 이것은 업데이트 단계의 최종 방법이다.
  • DOM에서 모든 변경 사항을 업데이트한 후 호출합니다.
  • 그 문법은 다음과 같다.
  • componentDidUpdate(prevProps, prevState, snapShot)

  • 세 번째 인자인 스냅샷은 getsnapshot Before Update () 방법으로 되돌아오는 값입니다.
  • 다음 코드를 사용하여 업데이트 단계를 살펴보겠습니다.

    Child.js:


    import React, { Component } from 'react';  
    
    class Child extends Component{  
            constructor(props){  
                    super(props);  
                    this.state={  
                            value:'React Application'  
                    }  
                    console.log("Inside child constructor");  
            }  
    
            static getDerivedStateFromProps(props,state){  
                    console.log("Inside child getDerivedStateFromProps");  
                    return null;  
            }  
    
            componentDidMount(){  
                    console.log("Inside child componentDidMount");  
             }  
    
            shouldComponentUpdate(){  
                    console.log("Inside child shouldComponentUpdate");  
                    return true;  
            }  
    
            getSnapshotBeforeUpdate(prevProps,prevState){  
                    console.log("inside child getSnapshotBeforeUpdate");  
                    return null;  
            }  
    
            componentDidUpdate(){  
                    console.log("Inside child componentDidUpdate");  
            }  
    
            render(){  
                    console.log("Inside child render");  
                    return <div/>  
            }  
    }  
    
    export default LifecycleChild;
    

    App.js


    import React,{Component} from 'react';  
    import Child from './Child';  
    
    class App extends Component{  
            constructor(props){  
                    super(props);  
                    this.state={  
                            value:'React Application'  
                    }  
                    this.changeState = this.changeState.bind(this);  
                    console.log("Inside constructor");  
            }  
    
            static getDerivedStateFromProps(props,state){  
                    console.log("Inside getDerivedStateFromProps");  
                    return null;  
            }  
    
            componentDidMount(){  
                    console.log("Inside componentDidMount");  
            }  
    
            shouldComponentUpdate(){  
                    console.log("Inside shouldComponentUpdate");  
                    return true;  
            }  
    
            getSnapshotBeforeUpdate(prevProps,prevState){  
                    console.log("Inside getSnapshotBeforeUpdate");  
                    return null;  
            }  
    
            componentDidUpdate(){  
                    console.log("Inside componentDidUpdate");  
            }  
    
            changeState = () => {   
                    this.setState({  
                            value : "React Application started"  
                    })  
            }  
    
            render(){  
                    console.log("Inside render");  
                    return(  
                            <div>  
                                    <div>React Parent</div>  
                                    <button onClick={this.changeState}>Click Me</button>  
                                    <Child />
                            </div>  
                    );  
            }  
    }  
    
    export default App; 
    

    Console Outputs:

    1. During Mounting..

    1. During Updating (On clicking the "Click Me")...

    Notice that all the console outputs are in the order for all the methods as per the lifecycle. But there is a small different in calling of getSnapshotBeforeUpdate().
    For the getSnapshotBeforeUpdate() method, the child's method is called before the Parent's method. Once called, all the other Parent's methods are called.


    주의: 업데이트 단계에서 5가지 방법을 보았지만, 가장 자주 사용하는 방법은render () 와componentDidUpdate () 이며, 그 중에서render () 가 유일한 강제 방법입니다.

    셋.🥂 제거 단계

  • 구성 요소가 DOM에서 제거될 때 React 구성 요소는 업데이트 단계를 거친 후에 이 단계로 들어갑니다.
  • 이 단계는 1가지 방법으로만 사용됩니다. 즉,
  • 구성 요소가 제거됩니다()

  • DOM에서 어셈블리를 제거하기 전에 이 메서드를 호출합니다.이러한 제거는 제거할 수도 있고 제거할 수도 있습니다.
  • 우리는 이 방법에서 set State () 방법을 영원히 사용하지 않도록 확보해야 한다.
  • 이유는 component Will Unmount() 방법은 모든 React 구성 요소의 생명주기의 마지막 단계로 마운트 해제되면 다시 마운트하지 않기 때문이다.또한 setState () 방법은 DOM에서 내용을 다시 보여 주기 때문에 불가능하다.

  • 사용법: 이 방법은 청결 과정에 사용할 수 있습니다.예를 들어 열려 있는 모든 연결을 닫거나 네트워크 요청을 취소하거나 이벤트 처리 프로그램을 삭제하는 등
  • 요약:


    따라서 모든 React 구성 요소의 생명 주기에는 설치, 업데이트, 마운트 해제 단계가 다르다.오류 처리 단계라고 하는 또 다른 단계는 getDerivedStateFromError()componentDidCatch() 두 가지 방법을 포함한다.

    Thanks for Reading.. 🔚

    좋은 웹페이지 즐겨찾기