• 使用 Effect Hook
    • 无需清除的 effect
      • 使用 class 的示例
      • 使用 Hook 的示例
      • 详细说明
    • 需要清除的 effect
      • 使用 Class 的示例
      • 使用 Hook 的示例
    • 小结
    • 使用 Effect 的提示
      • 提示: 使用多个 Effect 实现关注点分离
      • 解释: 为什么每次更新的时候都要运行 Effect
      • 提示: 通过跳过 Effect 进行性能优化
    • 下一步

    使用 Effect Hook

    Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。

    Effect Hook 可以让你在函数组件中执行副作用操作

    1. import React, { useState, useEffect } from 'react';
    3. function Example() {
    4.   const [count, setCount] = useState(0);
    6.   // Similar to componentDidMount and componentDidUpdate:
    7.   useEffect(() => {
    8.     // Update the document title using the browser API
    9.     document.title = `You clicked ${count} times`;
    10.   });
    12.   return (
    13.     <div>
    14.       <p>You clicked {count} times</p>
    15.       <button onClick={() => setCount(count + 1)}>
    16.         Click me
    17.       </button>
    18.     </div>
    19.   );
    20. }

    这段代码基于上一章节中的计数器示例进行修改，我们为计数器增加了一个小功能：将 document 的 title 设置为包含了点击次数的消息。

    数据获取，设置订阅以及手动更改 React 组件中的 DOM 都属于副作用。不管你知不知道这些操作，或是“副作用”这个名字，应该都在组件中使用过它们。

    提示

    如果你熟悉 React class 的生命周期函数，你可以把 useEffect Hook 看做 componentDidMount，componentDidUpdate 和 componentWillUnmount 这三个函数的组合。

    在 React 组件中有两种常见副作用操作：需要清除的和不需要清除的。我们来更仔细地看一下他们之间的区别。

    无需清除的 effect

    有时候，我们只想在 React 更新 DOM 之后运行一些额外的代码。比如发送网络请求，手动变更 DOM，记录日志，这些都是常见的无需清除的操作。因为我们在执行完这些操作之后，就可以忽略他们了。让我们对比一下使用 class 和 Hook 都是怎么实现这些副作用的。

    使用 class 的示例

    在 React 的 class 组件中，render 函数是不应该有任何副作用的。一般来说，在这里执行操作太早了，我们基本上都希望在 React 更新 DOM 之后才执行我们的操作。

    这就是为什么在 React class 中，我们把副作用操作放到 componentDidMount 和 componentDidUpdate 函数中。回到示例中，这是一个 React 计数器的 class 组件。它在 React 对 DOM 进行操作之后，立即更新了 document 的 title 属性

    1. class Example extends React.Component {
    2.   constructor(props) {
    3.     super(props);
    4.     this.state = {
    5.       count: 0
    6.     };
    7.   }
    9.   componentDidMount() {
    10.     document.title = `You clicked ${this.state.count} times`;
    11.   }
    13.   componentDidUpdate() {
    14.     document.title = `You clicked ${this.state.count} times`;
    15.   }
    17.   render() {
    18.     return (
    19.       <div>
    20.         <p>You clicked {this.state.count} times</p>
    21.         <button onClick={() => this.setState({ count: this.state.count + 1 })}>
    22.           Click me
    23.         </button>
    24.       </div>
    25.     );
    26.   }
    27. }

    注意，在这个 class 中，我们需要在两个生命周期函数中编写重复的代码。

    这是因为很多情况下，我们希望在组件加载和更新时执行同样的操作。从概念上说，我们希望它在每次渲染之后执行 —— 但 React 的 class 组件没有提供这样的方法。即使我们提取出一个方法，我们还是要在两个地方调用它。

    现在让我们来看看如何使用 useEffect 执行相同的操作。

    使用 Hook 的示例

    我们在本章节开始时已经看到了这个示例，但让我们再仔细观察它：

    1. import React, { useState, useEffect } from 'react';
    3. function Example() {
    4.   const [count, setCount] = useState(0);
    6.   useEffect(() => {
    7.     document.title = `You clicked ${count} times`;
    8.   });
    10.   return (
    11.     <div>
    12.       <p>You clicked {count} times</p>
    13.       <button onClick={() => setCount(count + 1)}>
    14.         Click me
    15.       </button>
    16.     </div>
    17.   );
    18. }

    useEffect 做了什么？ 通过使用这个 Hook，你可以告诉 React 组件需要在渲染后执行某些操作。React 会保存你传递的函数（我们将它称之为 “effect”），并且在执行 DOM 更新之后调用它。在这个 effect 中，我们设置了 document 的 title 属性，不过我们也可以执行数据获取或调用其他命令式的 API。

    为什么在组件内部调用 useEffect？ 将 useEffect 放在组件内部让我们可以在 effect 中直接访问 count state 变量（或其他 props）。我们不需要特殊的 API 来读取它 —— 它已经保存在函数作用域中。Hook 使用了 JavaScript 的闭包机制，而不用在 JavaScript 已经提供了解决方案的情况下，还引入特定的 React API。

    useEffect 会在每次渲染后都执行吗？ 是的，默认情况下，它在第一次渲染之后和每次更新之后都会执行。（我们稍后会谈到如何控制它。）你可能会更容易接受 effect 发生在“渲染之后”这种概念，不用再去考虑“挂载”还是“更新”。React 保证了每次运行 effect 的同时，DOM 都已经更新完毕。

    详细说明

    现在我们已经对 effect 有了大致了解，下面这些代码应该不难看懂了：

    1. function Example() {
    2.   const [count, setCount] = useState(0);
    4.   useEffect(() => {
    5.     document.title = `You clicked ${count} times`;
    6.   });

    我们声明了 count state 变量，并告诉 React 我们需要使用 effect。紧接着传递函数给 useEffect Hook。此函数就是我们的 effect。然后使用 document.title 浏览器 API 设置 document 的 title。我们可以在 effect 中获取到最新的 count 值，因为他在函数的作用域内。当 React 渲染组件时，会保存已使用的 effect，并在更新完 DOM 后执行它。这个过程在每次渲染时都会发生，包括首次渲染。

    经验丰富的 JavaScript 开发人员可能会注意到，传递给 useEffect 的函数在每次渲染中都会有所不同，这是刻意为之的。事实上这正是我们可以在 effect 中获取最新的 count 的值，而不用担心其过期的原因。每次我们重新渲染，都会生成新的 effect，替换掉之前的。某种意义上讲，effect 更像是渲染结果的一部分 —— 每个 effect “属于”一次特定的渲染。我们将在本章节后续部分更清楚地了解这样做的意义。

    提示

    与 componentDidMount 或 componentDidUpdate 不同，使用 useEffect 调度的 effect 不会阻塞浏览器更新屏幕，这让你的应用看起来响应更快。大多数情况下，effect 不需要同步地执行。在个别情况下（例如测量布局），有单独的 useLayoutEffect Hook 供你使用，其 API 与 useEffect 相同。

    需要清除的 effect

    之前，我们研究了如何使用不需要清除的副作用，还有一些副作用是需要清除的。例如订阅外部数据源。这种情况下，清除工作是非常重要的，可以防止引起内存泄露！现在让我们来比较一下如何用 Class 和 Hook 来实现。

    使用 Class 的示例

    在 React class 中，你通常会在 componentDidMount 中设置订阅，并在 componentWillUnmount 中清除它。例如，假设我们有一个 ChatAPI 模块，它允许我们订阅好友的在线状态。以下是我们如何使用 class 订阅和显示该状态：

    1. class FriendStatus extends React.Component {
    2.   constructor(props) {
    3.     super(props);
    4.     this.state = { isOnline: null };
    5.     this.handleStatusChange = this.handleStatusChange.bind(this);
    6.   }
    8.   componentDidMount() {
    9.     ChatAPI.subscribeToFriendStatus(
    10.       this.props.friend.id,
    11.       this.handleStatusChange
    12.     );
    13.   }
    15.   componentWillUnmount() {
    16.     ChatAPI.unsubscribeFromFriendStatus(
    17.       this.props.friend.id,
    18.       this.handleStatusChange
    19.     );
    20.   }
    22.   handleStatusChange(status) {
    23.     this.setState({
    24.       isOnline: status.isOnline
    25.     });
    26.   }
    28.   render() {
    29.     if (this.state.isOnline === null) {
    30.       return 'Loading...';
    31.     }
    32.     return this.state.isOnline ? 'Online' : 'Offline';
    33.   }
    34. }

    你会注意到 componentDidMount 和 componentWillUnmount 之间相互对应。使用生命周期函数迫使我们拆分这些逻辑代码，即使这两部分代码都作用于相同的副作用。

    注意

    眼尖的读者可能已经注意到了，这个示例还需要编写 componentDidUpdate 方法才能保证完全正确。我们先暂时忽略这一点，本章节中后续部分会介绍它。

    使用 Hook 的示例

    如何使用 Hook 编写这个组件。

    你可能认为需要单独的 effect 来执行清除操作。但由于添加和删除订阅的代码的紧密性，所以 useEffect 的设计是在同一个地方执行。如果你的 effect 返回一个函数，React 将会在执行清除操作时调用它：

    1. import React, { useState, useEffect } from 'react';
    3. function FriendStatus(props) {
    4.   const [isOnline, setIsOnline] = useState(null);
    6.   useEffect(() => {
    7.     function handleStatusChange(status) {
    8.       setIsOnline(status.isOnline);
    9.     }
    11.     ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);
    12.     // Specify how to clean up after this effect:
    13.     return function cleanup() {
    14.       ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);
    15.     };
    16.   });
    18.   if (isOnline === null) {
    19.     return 'Loading...';
    20.   }
    21.   return isOnline ? 'Online' : 'Offline';
    22. }

    为什么要在 effect 中返回一个函数？ 这是 effect 可选的清除机制。每个 effect 都可以返回一个清除函数。如此可以将添加和移除订阅的逻辑放在一起。它们都属于 effect 的一部分。

    React 何时清除 effect？ React 会在组件卸载的时候执行清除操作。正如之前学到的，effect 在每次渲染的时候都会执行。这就是为什么 React 会在执行当前 effect 之前对上一个 effect 进行清除。我们稍后将讨论为什么这将助于避免 bug以及如何在遇到性能问题时跳过此行为。

    注意

    并不是必须为 effect 中返回的函数命名。这里我们将其命名为 cleanup 是为了表明此函数的目的，但其实也可以返回一个箭头函数或者给起一个别的名字。

    小结

    了解了 useEffect 可以在组件渲染后实现各种不同的副作用。有些副作用可能需要清除，所以需要返回一个函数：

    1.   useEffect(() => {
    2.     function handleStatusChange(status) {
    3.       setIsOnline(status.isOnline);
    4.     }
    6.     ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);
    7.     return () => {
    8.       ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);
    9.     };
    10.   });

    其他的 effect 可能不必清除，所以不需要返回。

    1.   useEffect(() => {
    2.     document.title = `You clicked ${count} times`;
    3.   });

    effect Hook 使用同一个 API 来满足这两种情况。

    如果你对 Effect Hook 的机制已经有很好的把握，或者暂时难以消化更多内容，你现在就可以跳转到下一章节学习 Hook 的规则。

    使用 Effect 的提示

    在本节中将继续深入了解 useEffect 的某些特性，有经验的 React 使用者可能会对此感兴趣。你不一定要在现在了解他们，你可以随时查看此页面以了解有关 Effect Hook 的更多详细信息。

    提示: 使用多个 Effect 实现关注点分离

    使用 Hook 其中一个目的就是要解决 class 中生命周期函数经常包含不相关的逻辑，但又把相关逻辑分离到了几个不同方法中的问题。下述代码是将前述示例中的计数器和好友在线状态指示器逻辑组合在一起的组件：

    1. class FriendStatusWithCounter extends React.Component {
    2.   constructor(props) {
    3.     super(props);
    4.     this.state = { count: 0, isOnline: null };
    5.     this.handleStatusChange = this.handleStatusChange.bind(this);
    6.   }
    8.   componentDidMount() {
    9.     document.title = `You clicked ${this.state.count} times`;
    10.     ChatAPI.subscribeToFriendStatus(
    11.       this.props.friend.id,
    12.       this.handleStatusChange
    13.     );
    14.   }
    16.   componentDidUpdate() {
    17.     document.title = `You clicked ${this.state.count} times`;
    18.   }
    20.   componentWillUnmount() {
    21.     ChatAPI.unsubscribeFromFriendStatus(
    22.       this.props.friend.id,
    23.       this.handleStatusChange
    24.     );
    25.   }
    27.   handleStatusChange(status) {
    28.     this.setState({
    29.       isOnline: status.isOnline
    30.     });
    31.   }
    32.   // ...

    可以发现设置 document.title 的逻辑是如何被分割到 componentDidMount 和 componentDidUpdate 中的，订阅逻辑又是如何被分割到 componentDidMount 和 componentWillUnmount 中的。而且 componentDidMount 中同时包含了两个不同功能的代码。

    那么 Hook 如何解决这个问题呢？就像你可以使用多个 state 的 Hook 一样，你也可以使用多个 effect。这会将不相关逻辑分离到不同的 effect 中：

    1. function FriendStatusWithCounter(props) {
    2.   const [count, setCount] = useState(0);
    3.   useEffect(() => {
    4.     document.title = `You clicked ${count} times`;
    5.   });
    7.   const [isOnline, setIsOnline] = useState(null);
    8.   useEffect(() => {
    9.     function handleStatusChange(status) {
    10.       setIsOnline(status.isOnline);
    11.     }
    13.     ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);
    14.     return () => {
    15.       ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);
    16.     };
    17.   });
    18.   // ...
    19. }

    Hook 允许我们按照代码的用途分离他们， 而不是像生命周期函数那样。React 将按照 effect 声明的顺序依次调用组件中的每一个 effect。

    解释: 为什么每次更新的时候都要运行 Effect

    如果你已经习惯了使用 class，那么你可能会想知道为什么 effect 在每次重渲染时都会执行，而不是只在卸载组件的时候执行一次。让我们看一个实际的例子，看看为什么这个设计可以帮助我们创建 bug 更少的组件。

    在本章节开始时，我们介绍了一个用于显示好友是否在线的 FriendStatus 组件。从 class 中 props 读取 friend.id，然后在组件挂载后订阅好友的状态，并在卸载组件的时候取消订阅：

    1.   componentDidMount() {
    2.     ChatAPI.subscribeToFriendStatus(
    3.       this.props.friend.id,
    4.       this.handleStatusChange
    5.     );
    6.   }
    8.   componentWillUnmount() {
    9.     ChatAPI.unsubscribeFromFriendStatus(
    10.       this.props.friend.id,
    11.       this.handleStatusChange
    12.     );
    13.   }

    但是当组件已经显示在屏幕上时，friend prop 发生变化时会发生什么？ 我们的组件将继续展示原来的好友状态。这是一个 bug。而且我们还会因为取消订阅时使用错误的好友 ID 导致内存泄露或崩溃的问题。

    在 class 组件中，我们需要添加 componentDidUpdate 来解决这个问题：

    1.   componentDidMount() {
    2.     ChatAPI.subscribeToFriendStatus(
    3.       this.props.friend.id,
    4.       this.handleStatusChange
    5.     );
    6.   }
    8.   componentDidUpdate(prevProps) {
    9.     // 取消订阅之前的 friend.id
    10.     ChatAPI.unsubscribeFromFriendStatus(
    11.       prevProps.friend.id,
    12.       this.handleStatusChange
    13.     );
    14.     // 订阅新的 friend.id
    15.     ChatAPI.subscribeToFriendStatus(
    16.       this.props.friend.id,
    17.       this.handleStatusChange
    18.     );
    19.   }
    21.   componentWillUnmount() {
    22.     ChatAPI.unsubscribeFromFriendStatus(
    23.       this.props.friend.id,
    24.       this.handleStatusChange
    25.     );
    26.   }

    忘记正确地处理 componentDidUpdate 是 React 应用中常见的 bug 来源。

    现在看一下使用 Hook 的版本：

    1. function FriendStatus(props) {
    2.   // ...
    3.   useEffect(() => {
    4.     // ...
    5.     ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);
    6.     return () => {
    7.       ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);
    8.     };
    9.   });

    它并不会受到此 bug 影响。(虽然我们没有对它做任何改动。)

    并不需要特定的代码来处理更新逻辑，因为 useEffect 默认就会处理。它会在调用一个新的 effect 之前对前一个 effect 进行清理。为了说明这一点，下面按时间列出一个可能会产生的订阅和取消订阅操作调用序列：

    1. // Mount with { friend: { id: 100 } } props
    2. ChatAPI.subscribeToFriendStatus(100, handleStatusChange);     // 运行第一个 effect
    4. // Update with { friend: { id: 200 } } props
    5. ChatAPI.unsubscribeFromFriendStatus(100, handleStatusChange); // 清除上一个 effect
    6. ChatAPI.subscribeToFriendStatus(200, handleStatusChange);     // 运行下一个 effect
    8. // Update with { friend: { id: 300 } } props
    9. ChatAPI.unsubscribeFromFriendStatus(200, handleStatusChange); // 清除上一个 effect
    10. ChatAPI.subscribeToFriendStatus(300, handleStatusChange);     // 运行下一个 effect
    12. // Unmount
    13. ChatAPI.unsubscribeFromFriendStatus(300, handleStatusChange); // 清除最后一个 effect

    此默认行为保证了一致性，避免了在 class 组件中因为没有处理更新逻辑而导致常见的 bug。

    提示: 通过跳过 Effect 进行性能优化

    在某些情况下，每次渲染后都执行清理或者执行 effect 可能会导致性能问题。在 class 组件中，我们可以通过在 componentDidUpdate 中添加对 prevProps 或 prevState 的比较逻辑解决：

    1. componentDidUpdate(prevProps, prevState) {
    2.   if (prevState.count !== this.state.count) {
    3.     document.title = `You clicked ${this.state.count} times`;
    4.   }
    5. }

    这是很常见的需求，所以它被内置到了 useEffect 的 Hook API 中。如果某些特定值在两次重渲染之间没有发生变化，你可以通知 React 跳过对 effect 的调用，只要传递数组作为 useEffect 的第二个可选参数即可：

    1. useEffect(() => {
    2.   document.title = `You clicked ${count} times`;
    3. }, [count]); // 仅在 count 更改时更新

    上面这个示例中，我们传入 [count] 作为第二个参数。这个参数是什么作用呢？如果 count 的值是 5，而且我们的组件重渲染的时候 count 还是等于 5，React 将对前一次渲染的 [5] 和后一次渲染的 [5] 进行比较。因为数组中的所有元素都是相等的(5 === 5)，React 会跳过这个 effect，这就实现了性能的优化。

    当渲染时，如果 count 的值更新成了 6，React 将会把前一次渲染时的数组 [5] 和这次渲染的数组 [6] 中的元素进行对比。这次因为 5 !== 6，React 就会再次调用 effect。如果数组中有多个元素，即使只有一个元素发生变化，React 也会执行 effect。

    对于有清除操作的 effect 同样适用：

    1. useEffect(() => {
    2.   function handleStatusChange(status) {
    3.     setIsOnline(status.isOnline);
    4.   }
    6.   ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);
    7.   return () => {
    8.     ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);
    9.   };
    10. }, [props.friend.id]); // 仅在 props.friend.id 发生变化时，重新订阅

    未来版本，可能会在构建时自动添加第二个参数。

    注意：

    如果你要使用此优化方式，请确保数组中包含了所有外部作用域中会随时间变化并且在 effect 中使用的变量，否则你的代码会引用到先前渲染中的旧变量。参阅文档，了解更多关于如何处理函数以及数组频繁变化时的措施内容。

    如果想执行只运行一次的 effect（仅在组件挂载和卸载时执行），可以传递一个空数组（[]）作为第二个参数。这就告诉 React 你的 effect 不依赖于 props 或 state 中的任何值，所以它永远都不需要重复执行。这并不属于特殊情况 —— 它依然遵循依赖数组的工作方式。

    如果你传入了一个空数组（[]），effect 内部的 props 和 state 就会一直拥有其初始值。尽管传入 [] 作为第二个参数更接近大家更熟悉的 componentDidMount 和 componentWillUnmount 思维模式，但我们有更好的方式来避免过于频繁的重复调用 effect。除此之外，请记得 React 会等待浏览器完成画面渲染之后才会延迟调用 useEffect，因此会使得额外操作很方便。

    我们推荐启用 eslint-plugin-react-hooks 中的 exhaustive-deps 规则。此规则会在添加错误依赖时发出警告并给出修复建议。

    下一步

    恭喜你！完成本章节学习，希望关于 effect 的大多数问题都得到了解答。你已经学习了 State Hook 和 Effect Hook，将它们结合起来你可以做很多事情了。它们涵盖了大多数使用 class 的用例 —— 如果没有，你可以查看其他的 Hook。

    我们看到了 Hook 如何解决简介章节中动机部分提出的问题。我们也发现 effect 的清除机制可以避免了 componentDidUpdate 和 componentWillUnmount 中的重复，同时让相关的代码关联更加紧密，帮助我们避免一些 bug。我们还看到了我们如何根据 effect 的功能分隔他们，这是在 class 中无法做到的。

    此时你可能会好奇 Hook 是如何工作的。在两次渲染间，React如何知道哪个 useState 调用对应于哪个 state 变量？React 又是如何匹配前后两次渲染中的每一个 effect 的？在下一章节中我们会学习使用 Hook 的规则 —— 这对 Hook 的工作至关重要。