当前位置: 首页 > news >正文

react hooks讲解--通俗易懂版

面试必备!

useState:状态管理

useState有两个状态,一个是status,一个是setStatus

setStatus修改数据后,会触发<App/>的re-render

什么是re-render?

re-render:重新渲染,re-render并不意味着dom会更新,re-render是react自身执行一系列的组件自身生命周期,render,虚拟dom之间diff之后,如果dom发生变化,则更新新的dom,如果没有变化则不更新。

以下情况会导致re-render:

  1. 组件内部state变化:无论这个声明的state在组件的render中是否使用,state的变化都会导致组件自身及其子节点的re-render;
  2. 组件的props变化:这是站在子组件的角度上得出的结论,而子组件props变化来源于父组件的state,究其根本,还是组件内部state发生了变化;
  3. 用户交互事件触发或者接口请求数据响应;
  4. 组件订阅的context发生变化:组件订阅的context发生变化,是由于provider中的state发生了变化,同理,还是因为state发生变化导致的re-render
  5. 父组件的render:父组件render,子组件就会re-render.除非子组件是一个纯组件(纯组件:即他的props没有发生变化,那么他就不会更新,可以使用React.memo(),React.PureComponent将组件变为纯组件。)

如何避免不必要的re-render?

  1. 使用类组件PureComponent:引入PureComponent,在需要用到Component的地方修改为PureComponent
    import {PureComponent} from 'react';
    export class Root extends PureComponent{
    ...
    }//或者直接继承
    //export class Root extends React.PureComponent{...}
  2. 使用函数组件Memo:父组件中修改state时,下面这个子组件如果没有用到这个state,则不会re-render。换言之,react.memo()是校验props中数据的内存地址是否改变来决定是否重新渲染
    
    import { memo } from "react"
    const Memodemo=({props,children})=>{console.log('Memodemo')return <><p>这里用的是memo</p></>}export default memo(Memodemo)
  3. 利用高阶组件shouldComponentUpdate:组件在重新渲染之前(也就是虚拟dom对比完毕并生成最终dom之后),会调用该函数,该函数将是否重新渲染的权限交给开发者,若该函数返回true,则更新dom
    //下面这个示例,仅在value变化时发生dom更新,否则跳过dom更新
    class MyComponent extends React.Copmonent{shouldComponentUpdate(nextProps,nextState){return nextProps.value!===this.props.value}
    }
    //nextProps:即将传入的新的props
    //nextState:即将传入的新的state

useEffect:

useEffect接受两个参数,第一个参数是一个函数,必传,可以看作componentDidMount、componentDidUpdate、componentWillUnmount这三个函数的组合

useEffect中第一个参数如果添加了return返回一个函数,切换路由时,就会执行这个return返回的函数,相当于componentWillUnmount。

第二个参数可以不传或者传一个数组

那么useEffect会出现以下四种使用情况:

  1. 不传递第二个参数,当前组件每次渲染都会执行,包括state的每次更新都会触发useEffect
    useEffect(()=>{console.log('useEffect')}
    )
  2. 第二个参数传递空数组:只在挂载和卸载的时候执行
    useEffect(()=>{
    console.log('useEffect[]')
    },[])
  3. 第二个参数传递一个值
    useEffect(
    ()=>{
    console.log('当page发生修改的时候,会输出此行');
    },[page])
  4. 第二个参数传递多个值:数组中的任意一个或者多个发生变化,useEffect都会重新运行一次;
    useEffect(()=>{console.log('useEffect');
    },[level,level1])

componentDidMount :react在组件添加到屏幕上(挂在)后调用它,一般用于进入页面后,数据初始化

componentDidUpdate:页面中的state或者model中的state定义的变量发生了变化,这个方法就会执行;

componentWillUnmount:组件被移除屏幕(卸载)之前调用

这三个类生命周期和useEffect等同方式,看下面代码:

//类生命周期
class Example extends React.Component{constructor(props){super(props);this.state={count:0,dateNow:''}}componentDidMount(){    console.log('当前count=',this.state.count)this.timeFlag=setInterval(()=>{this.setState.dateNow=new Date()})}componentDidUpdate(){console.log('当前更新为count=',this.state.count)}componentWillUnmount(){clearInterval(this.timeFlag)}render(){return(<div><p>当前count={this.state.count}</P><p>当前时间={this.state.dateNow}</P><button onClick={()=>{this.state.count=this.state.count+1}}>count+1</button></div>)    }
}
//上面的类生命周期代码,等同于下面的代码
import {useState,useEffect} from 'react';
const Example=()=>{const [count,setCount]=useState(0);const [dateNow,setDateNow]=useState('');
//下面这一行没有写第二个参数,所以,当state中的变量发生变化时,这里的useEffect就会调用useEffect(()=>{console.log('当前count=',count)})
//这一行只有count发生变化,才会调用useEffectuseEffect(()=>{ console.log('当前更新为count=',count)},[count])uesEffect(()=>{const timeFlag=setInterval(()=>{setDateNow(new Date())        })return()=>{clearInterval(timeFlag)}},[])return(<div><p>当前count={count}</P><p>当前时间={dateNow}</P><button onClick={()=>{setCount(count+1)}}>count+1</button></div>)
}

useMemo:性能优化工具,主要解决使用react hooks产生的无用渲染的性能问题,类似于vue的computed,可以缓存计算结果,用于跳过昂贵的计算

useMemo使用方式为:useMemo(fn,arr);

第二个参数arr分以下几种情况:

  1. 不传,即useMemo(fn):每次更新都会重新计算
  2. arr=空数组[]:只会计算一次;
  3. arr=[a]:当a发生变化的时候,会重新执行fn;

useMemo的作用时跳过昂贵的计算,那我们看以下几个例子:

//当x或者y发生变化,组件re-render时,a都会进行重新计算,可以看到time的计算时间都是很长的
import { useMemo, useState } from "react"
const MemoPage=()=>{const [x,setX]=useState(1);const [y,setY]=useState(1);console.time('time')
let a=0;
for(var i=0;i<100000000;i++){a=a+i+y
}console.timeEnd('time')return(<><div>x={x}</div><div>y={y}</div><div>x={a}</div><div><button onClick={()=>setX(x+1)}>x++</button><button onClick={()=>setY(y+1)}>y++</button></div></>)
}
export default MemoPage

//用useMemo返回一个a,无论x还是y发生了修改, x={a}取的都是缓存中的a的值,不会进行重新计算,可以看到下图,time的计算时间变短
import { useMemo, useState } from "react"
const MemoPage=()=>{const [x,setX]=useState(1);const [y,setY]=useState(1);console.time('time')let a= useMemo(()=>{let a=0;for(var i=0;i<100000000;i++){a=a+i}return a},[])
//上面的[]必须写,如果不写,当x或者y发生修改,则a还是会重新计算console.timeEnd('time')return(<><div>x={x}</div><div>y={y}</div><div>x={a}</div><div><button onClick={()=>setX(x+1)}>x++</button><button onClick={()=>setY(y+1)}>y++</button></div></>)
}
export default MemoPage

//上面的代码a是固定不变的,假如,a是变化的呢?
//下面代码,当x发生变化时,a仍然取缓存,当y发生变化时,则重新计算
import { useMemo, useState } from "react"
const MemoPage=()=>{const [x,setX]=useState(1);const [y,setY]=useState(1);console.time('time')let a= useMemo(()=>{let a=0;for(var i=0;i<100000000;i++){a=a+i+y}return a},[y])console.timeEnd('time')return(<><div>x={x}</div><div>y={y}</div><div>x={a}</div><div><button onClick={()=>setX(x+1)}>x++</button><button onClick={()=>setY(y+1)}>y++</button></div></>)
}
export default MemoPage

上面是useMemo的主要作用

还有一些扩展作用 ,这些只是能达到效果,不是useMemo的主要作用

import { memo, useMemo, useState ,useRef} from "react";
const Child=memo(({a})=>{console.log('子组件')return <><div>子组件</div></>
})
const MemoPage=()=>{const [x,setX]=useState(1);const [y,setY]=useState(1);// let a=['a','b','c'];//直接写这一行,当x或者y发生变化时,子组件还是会重新渲染let a=useMemo(()=>['a','b','c'],[])//这一行子组件不会重新渲染
//    const [a,setA]=useState(['a','b','c'])//这一行子组件也不会重新渲染
// let a=useRef(['a','b','c']);//下面的子组件修改为<Child a={a.current}/>,也能达到一样效果console.log('父组件')return(<><div>x={x}</div><div>y={y}</div>{/* <div>x={a}</div> */}<div><button onClick={()=>setX(x+1)}>x++</button><button onClick={()=>setY(y+1)}>y++</button></div><Child a={a}/></>)
}
export default MemoPage

memo和useMemo的区别和相同点是什么呢?

区别:

  1. 用途:useMemo是一个hook,用于记忆计算结果,可以在组件重新渲染时避免重新计算某些值,从而提升性能;react.memo是一个高阶组件,用于记忆组件的渲染结果,可以在父组件re-render时避免重新渲染子组件,从而提升性能。
  2. 使用场景:假设有一个昂贵的计算(简易理解为超大数字计算),可以用useMemo缓存计算结果,当依赖的变量发生变化时,再从新计算;react.memo用于当一个纯函数组件,渲染结果仅仅依赖于props时,react.memo可以避免不必要的重新渲染;
  3. 语法方面也有所不同;
  4. 返回值:useMemo返回计算结果值,用户缓存计算后的状态;react.memo翻译一个新的组件。

    总结:useMemo用于记忆计算结果,避免重复计算,适用于需要缓存计算结果的场景;
    react.memo用于记忆组件的渲染结果,避免重复渲染,适用于纯函数组件,避免不必要的重新渲染。

相同点:

  1. 两者都是为了性能优化,减少不必要的计算或者渲染;
  2. 两者都接受一个依赖项数组,用于决定是否需要重新计算或者渲染。

useCallback:主要作用是缓存一个回调函数,确保组件在re-render时不会重新创建新的回调函数,优化函数性能。需要搭配React.memo()使用。

重点:useCallback的作用不是阻止函数创建,而是依赖不变的情况下,返回旧函数地址。

import { useCallback, useState } from "react"
const CallPage=()=>{const [state,setState]=useState(1)const a=useCallback(()=>{console.log('a',state)},[])const b=()=>{console.log('b',state)}return <><button onClick={()=>{a();b();setState(state+1)}}>btn</button></>
}
export default CallPage

比如上面的代码,点击 btn的时候,a(),返回的count不变,但是b()返回的count永远+1

每一个被useCallback的函数都会被加入到useCallback内部管理队列,一个使用了useCallback的函数在组件重新渲染时,会去useCallback内部管理队列中寻找校验依赖是否改变并校验。在这个过程中,寻找指定函数和校验都需要性能,如果滥用useCallback会增加寻找指定函数和校验依赖是否改变两个功能,为项目增加不必要的负担。

什么时候使用useCallback?

import { memo, useCallback, useState } from "react"
const Child1=memo(()=>{console.log('Child1')return<></>
})
const Child2=memo((props)=>{console.log('Child2')return<></>
})
const Child3=memo((props)=>{console.log('Child3')return<></>
})
const CallPage=()=>{const [state,setState]=useState(1)const fn=()=>{console.log('点击btn')}const fns=useCallback(()=>{console.log('点击btn')},[])return<><button onClick={()=>{setState(state+1)}}>btn</button><Child1 /><Child2 fn={fn}/><Child3 fn={fns}/></>
}
export default CallPage

上面的代码,child1没有传参,当父组件state更新的时候,child1对比到props没有发生变化,于是不更新;

child2,不行,会重新渲染;因为父组件re-render的时候,会重构父组件中的所有函数,也就是所有函数的内存地址发生了变化,在child2中,react.memo检测到props中的数据的栈的地址发生了变化,所以child2也会重新渲染。

child3,传参fns,被useCallback保护着,父组件re-render时,从useCallback的内部管理队列返回旧的内存地址,因此,子组件不会检测到地址变化,也就不会重新渲染。

useRef:创建一个容器

用途:

  1. 访问dom节点(多用于表单)
    import { useEffect, useRef } from "react"const Refpage=()=>{const ref1=useRef(null)useEffect(()=>{console.log(ref1)},[])return<><div ref={ref1}>ref</div></>
    }
    export default Refpage
  2. 存储任意可变的值(可以用到页面的定时器上)
    引用的值在组件re-render时(也就是整个生命周期内)是不会修改的(保持不变)
    let a=useRef(0);
    console.log(a.current);//a.current:访问引用值
    a.current=111;//a.current=newValue;修改引用的值
    console.log(a.current);
    

    引用的值在更新的时候,不会触发re-render

    import { useEffect, useRef, useState } from "react"
    const Refpage=()=>{const ref1=useRef(1);const [state,setState]=useState(1);console.log('组件-re-render',ref1.current)return<><button onClick={()=>{setState(state+1);}}>change state</button><button onClick={()=>{ref1.current++}}>change ref</button></>
    }
    export default Refpage

    上面代码点击change state组件会触发re-render,change ref不会让触发。

函数组件中,useState,useRef,和普通的变量有什么区别?

  1. useState命名的变量,变量值变化时会引起组件的更新;
  2. useRef命名的变量,变量值变化时,不会引起组件的更新,组件更新的时候,取的是更新前的历史值;
  3. var/let等命名的普通变量,变量是修改时,不会引起组件的更新,组件更新的时候,变量值恢复初始值。

useContext:跨组件传递变量,实现数据共享

使用场景:比如用户信息,主题设置,语言偏好等等全局的状态。

redex、Mobx等第三方状态管理库也可以实现useContext状态管理。

还没有写完,慢慢写~~

有需要补充的,麻烦私信我


http://www.mrgr.cn/news/79549.html

相关文章:

  • log4j漏洞复现--vulhub
  • 基于Pyhton的人脸识别(Python 3.12+face_recognition库)
  • 自然三次样条插值推导笔记
  • Linux:动静态库
  • 图神经网络学习笔记-点云数据处理(专题七)
  • Qt 2D绘图之五:图形视图框架的结构、坐标系统和框架间的事件处理与传播
  • 【前端】React_Next.js
  • 《MySQL 查询进阶:复杂查询语句的魅力》
  • ipset搭配iptables实现城市IP访问限制
  • Qt之第三方库QCustomPlot使用(二)
  • 数字图像处理(15):图像平移
  • ElasticSearch常见的索引_集群的备份与恢复方案
  • 5G模组AT命令脚本-关闭模组的IP过滤功能
  • vue深入理解(1)
  • MySQL数据库(3)-SQL基础语言学习
  • 《MySQL 表结构设计基础》
  • IdentityServer4框架、ASP.NET core Identity
  • 【Redis】not support: redis
  • 《MySQL 入门:数据库世界的第一扇门》
  • HTML旋转爱心(完整代码)