• useEffect 完整使用指南

    目录

    一、每一次渲染都有它自己的 Props and State

    二、每次渲染都有它自己的Effects

    三、关于依赖项不要对React撒谎

    四、两种诚实告知依赖的方法

    五、来自 useReducer 的助攻

    六、把函数移到Effects里

    七、我不想把可复用的函数放到Effect里

    这篇文章会假设你对useEffect API有一定程度的了解。

    一、每一次渲染都有它自己的 Props and State

    在我们讨论 effects 之前，我们需要先讨论一下渲染，当我们更新 state 的时候，React会重新渲染组件。每一次渲染都能拿到独立的 state，这个状态值是函数中的一个常量。

    这里关键的点在于任意一次渲染中的常量都不会随着时间改变。渲染输出会变是因为我们的组件被一次次调用，而每一次调用引起的渲染中，它包含的值独立于其他渲染。

    如果 props 和 state 在不同的渲染中是相互独立的，那么使用到它们的任何值也是独立的（包括事件处理函数）。它们都“属于”一次特定的渲染。即便是事件处理中的异步函数调用“看到”的也是这次渲染中的值。

    二、每次渲染都有它自己的Effects

    让我们先看向官网的 useEffect 的例子：

    1. function Counter() {
    2.   const [count, setCount] = useState(0);
    3.  
    4.   useEffect(() => {
    5.     document.title = `You clicked ${count} times`;
    6.   });
    7.  
    8.   return (
    9.     <div>
    10.       <p>You clicked {count} timesp>
    11.       <button onClick={() => setCount(count + 1)}>
    12.         Click me
    13.       button>
    14.     div>
    15.   );
    16. }

    effect是如何读取到最新的count 状态值的呢？

    也许，是某种 watching 机制类似 vue 中的数据响应式使得能够在 effect 函数内更新？也或许是一个可变的值，React 会在我们组件内部修改它以使我们的 effect 函数总能拿到最新的值？ 

    都不是。

    我们已经知道是某个特定渲染中的常量。事件处理函数“看到”的是属于它那次特定渲染中的状态值。对于 effects 也同样如此：

    并不是 count的值在“不变”的 effect 中发生了改变，而是 effect 函数本身在每一次渲染中都不相同。

    React 会记住你提供的 effect 函数，并且会在每次更改作用于DOM并让浏览器绘制屏幕后去调用它。

    所以虽然我们说的是一个 effect（这里指更新document的title），但其实每次渲染都是一个不同的函数 — 并且每个 effect 函数看到的 props 和 state 都来自于它属于的那次特定渲染。

     

    三、关于依赖项不要对React撒谎

    现在只需要记住：如果你设置了依赖项，effect 中用到的所有组件内的值都要包含在依赖中。这包括props，state，函数组件内的任何东西。

    在下面这个组件中，我们的直觉是：“开启一次定时器，清除也是一次”。直觉上我们会设置依赖为 '[]'。“我只想运行一次 effect ”，但是这样对吗？

    1. function Counter() {
    2.   const [count, setCount] = useState(0);
    3.  
    4.   useEffect(() => {
    5.     const id = setInterval(() => {
    6.       setCount(count + 1);
    7.     }, 1000);
    8.     return () => clearInterval(id);
    9.   }, []);
    10.  
    11.   return <h1>{count}h1>;
    12. }

    我们以为他会一直递增下去，但实际上他只会递增一次，你想要触发一次因为它是定时器 ，但为什么会有问题？

    在第一次渲染中我们执行了setCount(0 + 1)。但是我们设置了[]依赖，effect不会再重新运行，它后面每一秒都会调用setCount(0 + 1)。我们对 React 撒谎说我们的 effect 不依赖组件内的任何值，可实际上我们的 effect 有依赖。

    四、两种诚实告知依赖的方法

    第一种策略是在依赖中包含所有 effect 中用到的组件内的值。让我们在依赖中包含：count

    1. useEffect(() => {
    2.   const id = setInterval(() => {
    3.     setCount(count + 1);
    4.   }, 1000);
    5.   return () => clearInterval(id);
    6. }, [count]);

    这在我们大部分初级开发者的眼中都没有什么问题，并且程序确实不会出任何 bug，现在，每次修改都会重新运行 effect，这能解决问题但是我们的定时器会在每一次改变后清除和重新设定。这肯定不是我们想要的结果。

    第二种策略是修改 effect 内部的代码以确保它包含的值只会在需要的时候发生变更。

    在这个场景中，我们其实并不需要在effect中使用 count。当我们想要根据前一个状态更新状态的时候，我们可以使用的函数形式：

    1.   useEffect(() => {
    2.     const id = setInterval(() => {
    3.       setCount(c => c + 1);
    4.     }, 1000);
    5.     return () => clearInterval(id);
    6.   }, []);

    我们需要告知React的仅仅是去递增状态 - 不管它现在具体是什么值。注意我们做到了移除依赖，并且没有撒谎。我们的 effect 不再读取渲染中的 count值。

    五、来自 useReducer 的助攻

    如果我们有两个互相依赖的状态，或者我们想基于一个 prop 来计算下一次的 state，setCount(c => c + 1)它并不能做到。幸运的是， 有一个更强大的姐妹模式，它的名字叫 useReducer。

    我们先来修改上面的例子让它包含两个状态：count 和 step 。我们的定时器会每次在 count 上增加一个 step 值：

    1. function Counter() {
    2.   const [count, setCount] = useState(0);
    3.   const [step, setStep] = useState(1);
    4.  
    5.   useEffect(() => {
    6.     const id = setInterval(() => {
    7.       setCount(c => c + step);
    8.     }, 1000);
    9.     return () => clearInterval(id);
    10.   }, [step]);
    11.  
    12.   return (
    13.     <>
    14.       <h1>{count}h1>
    15.       <input value={step} onChange={e => setStep(Number(e.target.value))} />
    16.     
    17.   );
    18. }

    注意我们没有撒谎。既然我们在 effect 里使用了 step，我们就把它加到依赖里。所以这也是为什么代码能运行正确。

    这个例子目前的行为是修改会重启定时器 - 因为它是依赖项之一。在大多数场景下，这正是你所需要的。清除上一次的effect然后重新运行新的effect并没有任何错。不过，假如我们不想在改变后重启定时器，我们该如何从effect中移除对的依赖呢？

    下面这句话我希望你作为一名 react 开发人员要记下来：

    当你想更新一个状态，并且这个状态更新依赖于另一个状态的值时，你可能需要用useReducer去替换它们。 

    reducer 可以让你把组件内发生了什么(actions)和状态如何响应并更新分开表述。

    我们用一个 dispatch 依赖去替换 effect 的依赖 step ：

    1. function Counter() {
    2.   const [state, dispatch] = useReducer(reducer, initialState);
    3.   const { count, step } = state;
    4.  
    5.   useEffect(() => {
    6.     const id = setInterval(() => {
    7.       dispatch({ type: 'tick' });
    8.     }, 1000);
    9.     return () => clearInterval(id);
    10.   }, [dispatch]);
    11.  
    12.   return (
    13.     <>
    14.       <h1>{count}h1>
    15.       <input value={step} onChange={e => {
    16.         dispatch({
    17.           type: 'step',
    18.           step: Number(e.target.value)
    19.         });
    20.       }} />
    21.     
    22.   );
    23. }
    24.  
    25. const initialState = {
    26.   count: 0,
    27.   step: 1,
    28. };
    29.  
    30. function reducer(state, action) {
    31.   const { count, step } = state;
    32.   if (action.type === 'tick') {
    33.     return { count: count + step, step };
    34.   } else if (action.type === 'step') {
    35.     return { count, step: action.step };
    36.   } else {
    37.     throw new Error();
    38.   }
    39. }

    你可能会问：“这怎么就更好了？”答案是React会保证dispatch在组件的声明周期内保持不变。所以上面例子中不再需要重新订阅定时器 。

    相比于直接在 effect 里面读取状态，它 dispatch 了一个 action 来描述发生了什么。这使得我们的 effect 和状态解耦。我们的 effect 不再关心怎么更新状态，它只负责告诉我们发生了什么。更新的逻辑全都交由 reducer 去统一处理。

     

    六、把函数移到Effects里

    一个典型的误解是认为函数不应该成为依赖。举个例子，下面的代码看上去可以运行正常：

    1. function SearchResults() {
    2.   const [data, setData] = useState({ hits: [] });
    3.  
    4.   async function fetchData() {
    5.     const result = await axios(
    6.       'https://hn.algolia.com/api/v1/search?query=react',
    7.     );
    8.     setData(result.data);
    9.   }
    10.  
    11.   useEffect(() => {
    12.     fetchData();
    13.   }, []); 
    14.  
    15.   // ...

    需要明确的是，上面的代码可以正常工作。但这样做在组件日渐复杂的迭代过程中我们很难确保它在各种情况下还能正常运行。

    如果我们在某些函数内使用了某些 state 或者 prop：

    1. function SearchResults() {
    2.   const [query, setQuery] = useState('react');
    3.  
    4.   // Imagine this function is also long
    5.   function getFetchUrl() {
    6.     return 'https://hn.algolia.com/api/v1/search?query=' + query;
    7.   }
    8.  
    9.   // Imagine this function is also long
    10.   async function fetchData() {
    11.     const result = await axios(getFetchUrl());
    12.     setData(result.data);
    13.   }
    14.  
    15.   useEffect(() => {
    16.     fetchData();
    17.   }, []);
    18.  
    19.   // ...
    20. }
    '
    运行

    如果我们忘记去更新使用这些函数（很可能通过其他函数调用）的effects的依赖，我们的effects就不会同步props和state带来的变更。这当然不是我们想要的。

    如果某些函数仅在effect中调用，你可以把它们的定义移到effect中：

    1. function SearchResults() {
    2.   // ...
    3.   useEffect(() => {
    4.     // We moved these functions inside!
    5.     function getFetchUrl() {
    6.       return 'https://hn.algolia.com/api/v1/search?query=react';
    7.     }
    8.     async function fetchData() {
    9.       const result = await axios(getFetchUrl());
    10.       setData(result.data);
    11.     }
    12.  
    13.     fetchData();
    14.   }, []); 
    15. }
    '
    运行

    这么做有什么好处呢？我们不再需要去考虑这些“间接依赖”。我们的依赖数组也不再撒谎：在我们的 effect 中确实没有再使用组件范围内的任何东西。

    如果我们后面修改 getFetchUrl去使用状态 query，我们更可能会意识到我们正在effect里面编辑它因此，我们需要把 query添加到effect的依赖里：

    1. function SearchResults() {
    2.   const [query, setQuery] = useState('react');
    3.  
    4.   useEffect(() => {
    5.     function getFetchUrl() {
    6.       return 'https://hn.algolia.com/api/v1/search?query=' + query;
    7.     }
    8.  
    9.     async function fetchData() {
    10.       const result = await axios(getFetchUrl());
    11.       setData(result.data);
    12.     }
    13.  
    14.     fetchData();
    15.   }, [query]); 
    16. }
    '
    运行

    七、我不想把可复用的函数放到Effect里

    有时候你可能不想把函数移入 effect 里。比如，组件内有几个 effect 使用了相同的函数，你不想在每个 effect 里复制黏贴一遍这个逻辑。也或许这个函数是一个 prop。

    在这种情况下你应该忽略对函数的依赖吗？这么做是不对的。再次强调，effects不应该对它的依赖撒谎。通常我们还有更好的解决办法。一个常见的误解是，“函数从来不会改变”。但是这篇文章你读到现在，你知道这显然不是事实。实际上，在组件内定义的函数每一次渲染都在变。

    1. function SearchResults() {
    2.   function getFetchUrl(query) {
    3.     return 'https://hn.algolia.com/api/v1/search?query=' + query;
    4.   }
    5.  
    6.   useEffect(() => {
    7.     const url = getFetchUrl('react');
    8.     // ... Fetch data and do something ...
    9.   }, []);
    10.  
    11.   useEffect(() => {
    12.     const url = getFetchUrl('redux');
    13.     // ... Fetch data and do something ...
    14.   }, []);
    15. }
    '
    运行

    在这个例子中，你可能不想把 getFetchUrl移到 effects 中，因为你想复用逻辑。

    另一方面，如果你对依赖很“诚实”，你可能会掉到陷阱里。我们的两个 effects 都依赖 getFetchUrl，而它每次渲染都不同，所以我们的依赖数组会变得无用：

    1. function SearchResults() {
    2.   function getFetchUrl(query) {
    3.     return 'https://hn.algolia.com/api/v1/search?query=' + query;
    4.   }
    5.  
    6.   useEffect(() => {
    7.     const url = getFetchUrl('react');
    8.     // ... Fetch data and do something ...
    9.   }, [getFetchUrl]); 
    10.  
    11.   useEffect(() => {
    12.     const url = getFetchUrl('redux');
    13.     // ... Fetch data and do something ...
    14.   }, [getFetchUrl]);
    15.  
    16.   // ...
    17. }
    '
    运行

    我们有两个更简单的解决办法。

    第一个， 如果一个函数没有使用组件内的任何值，你应该把它提到组件外面去定义，然后就可以自由地在 effects 中使用：

    1. function getFetchUrl(query) {
    2.   return 'https://hn.algolia.com/api/v1/search?query=' + query;
    3. }
    4.  
    5. function SearchResults() {
    6.   useEffect(() => {
    7.     const url = getFetchUrl('react');
    8.     // ... Fetch data and do something ...
    9.   }, []);
    10.  
    11.   useEffect(() => {
    12.     const url = getFetchUrl('redux');
    13.     // ... Fetch data and do something ...
    14.   }, []); 
    15.  
    16.   // ...
    17. }
    '
    运行

    你不再需要把它设为依赖，因为它们不在渲染范围内，因此不会被数据流影响。

    或者， 你也可以把它包装成  useCallback Hook:

    1. function SearchResults() {
    2.   const getFetchUrl = useCallback((query) => {
    3.     return 'https://hn.algolia.com/api/v1/search?query=' + query;
    4.   }, []);
    5.  
    6.   useEffect(() => {
    7.     const url = getFetchUrl('react');
    8.     // ... Fetch data and do something ...
    9.   }, [getFetchUrl]);
    10.  
    11.   useEffect(() => {
    12.     const url = getFetchUrl('redux');
    13.     // ... Fetch data and do something ...
    14.   }, [getFetchUrl]);
    15.  
    16.   // ...
    17. }
    '
    运行

    我们用 useCallback 对 getFetchUrl 做了一层缓存，现在只有当依赖项变化的时候，才会重新执行 useCallback 来返回新的函数，依赖项没有变化的时候就算组件 rerender 了，这个函数也不会重新执行，这样我们把 getFetchUrl 作为 useEffect 的依赖就没问题了。

    不同于传递参数的方式，现在我们从状态中读取 query：

    1. function SearchResults() {
    2.   const [query, setQuery] = useState('react');
    3.   const getFetchUrl = useCallback(() => {
    4.     return 'https://hn.algolia.com/api/v1/search?query=' + query;
    5.   }, [query]);  
    6.  
    7.   useEffect(() => {
    8.     const url = getFetchUrl();
    9.     // ... Fetch data and do something ...
    10.   }, [getFetchUrl]);
    11.  
    12.   // ...
    13. }
    '
    运行

    如果 query保持不变，useCallback也会保持不变，我们的 effect 也不会重新运行。但是如果修改了 query，useCallback 也会随之改变，因此会重新请求数据。这就像你在Excel里修改了一个单元格的值，另一个使用它的单元格会自动重新计算一样。

  • 相关阅读:
    805.数组的均值分割(回溯+折半搜索+数学)
    《嵌入式虚拟化技术与应用》：深入浅出阐述嵌入式虚拟机原理，实现“小而能”嵌入式虚拟机！
    Java后台解决request请求体不能重复读取+解决XSS漏洞问题
    数据结构基本概念-Java常用算法
    STC89C51基础及项目第12天：IIC协议、OLED显示字符和图片
    什么是 CSRF 、原理及其解决方式
    MAC帧
    Docker第四天作业
    [LeetCode] 128. 最长连续序列
    autox.js的三个版本universal、armeabi-v7a、arm64-v8a的区别
  • 原文地址：https://blog.csdn.net/qq_49900295/article/details/127039404