11-05-react组件的生命周期

问:react.js中的核心是什么?
答:组件。

问:react中组件的核心是什么?
答:状态 组件的生命周期。

生命周期函数:
又叫钩子函数,一个组件从出生到死亡,这个过程会自动地调用一个函数,这个函数我们叫钩子函数,又叫生命周期函数。

旧版生命周期函数

React v16.0前的生命周期
在这里插入图片描述

initalizaion 初始化

使用constructor()来完成初始化

setup props and state 设置组件初始化属性 和 状态
    static defaultProps = {  // 初始默认属性
        name:"计数器"
    }
    constructor(props) {
        super(props);
        // 初始化状态机
        this.state = {
            number:0
        }
    }

Mounting 挂载阶段

挂载:把虚拟DOM转成真实DOM,塞到页面上的过程

componentWillMount

在组件挂载到DOM前调用,且只会被调用一次。但不适合ajax请求

render

组件挂载
不能发送ajax请求,原因是render不只在第1次挂载时调用,后面只要状态或属性发生改变,也会重新render。

componentDidMount

组件挂载到DOM后调用,且只会被调用一次。
在这个钩子,可以获取DOM元素。
一般这里发起ajax请求。

Updation

属性props变化

  • componentWillReceiveProps:组件收到属性时,将被调用,首次渲染不会触发。
  • shouldComponentUpdate:参数:接收的新的数据
    询问组件是否更新,组件中不写这个钩子,默认返回true,如果写了这个钩子函数,就要指明,是返回true,还是返回false
    返回true: 更新,继续执行下面的钩子
    返回false: 不允许更新,停止执行下面的钩子函数
  • componentWillUpdate: 组件更新这前调用
  • render: 根据接收的新的数据,重新挂载(渲染)组件
  • componentDidUpdate:组件更新完毕

状态state变化

  • shouldComponentUpdate:参数:接收的新的数据
    询问组件是否更新,组件中不写这个钩子,默认返回true,如果写了这个钩子函数,就要指明,是返回true,还是返回false
    返回true: 更新,继续执行下面的钩子
    返回false: 不允许更新,停止执行下面的钩子函数
  • componentWillUpdate: 组件更新这前调用
  • render: 根据接收的新的数据,重新挂载(渲染)组件
  • componentDidUpdate:组件更新完毕

Unmounting

componentWillUnmount 组件卸载之前调用

新版生命周期函数

新版的生命周期函数废弃了三个钩子:

  • componentWillMount
  • componentWillUpdate
  • componentWillReceiveProps

新版的生命周期函数中添加了两个钩子函数:

  • getDerivedStateFromProps
  • getSnapshotBeforeUpdate

在这里插入图片描述

创建阶段:

  • constructor: 初始化属性和状态
  • getDerivedStateFromProps: 传递的属性映射成状态 静态方法 可以把属性映射成状态
  • render: 挂载(渲染)组件
  • componentDidMount:组件挂载完毕

更新阶段:

  • getDerivedStateFromProps:传递的属性映射成状态 静态方法 可以把属性映射成状态

  • shouldComponentUpdate: 询问组件是否更新

  • render: 渲染 挂载组件

  • getSnapshotbeforeUpdate:获取更新前的一个快照

  • componentDidUpdate: 组件更新完成

卸载阶段(Unmounting):

  • componentWillUnmount 组件卸载之前调用

代码

旧版生命周期函数

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <script src="./js/react.development.js"></script>
    <script src="./js/react-dom.development.js"></script>
    <script src="./js/prop-types.js"></script>
    <script src="./js/babel.js"></script>
</head>
<body>
    <div id="root"></div>
    <script type="text/babel">
        class Counter extends React.Component {
            static defaultProps = {  // 初始默认属性
                name:"计数器"
            }
            constructor(props) {
                super(props);
                // 初始化状态机
                this.state = {
                    number:0
                }
                console.log("1.父的constructor初始化状态")
            }
            componentWillMount(){
                console.log("2.父的componentWillMount 将要挂载")
            }
            render(){
                console.log("3.父的render渲染,也就是挂载")
                return(
                    <div style={{border:"1px solid green"}}>
                        {this.props.name} : {this.state.number}
                        <button style={{display:"block"}} onClick={ e=>this._add(e) }>+</button>
                        { this.state.number % 3 !== 0 && <SubCounter number={this.state.number}></SubCounter> }
                    </div>
                )
            }
            _add(){
                // 更新状态机
                this.setState({
                    number:this.state.number+1
                })
            }
            componentDidMount(){
                console.log("4.父的compoentDidMount,组件挂载完毕")
            }
            shouldComponentUpdate(){
                console.log("5.父的shouldComponentUpdate,询问组件是否可以更新")
                // return false; // 不更新
                return true; // 更新
            }
            componentWillUpdate(){
                console.log("6.父的componentWillUpdate,组件将要更新")
            }
            componentDidUpdate(){
                console.log("6.父的componentDidUpdate,组件更新完毕")
            }
        }
        class SubCounter extends React.Component {
            static defaultProps = {
                number:10
            }

            constructor(props) {
                super(props);
                console.log("a.子的constructor初始化状态")
            }
            componentWillMount(){
                console.log("b.子的componentWillMount 将要挂载")
            }
            componentWillReceiveProps(){
                // 此钩子函数,在第1次子组件挂载时,并不会执行
                console.log("e.子的componentWillReceiveProps 接收父的属性(数据)")
            }
            shouldComponentUpdate(nextProps){
                console.log("f.子的shouldComponentUpdate访问组件是否可以更新");
                console.log(nextProps)
                if(nextProps.number % 3 === 0){
                    return true;
                }
                return false;
            }
            render(){
                console.log("c.子的render渲染,也就是挂载")
                return(
                    <div style={{border:"10px solid red"}}>
                        {this.props.number}
                    </div>
                )
            }
            componentDidMount(){
                console.log("d.子的compoentDidMount,组件挂载完毕")
            }
            componentWillUnmount(){
                console.log("g.子的componentWillUnmount,组件将要卸载")
            }
        }
        ReactDOM.render(<Counter />,document.getElementById("root"));
    </script>
</body>
</html>

新版版生命周期函数

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <script src="./js/react.development.js"></script>
    <script src="./js/react-dom.development.js"></script>
    <script src="./js/prop-types.js"></script>
    <script src="./js/babel.js"></script>
</head>
<body>
    <div id="root"></div>
    <script type="text/babel">
        class Counter extends React.Component {
            constructor(props) {
                super(props);
                this.state = {
                    number:0
                }
            }
            render(){
                return(
                    <div>
                        <p>{this.state.number}</p>
                        <button onClick={e=>this._add(e)}>+</button>
                        <hr />
                        <SubCounter number={this.state.number}></SubCounter>
                    </div>
                )
            }
            _add(){
                this.setState({
                    number:this.state.number+1
                })
            }
        }
        class SubCounter extends React.Component {
            constructor(props) {
                super(props);
                // 之前要更新状态,你需要通过this.setState({})
                this.state = {
                    number:0
                }
            }
            static getDerivedStateFromProps(nextProps,prevState){  // 把父组件传递给子组件的数据,映射成子组件的状态
                if(nextProps.number % 2 === 0){
                    return{
                        number:nextProps.number*2
                    }
                }else{
                    return {
                        number:nextProps.number*3
                    }
                }
            }
            render(){
                console.log(this.state)
                return(
                    <div>
                        <p>{this.state.number}</p>
                    </div>
                )
            }
        }
        ReactDOM.render(<Counter />,document.getElementById("root"));
    </script>
</body>
</html>

ajax请求

问:在constructor这个钩子中发送ajax请求,OK吗?
答:不好,如果发送ajax失败,可能报错,或者说,你的ajax请求时长很多,那么组件就渲染不出来,页面就是白屏。

问:在componentWillMount这个钩子中发送ajax请求,OK吗?
答:如果是SSR,此钩子会调用两次,此钩子,已经废弃了,也不推荐在这个钩子函数中发起ajax请求。

问:在componentDidMount这个钩子中发送ajax请求,OK吗?
答:1)render已经执行了,组件已经渲染出来的,页面不是白屏了。它只会调用一次。

生命周期函数详解

1)constructor(props)
react组件的构造函数, 在挂载之前被调用。在实现React.Component构造函数时,需要先在添加其他内容前,调用super(props),用来将父组件传来的props绑定到这个类中,使用this.props将会得到。
constructor中应当做些初始化的行为,如:初始化state,将事件处理函数绑定到类实例上,但不要使用setState()。如果没有必要初始化state或绑定方法,则不需要构造constructor,或者把这个组件换成纯函数写法。
可以利用props初始化state,在之后修改state不会对props造成任何修改,但仍然建议提升状态到父组件中,或使用redux统一进行状态管理。
官方建议不要在constructor引入任何具有副作用和订阅功能的代码,这些应当在componentDidMount()中写入。

2)getDerivedStateFromProps(nextProps, prevState)
	getDerivedStateFromProps在组件实例化后,或者接受新的props后被调用。他返回一个对象来更新状态,或者返回null表示新的props不需要任何state的更新。
	如果是由于父组件的props更改,所带来的重新渲染,也会触发此方法。调用steState()不会触发getDerivedStateFromProps()。

3)componentWillMount() / UNSAFE_componentWillMount()
	componentWillMount()将在react未来版本中被弃用; UNSAFE_componentWillMount()在组件挂载前被调用,在这个方法中调用setState()不会起作用,因为它在render()前被调用。
	为了避免副作用和其他的订阅,官方建议使用componentDidMount()代替。这个方法也是用于在服务器渲染上的唯一方法。

4)render()
	render()方法是必需的。当被调用时,将计算this.props和this.state,并返回以下一种类型:
	a) React元素, 通过jsx创建,既可以是dom元素,也可以是用户自定义的组件。
	b) 字符串或数字, 他们将会以文本节点形式渲染到dom中。
	c) Portals, react 16版本中提出的新的解决方案,可以使组件脱离父组件层级直接挂载在DOM树的任何位置。
	d) null, 什么也不渲染。
	e) 布尔值, 也是什么都不渲染,通常后跟组件进行判断。
	f)  当返回null,false,ReactDOM.findDOMNode(this)将会返回null,什么都不会渲染。
	注意: render()方法必须是一个纯函数,不能在里面改变state,也不能直接和浏览器进行交互,而是应该将事件放在其他生命周期函数中。 如果shouldComponentUpdate()返回false,render()不会被调用。

5)componentWillReceiveProps()
	官方建议使用getDerivedStateFromProps函数代替componentWillReceiveProps()。
	当组件挂载后,接收到新的props后会被调用。如果需要更新state来响应props的更改,则可以进行this.props和nextProps的比较,并在此方法中使用this.setState()。如果父组件会让这个组件重新渲染,即使props没有改变,也会调用这个方法。
	react不会在组件初始化props时调用这个方法,  调用this.setState也不会触发。

6)shouldComponentUpdate(nextProps, nextState)
	调用shouldComponentUpdate, 可以让react知道组件的输出是否受state和props的影响。默认每个状态的更改都会重新渲染,大多数情况下应该保持这个默认行为。在渲染新的props或state前,shouldComponentUpdate会被调用, 默认为true。这个方法不会在初始化时被调用,也不会在forceUpdate()时被调用。返回false不会阻止子组件在state更改时重新渲染。
	如果shouldComponentUpdate()返回false,componentwillupdate,render和componentDidUpdate不会被调用。在未来版本,shouldComponentUpdate()将会作为一个提示而不是严格的指令,返回false仍然可能导致组件的重新渲染。官方并不建议在shouldComponentUpdate()中进行深度查询或使用JSON.stringify(),他效率非常低,并且损伤性能。

7)UNSAFE_componentWillUpdate(nextProps, nextState)
	在渲染新的state或props时,UNSAFE_componentWillUpdate会被调用,将此作为在更新发生之前进行准备的机会。这个方法不会在初始化时被调用。不能在这里使用this.setState(),也不能做会触发视图更新的操作。如果需要更新state或props,调用getDerivedStateFromProps。

8)getSnapshotBeforeUpdate()
	在react render()后的输出被渲染到DOM之前被调用。它让组件能够在它们被潜在更改之前捕获当前值(如滚动位置)。这个生命周期返回的任何值都将作为参数传递给componentDidUpdate()。

9)componentDidUpdate(prevProps, prevState, snapshot)
	调用shouldComponentUpdate, 可以让react知道组件的输出是否受state和props的影响。默认每个状态的更改都会重新渲染,大多数情况下应该保持这个默认行为。在渲染新的props或state前,shouldComponentUpdate会被调用, 默认为true。这个方法不会在初始化时被调用,也不会在forceUpdate()时被调用。返回false不会阻止子组件在state更改时重新渲染。
	如果shouldComponentUpdate()返回false,componentwillupdate,render和componentDidUpdate不会被调用。在未来版本,shouldComponentUpdate()将会作为一个提示而不是严格的指令,返回false仍然可能导致组件的重新渲染。官方并不建议在shouldComponentUpdate()中进行深度查询或使用JSON.stringify(),他效率非常低,并且损伤性能。
©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页
实付 9.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值