先说结论：
- 状态变化
- 父组件 re-render
- Context 变化
- Hooks 变化
这里有个误解：props 变化也会导致 re-render。其实不会的，props 的变化往上追溯是因为父组件的 state 变化导致父组件 re-render，从而引起了子组件的 re-render，与 props 是否变化无关的。只有那些使用了 React.memo 和 useMemo 的组件，props 的变化才会触发组件的 re-render。
针对上述造成 re-render 的原因，又该通过怎样的策略优化呢？感兴趣的朋友可以看这篇文章：React re-renders guide: everything, all at once。
接下来开始我们今天的主题：如何优雅的使用 React Context。上面我们提到了 Context 的变化也会触发组件的 re-render，那 React Context 又是怎么工作呢？先简单介绍一下 Context 的工作原理。
Context 的工作原理
Context 是 React 提供的一种直接访问祖先节点上的状态的方法，从而避免了多级组件层层传递 props 的频繁操作。
创建 Context
通过 React.createContext 创建 Context 对象
export function createContext(
defaultValue
) {
const context = {
$$typeof: REACT_CONTEXT_TYPE,
_currentValue: defaultValue,
_currentValue2: defaultValue,
_threadCount: 0,
Provider: (null: any),
Consumer: (null: any),
};
context.Provider = {
$$typeof: REACT_PROVIDER_TYPE,
_context: context,
};
context.Consumer = context;
return context;
}React.createContext 的核心逻辑：
- 将初始值存储在 context._currentValue
- 创建 Context.Provider 和 Context.Consumer 对应的 ReactElement 对象
在 fiber 树渲染时，通过不同的 workInProgress.tag 处理 Context.Provider 和 Context.Consumer 类型的节点。
主要看下针对 Context.Provider 的处理逻辑：
function updateContextProvider(
current: Fiber | null,
workInProgress: Fiber,
renderLanes: Lanes,
) {
const providerType = workInProgress.type;
const context = providerType._context;
const newProps = workInProgress.pendingProps;
const oldProps = workInProgress.memoizedProps;
const newValue = newProps.value;
pushProvider(workInProgress, context, newValue);
if (oldProps !== null) {
// 更新 context 的核心逻辑
}
const newChildren = newProps.children;
reconcileChildren(current, workInProgress, newChildren, renderLanes);
return workInProgress.child;
}消费 Context
在 React 中提供了 3 种消费 Context 的方式
- 直接使用 Context.Consumer 组件（也就是上面 createContext 时创建的 Consumer）
- 类组件中，可以通过静态属性 contextType 消费 Context
- 函数组件中，可以通过 useContext 消费 Context
这三种方式内部都会调用 prepareToReadContext 和 readContext 处理 Context。prepareToReadContext 中主要是重置全局变量为readContext 做准备。
接下来主要看下readContext ：
export function readContext(
context: ReactContext,
observedBits: void | number | boolean,
): T {
const contextItem = {
context: ((context: any): ReactContext),
observedBits: resolvedObservedBits,
next: null,
};
if (lastContextDependency === null) {
lastContextDependency = contextItem;
currentlyRenderingFiber.dependencies = {
lanes: NoLanes,
firstContext: contextItem,
responders: null,
};
} else {
lastContextDependency = lastContextDependency.next = contextItem;
}
// 2. 返回 currentValue
return isPrimaryRenderer ? context._currentValue : context._currentValue2;
} readContext的核心逻辑：
- 构建 contextItem 并添加到 workInProgress.dependencies 链表（contextItem 中保存了对当前 context 的引用，这样在后续更新时，就可以判断当前 fiber 是否依赖了 context ，从而判断是否需要 re-render）
- 返回对应 context 的 _currentValue 值
更新 Context
当触发 Context.Provider 的 re-render 时，重新走 updateContextProvider 中更新的逻辑：
function updateContextProvider(
current: Fiber | null,
workInProgress: Fiber,
renderLanes: Lanes,
) {
// ...
// 更新逻辑
if (oldProps !== null) {
const oldValue = oldProps.value;
if (is(oldValue, newValue)) {
// 1. value 未发生变化时，直接走 bailout 逻辑
if (
oldProps.children === newProps.children &&
!hasLegacyContextChanged()
) {
return bailoutOnAlreadyFinishedWork(
current,
workInProgress,
renderLanes,
);
}
} else {
// 2. value 变更时，走更新逻辑
propagateContextChange(workInProgress, context, renderLanes);
}
//...
}接下来看下 propagateContextChange (核心逻辑在 propagateContextChange_eager 中) 的逻辑：
function propagateContextChange_eager < T > (
workInProgress: Fiber,
context: ReactContext < T > ,
renderLanes: Lanes,
): void {
let fiber = workInProgress.child;
if (fiber !== null) {
fiber.return = workInProgress;
}
// 从子节点开始匹配是否存在消费了当前 Context 的节点
while (fiber !== null) {
let nextFiber;
const list = fiber.dependencies;
if (list !== null) {
nextFiber = fiber.child;
let dependency = list.firstContext;
while (dependency !== null) {
// 1. 判断 fiber 节点的 context 和当前 context 是否匹配
if (dependency.context === context) {
// 2. 匹配时，给当前节点调度一个更新任务
if (fiber.tag === ClassComponent) {}
fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
const alternate = fiber.alternate;
if (alternate !== null) {
alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
}
// 3. 向上标记 childLanes
scheduleContextWorkOnParentPath(
fiber.return,
renderLanes,
workInProgress,
);
list.lanes = mergeLanes(list.lanes, renderLanes);
break;
}
dependency = dependency.next;
}
} else if (fiber.tag === ContextProvider) {} else if (fiber.tag === DehydratedFragment) {} else {}
// ...
fiber = nextFiber;
}
}核心逻辑：
- 从 ContextProvider 的节点出发，向下查找所有 fiber.dependencies 依赖当前 Context 的节点
- 找到消费节点时，从当前节点出发，向上回溯标记父节点 fiber.childLanes，标识其子节点需要更新，从而保证了所有消费了该 Context 的子节点都会被重新渲染，实现了 Context 的更新
总结
- 在消费阶段，消费者通过 readContext 获取最新状态，并通过 fiber.dependencies 关联当前 Context
- 在更新阶段，从 ContextProvider 节点出发查找所有消费了该 context 的节点
如何避免 Context 引起的 re-render
从上面分析 Context 的整个工作流程，我们可以知道当 ContextProvider 接收到 value 变化时就会找到所有消费了该 Context 的组件进行 re-render，若 ContextProvider 的 value 是一个对象时，即使没有使用到发生变化的 value 的组件也会造成多次不必要的 re-render。
那我们怎么做优化呢？直接说方案：
- 将 ContextProvider 的值做 memoize 处理
- 对数据和 API 做拆分（或者说是将 getter（state）和 setter（API）做拆分）
- 对数据做拆分（细粒度拆分）
- Context Selector
具体的 case 可参考上述提到的优化文章：React re-renders guide: everything, all at once。
接下来开始我们今天的重点：Context Selector。开始之前先来个 case1：
import React, { useState } from "react";
const StateContext = React.createContext(null);
const StateProvider = ({ children }) => {
console.log("StateProvider render");
const [count1, setCount1] = useState(1);
const [count2, setCount2] = useState(1);
return (
{children}
);
};
const Counter1 = () => {
console.log("count1 render");
const { count1, setCount1 } = React.useContext(StateContext);
return (
<>
Count1: {count1}
);
};
const Counter2 = () => {
console.log("count2 render");
const { count2, setCount2 } = React.useContext(StateContext);
return (
<>
Count2: {count2}
);
};
const App = () => {
return (
);
};
export default App;❝
开发环境记得关闭 StrictMode 模式，否则每次 re-render 都会走两遍。具体使用方式和 StrictMode 的意义可参考官方文档。
❞
通过上面的 case，我们会发现在 count1 触发更新时，即使 Counter2 没有使用 count1 也会进行 re-render。这是因为 count1 的更新会引起 StateProvider 的 re-render，从而会导致 StateProvider 的 value 生成全新的对象，触发 ContextProvider 的 re-render，找到当前 Context 的所有消费者进行 re-render。
如何做到只有使用到 Context 的 value 改变才触发组件的 re-render 呢？社区有一个对应的解决方案 dai-shi/use-context-selector: React useContextSelector hook in userland。
接下来我们改造一下上述的 case2：
import React, { useState } from 'react';
import { createContext, useContextSelector } from 'use-context-selector';
const context = createContext(null);
const Counter1 = () => {
const count1 = useContextSelector(context, v => v[0].count1);
const setState = useContextSelector(context, v => v[1]);
const increment = () => setState(s => ({
...s,
count1: s.count1 + 1,
}));
return (
Count1: {count1}
{Math.random()}
);
};
const Counter2 = () => {
const count2 = useContextSelector(context, v => v[0].count2);
const setState = useContextSelector(context, v => v[1]);
const increment = () => setState(s => ({
...s,
count2: s.count2 + 1,
}));
return (
Count2: {count2}
{Math.random()}
);
};
const StateProvider = ({ children }) => (
{children}
);
const App = () => (
);
export default App这时候问题来了，不是说好精准渲染的吗？怎么还是都会进行 re-render。解决方案：将 react 改为 v17 版本（v17对应的case3），后面我们再说具体原因（只想说好坑..）。
use-context-selector
接下来我们主要分析下 createContext 和 useContextSelector 都做了什么（官方还有其他的 API ，感兴趣的朋友可以自行查看，核心还是这两个 API）。
createContext
简化一下，只看核心逻辑：
import { createElement, useLayoutEffect, useRef, createContext as createContextOrig } from 'react'
const CONTEXT_VALUE = Symbol();
const ORIGINAL_PROVIDER = Symbol();
const createProvider = (
ProviderOrig
) => {
const ContextProvider = ({ value, children }) => {
const valueRef = useRef(value);
const contextValue = useRef();
if (!contextValue.current) {
const listeners = new Set();
contextValue.current = {
[CONTEXT_VALUE]: {
v: valueRef,
l: listeners,
},
};
}
useLayoutEffect(() => {
valueRef.current = value;
contextValue.current[CONTEXT_VALUE].l.forEach((listener) => {
listener({ v: value });
});
}, [value]);
return createElement(ProviderOrig, { value: contextValue.current }, children);
};
return ContextProvider;
};
export function createContext(defaultValue) {
const context = createContextOrig({
[CONTEXT_VALUE]: {
v: { current: defaultValue },
l: new Set(),
},
});
context[ORIGINAL_PROVIDER] = context.Provider;
context.Provider = createProvider(context.Provider);
delete context.Consumer; // no support for Consumer
return context;
}对原始的 createContext 包一层，同时为了避免 value 的意外更新造成消费者的不必要 re-render ，将传递给原始的 createContext 的 value 通过 uesRef 进行存储，这样在 React 内部对比新旧 value 值时就不会再操作 re-render（后续 value 改变后派发更新时就需要通过 listener 进行 re-render 了），最后返回包裹后的 createContext 给用户使用。
useContextSelector
接下来看下简化后的 useContextSelector ：
export function useContextSelector(context, selector) {
const contextValue = useContextOrig(context)[CONTEXT_VALUE];
const {
v: { current: value },
l: listeners
} = contextValue;
const selected = selector(value);
const [state, dispatch] = useReducer(
(prev, action) => {
if ("v" in action) {
if (Object.is(prev[0], action.v)) {
return prev; // do not update
}
const nextSelected = selector(action.v);
if (Object.is(prev[1], nextSelected)) {
return prev; // do not update
}
return [action.v, nextSelected];
}
},
[value, selected]
);
useLayoutEffect(() => {
listeners.add(dispatch);
return () => {
listeners.delete(dispatch);
};
}, [listeners]);
return state[1];
}核心逻辑：
- 每次渲染时，通过 selector 和 value 获取最新的 selected
- 同时将 useReducer 对应的 dispatch 添加到 listeners
- 当 value 改变时，就会执行 listeners 中收集到 dispatch 函数，从而在触发 reducer 内部逻辑，通过对比 value 和 selected 是否有变化，来决定是否触发当前组件的 re-render
在 react v18 下的 bug
回到上面的 case 在 react v18 的表现和在原始 Context 的表现几乎一样，每次都会触发所有消费者的 re-render。再看 use-context-selector 内部是通过 useReducer 返回的 dispatch 函数派发组件更新的。
接下来再看下 useReducer 在 react v18 和 v17 版本到底有什么不一样呢？看个简单的 case：
import React, { useReducer } from "react";
const initialState = 0;
const reducer = (state, action) => {
switch (action) {
case "increment":
return state;
default:
return state;
}
};
export const App = () => {
console.log("UseReducer Render");
const [count, dispatch] = useReducer(reducer, initialState);
return (
Count = {count}
);
};简单描述下：多次点击按钮「Inacrement」，在 react 的 v17 和 v18 版本分别会有什么表现？
先说结论：
- v17：只有首次渲染会触发 App 组件的 render，后续点击将不再触发 re-render
- v18：每次都会触发 App 组件的 re-render（即使状态没有实质性的变化也会触发 re-render）
这就要说到【eager state 策略】了，在 React 内部针对多次触发更新，而最后状态并不会发生实质性变化的情况，组件是没有必要渲染的，提前就可以中断更新了。
也就是说 useReducer 内部是有做一定的性能优化的，而这优化会存在一些 bug，最后 React 团队也在 v18 后移除了该优化策略（注：useState 还是保留该优化），详细可看该相关 PR Remove usereducer eager bailout。当然该 PR 在社区也存在一些讨论（Bug: useReducer and same state in React 18），毕竟无实质性的状态变更也会触发 re-render，对性能还是有一定影响的。
回归到 useContextSelector ，无优化版本的 useReducer 又是如何每次都触发组件 re-render 呢？
具体原因：在上面 useReducer 中，是通过 Object.is 判断 value 是否发生了实质性变化，若没有，就返回旧的状态，在 v17 有优化策略下，就不会再去调度更新任务了，而在 v18 没有优化策略的情况下，每次都会调度新的更新任务，从而引发组件的 re-render。
通过 useSyncExternalStore 优化
通过分析知道造成 re-render 的原因是使用了 useReducer，那就不再依赖该 hook，使用 react v18 新的 hook useSyncExternalStore 来实现 useContextSelector（优化后的 case4）。
export function useContextSelector(context, selector) {
const contextValue = useContextOrig(context)[CONTEXT_VALUE];
const {
v: { current: value },
l: listeners
} = contextValue;
const lastSnapshot = useRef(selector(value));
const subscribe = useCallback(
(callback) => {
listeners.add(callback);
return () => {
listeners.delete(callback);
};
},
[listeners]
);
const getSnapshot = () => {
const {
v: { current: value }
} = contextValue;
const nextSnapshot = selector(value);
lastSnapshot.current = nextSnapshot;
return nextSnapshot;
};
return useSyncExternalStore(subscribe, getSnapshot);
}实现思路：
- 收集订阅函数 subscribe 的 callback（即 useSyncExternalStore 内部的 handleStoreChange ）
- 当 value 发生变化时，触发 listeners 收集到的 callback ，也就是执行 handleStoreChange 函数，通过 getSnapshot 获取新旧值，并通过 Object.is 进行对比，判断当前组件是否需要更新，从而实现了 useContextSelector 的精确更新
当然除了 useReducer 对应的性能问题，use-context-selector 还存在其他的性能，感兴趣的朋友可以查看这篇文章从 0 实现 use-context-selector。同时，use-context-selector 也是存在一些限制，比如说不支持 Class 组件、不支持 Consumer …
针对上述文章中，作者提到的问题二和问题三，个人认为这并不是 use-context-selector 的问题，而是 React 底层自身带来的问题。比如说：问题二，React 组件是否 re-render 跟是否使用了状态是没有关系的，而是和是否触发了更新状态的 dispatch 有关，如果一定要和状态绑定一起，那不就是 Vue 了吗。对于问题三，同样是 React 底层的优化策略处理并没有做到极致这样。
总结
回到 React Context 工作原理来看，只要有消费者订阅了该 Context，在该 Context 发生变化时就会触达所有的消费者。也就是说整个工作流程都是以 Context 为中心的，那只要把 Context 拆分的粒度足够小就不会带来额外的渲染负担。但是这样又会带来其他问题：ContextProvider 会嵌套多层，同时对于粒度的把握对开发者来说又会带来一定的心智负担。
从另一条路出发：Selector 机制，通过选择需要的状态从而规避掉无关的状态改变时带来的渲染开销。除了社区提到的 use-context-selector ，React 团队也有一个相应的 RFC 方案 RFC: Context selectors，不过这个 RFC 从 19 年开始目前还处于持续更新阶段。
最后，对于 React Context 的使用，个人推荐：「不频繁更改的全局状态（比如说：自定义主题、账户信息、权限信息等）可以合理使用 Context，而对于其他频繁修改的全局状态可以通过其他数据流方式维护，可以更好的避免不必要的 re-render 开销」。
参考
- https://www.developerway.com/posts/react-re-renders-guide
- https://react.dev/reference/react/StrictMode#enabling-strict-mode-for-entire-app
- https://github.com/dai-shi/use-context-selector
- https://github.com/facebook/react/pull/22445
- https://github.com/facebook/react/issues/24596
- https://react.dev/reference/react/useSyncExternalStore
- https://juejin.cn/post/7197972831795380279
- https://github.com/reactjs/rfcs/pull/119
- case1：https://codesandbox.io/s/serverless-frost-9ryw2x?file=/src/App.js
- case2：https://codesandbox.io/s/use-context-selector-vvs93q?file=/src/App.js
- case3：https://codesandbox.io/s/elegant-montalcini-nkrvlh?file=/src/App.js
- case4：https://codesandbox.io/s/use-context-selector-smsft3?file=/src/App.js
