? React Hooks的使用
2022/2/4 23:44:14
本文主要是介绍? React Hooks的使用,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
React Hooks的使用
为什么需要Hook?
Hook 是 React 16.8 的新增特性,它可以让我们在不编写class的情况下使用state以及其他的React特性(比如生命周期)。
- class组件可以定义自己的state,用来保存组件自己内部的状态;函数式组件不可以,因为函数每次调用都会产生新的临时变量;
- class组件有自己的生命周期,我们可以在对应的生命周期中完成自己的逻辑;比如在componentDidMount中发送网络请求,并且该生命周期函数只会执行一次;函数式组件在学习hooks之前,如果在函数中发送网络请求,意味着每次重新渲染都会重新发送一次网络请求;
- class组件可以在状态改变时只会重新执行render函数以及我们希望重新调用的生命周期函数componentDidUpdate等;函数式组件在重新渲染时,整个函数都会被执行,似乎没有什么地方可以只让它们调用一次;
Class组件存在的问题
- 复杂组件变得难以理解:
- 我们在最初编写一个class组件时,往往逻辑比较简单,并不会非常复杂。但是随着业务的增多,我们的class组件会变得越来越复杂;
- 比如componentDidMount中,可能就会包含大量的逻辑代码:包括网络请求、一些事件的监听(还需要在componentWillUnmount中移除);
- 而对于这样的class实际上非常难以拆分:因为它们的逻辑往往混在一起,强行拆分反而会造成过度设计,增加代码的复杂度;
- 难以理解的class:
- 很多人发现学习ES6的class是学习React的一个障碍。
- 比如在class中,我们必须搞清楚this的指向到底是谁,所以需要花很多的精力去学习this;
- 虽然我认为前端开发人员必须掌握this,但是依然处理起来非常麻烦;
- 组件复用状态很难:
- 在前面为了一些状态的复用我们需要通过高阶组件或render props;
- 像我们之前学习的redux中connect或者react-router中的withRouter,这些高阶组件设计的目的就是为了状态的复用;
- 或者类似于Provider、Consumer来共享一些状态,但是多次使用Consumer时,我们的代码就会存在很多嵌套;
- 这些代码让我们不管是编写和设计上来说,都变得非常困难;
Hook的出现,可以解决上面提到的这些问题;
简单总结一下hooks: 它可以让我们在不编写class的情况下使用state以及其他的React特性;但是我们可以由此延伸出非常多的用法,来让我们前面所提到的问题得到解决;
Hook的使用场景:
- Hook的出现基本可以代替我们之前所有使用class组件的地方(除了一些非常不常用的场景);
- 但是如果是一个旧的项目,你并不需要直接将所有的代码重构为Hooks,因为它完全向下兼容,你可以渐进式的来使用它;
- Hook只能在函数组件中使用,不能在类组件,或者函数组件之外的地方使用;
useState解析
useState来自react,需要从react中导入,它是一个hook;
- 参数:初始化值,如果不设置为undefined;
- 返回值:数组,包含两个元素;
- 元素一:当前状态的值(第一调用为初始化值);
- 元素二:设置状态值的函数;
查看代码
import React, { useState } from 'react' export default function ComplexHookState() { const [friends, setFrineds] = useState(["kobe", "lilei"]); const [students, setStudents] = useState([ { id: 110, name: "why", age: 18 }, { id: 111, name: "kobe", age: 30 }, { id: 112, name: "lilei", age: 25 }, ]) function addFriend() { friends.push("hmm"); setFrineds(friends); } function incrementAgeWithIndex(index) { const newStudents = [...students]; newStudents[index].age += 1; setStudents(newStudents); } return ( <div> <h2>好友列表:</h2> <ul> { friends.map((item, index) => { return <li key={index}>{item}</li> }) } </ul> <button onClick={e => setFrineds([...friends, "tom"])}>添加朋友</button> {/* 错误的做法 */} <button onClick={addFriend}>添加朋友</button> <h2>学生列表</h2> <ul> { students.map((item, index) => { return ( <li key={item.id}> <span>名字: {item.name} 年龄: {item.age}</span> <button onClick={e => incrementAgeWithIndex(index)}>age+1</button> </li> ) }) } </ul> </div> ) }
但是使用它们会有两个额外的规则:
- 只能在函数最外层调用 Hook。不要在循环、条件判断或者子函数中调用。
- 只能在 React 的函数组件中调用 Hook。不要在其他 JavaScript 函数中调用。
State Hook的API就是 useState
- useState会帮助我们定义一个 state变量,useState 是一种新方法,它与 class 里面的 this.state 提供的功能完全相同。一般来说,在函数退出后变量就会”消失”,而 state 中的变量会被 React 留。
- useState接受唯一一个参数,在第一次组件被调用时使用来作为初始化值。(如果没有传递参数,那么初始化值为undefined)。
- useState是一个数组,我们可以通过数组的解构,来完成赋值会非常方便。https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment
认识Effect Hook
目前我们已经通过hook在函数式组件中定义state,那么类似于生命周期这些呢?
- Effect Hook 可以让你来完成一些类似于class中生命周期的功能;
- 事实上,类似于网络请求、手动更新DOM、一些事件的监听,都是React更新DOM的一些副作用(Side Effects);
- 所以对于完成这些功能的Hook被称之为 Effect Hook;
useEffect的解析:
- 通过useEffect的Hook,可以告诉React需要在渲染后执行某些操作;
- useEffect要求我们传入一个回调函数,在React执行完更新DOM操作之后,就会回调这个函数;
- 默认情况下,无论是第一次渲染之后,还是每次更新之后,都会执行这个 回调函数;
在class组件的编写过程中,某些副作用的代码,我们需要在componentWillUnmount中进行清除:比如我们之前的事件总线或Redux中手动调用subscribe;都需要在componentWillUnmount有对应的取消订阅;Effect Hook通过什么方式来模拟componentWillUnmount呢?
useEffect传入的回调函数A本身可以有一个返回值,这个返回值是另外一个回调函数B:type EffectCallback = () => (void | (() => void | undefined));
为什么要在 effect 中返回一个函数? 这是 effect 可选的清除机制。每个 effect 都可以返回一个清除函数;如此可以将添加和移除订阅的逻辑放在一起;它们都属于 effect 的一部分;
查看代码
import React, { useEffect, useState } from 'react' export default function EffectHookCancelDemo() { const [count, setCount] = useState(0); useEffect(() => { console.log("订阅一些事件"); return () => { console.log("取消订阅事件") } }, []); return ( <div> <h2>EffectHookCancelDemo</h2> <h2>{count}</h2> <button onClick={e => setCount(count + 1)}>+1</button> </div> ) }
使用多个Effect
Hook 允许我们按照代码的用途分离它们, 而不是像生命周期函数那样:React 将按照 effect 声明的顺序依次调用组件中的每一个 effect;
查看代码
import React, { useState, useEffect } from 'react' export default function MultiEffectHookDemo() { const [count, setCount] = useState(0); const [isLogin, setIsLogin] = useState(true); useEffect(() => { console.log("修改DOM", count); }, [count]); useEffect(() => { console.log("订阅事件"); }, []); useEffect(() => { console.log("网络请求"); }, []); return ( <div> <h2>MultiEffectHookDemo</h2> <h2>{count}</h2> <button onClick={e => setCount(count + 1)}>+1</button> <h2>{isLogin ? "coderwhy": "未登录"}</h2> <button onClick={e => setIsLogin(!isLogin)}>登录/注销</button> </div> ) }
Effect性能优化
默认情况下,useEffect的回调函数会在每次渲染时都重新执行,但是这会导致两个问题:
- 某些代码我们只是希望执行一次即可,类似于componentDidMount和componentWillUnmount中完成的事情;(比如网络请求、订阅和取消订阅);
- 另外,多次执行也会导致一定的性能问题;
我们如何决定useEffect在什么时候应该执行和什么时候不应该执行呢?useEffect实际上有两个参数:
- 参数一:执行的回调函数;
- 参数二:该useEffect在哪些state发生变化时,才重新执行;(受谁的影响)
但是,如果一个函数我们不希望依赖任何的内容时,也可以传入一个空的数组 [],那么这里的两个回调函数分别对应的就是componentDidMount和componentWillUnmount生命周期函数了;
useContext的使用
在之前的开发中,我们要在组件中使用共享的Context有两种方式:
- 类组件可以通过 类名.contextType = MyContext方式,在类中获取context;
- 多个Context或者在函数式组件中通过 MyContext.Consumer 方式共享context;
但是多个Context共享时的方式会存在大量的嵌套:Context Hook允许我们通过Hook来直接获取某个Context的值;
useReducer
很多人看到useReducer的第一反应应该是redux的某个替代品,其实并不是。
useReducer仅仅是useState的一种替代方案:
在某些场景下,如果state的处理逻辑比较复杂,我们可以通过useReducer来对其进行拆分;或者这次修改的state需要依赖之前的state时,也可以使用;
查看代码
import React, { useState, useReducer } from 'react'; import reducer from './reducer'; export default function Home() { // const [count, setCount] = useState(0); const [state, dispatch] = useReducer(reducer, {counter: 0}); return ( <div> <h2>Home当前计数: {state.counter}</h2> <button onClick={e => dispatch({type: "increment"})}>+1</button> <button onClick={e => dispatch({type: "decrement"})}>-1</button> </div> ) }
查看代码
import React, { useReducer } from 'react'; import reducer from './reducer'; export default function Profile() { // const [count, setCount] = useState(0); const [state, dispatch] = useReducer(reducer, { counter: 0 }); return ( <div> <h2>Profile当前计数: {state.counter}</h2> <button onClick={e => dispatch({ type: "increment" })}>+1</button> <button onClick={e => dispatch({ type: "decrement" })}>-1</button> </div> ) }
查看代码
export default function reducer(state, action) { switch(action.type) { case "increment": return {...state, counter: state.counter + 1}; case "decrement": return {...state, counter: state.counter - 1}; default: return state; } }
数据是不会共享的,它们只是使用了相同的counterReducer的函数而已。所以,useReducer只是useState的一种替代品,并不能替代Redux。
useCallback
useCallback实际的目的是为了进行性能的优化。
如何进行性能的优化呢?
- useCallback会返回一个函数的 memoized(记忆的) 值;
- 在依赖不变的情况下,多次定义的时候,返回的值是相同的;
案例
- 案例一:使用useCallback和不使用useCallback定义一个函数是否会带来性能的优化;
- 案例二:使用useCallback和不使用useCallback定义一个函数传递给子组件是否会带来性能的优化;
通常使用useCallback的目的是不希望子组件进行多次渲染,并不是为了函数进行缓存;
查看代码
import React, { useState, useCallback, useMemo } from 'react' //不能进行的性能优化 export default function CallbackHookDemo01() { const [count, setCount] = useState(0); const increment1 = () => { console.log("执行increment1函数"); setCount(count + 1); } const increment2 = useCallback(() => { console.log("执行increment2函数"); setCount(count + 1); }, [count]); const increment3 = useMemo(() => { return () => { console.log("执行increment2函数"); setCount(count + 1); } }, [count]); return ( <div> <h2>CallbackHookDemo01: {count}</h2> <button onClick={increment1}>+1</button> <button onClick={increment2}>+1</button> </div> ) }
查看代码
import React, {useState, useCallback, memo} from 'react'; /** * useCallback在什么时候使用? * 场景: 在将一个组件中的函数, 传递给子元素进行回调使用时, 使用useCallback对函数进行处理. */ const HYButton = memo((props) => { console.log("HYButton重新渲染: " + props.title); return <button onClick={props.increment}>HYButton +1</button> }); export default function CallbackHookDemo02() { console.log("CallbackHookDemo02重新渲染"); const [count, setCount] = useState(0); const [show, setShow] = useState(true); const increment1 = () => { console.log("执行increment1函数"); setCount(count + 1); } const increment2 = useCallback(() => { console.log("执行increment2函数"); setCount(count + 1); }, [count]); return ( <div> <h2>CallbackHookDemo01: {count}</h2> {/* <button onClick={increment1}>+1</button> <button onClick={increment2}>+1</button> */} <HYButton title="btn1" increment={increment1}/> <HYButton title="btn2" increment={increment2}/> <button onClick={e => setShow(!show)}>show切换</button> </div> ) }
useMemo
useMemo实际的目的也是为了进行性能的优化。如何进行性能的优化呢?
- useMemo返回的也是一个 memoized(记忆的) 值;
- 在依赖不变的情况下,多次定义的时候,返回的值是相同的;
案例:
- 案例一:进行大量的计算操作,是否有必须要每次渲染时都重新计算;
- 案例二:对子组件传递相同内容的对象时,使用useMemo进行性能的优化
查看代码
import React, {useState, useMemo} from 'react'; function calcNumber(count) { console.log("calcNumber重新计算"); let total = 0; for (let i = 1; i <= count; i++) { total += i; } return total; } export default function MemoHookDemo01() { const [count, setCount] = useState(10); const [show, setShow] = useState(true); // const total = calcNumber(count); const total = useMemo(() => { return calcNumber(count); }, [count]); return ( <div> <h2>计算数字的和: {total}</h2> <button onClick={e => setCount(count + 1)}>+1</button> <button onClick={e => setShow(!show)}>show切换</button> </div> ) }
查看代码
import React, { useState, memo, useMemo } from 'react'; const HYInfo = memo((props) => { console.log("HYInfo重新渲染"); return <h2>名字: {props.info.name} 年龄: {props.info.age}</h2> }); export default function MemoHookDemo02() { console.log("MemoHookDemo02重新渲染"); const [show, setShow] = useState(true); // const info = { name: "why", age: 18 }; const info = useMemo(() => { return { name: "why", age: 18 }; }, []); return ( <div> <HYInfo info={info} /> <button onClick={e => setShow(!show)}>show切换</button> </div> ) }
这篇关于? React Hooks的使用的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-11-16Vue项目实战:新手入门指南
- 2024-11-16React Hooks之useEffect案例详解
- 2024-11-16useRef案例详解:React中的useRef使用教程
- 2024-11-16React Hooks之useState案例详解
- 2024-11-16Vue入门指南:从零开始搭建第一个Vue项目
- 2024-11-16Vue3学习:新手入门教程与实践指南
- 2024-11-16Vue3学习:从入门到初级实战教程
- 2024-11-16Vue学习:新手入门必备教程
- 2024-11-16Vue3入门:新手必读的简单教程
- 2024-11-16Vue3入门:新手必读的简单教程