React 的使用
![https://raw.githubusercontent.com/orionpax1997/picx-images-hosting/master/Development/react-banner.3b3ttc6ic9q0.webp](https://raw.githubusercontent.com/orionpax1997/picx-images-hosting/master/Development/react-banner.3b3ttc6ic9q0.webp)
1 简介
React 是一个用于构建用户界面的 JavaScript 库。(就是个状态机,将根据数据源映射出 UI,遵守一定的规范可以将,UI 和 逻辑分离,更容易调试和编写单元测试)
声明式
React 可以非常轻松地创建用户交互界面。为你应用的每一个状态设计简洁的视图,在数据改变时 React 也可以高效地更新渲染界面。以声明式编写 UI,可以让你的代码更加可靠,且方便调试。
组件化
创建好拥有各自状态的组件,再由组件构成更加复杂的界面。无需再用模版代码,通过使用 JavaScript 编写的组件你可以更好地传递数据,将应用状态和 DOM 拆分开来。
2 基础
2.1 Hello World
|
|
2.2 理解 JSX
- 本质 : 不是模板引擎而是动态创建组件(使用 JavaScript 原生的 DOM API
document.createElement()
)的语法糖。JSX 防注入攻击。React DOM 在渲染之前默认会过滤所有传入的值。它可以确保你的应用不会被注入攻击。所有的内容在渲染之前都被转换成了字符串。这样可以有效地防止 XSS(跨站脚本)攻击。 - 对比其他模板语言的优点
- 使用声明式创建页面比较直观
- 使用代码创建页面十分灵活
- 不需要学习一门新的模板语言
- 约定
- React 认为小写的 tag 是原生的 DOM 节点,例如:
<div>
。 - 大写字母开头的为自定义组件。
- JAX 标记可以直接使用属性语法,例如:
<menu.Item>
。
- React 认为小写的 tag 是原生的 DOM 节点,例如:
2.3 元素渲染
React 只会更新必要的部分。React DOM 首先会比较元素内容先后的不同,而在渲染过程中只会更新改变了的部分。根据我们以往的经验,将界面视为一个个特定时刻的固定内容(就像一帧一帧的动画),而不是随时处于变化之中(而不是处于变化中的一整段动画),将会有利于我们理清开发思路,减少各种 bug。
2.4 理解 React 组件
2.4.1 概念
- React 组件一般不提供方法,而是某种状态机。
- React 组件可以理解为一个纯函数(输入是什么结果一定是什么)。
- 单向数据绑定(外部通过 props 传递参数给内部,内部发生变化时暴露事件给外部)。
2.4.2 实例
|
|
2.4.3 创建一个 React 组件
- 方法论
- 创建静态 UI(原型)。
- 考虑组件的状态组成(外部传递还是内部维护)。
- 考虑组件的交互方式(内部用户进行的操作如何暴露给外部的人使用)。
- 单一职责原则
- 每个组件只做一件事。
- 如果组件变得复杂,那么应该拆分成小的组件(拆分小组件可以在降低复杂度的同时提高性能,对组件状态进行更新时刷新范围变小)。
- DRY 原则
- 能够计算得到的状态就不要单独存储。
- 组件尽量无状态,所需数据通过 props 获取。
2.4.4 受控组件和非受控组件
- 受控组件 : 组件或表单元素状态由使用者维护。React 中表单元素通常作为受控组件使用。对外暴露修改事件的静态组件也属于受控组件。
- 非受控组件 : 组件状态由自身维护,或表单元素状态由 DOM 自身维护。
2.5 Props
- 当 React 遇到的元素是用户自定义的组件,它会将 JSX 属性作为单个对象传递给该组件,这个对象称之为“props”。
- Props 的只读性。无论是使用函数或是类来声明一个组件,它决不能修改它自己的 props。
- 我们建议从组件自身的角度来命名 props,而不是根据使用组件的上下文命名。
- React 是非常灵活的,但它也有一个严格的规则:所有的 React 组件必须像纯函数那样使用它们的 props。
2.6 State
- 不要直接更新状态。应当使用 setState()。构造函数是唯一能够初始化 this.state 的地方。
- 状态更新可能是异步的。React 可以将多个 setState() 调用合并成一个调用来提高性能。因为 this.props 和 this.state 可能是异步更新的,你不应该依靠它们的值来计算下一个状态。
- 数据自顶向下流动。父组件或子组件都不能知道某个组件是有状态还是无状态,并且它们不应该关心某组件是被定义为一个函数还是一个类。这就是为什么状态通常被称为局部或封装。 除了拥有并设置它的组件外,其它组件不可访问。这通常被称为自顶向下或单向数据流。 任何状态始终由某些特定组件所有,并且从该状态导出的任何数据或 UI 只能影响树中下方的组件。
- 经过计算后的值不应该赋给 state,正确的模式应该是在渲染时计算这些值。这样保证了计算后的值永远不会与派生出它的 props 值不同步。
- 在 React 应用程序中,组件是有状态还是无状态被认为是可能随时间而变化的组件的实现细节。 可以在有状态组件中使用无状态组件,反之亦然。
2.7 React 组件生命周期及使用场景
- render()
- 唯一必须实现的方法
- render() 函数应该为纯函数,这意味着在不修改组件 state 的情况下,每次调用时都返回相同的结果,并且它不会直接与浏览器交互。
- constructor(props)
- 用于初始化内部状态(很少使用)
- 唯一可以直接修改 state 的地方
- static getDerivedStateFromProps(props, state)
- 当 state 需要从 props 初始化时使用
- 尽量不要使用(维护两者状态一致性会增加复杂度)
- 每次 render 都会调用
- 典型场景:表单控件获取默认值
- componentDidMount()
- UI 渲染完成后调用
- 只执行一次
- 典型场景:获取外部资源初始化 state
- componentWillUnmount()
- 组件移除时调用
- 典型场景:释放资源
- getSnapshotBeforeUpdate(prevProps, prevState)
- 在最近一次渲染输出(提交到 DOM 节点)之前调用。
- 典型场景:获取 render 之前的 DOM 状态(例如:滚动位置)
- componentDidUpdate(prevProps, prevState, snapshot)
- 每次 UI 更新时调用
- 典型场景:页面需要根据 props 变化重新获取数据
- shouldComponentUpdate(nextProps, nextState)
- 决定 Virtual DOM 是否要重绘
- 一般可以由 PureComponent 自动实现
- 典型场景:性能优化
2.8 React 事件处理
- React 事件绑定属性的命名采用驼峰式写法,而不是小写。
- 如果采用 JSX 的语法你需要传入一个函数作为事件处理函数,而不是一个字符串(DOM 元素的写法)
- 在 React 中另一个不同是你不能使用返回 false 的方式阻止默认行为。你必须明确的使用 preventDefault。
- 你必须谨慎对待 JSX 回调函数中的 this,类的方法默认是不会绑定 this 的。如果你忘记绑定 this, 当你调用这个函数的时候 this 的值会是 undefined。
- 向事件处理程序传递参数
1 2 3 4 5
//两种方式是等价的,分别通过 arrow functions 和 Function.prototype.bind 来为事件处理函数传递参数。 //通过箭头函数的方式,事件对象必须显式的进行传递 <button onClick={(e) => this.deleteRow(id, e)}>Delete Row</button> //但是通过 bind 的方式,事件对象以及更多的参数将会被隐式的进行传递。值得注意的是,通过 bind 方式向监听函数传参,在类组件中定义的监听函数,事件对象 e 要排在所传递参数的后面。 <button onClick={this.deleteRow.bind(this, id)}>Delete Row</button>
2.9 条件渲染
- 与运算符 &&
- 三目运算符
- 阻止组件渲染。在极少数情况下,你可能希望隐藏组件,即使它被其他组件渲染。让 render 方法返回 null 而不是它的渲染结果即可实现。
2.10 Keys
- Keys 可以在 DOM 中的某些元素被增加或删除的时候帮助 React 识别哪些元素发生了变化。因此你应当给数组中的每一个元素赋予一个确定的标识。
- 一个元素的 key 最好是这个元素在列表中拥有的一个独一无二的字符串。通常,我们使用来自数据的 id 作为元素的 key。当元素没有确定的 id 时,你可以使用他的序列号索引 index 作为 key。==如果列表项目的顺序可能会变化,我们不建议使用索引来用作键值,因为这样做会导致性能的负面影响==,还可能引起组件状态问题。如果你选择不指定显式的键值,那么 React 将默认使用索引用作为列表项目的键值。
- 元素的 key 只有放在其环绕数组的上下文中才有意义。比方说,如果你提取出一个 ListItem 组件,你应该把 key 保存在数组中的这个<ListItem />元素上,而不是放在 ListItem 组件中的<li>元素上。
2.11 表单
-
在 HTML 当中,像
<input>
,<textarea>
, 和<select>
这类表单元素会维持自身状态,并根据用户输入进行更新。但在 React 中,可变的状态通常保存在组件的状态属性中,并且只能用setState()
方法进行更新。我们通过使 react 变成一种单一数据源的状态来结合二者。React 负责渲染表单的组件仍然控制用户后续输入时所发生的变化。相应的,其值由 React 控制的输入表单元素称为“受控组件”。 -
多个输入的解决方法
1 2 3 4 5 6 7 8 9 10
//当你有处理多个受控的input元素时,你可以通过给每个元素添加一个name属性,来让处理函数根据 event.target.name的值来选择做什么。 handleInputChange(event) { const target = event.target; const value = target.type === 'checkbox' ? target.checked : target.value; const name = target.name; this.setState({ [name]: value }); }
2.12 状态提升
- 在 React 应用中,对应任何可变数据理应只有一个单一“数据源”。通常,状态都是首先添加在需要渲染数据的组件中。然后,如果另一个组件也需要这些数据,你可以将数据提升至离它们最近的共同祖先中。
- 向下传递父组件的 State 及其更新方法。
- 状态提升要写更多的“炉墙代码”,比起双向绑定方式,但带来的好处是,你也可以花更少的工作量找到和隔离 bug。因为任何生活在某些组件中的状态数据,也只有该组件它自己能够操作这些数据,发生 bug 的表面积就被大大地减小了。
- 如果某些数据可以由 props 或者 state 推导出来,那么它很有可能不应该在 state 中出现。
2.13 组合 vs 继承
React 有十分强大的组合模式。我们推荐使用组合而非继承来实现组件间的代码重用。
在这篇文档中,我们将考虑初学 React 的开发人员使用继承时经常会遇到的一些问题,并展示如何通过组合思想来解决这些问题。
2.13.1 包含关系
有些组件无法提前知晓它们子组件的具体内容。在 Sidebar
(侧边栏)和 Dialog
(对话框)等展现通用容器(box)的组件中特别容易遇到这种情况。
我们建议这些组件使用一个特殊的 children
prop 来将他们的子组件传递到渲染结果中:
|
|
这使得别的组件可以通过 JSX 嵌套,将任意组件作为子组件传递给它们。
|
|
<FancyBorder>
JSX 标签中的所有内容都会作为一个 children
prop 传递给 FancyBorder
组件。因为 FancyBorder
将 {props.children}
渲染在一个 <div>
中,被传递的这些子组件最终都会出现在输出结果中。
少数情况下,你可能需要在一个组件中预留出几个“洞”。这种情况下,我们可以不使用 children
,而是自行约定:将所需内容传入 props,并使用相应的 prop。
|
|
<Contacts />
和 <Chat />
之类的 React 元素本质就是对象(object),所以你可以把它们当作 props,像其他数据一样传递。这种方法可能使你想起别的库中“槽”(slot)的概念,但在 React 中没有“槽”这一概念的限制,你可以将任何东西作为 props 进行传递。
2.13.2 特例关系
有些时候,我们会把一些组件看作是其他组件的特殊实例,比如 WelcomeDialog
可以说是 Dialog
的特殊实例。
在 React 中,我们也可以通过组合来实现这一点。“特殊”组件可以通过 props 定制并渲染“一般”组件:
|
|
组合也同样适用于以 class 形式定义的组件。
|
|
2.13.3 那么继承呢?
在 Facebook,我们在成百上千个组件中使用 React。我们并没有发现需要使用继承来构建组件层次的情况。
Props 和组合为你提供了清晰而安全地定制组件外观和行为的灵活方式。注意:组件可以接受任意 props,包括基本数据类型,React 元素以及函数。
如果你想要在组件间复用非 UI 的功能,我们建议将其提取为一个单独的 JavaScript 模块,如函数、对象或者类。组件可以直接引入(import)而无需通过 extend 继承它们。
2.14 React 哲学
我们认为,React 是用 JavaScript 构建快速响应的大型 Web 应用程序的首选方式。它在 Facebook 和 Instagram 上表现优秀。
React 最棒的部分之一是引导我们思考如何构建一个应用。在这篇文档中,我们将会通过 React 构建一个可搜索的产品数据表格来更深刻地领会 React 哲学。
2.14.1 从设计稿开始
假设我们已经有了一个返回 JSON 的 API,以及设计师提供的组件设计稿。如下所示:
该 JSON API 会返回以下数据:
|
|
2.14.2 第一步:将设计好的 UI 划分为组件层级
首先,你需要在设计稿上用方框圈出每一个组件(包括它们的子组件),并且以合适的名称命名。如果你是和设计师一起完成此任务,那么他们可能已经做过类似的工作,所以请和他们进行交流!他们的 Photoshop 的图层名称可能最终就是你编写的 React 组件的名称!
但你如何确定应该将哪些部分划分到一个组件中呢?你可以将组件当作一种函数或者是对象来考虑,根据单一功能原则来判定组件的范围。也就是说,一个组件原则上只能负责一个功能。如果它需要负责更多的功能,这时候就应该考虑将它拆分成更小的组件。
在实践中,因为你经常是在向用户展示 JSON 数据模型,所以如果你的模型设计得恰当,UI(或者说组件结构)便会与数据模型一一对应,这是因为 UI 和数据模型都会倾向于遵守相同的信息结构。将 UI 分离为组件,其中每个组件需与数据模型的某部分匹配。
你会看到我们的应用中包含五个组件。我们已经将每个组件展示的数据标注为了斜体。图片中的序号与下方列表中的序号对应。
FilterableProductTable
(橙色): 是整个示例应用的整体SearchBar
(蓝色): 接受所有的用户输入ProductTable
(绿色): 展示数据内容并根据用户输入筛选结果ProductCategoryRow
(天蓝色): 为每一个产品类别展示标题ProductRow
(红色): 每一行展示一个产品
你可能注意到,ProductTable
的表头(包含 “Name” 和 “Price” 的那一部分)并未单独成为一个组件。这仅仅是一种偏好选择,如何处理这一问题也一直存在争论。就这个示例而言,因为表头只起到了渲染数据集合的作用——这与 ProductTable
是一致的,所以我们仍然将其保留为 ProductTable
的一部分。但是,如果表头过于复杂(例如,我们需为其添加排序功能),那么将它作为一个独立的 ProductTableHeader
组件就显得很有必要了。
现在我们已经确定了设计稿中应该包含的组件,接下来我们将把它们描述为更加清晰的层级。设计稿中被其他组件包含的子组件,在层级上应该作为其子节点。
FilterableProductTable
SearchBar
ProductTable
ProductCategoryRow
ProductRow
2.14.3 第二步:用 React 创建一个静态版本
参阅 CodePen 上的 React 哲学:第二步。
现在我们已经确定了组件层级,可以编写对应的应用了。最容易的方式,是先用已有的数据模型渲染一个不包含交互功能的 UI。最好将渲染 UI 和添加交互这两个过程分开。这是因为,编写一个应用的静态版本时,往往要编写大量代码,而不需要考虑太多交互细节;添加交互功能时则要考虑大量细节,而不需要编写太多代码。所以,将这两个过程分开进行更为合适。我们会在接下来的代码中体会到其中的区别。
在构建应用的静态版本时,我们需要创建一些会重用其他组件的组件,然后通过 props 传入所需的数据。props 是父组件向子组件传递数据的方式。即使你已经熟悉了 state 的概念,也完全不应该使用 state 构建静态版本。state 代表了随时间会产生变化的数据,应当仅在实现交互时使用。所以构建应用的静态版本时,你不会用到它。
你可以自上而下或者自下而上构建应用:自上而下意味着首先编写层级较高的组件(比如 FilterableProductTable
),自下而上意味着从最基本的组件开始编写(比如 ProductRow
)。当你的应用比较简单时,使用自上而下的方式更方便;对于较为大型的项目来说,自下而上地构建,并同时为低层组件编写测试是更加简单的方式。
到此为止,你应该已经有了一个可重用的组件库来渲染你的数据模型。由于我们构建的是静态版本,所以这些组件目前只需提供 render()
方法用于渲染。最顶层的组件 FilterableProductTable
通过 props 接受你的数据模型。如果你的数据模型发生了改变,再次调用 root.render()
,UI 就会相应地被更新。数据模型变化、调用 render()
方法、UI 相应变化,这个过程并不复杂,因此很容易看清楚 UI 是如何被更新的,以及是在哪里被更新的。React 单向数据流(也叫单向绑定)的思想使得组件模块化,易于快速开发。
如果你在完成这一步骤时遇到了困难,可以参阅 React 文档。
2.14.3.1 补充说明: 有关 props 和 state
在 React 中,有两类“模型”数据:props 和 state。清楚地理解两者的区别是十分重要的;如果你不太有把握,可以参阅 React 官方文档。你也可以查看 FAQ: state 与 props 的区别是什么?
2.14.4 第三步:确定 UI state 的最小(且完整)表示
想要使你的 UI 具备交互功能,需要有触发基础数据模型改变的能力。React 通过实现 state 来完成这个任务。
为了正确地构建应用,你首先需要找出应用所需的 state 的最小表示,并根据需要计算出其他所有数据。其中的关键正是 DRY: Don’t Repeat Yourself。只保留应用所需的可变 state 的最小集合,其他数据均由它们计算产生。比如,你要编写一个任务清单应用,你只需要保存一个包含所有事项的数组,而无需额外保存一个单独的 state 变量(用于存储任务个数)。当你需要展示任务个数时,只需要利用该数组的 length 属性即可。
我们的示例应用拥有如下数据:
- 包含所有产品的原始列表
- 用户输入的搜索词
- 复选框是否选中的值
- 经过搜索筛选的产品列表
通过问自己以下三个问题,你可以逐个检查相应数据是否属于 state:
- 该数据是否是由父组件通过 props 传递而来的?如果是,那它应该不是 state。
- 该数据是否随时间的推移而保持不变?如果是,那它应该也不是 state。
- 你能否根据其他 state 或 props 计算出该数据的值?如果是,那它也不是 state。
包含所有产品的原始列表是经由 props 传入的,所以它不是 state;搜索词和复选框的值应该是 state,因为它们随时间会发生改变且无法由其他数据计算而来;经过搜索筛选的产品列表不是 state,因为它的结果可以由产品的原始列表根据搜索词和复选框的选择计算出来。
综上所述,属于 state 的有:
- 用户输入的搜索词
- 复选框是否选中的值
2.14.5 第四步:确定 state 放置的位置
参阅 CodePen 上的 React 哲学:第四步。
我们已经确定了应用所需的 state 的最小集合。接下来,我们需要确定哪个组件能够改变这些 state,或者说拥有这些 state。
注意:React 中的数据流是单向的,并顺着组件层级从上往下传递。哪个组件应该拥有某个 state 这件事,对初学者来说往往是最难理解的部分。尽管这可能在一开始不是那么清晰,但你可以尝试通过以下步骤来判断:
对于应用中的每一个 state:
- 找到根据这个 state 进行渲染的所有组件。
- 找到他们的共同所有者(common owner)组件(在组件层级上高于所有需要该 state 的组件)。
- 该共同所有者组件或者比它层级更高的组件应该拥有该 state。
- 如果你找不到一个合适的位置来存放该 state,就可以直接创建一个新的组件来存放该 state,并将这一新组件置于高于共同所有者组件层级的位置。
根据以上策略重新考虑我们的示例应用:
ProductTable
需要根据 state 筛选产品列表。SearchBar
需要展示搜索词和复选框的状态。- 他们的共同所有者是
FilterableProductTable
。 - 因此,搜索词和复选框的值应该很自然地存放在
FilterableProductTable
组件中。
很好,我们已经决定把这些 state 存放在 FilterableProductTable
组件中。首先,将实例属性 this.state = {filterText: '', inStockOnly: false}
添加到 FilterableProductTable
的 constructor
中,设置应用的初始 state;接着,将 filterText
和 inStockOnly
作为 props 传入 ProductTable
和 SearchBar
;最后,用这些 props 筛选 ProductTable
中的产品信息,并设置 SearchBar
的表单值。
你现在可以看到应用的变化了:将 filterText
设置为 "ball"
并刷新应用,你能发现表格中的数据已经更新了。
2.14.6 第五步:添加反向数据流
参阅 CodePen 上的 React 哲学:第五步。
到目前为止,我们已经借助自上而下传递的 props 和 state 渲染了一个应用。现在,我们将尝试让数据反向传递:处于较低层级的表单组件更新较高层级的 FilterableProductTable
中的 state。
React 通过一种比传统的双向绑定略微繁琐的方法来实现反向数据传递。尽管如此,但这种需要显式声明的方法更有助于人们理解程序的运作方式。
如果你尝试在上一个示例的搜索框中输入或勾选复选框(步骤 4),React 不会产生任何响应。这是正常的,因为我们之前已经将 input
的值设置为了从 FilterableProductTable
的 state
传递而来的固定值。
让我们重新梳理一下需要实现的功能:每当用户改变表单的值,我们需要改变 state 来反映用户的当前输入。由于 state 只能由拥有它们的组件进行更改,FilterableProductTable
必须将一个能够触发 state 改变的回调函数(callback)传递给 SearchBar
。我们可以使用输入框的 onChange
事件来监视用户输入的变化,并通知 FilterableProductTable
传递给 SearchBar
的回调函数。然后该回调函数将调用 setState()
,从而更新应用。
3 扩展
3.1 理解 Virtual DOM
- 虚拟 DOM 如何工作(DIFF 算法)
- 广度优先分层比较,针对 UI 很少发生跨层移动
- 兄弟间位置移动会根据 key 交换位置
- DOM 跨层移动 React 不会做检查,就是简单的删除然后添加
- 虚拟 DOM 的两个假设
- 组件的 DOM 结构是相对稳定的
- 类型相同的兄弟节点可以被唯一标识
3.2 组件设计模式
3.2.1 高阶组件
-
高阶组件接收组件作为参数,定义通用逻辑、状态,render 方法中将定义的状态和逻辑作为 props 传给接收的组件并直接返回。
-
高阶组件类似于已实现的功能接口,子组件引入高阶组件
import 高阶组件函数名 form "组件路径"
,在内部使用高阶组件将会传递的 props,然后导出通过高阶组件封装的组件给外部使用export default 高阶组件函数名(组件)
-
不要改变原始组件,高阶组件应该使用组合技术,将输入组件包裹到一个容器组件。
-
约定:贯穿传递不相关 props 属性给被包裹的组件
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
render() { // 过滤掉专用于这个阶组件的props属性, // 不应该被贯穿传递 const { extraProp, ...passThroughProps } = this.props; // 向被包裹的组件注入props属性,这些一般都是状态值或 // 实例方法 const injectedProp = someStateOrInstanceMethod; // 向被包裹的组件传递props属性 return ( <WrappedComponent injectedProp={injectedProp} {...passThroughProps} /> ); }
-
约定:包装显示名字以便于调试
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
//最常用的技术是包裹显示名字给被包裹的组件。所以,如果你的高阶组件名字是 withSubscription, //且被包裹的组件的显示名字是 CommentList,那么就是用 WithSubscription(CommentList)这样的显示名字 function withSubscription(WrappedComponent) { class WithSubscription extends React.Component { /* ... */ } WithSubscription.displayName = `WithSubscription(${getDisplayName( WrappedComponent )})`; return WithSubscription; } function getDisplayName(WrappedComponent) { return WrappedComponent.displayName || WrappedComponent.name || "Component"; }
-
告诫:不要在 render 方法内使用高阶组件
-
告诫:必须将静态方法做拷贝。当你应用一个高阶组件到一个组件时,原始组件被包裹于一个容器组件内,也就意味着新组件会没有原始组件的任何静态方法。
-
告诫:Refs 属性不能贯穿传递
-
典型场景:通用逻辑复用
3.2.2 框架(外包装)组件
- 框架组件接收 props.children 作为可变的 UI 显示。定义通用 UI,变化部分使用 props.children,使用者决定这部分如何展示。
- 典型场景:通用 UI 复用
3.3 Context
-
Context 通过组件树提供了一个传递数据的方法,从而避免了在每一个层级手动的传递 props 属性。
-
不要仅仅为了避免在几个层级下的组件传递 props 而使用 context,它是被用于在多个层级的多个组件需要访问相同数据的情景。
-
实例
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// 创建一个 theme Context, 默认 theme 的值为 light const ThemeContext = React.createContext("light"); function ThemedButton(props) { // ThemedButton 组件从 context 接收 theme return ( <ThemeContext.Consumer> {theme => <Button {...props} theme={theme} />} </ThemeContext.Consumer> ); } // 中间组件 function Toolbar(props) { return ( <div> <ThemedButton /> </div> ); } class App extends React.Component { render() { return ( <ThemeContext.Provider value="dark"> <Toolbar /> </ThemeContext.Provider> ); } }
-
可以使用高阶组件的设计模式很容易的封装 Context
1 2 3 4 5 6 7 8 9 10 11 12 13 14
const ThemeContext = React.createContext("light"); // 在函数中引入组件 export function withTheme(Component) { // 然后返回另一个组件 return function ThemedComponent(props) { // 最后使用context theme渲染这个被封装组件 // 注意我们照常引用了被添加的属性 return ( <ThemeContext.Consumer> {theme => <Component {...props} theme={theme} />} </ThemeContext.Consumer> ); }; }
-
React 以前使用实验性的 context API 运行,旧的 API 将会在 16.x 版本中得到支持,但使用到它的应用应该迁移到新版本。遗留的 API 将在未来的 React 版本中被移除。
3.4 脚手架工具
Create React App 是 Facebook 的一个最简依赖的脚手架工具,适合学习 React 或者开发简单应用。
Rekit 基于 Create React App 多整合了很多必要的库,同时提供拆分大型项目耦合度的架构。
Codesandbox 在线 IDE + 脚手架,不关注项目细节,打包部署过程隐藏。
3.5 生态圈
3.5.1 Redux
Redux 是 React 全家桶的一员,Redux 是 JavaScript 状态容器,提供可预测化的状态管理。
3.5.2 React Router
React Router 是完整的 React 路由解决方案。React Router 保持 UI 与 URL 同步。它拥有简单的 API 与强大的功能例如代码缓冲加载、动态路由匹配、以及建立正确的位置过渡处理。
3.5.3 webpack
前端打包工具
3.5.4 react-loadable
和 webpack 结合实现按需加载,提高 APP 第一次访问速度
|
|
3.6 Hook
3.6.1 Hook 概览
Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。
Hook 是向下兼容的。本页面为有经验的 React 用户提供一个对 Hook 的概览。这是一个相当快速的概览,如果你有疑惑,可以参阅下面这样的黄色提示框。
详细说明
有关我们为什么要在 React 中引入 Hook 的原因,请参考动机。
↑↑↑ 每个部分的结尾都会有一个如上所示的黄色方框。 它们会链接到更详细的说明。
3.6.1.1 📌 State Hook
这个例子用来显示一个计数器。当你点击按钮,计数器的值就会增加:
|
|
在这里,useState
就是一个 Hook (等下我们会讲到这是什么意思)。通过在函数组件里调用它来给组件添加一些内部 state。React 会在重复渲染时保留这个 state。useState
会返回一对值:当前状态和一个让你更新它的函数,你可以在事件处理函数中或其他一些地方调用这个函数。它类似 class 组件的 this.setState
,但是它不会把新的 state 和旧的 state 进行合并。(我们会在使用 State Hook 里展示一个对比 useState
和 this.state
的例子)。
useState
唯一的参数就是初始 state。在上面的例子中,我们的计数器是从零开始的,所以初始 state 就是 0
。值得注意的是,不同于 this.state
,这里的 state 不一定要是一个对象 —— 如果你有需要,它也可以是。这个初始 state 参数只有在第一次渲染时会被用到。
####### 声明多个 state 变量
你可以在一个组件中多次使用 State Hook:
|
|
数组解构的语法让我们在调用 useState
时可以给 state 变量取不同的名字。当然,这些名字并不是 useState
API 的一部分。React 假设当你多次调用 useState
的时候,你能保证每次渲染时它们的调用顺序是不变的。后面我们会再次解释它是如何工作的以及在什么场景下使用。
####### 那么,什么是 Hook?
Hook 是一些可以让你在函数组件里“钩入” React state 及生命周期等特性的函数。Hook 不能在 class 组件中使用 —— 这使得你不使用 class 也能使用 React。(我们不推荐把你已有的组件全部重写,但是你可以在新组件里开始使用 Hook。)
React 内置了一些像 useState
这样的 Hook。你也可以创建你自己的 Hook 来复用不同组件之间的状态逻辑。我们会先介绍这些内置的 Hook。
详细说明
你可以在这一章节了解更多关于 State Hook 的内容:使用 State Hook。
3.6.1.2 ⚡️ Effect Hook
你之前可能已经在 React 组件中执行过数据获取、订阅或者手动修改过 DOM。我们统一把这些操作称为“副作用”,或者简称为“作用”。
useEffect
就是一个 Effect Hook,给函数组件增加了操作副作用的能力。它跟 class 组件中的 componentDidMount
、componentDidUpdate
和 componentWillUnmount
具有相同的用途,只不过被合并成了一个 API。(我们会在使用 Effect Hook 里展示对比 useEffect
和这些方法的例子。)
例如,下面这个组件在 React 更新 DOM 后会设置一个页面标题:
|
|
当你调用 useEffect
时,就是在告诉 React 在完成对 DOM 的更改后运行你的“副作用”函数。由于副作用函数是在组件内声明的,所以它们可以访问到组件的 props 和 state。默认情况下,React 会在每次渲染后调用副作用函数 —— 包括第一次渲染的时候。(我们会在使用 Effect Hook 中跟 class 组件的生命周期方法做更详细的对比。)
副作用函数还可以通过返回一个函数来指定如何“清除”副作用。例如,在下面的组件中使用副作用函数来订阅好友的在线状态,并通过取消订阅来进行清除操作:
|
|
在这个示例中,React 会在组件销毁时取消对 ChatAPI
的订阅,然后在后续渲染时重新执行副作用函数。(如果传给 ChatAPI
的 props.friend.id
没有变化,你也可以告诉 React 跳过重新订阅。)
跟 useState
一样,你可以在组件中多次使用 useEffect
:
|
|
通过使用 Hook,你可以把组件内相关的副作用组织在一起(例如创建订阅及取消订阅),而不要把它们拆分到不同的生命周期函数里。
详细说明
你可以在这一章节了解更多关于
useEffect
的内容:使用 Effect Hook
3.6.1.3 ✌️ Hook 使用规则
Hook 就是 JavaScript 函数,但是使用它们会有两个额外的规则:
- 只能在函数最外层调用 Hook。不要在循环、条件判断或者子函数中调用。
- 只能在 React 的函数组件中调用 Hook。不要在其他 JavaScript 函数中调用。(还有一个地方可以调用 Hook —— 就是自定义的 Hook 中,我们稍后会学习到。)
同时,我们提供了 linter 插件来自动执行这些规则。这些规则乍看起来会有一些限制和令人困惑,但是要让 Hook 正常工作,它们至关重要。
详细说明
你可以在这章节了解更多关于这些规则的内容:Hook 使用规则。
3.6.1.4 💡 自定义 Hook
有时候我们会想要在组件之间重用一些状态逻辑。目前为止,有两种主流方案来解决这个问题:高阶组件和 render props。自定义 Hook 可以让你在不增加组件的情况下达到同样的目的。
前面,我们介绍了一个叫 FriendStatus
的组件,它通过调用 useState
和 useEffect
的 Hook 来订阅一个好友的在线状态。假设我们想在另一个组件里重用这个订阅逻辑。
首先,我们把这个逻辑抽取到一个叫做 useFriendStatus
的自定义 Hook 里:
|
|
它将 friendID
作为参数,并返回该好友是否在线:
现在我们可以在两个组件中使用它:
|
|
每个组件间的 state 是完全独立的。Hook 是一种复用状态逻辑的方式,它不复用 state 本身。事实上 Hook 的每次调用都有一个完全独立的 state —— 因此你可以在单个组件中多次调用同一个自定义 Hook。
自定义 Hook 更像是一种约定而不是功能。如果函数的名字以 “use
” 开头并调用其他 Hook,我们就说这是一个自定义 Hook。 useSomething
的命名约定可以让我们的 linter 插件在使用 Hook 的代码中找到 bug。
你可以创建涵盖各种场景的自定义 Hook,如表单处理、动画、订阅声明、计时器,甚至可能还有更多我们没想到的场景。我们很期待看到 React 社区会出现什么样的自定义 Hook。
详细说明
我们会在这一章节介绍更多关于自定义 Hook 的内容: 创建你自己的 Hook。
3.6.1.5 🔌 其他 Hook
除此之外,还有一些使用频率较低的但是很有用的 Hook。比如,useContext
让你不使用组件嵌套就可以订阅 React 的 Context。
|
|
另外 useReducer
可以让你通过 reducer 来管理组件本地的复杂 state。
|
|
详细说明
你可以在这一章节了解更多关于所有内置 Hook 的内容:Hook API 索引。
3.6.2 使用 State Hook
Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。
Hook 简介章节中使用下面的例子介绍了 Hook:
|
|
我们将通过将这段代码与一个等价的 class 示例进行比较来开始学习 Hook。
3.6.2.1 等价的 class 示例
如果你之前在 React 中使用过 class,这段代码看起来应该很熟悉:
|
|
state 初始值为 { count: 0 }
,当用户点击按钮后,我们通过调用 this.setState()
来增加 state.count
。整个章节中都将使用该 class 的代码片段做示例。
注意
你可能想知道为什么我们在这里使用一个计数器例子而不是一个更实际的示例。因为我们还只是初步接触 Hook ,这可以帮助我们将注意力集中到 API 本身。
3.6.2.2 Hook 和函数组件
复习一下, React 的函数组件是这样的:
|
|
或是这样:
|
|
你之前可能把它们叫做“无状态组件”。但现在我们为它们引入了使用 React state 的能力,所以我们更喜欢叫它”函数组件”。
Hook 在 class 内部是不起作用的。但你可以使用它们来取代 class 。
3.6.2.3 Hook 是什么?
在新示例中,首先引入 React 中 useState
的 Hook
|
|
Hook 是什么? Hook 是一个特殊的函数,它可以让你“钩入” React 的特性。例如,useState
是允许你在 React 函数组件中添加 state 的 Hook。稍后我们将学习其他 Hook。
什么时候我会用 Hook? 如果你在编写函数组件并意识到需要向其添加一些 state,以前的做法是必须将其转化为 class。现在你可以在现有的函数组件中使用 Hook。
注意:
在组件中有些特殊的规则,规定什么地方能使用 Hook,什么地方不能使用。我们将在 Hook 规则中学习它们。
3.6.2.4 声明 State 变量
在 class 中,我们通过在构造函数中设置 this.state
为 { count: 0 }
来初始化 count
state 为 0
:
|
|
在函数组件中,我们没有 this
,所以我们不能分配或读取 this.state
。我们直接在组件中调用 useState
Hook:
|
|
调用 useState
方法的时候做了什么? 它定义一个 “state 变量”。我们的变量叫 count
, 但是我们可以叫他任何名字,比如 banana
。这是一种在函数调用时保存变量的方式 —— useState
是一种新方法,它与 class 里面的 this.state
提供的功能完全相同。一般来说,在函数退出后变量就会”消失”,而 state 中的变量会被 React 保留。
useState
需要哪些参数? useState()
方法里面唯一的参数就是初始 state。不同于 class 的是,我们可以按照需要使用数字或字符串对其进行赋值,而不一定是对象。在示例中,只需使用数字来记录用户点击次数,所以我们传了 0
作为变量的初始 state。(如果我们想要在 state 中存储两个不同的变量,只需调用 useState()
两次即可。)
useState
方法的返回值是什么? 返回值为:当前 state 以及更新 state 的函数。这就是我们写 const [count, setCount] = useState()
的原因。这与 class 里面 this.state.count
和 this.setState
类似,唯一区别就是你需要成对的获取它们。如果你不熟悉我们使用的语法,我们会在本章节的底部介绍它。
既然我们知道了 useState
的作用,我们的示例应该更容易理解了:
|
|
我们声明了一个叫 count
的 state 变量,然后把它设为 0
。React 会在重复渲染时记住它当前的值,并且提供最新的值给我们的函数。我们可以通过调用 setCount
来更新当前的 count
。
注意
你可能想知道:为什么叫
useState
而不叫createState
?“Create” 可能不是很准确,因为 state 只在组件首次渲染的时候被创建。在下一次重新渲染时,
useState
返回给我们当前的 state。否则它就不是 “state”了!这也是 Hook 的名字总是以use
开头的一个原因。我们将在后面的 Hook 规则中了解原因。
3.6.2.5 读取 State
当我们想在 class 中显示当前的 count,我们读取 this.state.count
:
|
|
在函数中,我们可以直接用 count
:
|
|
3.6.2.6 更新 State
在 class 中,我们需要调用 this.setState()
来更新 count
值:
|
|
在函数中,我们已经有了 setCount
和 count
变量,所以我们不需要 this
:
|
|
3.6.2.7 总结
现在让我们来仔细回顾一下学到的知识,看下我们是否真正理解了。
|
|
- 第一行: 引入 React 中的
useState
Hook。它让我们在函数组件中存储内部 state。 - 第四行: 在
Example
组件内部,我们通过调用useState
Hook 声明了一个新的 state 变量。它返回一对值给到我们命名的变量上。我们把变量命名为count
,因为它存储的是点击次数。我们通过传0
作为useState
唯一的参数来将其初始化为0
。第二个返回的值本身就是一个函数。它让我们可以更新count
的值,所以我们叫它setCount
。 - 第九行: 当用户点击按钮后,我们传递一个新的值给
setCount
。React 会重新渲染Example
组件,并把最新的count
传给它。
乍一看这似乎有点太多了。不要急于求成!如果你有不理解的地方,请再次查看以上代码并从头到尾阅读。我们保证一旦你试着”忘记” class 里面 state 是如何工作的,并用新的眼光看这段代码,就容易理解了。
3.6.2.7.1 提示:方括号有什么用?
你可能注意到我们用方括号定义了一个 state 变量
|
|
等号左边名字并不是 React API 的部分,你可以自己取名字:
|
|
这种 JavaScript 语法叫数组解构。它意味着我们同时创建了 fruit
和 setFruit
两个变量,fruit
的值为 useState
返回的第一个值,setFruit
是返回的第二个值。它等价于下面的代码:
|
|
当我们使用 useState
定义 state 变量时候,它返回一个有两个值的数组。第一个值是当前的 state,第二个值是更新 state 的函数。使用 [0]
和 [1]
来访问有点令人困惑,因为它们有特定的含义。这就是我们使用数组解构的原因。
注意
你可能会好奇 React 怎么知道
useState
对应的是哪个组件,因为我们并没有传递this
给 React。我们将在 FAQ 部分回答这个问题以及许多其他问题。
3.6.2.7.2 提示:使用多个 state 变量
将 state 变量声明为一对 [something, setSomething]
也很方便,因为如果我们想使用多个 state 变量,它允许我们给不同的 state 变量取不同的名称:
|
|
在以上组件中,我们有局部变量 age
,fruit
和 todos
,并且我们可以单独更新它们:
|
|
你不必使用多个 state 变量。State 变量可以很好地存储对象和数组,因此,你仍然可以将相关数据分为一组。然而,不像 class 中的 this.setState
,更新 state 变量总是替换它而不是合并它。
我们在 FAQ 中提供了更多关于分离独立 state 变量的建议。
3.6.3 使用 Effect Hook
Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。
Effect Hook 可以让你在函数组件中执行副作用操作
|
|
这段代码基于上一章节中的计数器示例进行修改,我们为计数器增加了一个小功能:将 document 的 title 设置为包含了点击次数的消息。
数据获取,设置订阅以及手动更改 React 组件中的 DOM 都属于副作用。不管你知不知道这些操作,或是“副作用”这个名字,应该都在组件中使用过它们。
提示
如果你熟悉 React class 的生命周期函数,你可以把
useEffect
Hook 看做componentDidMount
,componentDidUpdate
和componentWillUnmount
这三个函数的组合。
在 React 组件中有两种常见副作用操作:需要清除的和不需要清除的。我们来更仔细地看一下他们之间的区别。
3.6.3.1 无需清除的 effect
有时候,我们只想**在 React 更新 DOM 之后运行一些额外的代码。**比如发送网络请求,手动变更 DOM,记录日志,这些都是常见的无需清除的操作。因为我们在执行完这些操作之后,就可以忽略他们了。让我们对比一下使用 class 和 Hook 都是怎么实现这些副作用的。
3.6.3.1.1 使用 class 的示例
在 React 的 class 组件中,render
函数是不应该有任何副作用的。一般来说,在这里执行操作太早了,我们基本上都希望在 React 更新 DOM 之后才执行我们的操作。
这就是为什么在 React class 中,我们把副作用操作放到 componentDidMount
和 componentDidUpdate
函数中。回到示例中,这是一个 React 计数器的 class 组件。它在 React 对 DOM 进行操作之后,立即更新了 document 的 title 属性
|
|
注意,在这个 class 中,我们需要在两个生命周期函数中编写重复的代码。
这是因为很多情况下,我们希望在组件加载和更新时执行同样的操作。从概念上说,我们希望它在每次渲染之后执行 —— 但 React 的 class 组件没有提供这样的方法。即使我们提取出一个方法,我们还是要在两个地方调用它。
现在让我们来看看如何使用 useEffect
执行相同的操作。
3.6.3.1.2 使用 Hook 的示例
我们在本章节开始时已经看到了这个示例,但让我们再仔细观察它:
|
|
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 都已经更新完毕。
3.6.3.1.3 详细说明
现在我们已经对 effect 有了大致了解,下面这些代码应该不难看懂了:
|
|
我们声明了 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
相同。
3.6.3.2 需要清除的 effect
之前,我们研究了如何使用不需要清除的副作用,还有一些副作用是需要清除的。例如订阅外部数据源。这种情况下,清除工作是非常重要的,可以防止引起内存泄露!现在让我们来比较一下如何用 Class 和 Hook 来实现。
3.6.3.2.1 使用 Class 的示例
在 React class 中,你通常会在 componentDidMount
中设置订阅,并在 componentWillUnmount
中清除它。例如,假设我们有一个 ChatAPI
模块,它允许我们订阅好友的在线状态。以下是我们如何使用 class 订阅和显示该状态:
|
|
你会注意到 componentDidMount
和 componentWillUnmount
之间相互对应。使用生命周期函数迫使我们拆分这些逻辑代码,即使这两部分代码都作用于相同的副作用。
注意
眼尖的读者可能已经注意到了,这个示例还需要编写
componentDidUpdate
方法才能保证完全正确。我们先暂时忽略这一点,本章节中后续部分会介绍它。
3.6.3.2.2 使用 Hook 的示例
如何使用 Hook 编写这个组件。
你可能认为需要单独的 effect 来执行清除操作。但由于添加和删除订阅的代码的紧密性,所以 useEffect
的设计是在同一个地方执行。如果你的 effect 返回一个函数,React 将会在执行清除操作时调用它:
|
|
为什么要在 effect 中返回一个函数? 这是 effect 可选的清除机制。每个 effect 都可以返回一个清除函数。如此可以将添加和移除订阅的逻辑放在一起。它们都属于 effect 的一部分。
React 何时清除 effect? React 会在组件卸载的时候执行清除操作。正如之前学到的,effect 在每次渲染的时候都会执行。这就是为什么 React 会在执行当前 effect 之前对上一个 effect 进行清除。我们稍后将讨论为什么这将助于避免 bug以及如何在遇到性能问题时跳过此行为。
注意
并不是必须为 effect 中返回的函数命名。这里我们将其命名为
cleanup
是为了表明此函数的目的,但其实也可以返回一个箭头函数或者给起一个别的名字。
3.6.3.3 小结
了解了 useEffect
可以在组件渲染后实现各种不同的副作用。有些副作用可能需要清除,所以需要返回一个函数:
|
|
其他的 effect 可能不必清除,所以不需要返回。
|
|
effect Hook 使用同一个 API 来满足这两种情况。
如果你对 Effect Hook 的机制已经有很好的把握,或者暂时难以消化更多内容,你现在就可以跳转到下一章节学习 Hook 的规则。
3.6.3.4 使用 Effect 的提示
在本节中将继续深入了解 useEffect
的某些特性,有经验的 React 使用者可能会对此感兴趣。你不一定要在现在了解他们,你可以随时查看此页面以了解有关 Effect Hook 的更多详细信息。
3.6.3.4.1 提示: 使用多个 Effect 实现关注点分离
使用 Hook 其中一个目的就是要解决 class 中生命周期函数经常包含不相关的逻辑,但又把相关逻辑分离到了几个不同方法中的问题。下述代码是将前述示例中的计数器和好友在线状态指示器逻辑组合在一起的组件:
|
|
可以发现设置 document.title
的逻辑是如何被分割到 componentDidMount
和 componentDidUpdate
中的,订阅逻辑又是如何被分割到 componentDidMount
和 componentWillUnmount
中的。而且 componentDidMount
中同时包含了两个不同功能的代码。
那么 Hook 如何解决这个问题呢?就像你可以使用多个 state 的 Hook 一样,你也可以使用多个 effect。这会将不相关逻辑分离到不同的 effect 中:
|
|
Hook 允许我们按照代码的用途分离他们, 而不是像生命周期函数那样。React 将按照 effect 声明的顺序依次调用组件中的每一个 effect。
3.6.3.4.2 解释: 为什么每次更新的时候都要运行 Effect
如果你已经习惯了使用 class,那么你或许会疑惑为什么 effect 的清除阶段在每次重新渲染时都会执行,而不是只在卸载组件的时候执行一次。让我们看一个实际的例子,看看为什么这个设计可以帮助我们创建 bug 更少的组件。
在本章节开始时,我们介绍了一个用于显示好友是否在线的 FriendStatus
组件。从 class 中 props 读取 friend.id
,然后在组件挂载后订阅好友的状态,并在卸载组件的时候取消订阅:
|
|
但是当组件已经显示在屏幕上时,friend
prop 发生变化时会发生什么? 我们的组件将继续展示原来的好友状态。这是一个 bug。而且我们还会因为取消订阅时使用错误的好友 ID 导致内存泄露或崩溃的问题。
在 class 组件中,我们需要添加 componentDidUpdate
来解决这个问题:
|
|
忘记正确地处理 componentDidUpdate
是 React 应用中常见的 bug 来源。
现在看一下使用 Hook 的版本:
|
|
它并不会受到此 bug 影响。(虽然我们没有对它做任何改动。)
并不需要特定的代码来处理更新逻辑,因为 useEffect
默认就会处理。它会在调用一个新的 effect 之前对前一个 effect 进行清理。为了说明这一点,下面按时间列出一个可能会产生的订阅和取消订阅操作调用序列:
|
|
此默认行为保证了一致性,避免了在 class 组件中因为没有处理更新逻辑而导致常见的 bug。
3.6.3.4.3 提示: 通过跳过 Effect 进行性能优化
在某些情况下,每次渲染后都执行清理或者执行 effect 可能会导致性能问题。在 class 组件中,我们可以通过在 componentDidUpdate
中添加对 prevProps
或 prevState
的比较逻辑解决:
|
|
这是很常见的需求,所以它被内置到了 useEffect
的 Hook API 中。如果某些特定值在两次重渲染之间没有发生变化,你可以通知 React 跳过对 effect 的调用,只要传递数组作为 useEffect
的第二个可选参数即可:
|
|
上面这个示例中,我们传入 [count]
作为第二个参数。这个参数是什么作用呢?如果 count
的值是 5
,而且我们的组件重渲染的时候 count
还是等于 5
,React 将对前一次渲染的 [5]
和后一次渲染的 [5]
进行比较。因为数组中的所有元素都是相等的(5 === 5
),React 会跳过这个 effect,这就实现了性能的优化。
当渲染时,如果 count
的值更新成了 6
,React 将会把前一次渲染时的数组 [5]
和这次渲染的数组 [6]
中的元素进行对比。这次因为 5 !== 6
,React 就会再次调用 effect。如果数组中有多个元素,即使只有一个元素发生变化,React 也会执行 effect。
对于有清除操作的 effect 同样适用:
|
|
未来版本,可能会在构建时自动添加第二个参数。
注意:
如果你要使用此优化方式,请确保数组中包含了所有外部作用域中会随时间变化并且在 effect 中使用的变量,否则你的代码会引用到先前渲染中的旧变量。参阅文档,了解更多关于如何处理函数以及数组频繁变化时的措施内容。
如果想执行只运行一次的 effect(仅在组件挂载和卸载时执行),可以传递一个空数组(
[]
)作为第二个参数。这就告诉 React 你的 effect 不依赖于 props 或 state 中的任何值,所以它永远都不需要重复执行。这并不属于特殊情况 —— 它依然遵循依赖数组的工作方式。如果你传入了一个空数组(
[]
),effect 内部的 props 和 state 就会一直拥有其初始值。尽管传入[]
作为第二个参数更接近大家更熟悉的componentDidMount
和componentWillUnmount
思维模式,但我们有更好的方式来避免过于频繁的重复调用 effect。除此之外,请记得 React 会等待浏览器完成画面渲染之后才会延迟调用useEffect
,因此会使得额外操作很方便。我们推荐启用
eslint-plugin-react-hooks
中的exhaustive-deps
规则。此规则会在添加错误依赖时发出警告并给出修复建议。
3.6.4 Hook 规则
Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。
Hook 本质就是 JavaScript 函数,但是在使用它时需要遵循两条规则。我们提供了一个 linter 插件来强制执行这些规则:
3.6.4.0.4 只在最顶层使用 Hook
不要在循环,条件或嵌套函数中调用 Hook, 确保总是在你的 React 函数的最顶层以及任何 return 之前调用他们。遵守这条规则,你就能确保 Hook 在每一次渲染中都按照同样的顺序被调用。这让 React 能够在多次的 useState
和 useEffect
调用之间保持 hook 状态的正确。(如果你对此感到好奇,我们在下面会有更深入的解释。)
3.6.4.0.5 只在 React 函数中调用 Hook
**不要在普通的 JavaScript 函数中调用 Hook。**你可以:
- ✅ 在 React 的函数组件中调用 Hook
- ✅ 在自定义 Hook 中调用其他 Hook (我们将会在下一页 中学习这个。)
遵循此规则,确保组件的状态逻辑在代码中清晰可见。
3.6.4.1 ESLint 插件
我们发布了一个名为 eslint-plugin-react-hooks
的 ESLint 插件来强制执行这两条规则。如果你想尝试一下,可以将此插件添加到你的项目中:
我们打算后续版本默认添加此插件到 Create React App 及其他类似的工具包中。
|
|
**现在你可以跳转到下一章节学习如何编写你自己的 Hook。**在本章节中,我们将继续解释这些规则背后的原因。
3.6.4.2 说明
正如我们之前学到的,我们可以在单个组件中使用多个 State Hook 或 Effect Hook:
|
|
那么 React 怎么知道哪个 state 对应哪个 useState
?答案是 React 靠的是 Hook 调用的顺序。因为我们的示例中,Hook 的调用顺序在每次渲染中都是相同的,所以它能够正常工作:
|
|
只要 Hook 的调用顺序在多次渲染之间保持一致,React 就能正确地将内部 state 和对应的 Hook 进行关联。但如果我们将一个 Hook (例如 persistForm
effect) 调用放到一个条件语句中会发生什么呢?
|
|
在第一次渲染中 name !== ''
这个条件值为 true
,所以我们会执行这个 Hook。但是下一次渲染时我们可能清空了表单,表达式值变为 false
。此时的渲染会跳过该 Hook,Hook 的调用顺序发生了改变:
|
|
React 不知道第二个 useState
的 Hook 应该返回什么。React 会以为在该组件中第二个 Hook 的调用像上次的渲染一样,对应的是 persistForm
的 effect,但并非如此。从这里开始,后面的 Hook 调用都被提前执行,导致 bug 的产生。
**这就是为什么 Hook 需要在我们组件的最顶层调用。**如果我们想要有条件地执行一个 effect,可以将判断放到 Hook 的内部:
|
|
注意:如果使用了提供的 lint 插件,就无需担心此问题。 不过你现在知道了为什么 Hook 会这样工作,也知道了这个规则是为了避免什么问题。
3.6.5 自定义 Hook
Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。
通过自定义 Hook,可以将组件逻辑提取到可重用的函数中。
在我们学习使用 Effect Hook 时,我们已经见过这个聊天程序中的组件,该组件用于显示好友的在线状态:
|
|
现在我们假设聊天应用中有一个联系人列表,当用户在线时需要把名字设置为绿色。我们可以把上面类似的逻辑复制并粘贴到 FriendListItem
组件中来,但这并不是理想的解决方案:
|
|
相反,我们希望在 FriendStatus
和 FriendListItem
之间共享逻辑。
目前为止,在 React 中有两种流行的方式来共享组件之间的状态逻辑: render props 和高阶组件,现在让我们来看看 Hook 是如何在让你不增加组件的情况下解决相同问题的。
3.6.5.1 提取自定义 Hook
当我们想在两个函数之间共享逻辑时,我们会把它提取到第三个函数中。而组件和 Hook 都是函数,所以也同样适用这种方式。
自定义 Hook 是一个函数,其名称以 “use
” 开头,函数内部可以调用其他的 Hook。 例如,下面的 useFriendStatus
是我们第一个自定义的 Hook:
|
|
此处并未包含任何新的内容——逻辑是从上述组件拷贝来的。与组件中一致,请确保只在自定义 Hook 的顶层无条件地调用其他 Hook。
与 React 组件不同的是,自定义 Hook 不需要具有特殊的标识。我们可以自由的决定它的参数是什么,以及它应该返回什么(如果需要的话)。换句话说,它就像一个正常的函数。但是它的名字应该始终以 use
开头,这样可以一眼看出其符合 Hook 的规则。
此处 useFriendStatus
的 Hook 目的是订阅某个好友的在线状态。这就是我们需要将 friendID
作为参数,并返回这位好友的在线状态的原因。
|
|
现在让我们看看应该如何使用自定义 Hook。
3.6.5.2 使用自定义 Hook
我们一开始的目标是在 FriendStatus
和 FriendListItem
组件中去除重复的逻辑,即:这两个组件都想知道好友是否在线。
现在我们已经把这个逻辑提取到 useFriendStatus
的自定义 Hook 中,然后就可以使用它了:
|
|
**这段代码等价于原来的示例代码吗?**等价,它的工作方式完全一样。如果你仔细观察,你会发现我们没有对其行为做任何的改变,我们只是将两个函数之间一些共同的代码提取到单独的函数中。自定义 Hook 是一种自然遵循 Hook 设计的约定,而并不是 React 的特性。
**自定义 Hook 必须以 “use
” 开头吗?**必须如此。这个约定非常重要。不遵循的话,由于无法判断某个函数是否包含对其内部 Hook 的调用,React 将无法自动检查你的 Hook 是否违反了 Hook 的规则。
**在两个组件中使用相同的 Hook 会共享 state 吗?**不会。自定义 Hook 是一种重用状态逻辑的机制(例如设置为订阅并存储当前值),所以每次使用自定义 Hook 时,其中的所有 state 和副作用都是完全隔离的。
**自定义 Hook 如何获取独立的 state?**每次调用 Hook,它都会获取独立的 state。由于我们直接调用了 useFriendStatus
,从 React 的角度来看,我们的组件只是调用了 useState
和 useEffect
。 正如我们在之前章节中了解到的一样,我们可以在一个组件中多次调用 useState
和 useEffect
,它们是完全独立的。
3.6.5.2.1 提示:在多个 Hook 之间传递信息
由于 Hook 本身就是函数,因此我们可以在它们之间传递信息。
我们将使用聊天程序中的另一个组件来说明这一点。这是一个聊天消息接收者的选择器,它会显示当前选定的好友是否在线:
|
|
我们将当前选择的好友 ID 保存在 recipientID
状态变量中,并在用户从 <select>
中选择其他好友时更新这个 state。
由于 useState
为我们提供了 recipientID
状态变量的最新值,因此我们可以将它作为参数传递给自定义的 useFriendStatus
Hook:
|
|
如此可以让我们知道当前选中的好友是否在线。当我们选择不同的好友并更新 recipientID
状态变量时,useFriendStatus
Hook 将会取消订阅之前选中的好友,并订阅新选中的好友状态。
3.6.5.3 useYourImagination()
自定义 Hook 解决了以前在 React 组件中无法灵活共享逻辑的问题。你可以创建涵盖各种场景的自定义 Hook,如表单处理、动画、订阅声明、计时器,甚至可能还有其他我们没想到的场景。更重要的是,创建自定义 Hook 就像使用 React 内置的功能一样简单。
尽量避免过早地增加抽象逻辑。既然函数组件能够做的更多,那么代码库中函数组件的代码行数可能会剧增。这属于正常现象 —— 不必立即将它们拆分为 Hook。但我们仍鼓励你能通过自定义 Hook 寻找可能,以达到简化代码逻辑,解决组件杂乱无章的目的。
例如,有个复杂的组件,其中包含了大量以特殊的方式来管理的内部状态。useState
并不会使得集中更新逻辑变得容易,因此你可能更愿意使用 redux 中的 reducer 来编写。
|
|
Reducers 非常便于单独测试,且易于扩展,以表达复杂的更新逻辑。如有必要,您可以将它们分成更小的 reducer。但是,你可能还享受着 React 内部 state 带来的好处,或者可能根本不想安装其他库。
那么,为什么我们不编写一个 useReducer
的 Hook,使用 reducer 的方式来管理组件的内部 state 呢?其简化版本可能如下所示:
|
|
在组件中使用它,让 reducer 驱动它管理 state:
|
|
在复杂组件中使用 reducer 管理内部 state 的需求很常见,我们已经将 useReducer
的 Hook 内置到 React 中。你可以在 Hook API 索引中找到它使用,搭配其他内置的 Hook 一起使用。
3.6.6 Hooks FAQ
Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。
此章节回答了关于 Hook 的常见问题。
3.7 Hook API 索引
Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。
本页面主要描述 React 中内置的 Hook API。
如果你刚开始接触 Hook,那么可能需要先查阅 Hook 概览。你也可以在 Hooks FAQ 章节中获取有用的信息。
3.7.1 基础 Hook
3.7.1.1 useState
|
|
返回一个 state,以及更新 state 的函数。
在初始渲染期间,返回的状态 (state
) 与传入的第一个参数 (initialState
) 值相同。
setState
函数用于更新 state。它接收一个新的 state 值并将组件的一次重新渲染加入队列。
|
|
在后续的重新渲染中,useState
返回的第一个值将始终是更新后最新的 state。
注意
React 会确保
setState
函数的标识是稳定的,并且不会在组件重新渲染时发生变化。这就是为什么可以安全地从useEffect
或useCallback
的依赖列表中省略setState
。
3.7.1.1.1 函数式更新
如果新的 state 需要通过使用先前的 state 计算得出,那么可以将函数传递给 setState
。该函数将接收先前的 state,并返回一个更新后的值。下面的计数器组件示例展示了 setState
的两种用法:
|
|
“+” 和 “-” 按钮采用函数式形式,因为被更新的 state 需要基于之前的 state。但是“重置”按钮则采用普通形式,因为它总是把 count 设置回初始值。
如果你的更新函数返回值与当前 state 完全相同,则随后的重渲染会被完全跳过。
注意
与 class 组件中的
setState
方法不同,useState
不会自动合并更新对象。你可以用函数式的setState
结合展开运算符来达到合并更新对象的效果。
1 2 3 4 5
const [state, setState] = useState({}); setState(prevState => { // 也可以使用 Object.assign return {...prevState, ...updatedValues}; });
useReducer
是另一种可选方案,它更适合用于管理包含多个子值的 state 对象。
3.7.1.1.2 惰性初始 state
initialState
参数只会在组件的初始渲染中起作用,后续渲染时会被忽略。如果初始 state 需要通过复杂计算获得,则可以传入一个函数,在函数中计算并返回初始的 state,此函数只在初始渲染时被调用:
|
|
3.7.1.1.3 跳过 state 更新
如果你更新 State Hook 后的 state 与当前的 state 相同时,React 将跳过子组件的渲染并且不会触发 effect 的执行。(React 使用 Object.is
比较算法 来比较 state。)
需要注意的是,React 可能仍需要在跳过渲染前渲染该组件。不过由于 React 不会对组件树的“深层”节点进行不必要的渲染,所以大可不必担心。如果你在渲染期间执行了高开销的计算,则可以使用 useMemo
来进行优化。
3.7.1.1.4 Batching of state updates
React may group several state updates into a single re-render to improve performance. Normally, this improves performance and shouldn’t affect your application’s behavior.
Before React 18, only updates inside React event handlers were batched. Starting with React 18, batching is enabled for all updates by default. Note that React makes sure that updates from several different user-initiated events — for example, clicking a button twice — are always processed separately and do not get batched. This prevents logical mistakes.
In the rare case that you need to force the DOM update to be applied synchronously, you may wrap it in flushSync
. However, this can hurt performance so do this only where needed.
3.7.1.2 useEffect
|
|
该 Hook 接收一个包含命令式、且可能有副作用代码的函数。
在函数组件主体内(这里指在 React 渲染阶段)改变 DOM、添加订阅、设置定时器、记录日志以及执行其他包含副作用的操作都是不被允许的,因为这可能会产生莫名其妙的 bug 并破坏 UI 的一致性。
使用 useEffect
完成副作用操作。赋值给 useEffect
的函数会在组件渲染到屏幕之后执行。你可以把 effect 看作从 React 的纯函数式世界通往命令式世界的逃生通道。
默认情况下,effect 将在每轮渲染结束后执行,但你可以选择让它 在只有某些值改变的时候 才执行。
3.7.1.2.1 清除 effect
通常,组件卸载时需要清除 effect 创建的诸如订阅或计时器 ID 等资源。要实现这一点,useEffect
函数需返回一个清除函数。以下就是一个创建订阅的例子:
|
|
为防止内存泄漏,清除函数会在组件卸载前执行。另外,如果组件多次渲染(通常如此),则在执行下一个 effect 之前,上一个 effect 就已被清除。在上述示例中,意味着组件的每一次更新都会创建新的订阅。若想避免每次更新都触发 effect 的执行,请参阅下一小节。
3.7.1.2.2 effect 的执行时机
与 componentDidMount
、componentDidUpdate
不同的是,传给 useEffect
的函数会在浏览器完成布局与绘制之后,在一个延迟事件中被调用。这使得它适用于许多常见的副作用场景,比如设置订阅和事件处理等情况,因为绝大多数操作不应阻塞浏览器对屏幕的更新。
然而,并非所有 effect 都可以被延迟执行。例如,一个对用户可见的 DOM 变更就必须在浏览器执行下一次绘制前被同步执行,这样用户才不会感觉到视觉上的不一致。(概念上类似于被动监听事件和主动监听事件的区别。)React 为此提供了一个额外的 useLayoutEffect
Hook 来处理这类 effect。它和 useEffect
的结构相同,区别只是调用时机不同。
此外,从 React 18 开始,当它是离散的用户输入(如点击)的结果时,或者当它是由 flushSync
包装的更新结果时,传递给 useEffect
的函数将在屏幕布局和绘制之前同步执行。这种行为便于事件系统或 flushSync
的调用者观察该效果的结果。
注意
这只影响传递给
useEffect
的函数被调用时 — 在这些 effect 中执行的更新仍会被推迟。这与useLayoutEffect
不同,后者会立即启动该函数并处理其中的更新。
即使在 useEffect
被推迟到浏览器绘制之后的情况下,它也能保证在任何新的渲染前启动。React 在开始新的更新前,总会先刷新之前的渲染的 effect。
3.7.1.2.3 effect 的条件执行
默认情况下,effect 会在每轮组件渲染完成后执行。这样的话,一旦 effect 的依赖发生变化,它就会被重新创建。
然而,在某些场景下这么做可能会矫枉过正。比如,在上一章节的订阅示例中,我们不需要在每次组件更新时都创建新的订阅,而是仅需要在 source
prop 改变时重新创建。
要实现这一点,可以给 useEffect
传递第二个参数,它是 effect 所依赖的值数组。更新后的示例如下:
|
|
此时,只有当 props.source
改变后才会重新创建订阅。
注意
如果你要使用此优化方式,请确保数组中包含了所有外部作用域中会发生变化且在 effect 中使用的变量,否则你的代码会引用到先前渲染中的旧变量。请参阅文档,了解更多关于如何处理函数 以及数组频繁变化时的措施 的内容。
如果想执行只运行一次的 effect(仅在组件挂载和卸载时执行),可以传递一个空数组(
[]
)作为第二个参数。这就告诉 React 你的 effect 不依赖于 props 或 state 中的任何值,所以它永远都不需要重复执行。这并不属于特殊情况 —— 它依然遵循输入数组的工作方式。如果你传入了一个空数组(
[]
),effect 内部的 props 和 state 就会一直持有其初始值。尽管传入[]
作为第二个参数有点类似于componentDidMount
和componentWillUnmount
的思维模式,但我们有 更好的 方式 来避免过于频繁的重复调用 effect。除此之外,请记得 React 会等待浏览器完成画面渲染之后才会延迟调用useEffect
,因此会使得处理额外操作很方便。我们推荐启用
eslint-plugin-react-hooks
中的exhaustive-deps
规则。此规则会在添加错误依赖时发出警告并给出修复建议。
依赖项数组不会作为参数传给 effect 函数。虽然从概念上来说它表现为:所有 effect 函数中引用的值都应该出现在依赖项数组中。未来编译器会更加智能,届时自动创建数组将成为可能。
3.7.1.3 useContext
|
|
接收一个 context 对象(React.createContext
的返回值)并返回该 context 的当前值。当前的 context 值由上层组件中距离当前组件最近的 <MyContext.Provider>
的 value
prop 决定。
当组件上层最近的 <MyContext.Provider>
更新时,该 Hook 会触发重渲染,并使用最新传递给 MyContext
provider 的 context value
值。即使祖先使用 React.memo
或 shouldComponentUpdate
,也会在组件本身使用 useContext
时重新渲染。
别忘记 useContext
的参数必须是 context 对象本身:
- 正确:
useContext(MyContext)
- 错误:
useContext(MyContext.Consumer)
- 错误:
useContext(MyContext.Provider)
调用了 useContext
的组件总会在 context 值变化时重新渲染。如果重渲染组件的开销较大,你可以 通过使用 memoization 来优化。
提示
如果你在接触 Hook 前已经对 context API 比较熟悉,那应该可以理解,
useContext(MyContext)
相当于 class 组件中的static contextType = MyContext
或者<MyContext.Consumer>
。
useContext(MyContext)
只是让你能够读取 context 的值以及订阅 context 的变化。你仍然需要在上层组件树中使用<MyContext.Provider>
来为下层组件提供 context。
把如下代码与 Context.Provider 放在一起
|
|
对先前 Context 高级指南中的示例使用 hook 进行了修改,你可以在链接中找到有关如何 Context 的更多信息。
3.7.2 额外的 Hook
以下介绍的 Hook,有些是上一节中基础 Hook 的变体,有些则仅在特殊情况下会用到。不用特意预先学习它们。
3.7.2.1 useReducer
|
|
useState
的替代方案。它接收一个形如 (state, action) => newState
的 reducer,并返回当前的 state 以及与其配套的 dispatch
方法。(如果你熟悉 Redux 的话,就已经知道它如何工作了。)
在某些场景下,useReducer
会比 useState
更适用,例如 state 逻辑较复杂且包含多个子值,或者下一个 state 依赖于之前的 state 等。并且,使用 useReducer
还能给那些会触发深更新的组件做性能优化,因为你可以向子组件传递 dispatch
而不是回调函数 。
以下是用 reducer 重写 useState
一节的计数器示例:
|
|
注意
React 会确保
dispatch
函数的标识是稳定的,并且不会在组件重新渲染时改变。这就是为什么可以安全地从useEffect
或useCallback
的依赖列表中省略dispatch
。
3.7.2.1.1 指定初始 state
有两种不同初始化 useReducer
state 的方式,你可以根据使用场景选择其中的一种。将初始 state 作为第二个参数传入 useReducer
是最简单的方法:
|
|
注意
React 不使用
state = initialState
这一由 Redux 推广开来的参数约定。有时候初始值依赖于 props,因此需要在调用 Hook 时指定。如果你特别喜欢上述的参数约定,可以通过调用useReducer(reducer, undefined, reducer)
来模拟 Redux 的行为,但我们不鼓励你这么做。
3.7.2.1.2 惰性初始化
你可以选择惰性地创建初始 state。为此,需要将 init
函数作为 useReducer
的第三个参数传入,这样初始 state 将被设置为 init(initialArg)
。
这么做可以将用于计算 state 的逻辑提取到 reducer 外部,这也为将来对重置 state 的 action 做处理提供了便利:
|
|
3.7.2.1.3 跳过 dispatch
如果 Reducer Hook 的返回值与当前 state 相同,React 将跳过子组件的渲染及副作用的执行。(React 使用 Object.is
比较算法 来比较 state。)
需要注意的是,React 可能仍需要在跳过渲染前再次渲染该组件。不过由于 React 不会对组件树的“深层”节点进行不必要的渲染,所以大可不必担心。如果你在渲染期间执行了高开销的计算,则可以使用 useMemo
来进行优化。
3.7.2.2 useCallback
|
|
返回一个 memoized 回调函数。
把内联回调函数及依赖项数组作为参数传入 useCallback
,它将返回该回调函数的 memoized 版本,该回调函数仅在某个依赖项改变时才会更新。当你把回调函数传递给经过优化的并使用引用相等性去避免非必要渲染(例如 shouldComponentUpdate
)的子组件时,它将非常有用。
useCallback(fn, deps)
相当于 useMemo(() => fn, deps)
。
注意
依赖项数组不会作为参数传给回调函数。虽然从概念上来说它表现为:所有回调函数中引用的值都应该出现在依赖项数组中。未来编译器会更加智能,届时自动创建数组将成为可能。
我们推荐启用
eslint-plugin-react-hooks
中的exhaustive-deps
规则。此规则会在添加错误依赖时发出警告并给出修复建议。
3.7.2.3 useMemo
|
|
返回一个 memoized 值。
把“创建”函数和依赖项数组作为参数传入 useMemo
,它仅会在某个依赖项改变时才重新计算 memoized 值。这种优化有助于避免在每次渲染时都进行高开销的计算。
记住,传入 useMemo
的函数会在渲染期间执行。请不要在这个函数内部执行不应该在渲染期间内执行的操作,诸如副作用这类的操作属于 useEffect
的适用范畴,而不是 useMemo
。
如果没有提供依赖项数组,useMemo
在每次渲染时都会计算新的值。
**你可以把 useMemo
作为性能优化的手段,但不要把它当成语义上的保证。**将来,React 可能会选择“遗忘”以前的一些 memoized 值,并在下次渲染时重新计算它们,比如为离屏组件释放内存。先编写在没有 useMemo
的情况下也可以执行的代码 —— 之后再在你的代码中添加 useMemo
,以达到优化性能的目的。
注意
依赖项数组不会作为参数传给“创建”函数。虽然从概念上来说它表现为:所有“创建”函数中引用的值都应该出现在依赖项数组中。未来编译器会更加智能,届时自动创建数组将成为可能。
我们推荐启用
eslint-plugin-react-hooks
中的exhaustive-deps
规则。此规则会在添加错误依赖时发出警告并给出修复建议。
3.7.2.4 useRef
|
|
useRef
返回一个可变的 ref 对象,其 .current
属性被初始化为传入的参数(initialValue
)。返回的 ref 对象在组件的整个生命周期内持续存在。
一个常见的用例便是命令式地访问子组件:
|
|
本质上,useRef
就像是可以在其 .current
属性中保存一个可变值的“盒子”。
你应该熟悉 ref 这一种访问 DOM 的主要方式。如果你将 ref 对象以 <div ref={myRef} />
形式传入组件,则无论该节点如何改变,React 都会将 ref 对象的 .current
属性设置为相应的 DOM 节点。
然而,useRef()
比 ref
属性更有用。它可以很方便地保存任何可变值,其类似于在 class 中使用实例字段的方式。
这是因为它创建的是一个普通 Javascript 对象。而 useRef()
和自建一个 {current: ...}
对象的唯一区别是,useRef
会在每次渲染时返回同一个 ref 对象。
请记住,当 ref 对象内容发生变化时,useRef
并不会通知你。变更 .current
属性不会引发组件重新渲染。如果想要在 React 绑定或解绑 DOM 节点的 ref 时运行某些代码,则需要使用回调 ref 来实现。
3.7.2.5 useImperativeHandle
|
|
useImperativeHandle
可以让你在使用 ref
时自定义暴露给父组件的实例值。在大多数情况下,应当避免使用 ref 这样的命令式代码。useImperativeHandle
应当与 forwardRef
一起使用:
|
|
在本例中,渲染 <FancyInput ref={inputRef} />
的父组件可以调用 inputRef.current.focus()
。
3.7.2.6 useLayoutEffect
其函数签名与 useEffect
相同,但它会在所有的 DOM 变更之后同步调用 effect。可以使用它来读取 DOM 布局并同步触发重渲染。在浏览器执行绘制之前,useLayoutEffect
内部的更新计划将被同步刷新。
尽可能使用标准的 useEffect
以避免阻塞视觉更新。
提示
如果你正在将代码从 class 组件迁移到使用 Hook 的函数组件,则需要注意
useLayoutEffect
与componentDidMount
、componentDidUpdate
的调用阶段是一样的。但是,我们推荐你一开始先用useEffect
,只有当它出问题的时候再尝试使用useLayoutEffect
。如果你使用服务端渲染,请记住,无论
useLayoutEffect
还是useEffect
都无法在 Javascript 代码加载完成之前执行。这就是为什么在服务端渲染组件中引入useLayoutEffect
代码时会触发 React 告警。解决这个问题,需要将代码逻辑移至useEffect
中(如果首次渲染不需要这段逻辑的情况下),或是将该组件延迟到客户端渲染完成后再显示(如果直到useLayoutEffect
执行之前 HTML 都显示错乱的情况下)。若要从服务端渲染的 HTML 中排除依赖布局 effect 的组件,可以通过使用
showChild && <Child />
进行条件渲染,并使用useEffect(() => { setShowChild(true); }, [])
延迟展示组件。这样,在客户端渲染完成之前,UI 就不会像之前那样显示错乱了。
3.7.2.7 useDebugValue
|
|
useDebugValue
可用于在 React 开发者工具中显示自定义 hook 的标签。
例如,“自定义 Hook” 章节中描述的名为 useFriendStatus
的自定义 Hook:
|
|
提示
我们不推荐你向每个自定义 Hook 添加 debug 值。当它作为共享库的一部分时才最有价值。
3.7.2.7.1 延迟格式化 debug 值
在某些情况下,格式化值的显示可能是一项开销很大的操作。除非需要检查 Hook,否则没有必要这么做。
因此,useDebugValue
接受一个格式化函数作为可选的第二个参数。该函数只有在 Hook 被检查时才会被调用。它接受 debug 值作为参数,并且会返回一个格式化的显示值。
例如,一个返回 Date
值的自定义 Hook 可以通过格式化函数来避免不必要的 toDateString
函数调用:
|
|
3.7.2.8 useDeferredValue
|
|
useDeferredValue
接受一个值,并返回该值的新副本,该副本将推迟到更紧急地更新之后。如果当前渲染是一个紧急更新的结果,比如用户输入,React 将返回之前的值,然后在紧急渲染完成后渲染新的值。
该 hook 与使用防抖和节流去延迟更新的用户空间 hooks 类似。使用 useDeferredValue
的好处是,React 将在其他工作完成(而不是等待任意时间)后立即进行更新,并且像 startTransition
一样,延迟值可以暂停,而不会触发现有内容的意外降级。
3.7.2.8.1 Memoizing deferred children
useDeferredValue
仅延迟你传递给它的值。如果你想要在紧急更新期间防止子组件重新渲染,则还必须使用 React.memo 或 React.useMemo 记忆该子组件:
|
|
记忆该子组件告诉 React 它仅当 deferredQuery
改变而不是 query
改变的时候才需要去重新渲染。这个限制不是 useDeferredValue
独有的,它和使用防抖或节流的 hooks 使用的相同模式。
3.7.2.9 useTransition
|
|
返回一个状态值表示过渡任务的等待状态,以及一个启动该过渡任务的函数。
startTransition
允许你通过标记更新将提供的回调函数作为一个过渡任务:
|
|
isPending
指示过渡任务何时活跃以显示一个等待状态:
|
|
注意:
过渡任务中触发的更新会让更紧急地更新先进行,比如点击。
过渡任务中的更新将不会展示由于再次挂起而导致降级的内容。这个机制允许用户在 React 渲染更新的时候继续与当前内容进行交互。
3.7.2.10 useId
|
|
useId
是一个用于生成横跨服务端和客户端的稳定的唯一 ID 的同时避免 hydration 不匹配的 hook。
Note
useId
is not for generating keys in a list. Keys should be generated from your data.
For a basic example, pass the id
directly to the elements that need it: 一个最简单的例子,直接传递 id
给需要它的元素:
|
|
对于同一组件中的多个 ID,使用相同的 id
并添加后缀:
|
|
注意:
useId
生成一个包含:
的字符串 token。这有助于确保 token 是唯一的,但在 CSS 选择器或querySelectorAll
等 API 中不受支持。
useId
支持identifierPrefix
以防止在多个根应用的程序中发生冲突。 要进行配置,请参阅hydrateRoot
和ReactDOMServer
的选项。
3.7.3 Library Hooks
以下 hook 是为库作者提供的,用于将库深入集成到 React 模型中,通常不会在应用程序代码中使用。
3.7.3.1 useSyncExternalStore
|
|
useSyncExternalStore
是一个推荐用于读取和订阅外部数据源的 hook,其方式与选择性的 hydration 和时间切片等并发渲染功能兼容。
此方法返回存储的值并接受三个参数:
subscribe
:用于注册一个回调函数,当存储值发生更改时被调用。getSnapshot
: 返回当前存储值的函数。getServerSnapshot
:返回服务端渲染期间使用的存储值的函数
最简单的例子就是订阅整个存储值:
|
|
然而,你也可以订阅特定字段:
|
|
当服务端渲染的时候,你必须序列化在服务端使用的存储值,并将其提供给 usencexternalSternore
。React 将在 hydration 过程中使用此快照来防止服务端不匹配:
|
|
注意:
getSnapshot
必须返回缓存的值。如果 getSnapshot 连续多次调用,则必须返回相同的确切值,除非中间有存储值更新。提供了一个楔子,发布为
use-sync-external-store/shim
,用于支持多种版本的 React。如果可用,楔子将首选useSyncExternalStore
,如果不可用,则降级选择用户空间的实现。为了方便起见,我们还提供了一个版本的 API,该 API 发布为
use-sync-external-store/with-selector
,其自动支持记忆 getSnapshot 的结果。
3.7.3.2 useInsertionEffect
|
|
该签名与 useEffect
相同,但它在所有 DOM 突变 之前 同步触发。使用它在读取 useLayoutEffect
中的布局之前将样式注入 DOM。由于这个 hook 的作用域有限,所以这个 hook 不能访问 refs,也不能安排更新。
注意:
useInsertionEffect
应仅限于 css-in-js 库作者使用。优先考虑使用useEffect
或useLayoutEffect
来替代。
4 应用场景
4.1 如何解决 JAX 中 HTML 代码段被识别为字符串的问题?
4.1.1 问题描述
React 的 JAX 语法中进行动态数据绑定时不能动态绑定 HTML。
4.1.2 产生原因
JAX 的设计者,在设计时为了防止 XSS 攻击,特意限制了。
4.1.3 解决方式
|
|
不合时宜的使用 innerHTML 可能会导致 cross-site scripting (XSS) 攻击。 净化用户的输入来显示的时候,经常会出现错误,不合适的净化也是导致网页攻击的原因之一。我们的设计哲学是让确保安全应该是简单的,开发者在执行“不安全”的操作的时候应该清楚地知道他们自己的意图。dangerouslySetInnerHTML 这个 prop 的命名是故意这么设计的,以此来警告,它的 prop 值( 一个对象而不是字符串 )应该被用来表明净化后的数据。
4.2 如何处理 React 和直接修改 DOM 的前端框架的兼容性问题?
4.2.1 问题描述
因为 React 的状态到虚拟 DOM 再到 DOM 绘制的框架实现和通过 JQuery 去直接修改 DOM 是有冲突的。所以如果使用了 React 框架的话,最好就不要再使用会直接修改 DOM 的 JQuery 框架。
4.2.1.1 React 和 JQuery UI Sortable
-
产生原因:
使用 Sortable 进行拖拽排序时,在放置时 Sortable 会先根据拖拽起始和目标修改一次 DOM。然后如果在拖拽后更新了数据,React 会 render DOM,但是 React 并不知道 Sortable 对 DOM 进行了修改,因此产生的冲突。 -
解决方式:
在 stop 回调方法里取消 Sortable 的排序,将排序操作交给 React 管理。1 2 3
stop: function () { $schArLiBox.sortable("cancel"); }
4.2.1.2 React 和 JQuery tipsy
-
产生原因:
React 修改 title 后,如果是置为""
或删除 title 属性,都不会另 tipsy 重新加载 original-title 属性,只有修改为其他值是才重加载。因此要删除的话就有问题。 -
解决方式:
使用 jQuery 手动删除修改的元素的 original-title 属性