React-Hooks-useMemo

简介: React-Hooks-useMemo

useMemo Hook 概述


  • useMemo 用于优化代码, 可以让对应的函数只有在依赖发生变化时才返回新的值

其实我们可以把 useMemo 看成是 useCallback 底层的实现,如下:

function useCallback(fn, arr) {
    return useMemo(() => {
        return fn;
    }, arr);
}


使用 useMemo:

import React, {useState, memo, useMemo} from 'react';
function Home(props) {
    console.log('Home被渲染了');
    return (
        <div>
            <p>Home</p>
            <button onClick={() => {
                props.handler()
            }}>增加Home
            </button>
        </div>
    )
}
function About(props) {
    console.log('About被渲染了');
    return (
        <div>
            <p>About</p>
            <button onClick={() => {
                props.handler()
            }}>减少About
            </button>
        </div>
    )
}
const MemoHome = memo(Home);
const MemoAbout = memo(About);
export default function App() {
    console.log('App被渲染了');
    const [numState, setNumState] = useState(0);
    const [countState, setCountState] = useState(0);
    function increment() {
        setNumState(numState + 1);
    }
    const decrement = useMemo(() => {
        return () => {
            setCountState(countState - 1);
        };
    }, [countState]);
    return (
        <div>
            <p>numState = {numState}</p>
            <p>countState = {countState}</p>
            <MemoHome handler={increment}/>
            <MemoAbout handler={decrement}/>
        </div>
    )
}

如上的代码当中 decrement 方法,只要 countState 没有发生变化, 那么 useMemo 返回的永远都是同一个值,那么永远都是同一个值,相关对应的组件也就会不会重新渲染,因为值没有发生改变,state 是不会进行重新渲染。



useCallback 和 useMemo 的区别


  • useCallback 返回的永远是一个函数
  • useMemo 返回的是 return 返回的内容

那么,博主先来改造一下如上的这个案例:

import React, {useState, memo} from 'react';
function Home(props) {
    console.log('Home被渲染了');
    return (
        <div>
            <p>Home</p>
            <button onClick={() => {
                props.handler()
            }}>增加Home
            </button>
        </div>
    )
}
function About(props) {
    console.log('About被渲染了');
    return (
        <div>
            <p>About</p>
            <p>{props.user.name}</p>
            <p>{props.user.age}</p>
        </div>
    )
}
const MemoHome = memo(Home);
const MemoAbout = memo(About);
export default function App() {
    console.log('App被渲染了');
    const [numState, setNumState] = useState(0);
    const user = {name: 'yangbuyiya', age: 18};
    function increment() {
        setNumState(numState + 1);
    }
    return (
        <div>
            <p>numState = {numState}</p>
            <MemoHome handler={increment}/>
            <MemoAbout user={user}/>
        </div>
    )
}


大致改造的内容就是说,删除了之前的 decrementcountState 然后定义了一个对象,把这个对象传递给了 About 然后在 About 当中进行显示,然后运行项目点击 增加Home 你会发现,所有组件又重新渲染了,那么这个原因在之前博主已经详细的介绍过了,因为点击了增加按钮之后父组件重新渲染了,然后对象又会重新的进行定义那么这回的这个对象肯定是与上次的是不一样的,那么组件就会被重新渲染了,那么这个问题就可以利用 useCallback 和 useMemo 的区别来解决, useMemo 有一个特点就是 返回的是 return 返回的内容 那么我们如果将对象通过这种方式进行返回,不依赖任何属性那么在点击增加按钮,这个对象就是还是同一个这回 About 就不会进行重新渲染了,代码如下:

import React, {useState, memo, useMemo} from 'react';
function Home(props) {
    console.log('Home被渲染了');
    return (
        <div>
            <p>Home</p>
            <button onClick={() => {
                props.handler()
            }}>增加Home
            </button>
        </div>
    )
}
function About(props) {
    console.log('About被渲染了');
    return (
        <div>
            <p>About</p>
            <p>{props.user.name}</p>
            <p>{props.user.age}</p>
        </div>
    )
}
const MemoHome = memo(Home);
const MemoAbout = memo(About);
export default function App() {
    console.log('App被渲染了');
    const [numState, setNumState] = useState(0);
    function increment() {
        setNumState(numState + 1);
    }
    const user = useMemo(() => {
        return {name: 'yangbuyiya', age: 18}
    }, []);
    return (
        <div>
            <p>numState = {numState}</p>
            <MemoHome handler={increment}/>
            <MemoAbout user={user}/>
        </div>
    )
}

注意:[] 代表的是不依赖任何属性数据。




利用 useMemo 对实际代码优化


假如现在有这么一个场景,就是定义了一个函数,然后你调用这个函数可以拿到一个结果值,函数当中包含了大量的运算,然后, 你在根组件渲染的时候需要展示该函数渲染的值,代码如下:

import React, {useState} from 'react';
function calculate() {
    console.log('calculate被执行了');
    let total = 0;
    for (let i = 0; i < 999; i++) {
        total += i;
    }
    return total;
}
export default function App() {
    console.log('App被渲染了');
    const [numState, setNumState] = useState(0);
    const total = calculate();
    return (
        <div>
            <p>{total}</p>
            <p>{numState}</p>
            <button onClick={() => {
                setNumState(numState + 1)
            }}>增加
            </button>
        </div>
    )
}

运行结果如下:


通过运行结果可以发现只要每增加一次计算函数就被重新运行了一次,这是非常耗性能的那么如果该函数以后的计算更大呢,是吧,博主这里只是单纯的模拟而已,那么这个问题就可以利用 useMemo 来进行优化掉了,那么它怎么计算最终得到的结果都是一样的,那么我们就不用依赖任何的属性即可优化之后的代码如下:

import React, {useState, useMemo} from 'react';
function calculate() {
    console.log('calculate被执行了');
    let total = 0;
    for (let i = 0; i < 999; i++) {
        total += i;
    }
    return total;
}
export default function App() {
    console.log('App被渲染了');
    const [numState, setNumState] = useState(0);
    const total = useMemo(() => {
        return calculate();
    }, []);
    return (
        <div>
            <p>{total}</p>
            <p>{numState}</p>
            <button onClick={() => {
                setNumState(numState + 1)
            }}>增加
            </button>
        </div>
    )
}


再次查看运行结果:



最后

本期结束咱们下次再见👋~

🌊 关注我不迷路,如果本篇文章对你有所帮助,或者你有什么疑问,欢迎在评论区留言,我一般看到都会回复的。大家点赞支持一下哟~ 💗

相关文章
|
2月前
|
前端开发 JavaScript
React中函数式Hooks之useRef的使用
React中函数式Hooks的useRef用于获取DOM元素的引用,示例代码演示了其基本用法。
33 3
|
24天前
|
存储 缓存 JavaScript
深入理解 React-Hooks 之 useRef
【10月更文挑战第20天】总之,`useRef` 是 React-Hooks 中一个非常实用的工具,它为我们提供了一种灵活而强大的方式来处理组件中的各种数据和操作。通过深入理解和掌握 `useRef` 的原理和用法,我们能够更好地构建高效、稳定的 React 应用。
32 6
|
2月前
|
前端开发
React中函数式Hooks之useEffect的使用
本文通过示例代码讲解了React中`useEffect` Hook的用法,包括模拟生命周期、监听状态和清理资源。
56 2
React中函数式Hooks之useEffect的使用
|
2月前
|
缓存 前端开发
React中函数式Hooks之useMemo的使用
React的`useMemo` Hook 用于优化性能,通过记忆返回值避免重复计算。它接收一个函数和一个依赖数组,只有当依赖项改变时,才会重新计算被记忆的值。这可以用于避免在每次渲染时都进行昂贵的计算,或者防止子组件不必要的重新渲染。例如,可以在父组件中使用`useMemo`包裹子组件,以依赖特定的props,从而控制子组件的渲染。
36 0
|
前端开发
React-Hooks-useCallback
React-Hooks-useCallback
48 0
React-Hooks-useCallback
|
前端开发 JavaScript
React-Hooks-useReducer
React-Hooks-useReducer
48 0
|
存储
React-Hooks-useRef
React-Hooks-useRef
56 0
|
存储 前端开发 容器
React-Hooks-useContext
React-Hooks-useContext
43 0
React-Hooks之useMemo
React-Hooks之useMemo
67 0