useEffect

useEffect 是 React 提供的一个 Hook(钩子),用来在函数组件里执行副作用(side effect)——也就是把组件和 React 之外的系统同步起来:请求数据、订阅事件、操作真实 DOM、设置定时器等等。

一句话概括:渲染负责「算出界面长什么样」,useEffect 负责「渲染之后去做那些和界面显示无关的事」。

import { useState, useEffect } from 'react';
 
function Counter() {
  const [count, setCount] = useState(0);
 
  // 每次 count 变化后,把页面标题同步为最新值
  useEffect(() => {
    document.title = `点击了 ${count} 次`;
  }, [count]);
 
  return <button onClick={() => setCount(count + 1)}>+1</button>;
}

document.title 不属于 React 的渲染结果,但它是页面的真实状态之一,需要「跟着 count 变」——这就是副作用,交给 useEffect 处理。

渲染应该是纯的:同样的 props 和 state,就应该渲染出同样的 JSX,过程中不去碰外部世界。

但真实应用必须和外部世界打交道:

要做的事 涉及的外部对象
获取数据 服务器接口
监听窗口大小、键盘、滚动 浏览器事件
聚焦输入框、初始化地图/图表 真实 DOM
定时刷新 定时器 API
写 localStorage、改页面标题 浏览器存储 / document

这些「不参与计算界面、发生在渲染之外」的动作统称为副作用,useEffect 就是它们的安放之处。

useEffect(() => {
  // 副作用代码:DOM 更新完成之后执行
 
  return () => {
    // 清理函数(可选):卸载前、下次执行前调用
  };
}, [依赖项]);
  • 第一个参数:effect 函数,React 保证在 DOM 更新之后才调用它。
  • 第二个参数:依赖数组,决定什么时候重新执行这个 effect。
  • 返回值(可选):清理函数,用来撤销上一次的副作用。

和 useState 一样,useEffect 必须写在组件或自定义 Hook 的最顶层,不能放在条件、循环、嵌套函数里。

  • 组件渲染 → React 把结果提交到 DOM(浏览器可能已经绘制)→ 再执行 effect。
  • 因此 effect 不会阻塞页面绘制,不适合放「用户必须立刻看到」的同步逻辑。
  • 首次挂载一定会执行一次,不管依赖数组怎么写。
  • 依赖变化时:先执行上一次的清理函数,再执行新的 effect。
  • 组件卸载时:执行最后一次的清理函数。
写法 执行时机 适用场景
不传第二个参数 每次渲染后都执行 很少用,容易出问题
[](空数组) 只在挂载后执行一次 初始化一次即可(订阅、首次请求)
[a, b] 挂载后 + a 或 b 变化后执行 最常用
// 1. 不传依赖:每次渲染后都执行(通常不是你想要的)
useEffect(() => {
  console.log('每次渲染都会执行');
});
 
// 2. 空数组:只在挂载后执行一次
useEffect(() => {
  console.log('只执行一次');
}, []);
 
// 3. 指定依赖:count 或 userId 变化时重新执行
useEffect(() => {
  fetchUser(userId, count);
}, [userId, count]);

依赖项之间用 Object.is 逐个浅比较,只要有一个发生变化就重新执行。所以每次渲染都新建的对象/数组/函数,会被判定为「变了」。

返回一个函数就是清理函数,它会在两个时机被调用:

  • 组件卸载前
  • 依赖变化、下一次 effect 执行之前

作用是「把上一个副作用收干净」,避免内存泄漏、重复订阅、以及旧请求覆盖新结果。

// 订阅事件:卸载时必须退订
useEffect(() => {
  const onResize = () => setWidth(window.innerWidth);
  window.addEventListener('resize', onResize);
 
  return () => window.removeEventListener('resize', onResize);
}, []);
 
// 定时器:卸载时必须清除
useEffect(() => {
  const id = setInterval(() => setTick(t => t + 1), 1000);
  return () => clearInterval(id);
}, []);
 
// 请求:取消旧请求,避免竞态
useEffect(() => {
  const controller = new AbortController();
 
  fetch(`/api/user/${userId}`, { signal: controller.signal })
    .then(res => res.json())
    .then(setUser)
    .catch(err => {
      if (err.name !== 'AbortError') setError(err);
    });
 
  return () => controller.abort();
}, [userId]);

原则:任何「申请了资源」的 effect 都应有对应的清理——订阅要退订、定时器要清除、请求要取消、第三方实例要销毁。

const [data, setData] = useState(null);
const [loading, setLoading] = useState(true);
 
useEffect(() => {
  let ignore = false;
 
  setLoading(true);
  fetch(`/api/posts/${id}`)
    .then(res => res.json())
    .then(json => {
      if (!ignore) {
        setData(json);
        setLoading(false);
      }
    });
 
  return () => {
    ignore = true; // 丢弃已经过期的响应
  };
}, [id]);

注意:effect 本身不能是 async 函数(返回值必须是清理函数),要在里面定义并调用 async 函数,或用上面的 Promise 写法。

useEffect(() => {
  const unsubscribe = store.subscribe(() => {
    setSnapshot(store.getSnapshot());
  });
  return unsubscribe;
}, []);
const inputRef = useRef(null);
 
useEffect(() => {
  inputRef.current.focus(); // 挂载后自动聚焦
}, []);

初始化地图、图表、视频播放器等第三方库也属于这一类,都需要在清理函数里销毁实例。

useEffect(() => {
  document.title = title;
}, [title]);
 
useEffect(() => {
  localStorage.setItem('theme', theme);
}, [theme]);

无限循环:effect 里调用 setState,而这个 state 又在依赖数组里,于是「改状态 → 依赖变化 → 再执行」无限循环。

// 错误
useEffect(() => {
  setCount(count + 1);
}, [count]);
 
// 正确:用函数式更新,就不必把 count 放进依赖
useEffect(() => {
  setCount(prev => prev + 1);
}, []);

依赖里放了每次都是新引用的对象/函数:[options] 这类写法会让 effect 每次渲染都执行。用 useMemo / useCallback 稳定引用,或者只依赖 effect 里真正用到的字段(如 options.size)。

遗漏依赖(闭包旧值):effect 只依赖 [],却读了 count,拿到的永远是首次渲染时的旧值。依赖数组要如实列出所有用到的响应式值,开发时打开 ESLint 规则 react-hooks/exhaustive-deps。

把 async 直接写在 effect 里:useEffect(async () ⇒ { … }) 返回的是 Promise,React 无法把它当作清理函数,必须像前面那样在内部定义 async 函数再调用。

清理不彻底:只 addEventListener 不 removeEventListener,组件卸载后回调还在运行,导致报错或内存泄漏。

用 effect 做渲染时就能算出的事:例如「根据 firstName 和 lastName 得出 fullName」,直接在渲染时算即可,不需要额外的 state 和 effect。

StrictMode 下开发环境执行两次:React 18+ 在开发模式会「挂载 → 卸载 → 再挂载」,用来暴露清理不彻底的 bug。这是刻意行为;写法正确时不受影响,生产构建只执行一次。

useEffect 很容易被滥用,遇到下面的需求先想想是不是不该用:

需求 更好的做法
能由现有 props / state 算出 直接在渲染中计算
用户点击后要做的事 写在事件处理函数里
某个 prop 变化时要重置内部 state 给组件加 key,或在渲染中比较前值
缓存父组件传来的计算结果 放到父组件的 useMemo 里
读取最新值但不触发渲染 useRef
Hook 作用
useState 组件内部状态,驱动重新渲染
useRef 存不触发渲染的值(DOM 引用、定时器 id)
useEffect 渲染后与外部系统同步,可清理
useLayoutEffect 同上,但在浏览器绘制之前同步执行
useMemo / useCallback 稳定对象、函数引用,减少多余的 effect
useContext 跨层级读取共享数据,常与 effect 配合使用
  • useEffect 用来执行副作用:请求、订阅、DOM 操作、定时器、与浏览器存储同步。
  • 它在渲染提交到 DOM 之后执行,不阻塞绘制,首次挂载必然执行一次。
  • 依赖数组决定重跑时机:不传 = 每次渲染;[] = 仅一次;[a] = a 变化时。
  • 依赖是 Object.is 浅比较,对象/函数必须保持引用稳定。
  • 有副作用的申请,就要有清理函数:退订、清定时器、取消请求。
  • 不要在 effect 里做能用渲染计算或事件处理完成的事,避免滥用。
# useEffect

## 是什么
- React 内置 Hook
- 用来执行「副作用」
- 把组件与外部系统同步
- 渲染后执行,不阻塞绘制

## 什么是副作用
- 请求数据 → 服务器接口
- 订阅事件 → 浏览器事件
- 操作 DOM → 聚焦、滚动、第三方库
- 定时器 / localStorage / 页面标题
- 渲染应保持纯净,副作用另安放

## 基本语法
- `useEffect(effect, [deps])`
- effect:DOM 更新后调用
- 返回值:清理函数(可选)
- 必须在组件顶层调用

## 依赖数组
- 不传 → 每次渲染都执行
- `[]` → 只在挂载后执行一次
- `[a, b]` → 挂载后 + a / b 变化时
- Object.is 浅比较
- 对象 / 函数需保持引用稳定

## 执行时机
- 渲染 → 提交 DOM → 执行 effect
- 首次挂载必执行一次
- 不阻塞浏览器绘制
- useLayoutEffect:绘制前同步执行

## 清理函数
- 组件卸载前调用
- 下次 effect 执行前调用
- 退订事件、清除定时器
- 取消请求(AbortController)
- 有申请就应有清理

## 常见场景
- 获取数据(防竞态)
- 订阅外部 store
- 聚焦、初始化第三方库
- 同步 document.title / localStorage

## 常见坑
- 依赖不全 → 闭包读到旧值
- 依赖里放新引用对象 → 每次执行
- effect 里 setState 又依赖该 state → 无限循环
- 直接把 async 函数传给 useEffect
- 只订阅不取消 → 内存泄漏
- 用 effect 做渲染时就能算的事
- StrictMode 开发环境执行两次

## 不该用 useEffect
- 能由 props / state 算出 → 渲染时算
- 用户操作触发 → 事件处理函数
- 重置组件状态 → 用 key
- 读最新值但不渲染 → useRef

## 相关 Hook
- useState:状态与重渲染
- useRef:不触发渲染的值
- useMemo / useCallback:稳定引用
- useContext:跨层级共享数据

该主题尚不存在

您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。

  • react/useeffect.txt
  • 最后更改: 2026/10/14 10:04
  • 由 张叶安