w wyl123ly 的博客
MD

前端-07-React

70 KB 2026.10.11 原文件

前端-07-React

这篇笔记讲什么

React 是一个用于构建用户界面的 JavaScript 库(Library),官方对它的定位只有一句话:"用于构建 Web 和原生交互界面的库"。当前最新主版本为 React 19.3.0(本库核实时间 2026-10-11,见 版本与官方资源速查)。

本篇以 React 19 + TypeScript + 函数组件 + Hooks 为主线,不涉及类组件(class extends React.Component 的写法已不再是官方推荐的教学路径,旧代码里仍会遇到)。

读完你应该能:用 Vite 建起 React + TS 项目、说清 JSX 编译成什么、写出不出无限循环的 useEffect、判断什么时候真的需要状态管理库、解释"为什么直接改 state 不触发更新",并完成一个与 前端-06-Vue 版本对照的 TodoList。


一、是什么:React 的定位与核心思想

1.1 一句话定义

React 是一个声明式的、基于组件的 JavaScript 库:你把界面描述成组件的组合,把变化描述成状态的更新,React 负责在状态变化时算出最小必要的 DOM 操作。

注意用词是"库"而不是"框架":React 官方只提供"组件 + 状态 + 渲染"这三件事,路由(React Router)、状态管理(Redux / Zustand)、数据请求(TanStack Query)、表单、样式方案全部由社区生态补齐。这与 前端-06-Vue 的"渐进式框架 + 官方全家桶"路线形成鲜明对比。

1.2 四个核心思想

思想含义具体体现
UI = f(state)界面是状态的函数:给定同一份状态,渲染结果必然相同组件就是接收 props 返回 JSX 的纯函数
组件化(Component)一个组件 = 一段可复用的 UI + 它自己的逻辑与状态函数组件是唯一的推荐写法
单向数据流(One-way Data Flow)数据只能从父流向子,子不能改父的数据props 只读;要改就调用父传下来的回调
不可变更新(Immutable Update)更新状态时创建新对象/新数组,而不是改原对象setItems([...items, x]) 而不是 items.push(x)

1.3 声明式 vs 命令式:React 让你少写什么

同一个需求:点按钮给列表加一项,并显示总数。

命令式(原生 DOM):

let count = 0
const list = document.querySelector('#list')
const total = document.querySelector('#total')

document.querySelector('#add').addEventListener('click', () => {
  count++
  // 你必须手写:创建节点、填内容、插入、再同步派生数据
  const li = document.createElement('li')
  li.textContent = `条目 ${count}`
  list.appendChild(li)
  total.textContent = String(count)
})

声明式(React 19):

export default function App() {
  const [items, setItems] = useState<string[]>([])

  return (
    <>
      <ul>
        {items.map((item) => (
          <li key={item}>{item}</li>
        ))}
      </ul>
      <span>{items.length}</span>
      <button onClick={() => setItems([...items, `条目 ${items.length + 1}`])}>添加</button>
    </>
  )
}

你只负责"状态变成什么样",DOM 怎么变由 React 决定。 要加筛选、加删除,都只改数据。

对比维度命令式(原生 DOM / jQuery)声明式(React)
你写的是操作步骤状态与视图的对应关系
状态存放常散落在闭包与 DOM 中集中在 useState / useReducer
派生数据手动同步(容易忘)渲染时算出来(items.length)
性能优化方式精确手动控制先正确,再用 memo / useMemo 定位瓶颈
心智负担随交互数量增长随状态数量增长

形式化地说,React 保证的是:

这也是"组件必须是纯函数"这条规则的根本原因:只要渲染有副作用或依赖外部可变数据, 就不再是函数,界面就无法预测。


二、为什么这样设计

2.1 为什么要"重新执行整个组件函数"

React 的更新模型很"笨"也很可靠:状态变化 → 重新调用组件函数 → 得到新的 JSX 树(虚拟 DOM)→ 与上一次的树对比(Reconciliation)→ 只把差异写进真实 DOM。

好处是心智模型极简:你不需要知道"哪个 DOM 节点对应哪个数据",只需要保证"函数在给定 props/state 下返回正确的界面"。代价是每次更新都会重新执行组件函数(因此有 memo、useMemo 这类优化 API),以及必须遵守不可变更新(否则新旧树看起来一样,diff 就发现不了变化)。

2.2 为什么 props 是只读的

如果子组件能改父组件的数据,任何一次界面异常都要回溯整棵组件树去找"谁改的"。React 用"props 只读 + 回调上报"把数据流约束成单向的:数据向下流,事件向上走。这样任何一份数据的"修改入口"都是唯一的,调试范围立刻收敛。

2.3 为什么 Hooks 必须写在顶层

React 内部用调用顺序来把 Hook 与组件实例对应起来:第 1 个 useState 是 A,第 2 个是 B。如果 Hook 写在 if 或循环里,某次渲染少调用了"第 2 个",那么后面的 Hook 就会错误地拿到"第 2 个"的状态槽,状态全部错位。所以规则不是"风格建议",而是运行时机制决定的硬约束。

2.4 为什么现在少用 create-react-app

对比项Vite(当前推荐)create-react-app(CRA)
开发服务器原生 ESM 按需编译,启动快、HMR 快Webpack 全量打包,项目变大后启动明显变慢
维护状态活跃已停止维护(React 官方文档与 CRA 仓库均已不再推荐)
配置自由度vite.config.ts 一处搞定想改配置需要 eject,不可逆
SSR / 框架方向可用 Vite 生态,或直接用 Next.js 等框架无官方路径
该选谁单页应用、组件库、想理解构建流程仅存在于历史项目中

官方文档的三个起步选项

React 官方文档的"开始使用"章节给出的路径是:① 框架(如 Next.js / Remix,适合需要路由、数据获取、SSR 的完整应用);② 从零构建(用 Vite 等打包工具,适合纯客户端 SPA 与学习);③ CDN 引入(适合在已有页面里试用一个小部件)。具体推荐列表以官方最新文档为准。


三、核心内容

3.1 创建项目

# 需要 Node.js 18+ / 20+(具体下限以官方最新文档为准)
npm create vite@latest my-react-app -- --template react-ts
cd my-react-app
npm install
npm run dev     # http://localhost:5173
npm run build   # 产物在 dist/
npm run preview # 本地预览生产构建

生成的关键文件:

// package.json(关键部分)
{
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "tsc -b && vite build", // 先类型检查,再打包
    "preview": "vite preview"
  },
  "dependencies": {
    "react": "^19.3.0",
    "react-dom": "^19.3.0"
  },
  "devDependencies": {
    "@vitejs/plugin-react": "^5.0.0",
    "typescript": "~5.9.0",
    "vite": "^8.0.0"
  }
}
// src/main.tsx:入口
import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import App from './App.tsx'
import './index.css'

// React 18 起的客户端 API:createRoot 取代了 ReactDOM.render
createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <App />
  </StrictMode>,
)

StrictMode 会让开发环境的副作用执行两次

<StrictMode> 在开发环境会故意把组件函数与 useEffect 的挂载/卸载多跑一遍,用来暴露"没写清理函数"和"渲染时有副作用"的问题。这不是 bug:如果它让你的代码出错,说明代码本身有问题。生产构建不会重复执行。

3.2 JSX

3.2.1 JSX 本质是语法糖

JSX 不是 HTML 也不是字符串,而是函数调用的语法糖。现代构建工具(Vite 的 React 插件、Babel、TypeScript)默认使用 Automatic Runtime 转换:

// 你写的
const el = <h1 className="title">Hello {name}</h1>

// 编译后(自动运行时,自动注入 jsx 导入)+ 格式化后等价于:
import { jsx as _jsx } from 'react/jsx-runtime'

const el = _jsx('h1', {
  className: 'title',
  children: ['Hello ', name],
})

一次 <App /> 组件调用的编译结果同样是普通函数调用:

// 你写的
return <App count={1} />

// 编译后
return _jsx(App, { count: 1 })

因此 JSX 里可以放任何 JavaScript 表达式:{2 + 2}、{items.map(...)}、{cond ? <A /> : <B />},因为它们最终都只是函数参数。

// 需要多行/多元素时用 Fragment 包裹,它不产生额外 DOM 节点
const list = (
  <>
    <li>第一项</li>
    <li>第二项</li>
  </>
)
// 等价于 <React.Fragment>...</React.Fragment>
3.2.2 与 HTML 的差异清单
项目HTMLJSX原因
class 属性class="box"className="box"class 是 JS 保留字
label 关联for="id"htmlFor="id"同上
自闭合<img> / <br><img /> / <br /> 必须闭合JSX 是表达式,必须结构完整
插入表达式无{expr},属性值也用 {}属性值是 JS 值:value={n}
字符串属性title=hellotitle="hello"不加引号会被当成变量
条件渲染无{cond && <A />} 或三元表达式只能是表达式
列表渲染手写重复节点{items.map(i => <li key={i.id} />)}key 帮助 React 识别身份
stylestyle="color:red"style={{ color: 'red' }}值是对象,属性名用 camelCase
事件名onclick(小写)onClick(小驼峰)属性名映射到 React 的合成事件系统
注释<!-- -->{/ /}在大括号里写 JS 注释
布尔属性disableddisabled={true} 或省略值是 JS 布尔值
自定义属性任意data- / aria- 原样透传其它未识别属性在 React 19 会原样透传给 DOM(以官方最新文档为准)

几个容易写错的例子:

// ❌ 两个相邻元素没有父节点
return <li>a</li><li>b</li>

// ✅ Fragment
return (
  <>
    <li>a</li>
    <li>b</li>
  </>
)

// ❌ 0 会被渲染出来
{items.length && <List />}

// ✅ 显式判断
{items.length > 0 && <List />}

// ✅ 三元:二选一
{isLoading ? <Spinner /> : <List items={items} />}
3.2.3 key 的作用,以及为什么不能用数组索引

key 是 React 在协调(Reconciliation)时判断"新旧列表里哪个元素是同一个"的身份标识。有了稳定的 key,React 才能复用对应的 DOM 节点与组件状态、正确搬运节点,而不是逐个重建。

// ❌ 索引作 key:删除 / 排序后身份错位
{items.map((item, index) => (
  <Row key={index} item={item} />
))}

// ✅ 业务 id 作 key
{items.map((item) => (
  <Row key={item.id} item={item} />
))}

为什么索引会出问题:假设列表是 [A, B, C],key 为 0,1,2;删除 A 后新列表是 [B, C],key 变成 0,1。React 认为"key=0 这一项还在,只是内容从 A 变成了 B",于是复用原有 DOM 与组件状态(比如输入框里用户已输入的内容、展开状态、动画状态),把它们错配到别的数据上。

key 选择结果什么时候能用
稳定的业务 id身份正确,状态与数据一一对应默认选择
数组索引中间增删/排序时状态错位仅"只追加、不删除、不排序、项内无状态"
Math.random() / 时间戳每次渲染都重建整棵子树,性能与状态全毁永远不要
复合键 ${id}-${type}同一数据在不同列表位置需要独立状态时有用明确知道自己在做什么时

一个实用技巧

key 变化会让组件重新挂载、状态重置。可以利用这一点:想让"切换到另一个用户时表单清空",给表单加 key={userId} 比写一堆 useEffect 重置状态更简洁可靠。

3.3 组件与 Props

3.3.1 函数组件与 props
// React 19 + TS 的推荐写法:直接用函数类型标注 props
type AvatarProps = {
  src: string
  alt?: string
  size?: 'sm' | 'md' | 'lg'
}

const SIZE_MAP = { sm: 24, md: 40, lg: 64 } as const

export function Avatar({ src, alt = '头像', size = 'md' }: AvatarProps) {
  // props 只读:下面这行会报错(TS 层面就无法通过)
  // alt = '其它'

  const px = SIZE_MAP[size]
  return <img src={src} alt={alt} width={px} height={px} style={{ borderRadius: '50%' }} />
}
// React 18 及以前的常见写法(仍可用,但类型更啰嗦)
import type { FC } from 'react'
const Avatar: FC<AvatarProps> = ({ src }) => <img src={src} />
写法评价
function Comp(props: Props)推荐,类型推导自然,便于泛型组件
const Comp = (props: Props) => ...同样可以,但函数声明在堆栈里更好认
React.FC<Props>旧风格;早期版本的隐式 children 会造成误导,现已收敛,但没必要用
3.3.2 children 与组合优于继承
import type { ReactNode } from 'react'

type CardProps = {
  title: string
  children: ReactNode          // children 只是普通的 prop
  footer?: ReactNode
}

export function Card({ title, children, footer }: CardProps) {
  return (
    <section className="card">
      <h3>{title}</h3>
      <div className="card-body">{children}</div>
      {footer && <footer>{footer}</footer>}
    </section>
  )
}

// 使用:内容由调用方决定,Card 不关心里面是什么
;<Card title="用户信息" footer={<button>编辑</Button>}>
  <p>张三,20 岁</p>
</Card>

组合优于继承

React 没有"组件继承"这套机制,也不需要。要复用 UI,就用 children(内容交给调用方)、具名 prop 传 ReactNode(多个插槽位)、或抽取自定义 Hook 复用逻辑。用一个布尔 prop 控制一堆 if,通常是拆分或插槽的信号。

拆分原则:① UI 在两处以上出现;② 组件自己有状态且与父级无关;③ 组件文件超过约 200 行、或需要频繁上下滚动才能读完;④ 某部分有独立的性能优化需求(要包 memo)。

3.4 State 与 Hooks

3.4.1 useState 的异步与批量更新
import { useState } from 'react'

export function Counter() {
  const [count, setCount] = useState(0)
  const [flag, setFlag] = useState(false)

  function handleClick() {
    // ❌ 三次都基于"本次渲染时的 count"计算,结果只加 1
    setCount(count + 1)
    setCount(count + 1)
    setCount(count + 1)

    // ✅ 函数式更新:每次拿到"最新的待提交值"
    setCount((prev) => prev + 1)
    setCount((prev) => prev + 1)
    setCount((prev) => prev + 1)

    // 同一事件处理器里的多个 setState 会被"批量更新(Batching)",
    // 只触发一次重新渲染(React 18 起自动批量,包括异步回调里)
    setFlag((f) => !f)

    console.log(count) // 仍然是本次渲染的值,state 更新是"异步"的
  }

  return <button onClick={handleClick}>点了 {count} 次</button>
}
现象原因正确写法
setCount(count + 1) 连续三次只加 1count 是本次渲染的快照,三次读到同一个值setCount(p => p + 1)
调用 setState 后立刻 console.log 还是旧值更新被排队,本次执行上下文里的变量不会变在事件处理里自己算一份,或用 useEffect 观察
连续两次 setState 只重渲染一次自动批量更新(Batching)无需处理,这是优化
setState 相同值时组件仍重渲染一次React 用 Object.is 比较;相同则跳过渲染,但可能已进入调度不需要手动 if 拦截,除非值计算代价很高

什么时候必须用函数式更新:① 新值依赖旧值;② 在 setTimeout、Promise.then、事件订阅回调里更新(那里的闭包可能已经过期);③ 同一个值被连续更新多次。

3.4.2 useEffect 的依赖数组三种情况
import { useEffect, useState } from 'react'

export function Timer({ userId }: { userId: number }) {
  const [seconds, setSeconds] = useState(0)

  // ① 没有依赖数组:每次渲染后都执行 → 绝大多数情况下是错的
  useEffect(() => {
    console.log('每次渲染后执行')
  })

  // ② 空数组:只在挂载后执行一次(开发环境 StrictMode 会跑两遍用于暴露问题)
  useEffect(() => {
    console.log('只在挂载后执行一次')
  }, [])

  // ③ 有依赖:挂载后 + 依赖变化后执行
  useEffect(() => {
    setSeconds(0) // 切换用户时重置计时
    const id = window.setInterval(() => setSeconds((s) => s + 1), 1000)

    // 清理函数:在"下次 effect 执行前"和"组件卸载时"调用
    return () => window.clearInterval(id)
  }, [userId]) // 依赖必须写全:effect 里用到的所有响应式值都要列上

  return <p>用户 {userId} 已停留 {seconds} 秒</p>
}
依赖数组执行时机典型用途风险
省略每次渲染后极少(如需要与 DOM 同步的测量)极易造成无限循环
[]挂载后一次订阅、初始化第三方库、只执行一次的请求用到 props/state 时会捕获过期值(stale closure)
[a, b]挂载后 + a/b 变化后按参数重新取数、重新订阅漏写依赖 → 读取到旧值
return () => {}清理函数取消定时器、取消订阅、abort 请求不写清理 → 内存泄漏、重复订阅

副作用的四种正确去向(先问"这真的需要 effect 吗"):

需求不要用 effect应该怎么做
由 props/state 派生的值用 effect 同步到另一个 state直接在渲染时算(或 useMemo)
用户操作触发的请求——在事件处理函数里发
父组件传 prop 变化时重置子组件状态用 effect 里 setX用 key 让组件重新挂载
真正的外部同步(订阅、定时器、DOM 测量、非 React 组件)——这才是 effect 的用途
3.4.3 无限循环的成因与排查
// ❌ 成因一:effect 里 set 的 state 又是该 effect 的依赖
const [count, setCount] = useState(0)
useEffect(() => {
  setCount(count + 1) // 改了 count → 依赖 count 变化 → 再次执行 → 死循环
}, [count])

// ❌ 成因二:依赖是每次渲染都新建的对象/数组/函数
const [user, setUser] = useState({ id: 1 })
useEffect(() => {
  fetchData() // 每次都执行
}, [{ id: user.id }]) // 字面量每次都是新引用,永远不相等
useEffect(() => {}, [() => {}]) // 内联函数同理

// ❌ 成因三:渲染期间直接调用 setState(没有条件保护)
function Bad() {
  const [n, setN] = useState(0)
  setN(n + 1) // 渲染 → setState → 重新渲染 → …… 报 "Too many re-renders"
  return null
}
// ✅ 修法一:用函数式更新 + 空依赖(effect 不依赖 count)
useEffect(() => {
  const id = window.setInterval(() => setCount((c) => c + 1), 1000)
  return () => window.clearInterval(id)
}, [])

// ✅ 修法二:把对象/函数依赖用 useMemo / useCallback 稳定下来,
//           或改成依赖它的原始值
useEffect(() => {
  void fetchData(user.id)
}, [user.id]) // 依赖原始值,而不是每次新建的对象

// ✅ 修法三:只在渲染期间计算派生值,不要 setState
const doubled = n * 2

排查无限循环的四步

① 打开控制台看是否有 Maximum update depth exceeded 或 Too many re-renders;

② 用 console.trace() 放进可疑的 effect,看是谁在反复触发;

③ 逐条检查依赖:effect 里 set 的 state 是否出现在依赖里(最经典);

④ 检查依赖是否是对象/数组/函数字面量——如果是,改成原始值依赖或用 useCallback 包一层。

3.4.4 useRef 的两种用途
import { useRef, useState } from 'react'

export function SearchBox() {
  // 用途一:引用 DOM 节点(React 19 起 ref 是普通 prop,函数组件无需 forwardRef)
  const inputRef = useRef<HTMLInputElement>(null)

  // 用途二:保存"不需要触发渲染"的可变值
  const timerRef = useRef<number | undefined>(undefined)
  const renderCountRef = useRef(0)
  renderCountRef.current += 1 // 改 ref 不会重新渲染

  function focusInput() {
    inputRef.current?.focus()
  }

  function onInput() {
    window.clearTimeout(timerRef.current)
    timerRef.current = window.setTimeout(() => console.log('防抖请求'), 300)
  }

  return (
    <div>
      <input ref={inputRef} onInput={onInput} />
      <button onClick={focusInput}>聚焦</button>
      <p>渲染次数(不触发更新):{renderCountRef.current}</p>
    </div>
  )
}
对比项useStateuseRef
值变化是否触发渲染是否
是否在渲染间保持是是
是否应参与渲染输出是(界面依赖它)否(否则界面会与数据不同步)
典型用途界面要显示的数据DOM 引用、定时器 id、上一次的值、渲染计数
3.4.5 useMemo 与 useCallback
import { useCallback, useMemo, useState } from 'react'

export function ProductList({ products }: { products: Product[] }) {
  const [keyword, setKeyword] = useState('')
  const [sortAsc, setSortAsc] = useState(true)

  // useMemo:缓存"计算结果",依赖不变就复用
  const visible = useMemo(() => {
    return products
      .filter((p) => p.name.includes(keyword))
      .sort((a, b) => (sortAsc ? a.price - b.price : b.price - a.price))
  }, [products, keyword, sortAsc])

  // useCallback:缓存"函数引用",依赖不变就复用同一个函数对象
  // 主要用于:传给 memo 包裹的子组件,或作为其它 Hook 的依赖
  const handleAdd = useCallback((id: number) => {
    console.log('加入购物车', id)
  }, []) // 只用了 setState 与常量,依赖可以为空

  return (
    <>
      <input value={keyword} onChange={(e) => setKeyword(e.target.value)} />
      <button onClick={() => setSortAsc((v) => !v)}>切换排序</button>
      {visible.map((p) => (
        <Row key={p.id} product={p} onAdd={handleAdd} />
      ))}
    </>
  )
}
Hook缓存什么有效的前提无效(纯亏)的情况
useMemo计算结果计算代价高(大数据集遍历、复杂推导),或结果要作为其它 Hook 的依赖简单运算(a + b)——缓存本身的开销可能更大
useCallback函数引用函数要传给 memo 子组件,或作为 effect 依赖函数只在本组件内用,不传给子组件

过度优化的代价

① useMemo / useCallback 自身有开销:每次渲染都要比较依赖数组;

② 依赖写错会引入"值不更新"的诡异 bug,比性能问题更难查;

③ React 官方明确保留"未来可能丢弃缓存"的权利——语义正确性不能依赖缓存一定命中(useMemo 是性能优化,不是语义保证);

④ 真正有效的手段往往是"把状态往下挪(让 state 离使用它的组件更近)"、"用 children 把不变化的子树传进去",而不是到处包 memo。

3.4.6 useContext
import { createContext, useContext, useMemo, useState, type ReactNode } from 'react'

type Theme = 'light' | 'dark'
type ThemeContextValue = { theme: Theme; toggle: () => void }

// 默认值只在"没有 Provider"时生效;实际项目里常设为 null 并做断言
const ThemeContext = createContext<ThemeContextValue | null>(null)

export function ThemeProvider({ children }: { children: ReactNode }) {
  const [theme, setTheme] = useState<Theme>('light')

  // value 每次渲染都会新建对象 → 所有消费者都会重渲染
  // 用 useMemo 稳定引用,是 Context 最常见的性能修复
  const value = useMemo<ThemeContextValue>(
    () => ({ theme, toggle: () => setTheme((t) => (t === 'light' ? 'dark' : 'light')) }),
    [theme],
  )

  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>
}

// 自定义 Hook 封装 useContext:集中处理"未包裹 Provider"的错误
export function useTheme() {
  const ctx = useContext(ThemeContext)
  if (!ctx) throw new Error('useTheme 必须在 <ThemeProvider> 内使用')
  return ctx
}
// React 19 起可以直接渲染 <Context> 作为 Provider(以官方最新文档为准)
<ThemeContext value={value}>{children}</ThemeContext>
Context 适合Context 不适合
低频变化、全局读取的配置:主题、语言、当前用户高频变化的数据(每次变化会让所有消费者重渲染)
避免多层 props 透传(prop drilling)当作"全局 store"存放大量互不相关的状态
与 useReducer 组合做轻量状态管理需要中间件、时间旅行调试、跨 store 依赖时(改选 Zustand/Redux)
3.4.7 自定义 Hook

规则只有两条:名字必须以 use 开头(否则 React 不会按 Hook 规则检查它),内部调用的 Hook 必须在顶层。它只是"把逻辑抽出来的函数",不共享状态——两个组件调用同一个自定义 Hook,各自拿到独立的状态。

// src/hooks/useDebounce.ts
import { useEffect, useState } from 'react'

/**
 * 返回防抖后的值:只有 value 停止变化 delay 毫秒后才更新。
 * 用途:搜索框输入时避免每次按键都发请求。
 */
export function useDebounce<T>(value: T, delay = 300): T {
  const [debounced, setDebounced] = useState(value)

  useEffect(() => {
    const id = window.setTimeout(() => setDebounced(value), delay)
    // 清理:value 再次变化时取消上一次的定时器,这就是"防抖"的实现
    return () => window.clearTimeout(id)
  }, [value, delay])

  return debounced
}
// src/hooks/useFetch.ts:带取消与错误处理的数据请求 Hook
import { useEffect, useState } from 'react'

interface State<T> {
  data: T | null
  loading: boolean
  error: string | null
}

export function useFetch<T>(url: string): State<T> & { refetch: () => void } {
  const [state, setState] = useState<State<T>>({ data: null, loading: true, error: null })
  // 用一个自增值作为"重新请求"的触发器
  const [nonce, setNonce] = useState(0)

  useEffect(() => {
    // 关键:用 AbortController 在依赖变化/卸载时取消在途请求
    const controller = new AbortController()
    let alive = true // 双保险:即便 abort 未生效也不再 setState

    setState({ data: null, loading: true, error: null })

    fetch(url, { signal: controller.signal })
      .then((res) => {
        if (!res.ok) throw new Error(`HTTP ${res.status}`)
        return res.json() as Promise<T>
      })
      .then((data) => {
        if (alive) setState({ data, loading: false, error: null })
      })
      .catch((err: unknown) => {
        // abort 引发的中断不是错误,必须忽略,否则切页面会误报
        if (err instanceof DOMException && err.name === 'AbortError') return
        if (alive) setState({ data: null, loading: false, error: (err as Error).message })
      })

    return () => {
      alive = false
      controller.abort()
    }
  }, [url, nonce])

  return { ...state, refetch: () => setNonce((n) => n + 1) }
}
// 使用两个自定义 Hook 做"输入 → 防抖 → 请求"
import { useState } from 'react'
import { useDebounce } from '@/hooks/useDebounce'
import { useFetch } from '@/hooks/useFetch'

interface Article { id: number; title: string }

export function ArticleSearch() {
  const [keyword, setKeyword] = useState('')
  const debounced = useDebounce(keyword, 400)
  const { data, loading, error } = useFetch<Article[]>(`/api/articles?q=${encodeURIComponent(debounced)}`)

  return (
    <div>
      <input value={keyword} onChange={(e) => setKeyword(e.target.value)} placeholder="搜索文章" />
      {loading && <p>加载中…</p>}
      {error && <p>出错了:{error}</p>}
      <ul>
        {data?.map((a) => (
          <li key={a.id}>{a.title}</li>
        ))}
      </ul>
    </div>
  )
}

3.5 Hooks 规则

规则内容违反了会怎样
只在顶层调用不能放在 if、for、while、try/catch、嵌套函数里运行时 Hook 顺序错位,状态串位甚至崩溃
只在 React 函数里调用函数组件或自定义 Hook 内ESLint 报错;React 无法关联到实例
依赖数组要写全effect 里用到的所有响应式值读取过期值(stale closure)
自定义 Hook 用 use 前缀便于 lint 与团队识别lint 插件无法校验其中的 Hook 调用
// ❌ 条件里调用 Hook:两次渲染的 Hook 数量不同
function Bad({ show }) {
  if (show) {
    const [n, setN] = useState(0) // 违规
  }
  const [m, setM] = useState(0)
}

// ✅ 提前返回放在 Hook 之前?也不行——必须所有 Hook 都无条件调用
function Good({ show }) {
  const [n, setN] = useState(0) // 先无条件调用
  const [m, setM] = useState(0)
  if (!show) return null // 再决定渲染什么
  return <p>{n + m}</p>
}
// .eslintrc / eslint.config.js 里启用官方插件,让违规在编辑期就暴露
{
  "extends": ["plugin:react-hooks/recommended"],
  "plugins": ["react-hooks"]
}
// 两个核心规则:react-hooks/rules-of-hooks(error)、react-hooks/exhaustive-deps(warn)

exhaustive-deps 的警告不要随手关

它提示"依赖写漏了"。正确做法是按提示补全,或用函数式更新/把值挪进 effect 内部来消除对它的依赖。用 // eslint-disable-next-line 压掉警告,等于把过期闭包的 bug 留到线上。

3.6 受控组件与非受控组件

对比项受控组件(Controlled)非受控组件(Uncontrolled)
值的来源React state(唯一数据源)DOM 自己管,通过 ref 读取
取值方式value + onChangeuseRef<HTMLInputElement>(null) 后读 ref.current.value
能否实时校验/联动能(每次输入都可响应)只能在提交或失焦时
代码量多一些少
适合需要实时校验、联动、格式化、受控的 UI 组件库简单表单、文件输入 <input type="file" />、集成非 React 库
import { useRef, useState } from 'react'

export function UserForm() {
  // 受控:每次输入都更新 state
  const [email, setEmail] = useState('')
  const emailValid = /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)

  // 非受控:只在提交时读取
  const nicknameRef = useRef<HTMLInputElement>(null)
  const fileRef = useRef<HTMLInputElement>(null)

  function onSubmit(e: React.FormEvent<HTMLFormElement>) {
    e.preventDefault()
    console.log({
      email,                                   // 从 state 读
      nickname: nicknameRef.current?.value,    // 从 DOM 读
      file: fileRef.current?.files?.[0]?.name, // 文件输入必须非受控
    })
  }

  return (
    <form onSubmit={onSubmit}>
      <input value={email} onChange={(e) => setEmail(e.target.value)} placeholder="邮箱" />
      {!emailValid && email && <span style={{ color: 'red' }}>邮箱格式不正确</span>}

      <input ref={nicknameRef} defaultValue="匿名" placeholder="昵称" />

      {/* 文件输入无法受控:value 只能由用户设置 */}
      <input ref={fileRef} type="file" />

      <button type="submit" disabled={!emailValid}>提交</button>
    </form>
  )
}

value 没有配 onChange 会变成只读

只写 value={x} 而不写 onChange,React 会警告并把输入框变成只读。想要"初始值 + 用户自己改"用 defaultValue(非受控)。

3.7 状态管理

3.7.1 原生方案:Context + useReducer
// src/store/todo-context.tsx
import { createContext, useContext, useMemo, useReducer, type ReactNode, type Dispatch } from 'react'

export interface Todo { id: number; title: string; done: boolean }

type Action =
  | { type: 'add'; title: string }
  | { type: 'toggle'; id: number }
  | { type: 'remove'; id: number }
  | { type: 'clearDone' }

function reducer(state: Todo[], action: Action): Todo[] {
  switch (action.type) {
    case 'add':
      return [{ id: Date.now(), title: action.title, done: false }, ...state]
    case 'toggle':
      return state.map((t) => (t.id === action.id ? { ...t, done: !t.done } : t))
    case 'remove':
      return state.filter((t) => t.id !== action.id)
    case 'clearDone':
      return state.filter((t) => !t.done)
    default: {
      // 穷尽性检查:所有 action 都被处理时 action 的类型收窄为 never,
      // 将来新增 action 却忘了写 case,这一行会直接编译报错
      const _exhaustive: never = action
      return state
    }
  }
}

const TodoStateContext = createContext<Todo[] | null>(null)
const TodoDispatchContext = createContext<Dispatch<Action> | null>(null)

export function TodoProvider({ children }: { children: ReactNode }) {
  const [todos, dispatch] = useReducer(reducer, [] as Todo[])

  // 状态与 dispatch 分成两个 Context:
  // dispatch 的引用永远稳定,所以"只派发不读状态"的组件不会因状态变化而重渲染
  return (
    <TodoStateContext.Provider value={todos}>
      <TodoDispatchContext.Provider value={dispatch}>{children}</TodoDispatchContext.Provider>
    </TodoStateContext.Provider>
  )
}

export function useTodos() {
  const ctx = useContext(TodoStateContext)
  if (!ctx) throw new Error('useTodos 必须在 <TodoProvider> 内使用')
  return ctx
}

export function useTodoDispatch() {
  const ctx = useContext(TodoDispatchContext)
  if (!ctx) throw new Error('useTodoDispatch 必须在 <TodoProvider> 内使用')
  return ctx
}

为什么用 useReducer 而不是多个 useState:① 状态转移逻辑集中在一处,可测试(reducer 是纯函数,离开 React 也能单测);② dispatch 引用稳定,适合作为 Context 值或传给 memo 子组件,省掉一堆 useCallback;③ 复杂状态(多个字段需要一起变)不会出现"中间态不一致"。

3.7.2 选型:Context+useReducer / Zustand / Redux Toolkit
对比项Context + useReducerZustandRedux Toolkit
依赖无(React 内置)zustand(约 1KB 级)@reduxjs/toolkit + react-redux
学习成本低(但容易写出重渲染陷阱)低(一个 create 搞定)中高(slice、store、Provider、中间件)
更新粒度粗:Context 值一变,所有消费者重渲染细:用选择器订阅所需字段细:useSelector + 浅比较
组件外访问不行(需要额外传递)可以:useStore.getState()可以:store.getState()
异步自己写(函数里 dispatch)直接在 action 里 async/awaitcreateAsyncThunk / RTK Query
调试能力基本没有Redux DevTools 插件(可选接入)强(时间旅行、action 日志、DevTools)
适合规模中小型、低频更新的全局状态(主题、语言、登录用户)中小到大型,追求开发体验大型团队、需要严格规范与可追溯性

什么时候才真的需要状态管理库

按顺序判断:

① 只在父子之间 → props + 回调,不要库;

② 只是避免透传(prop drilling) → Context 就够;

③ 服务端数据(列表、详情、分页) → 用请求缓存库(如 TanStack Query / SWR),它解决的是缓存与失效,不是"全局状态";

④ 真正需要库的信号:多个不相关路由/功能都要读写同一份客户端状态;需要在组件外(如 axios 拦截器)读取或修改;状态变化需要被 DevTools 追踪或持久化。

一上来就全局 store 的代价是:组件与 store 强耦合、复用变难、测试要造 store、性能优化变成"选择器地狱"。

// Zustand 最小示例:组件外也能用,粒度天然更细
import { create } from 'zustand'
import { persist } from 'zustand/middleware'

interface CartState {
  items: { id: number; qty: number }[]
  add: (id: number) => void
  total: () => number
}

export const useCartStore = create<CartState>()(
  persist(
    (set, get) => ({
      items: [],
      add: (id) =>
        set((state) => {
          const found = state.items.find((i) => i.id === id)
          return found
            ? { items: state.items.map((i) => (i.id === id ? { ...i, qty: i.qty + 1 } : i)) }
            : { items: [...state.items, { id, qty: 1 }] } // 不可变更新
        }),
      total: () => get().items.reduce((sum, i) => sum + i.qty, 0),
    }),
    { name: 'cart' }, // 自动持久化到 localStorage
  ),
)

// 组件里:只订阅需要的字段,其它字段变化不会引起重渲染
// const qty = useCartStore((s) => s.items.length)
// Redux Toolkit 最小示例:slice + store + Provider
import { configureStore, createSlice, type PayloadAction } from '@reduxjs/toolkit'
import { Provider, useSelector, useDispatch } from 'react-redux'

const counterSlice = createSlice({
  name: 'counter',
  initialState: { value: 0 },
  reducers: {
    increment: (state, action: PayloadAction<number>) => {
      // RTK 内置 Immer:这里"看起来在改原对象",实际生成不可变的新状态
      state.value += action.payload
    },
  },
})

export const { increment } = counterSlice.actions
export const store = configureStore({ reducer: { counter: counterSlice.reducer } })

// 组件用法:<Provider store={store}><App /></Provider>
// const value = useSelector((s: RootState) => s.counter.value)
// const dispatch = useDispatch()
// dispatch(increment(1))

3.8 列表渲染与性能

3.8.1 React.memo 与浅比较
import { memo, useCallback, useState } from 'react'

interface RowProps {
  id: number
  title: string
  done: boolean
  onToggle: (id: number) => void
}

// 自定义比较函数:返回 true 表示"跳过重渲染"
// 只在确实需要忽略某个 prop 时才自定义,否则用默认浅比较
function areEqual(prev: RowProps, next: RowProps) {
  return prev.id === next.id && prev.title === next.title && prev.done === next.done
  // 注意这里刻意忽略了 onToggle:只要父组件保证它稳定,忽略它就是安全的
}

export const Row = memo(function Row({ id, title, done, onToggle }: RowProps) {
  console.log('Row 渲染', id)
  return (
    <li>
      <input type="checkbox" checked={done} onChange={() => onToggle(id)} />
      <span style={{ textDecoration: done ? 'line-through' : 'none' }}>{title}</span>
    </li>
  )
}, areEqual)

export function Parent() {
  const [items, setItems] = useState([{ id: 1, title: 'A', done: false }])
  const [text, setText] = useState('') // 与列表无关的 state

  // 如果这里写成内联箭头函数 (id) => {...},每次渲染都是新引用,memo 会失效
  const handleToggle = useCallback((id: number) => {
    setItems((prev) => prev.map((i) => (i.id === id ? { ...i, done: !i.done } : i)))
  }, [])

  return (
    <>
      <input value={text} onChange={(e) => setText(e.target.value)} />
      <ul>
        {items.map((i) => (
          <Row key={i.id} {...i} onToggle={handleToggle} />
        ))}
      </ul>
    </>
  )
}

memo 的默认行为是浅比较(shallow compare):逐个比较 props 的引用(Object.is)。所以:

prop 类型浅比较结果结论
原始值(string / number / boolean)值相同即相等天然友好
对象/数组字面量每次渲染都是新引用memo 失效,需要 useMemo 稳定引用或改传原始值
内联箭头函数每次渲染都是新函数memo 失效,需要 useCallback
children 里的 JSX每次渲染都新建元素对象会破坏 memo,除非把 children 从父组件"提前"创建

比 memo 更有效的两招

① 把状态往下挪:如果只有搜索框需要 text,就把 text 放进搜索框组件内部,这样父组件根本不会因输入而重渲染整张列表;

② 用 children 传稳定的子树:把不变的 <Heavy /> 作为 children 传进会频繁重渲染的父组件,React 会复用同一个元素对象,从而跳过它的重渲染。

3.8.2 虚拟列表思路
import { useMemo, useRef, useState } from 'react'

interface VirtualListProps<T> {
  items: T[]
  itemHeight: number
  height: number
  renderItem: (item: T, index: number) => React.ReactNode
  buffer?: number
}

export function VirtualList<T>({ items, itemHeight, height, renderItem, buffer = 3 }: VirtualListProps<T>) {
  const [scrollTop, setScrollTop] = useState(0)
  const containerRef = useRef<HTMLDivElement>(null)

  // 只渲染视口内的项:start/end 随 scrollTop 变化
  const { start, end, offsetY } = useMemo(() => {
    const first = Math.max(0, Math.floor(scrollTop / itemHeight) - buffer)
    const visibleCount = Math.ceil(height / itemHeight)
    const last = Math.min(items.length, first + visibleCount + buffer * 2)
    return { start: first, end: last, offsetY: first * itemHeight }
  }, [scrollTop, itemHeight, height, buffer, items.length])

  const visible = items.slice(start, end)

  return (
    <div
      ref={containerRef}
      style={{ height, overflowY: 'auto' }}
      onScroll={(e) => setScrollTop(e.currentTarget.scrollTop)} // 也可以用 requestAnimationFrame 节流
    >
      {/* 总高度占位,撑出真实滚动条长度 */}
      <div style={{ height: items.length * itemHeight, position: 'relative' }}>
        {/* 用 transform 平移可见区域,避免触发额外布局 */}
        <div style={{ transform: `translateY(${offsetY}px)` }}>
          {visible.map((item, i) => (
            <div key={start + i} style={{ height: itemHeight }}>
              {renderItem(item, start + i)}
            </div>
          ))}
        </div>
      </div>
    </div>
  )
}

// 使用:渲染 10000 条数据,DOM 里始终只有几十个节点
export function Demo() {
  const data = Array.from({ length: 10000 }, (_, i) => ({ id: i, name: `第 ${i} 行` }))
  return (
    <VirtualList
      items={data}
      itemHeight={36}
      height={400}
      renderItem={(item) => <div>{item.name}</div>}
    />
  )
}

生产环境建议

虚拟列表要处理行高不固定、横向滚动、scrollToIndex、无障碍等大量细节,实际项目更推荐成熟的方案(如 TanStack Virtual),以上思路用于理解原理。

3.9 渲染机制

3.9.1 虚拟 DOM 与协调(Reconciliation)

React 的渲染分两个阶段:

阶段做什么是否可中断
Render(渲染/协调)调用组件函数得到新的元素树,与上一次的树对比,算出需要变更的部分并发特性下可中断、可放弃(因此这个阶段必须是纯函数、不能有副作用)
Commit(提交)把算好的变更一次性写入真实 DOM,然后执行 useEffect不可中断,DOM 已变更

虚拟 DOM(Virtual DOM)只是"描述界面的普通 JS 对象":

// <div className="box">hi</div> 的元素对象大致长这样
{
  type: 'div',
  props: { className: 'box', children: 'hi' },
}

它带来了三件事:① 让"计算差异"可以在 JS 里完成,再把最小变更批量写入 DOM;② 让 React 不依赖浏览器,从而能做服务端渲染与原生渲染(React Native);③ 让开发者以声明式方式写 UI。

3.9.2 Diff 策略(启发式 )

完整的两棵树最小编辑距离是 ,对界面不可接受。React 用三条启发式规则把复杂度降到 :

规则做法
不同类型的元素 → 直接重建<div> 变成 <span>,整棵子树卸载重建(状态丢失)
同类型元素 → 保留 DOM,只更新变化的属性<div className="a"> → <div className="b"> 只改 class
列表用 key 匹配身份有 key 就能识别"这一项被移动了"而不是"内容变了"

两条实战推论

① 改变元素类型或 key,会丢掉子树内部状态(输入框内容、展开状态、滚动位置)——这也是"用 key 重置表单"技巧的原理;

② 因为"同类型元素保留 DOM",条件渲染时若两个分支的最外层元素类型相同,React 会以为还是同一个元素而复用状态,这时给它们加不同的 key 更安全。

3.9.3 为什么直接改 state 不触发更新
const [items, setItems] = useState([{ id: 1, done: false }])

// ❌ 直接改:引用没变,React 新旧树看起来完全一样,diff 找不到差异 → 不重渲染
function toggleWrong(id: number) {
  const found = items.find((i) => i.id === id)
  if (found) found.done = !found.done
  setItems(items) // 传的是同一个数组引用,Object.is 判定"没变",直接 bail out
}

// ✅ 不可变更新:创建新数组 + 新对象
function toggleRight(id: number) {
  setItems((prev) => prev.map((i) => (i.id === id ? { ...i, done: !i.done } : i)))
}

两个层面的原因:① 浅比较:useState 用 Object.is 判断新值是否与旧值相同,同一个引用会被认为"没变化"而跳过渲染;② 即使强行渲染,旧树与新树里的对象是同一个(已被就地修改),diff 也发现不了差异。

不可变更新的常用写法:

// 数组:增 / 删 / 改
const added = [...list, newItem]
const removed = list.filter((i) => i.id !== id)
const updated = list.map((i) => (i.id === id ? { ...i, done: true } : i))
const inserted = [...list.slice(0, idx), newItem, ...list.slice(idx)]

// 对象:改一个字段 / 嵌套字段
const nextUser = { ...user, name: '新名字' }
const nextState = { ...state, profile: { ...state.profile, age: 21 } }

// 用 Immer 写"看起来可变"的代码,得到不可变的结果
import { produce } from 'immer'
const next = produce(state, (draft) => {
  draft.profile.age = 21
  draft.items.push({ id: 9, done: false })
})

不可变更新最容易踩的三个坑

① arr.push(x); setArr(arr)——引用没变,不更新;要 setArr([...arr, x]);

② arr.sort() / arr.reverse() 会就地修改原数组(即使写了 setArr(sorted) 也可能因为引用相同而跳过),要 [...arr].sort(...);

③ 只改了深层对象:setState({ ...state, a: 1 }) 忘了 profile 也要展开,导致丢字段。Reducer 里用展开运算符要逐层处理,或改用 Immer。

3.10 React 19 新特性简介

版本说明

以下特性来自 React 19(当前最新主版本 19.3.0),细节与新增 API 以官方最新文档为准。React 19 是一次以"表单与异步"为重心的更新。

特性是什么解决了什么
Actions在 startTransition 里执行异步函数的约定;表单可以直接传 action 函数表单提交不再需要手写"pending + error + 手动禁用按钮"的三件套
useActionStateconst [state, formAction, isPending] = useActionState(fn, init)把"提交 → 返回状态 → 显示错误 → 禁用按钮"收敛成一个 Hook
useFormStatus在子组件里读取父级 <form> 的提交状态提交按钮组件不用层层传 isSubmitting
use在渲染中读取 Promise 或 Context:const data = use(promise)组件内直接消费 Promise(需配合 Suspense 与缓存)
useOptimistic乐观更新:先展示预期结果,请求失败自动回滚点赞、发送消息等即时反馈场景
ref 作为 prop函数组件可直接接收 ref,forwardRef 不再必要(仍向后兼容)少一层包装,ref 就是普通 prop
ref 清理函数ref 回调可以返回清理函数引用解除时自动收尾,替代以前的 null 判断
文档元数据<title> / <meta> / <link> 写在组件里会自动提升到 <head>不再需要 react-helmet 这类库处理基础场景
Context 作为 Provider可直接 <MyContext value={...}> 渲染少写 .Provider
更好的错误提示服务端渲染 hydration 错误会给出差异 diff排查更快
// React 19:表单 Action + 内置 pending 状态(不再手写 loading 三件套)
import { useActionState, useOptimistic, useRef } from 'react'

interface Todo { id: number; title: string; done: boolean }

// Action:签名固定为 (上一次的结果, 表单数据)。表单序列化后的数据都在 formData 里
async function createTodo(_prev: string | null, formData: FormData): Promise<string | null> {
  const title = String(formData.get('title') ?? '').trim()
  if (!title) return '标题不能为空'
  const res = await fetch('/api/todos', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ title }),
  })
  return res.ok ? null : '保存失败,请重试' // 返回 null 表示没有错误
}

export function AddTodo() {
  // error:最近一次 Action 的返回值;formAction:可直接交给 <form action={...}>
  // isPending:由 React 维护,无需自己 setState
  const [error, formAction, isPending] = useActionState(createTodo, null)
  const inputRef = useRef<HTMLInputElement>(null)

  // 乐观更新:先按"预期结果"渲染,请求失败后 React 会自动回滚到真实状态
  const [optimisticTodos, addOptimisticTodo] = useOptimistic<Todo[], string>(
    [],
    (todos, title) => [...todos, { id: -Date.now(), title, done: false }],
  )

  return (
    <form
      action={async (formData: FormData) => {
        addOptimisticTodo(String(formData.get('title') ?? '')) // 立刻显示"已添加"
        await formAction(formData) // 真正的提交;成功后列表会在父组件重新取数
        if (inputRef.current) inputRef.current.value = ''
      }}
    >
      {/* React 19 中 Action 提交完成后会自动重置非受控表单,这里只是演示 ref 用法 */}
      <input name="title" ref={inputRef} placeholder="输入待办标题" />
      <button type="submit" disabled={isPending}>
        {isPending ? '保存中…' : '添加'}
      </button>
      {error && <p style={{ color: 'red' }}>{error}</p>}

      {/* 乐观列表:id 为负数的项是"尚未确认"的临时项 */}
      <ul>
        {optimisticTodos.map((t) => (
          <li key={t.id}>{t.title}</li>
        ))}
      </ul>
    </form>
  )
}
// ref 作为 prop(React 19):不需要 forwardRef 了
// ComponentPropsWithRef<'input'> 里已经包含 ref 的类型,因此可以直接解构出来
function MyInput({ ref, ...props }: React.ComponentPropsWithRef<'input'>) {
  return <input ref={ref} {...props} />
}

// 使用
const ref = useRef<HTMLInputElement>(null)
;<MyInput ref={ref} placeholder="直接传 ref" />

3.11 完整示例:TodoList(并与 Vue 版对照)

下面的组件用到了本篇的 useState、useMemo、useRef、useEffect、useReducer、memo、自定义 Hook 与不可变更新,可直接放进 Vite 生成的 React + TS 项目运行。

// src/App.tsx
import { memo, useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react'

// ---------------- 类型 ----------------
export interface Todo {
  id: number
  title: string
  done: boolean
}
type Filter = 'all' | 'active' | 'done'

type Action =
  | { type: 'add'; title: string }
  | { type: 'toggle'; id: number }
  | { type: 'remove'; id: number }
  | { type: 'edit'; id: number; title: string }
  | { type: 'toggleAll'; done: boolean }
  | { type: 'clearDone' }

const STORAGE_KEY = 'react-todolist'

// ---------------- 纯函数 reducer:可单独单测 ----------------
function todoReducer(state: Todo[], action: Action): Todo[] {
  switch (action.type) {
    case 'add':
      // 新数组(不可变更新),新项放最前
      return [{ id: Date.now(), title: action.title, done: false }, ...state]
    case 'toggle':
      return state.map((t) => (t.id === action.id ? { ...t, done: !t.done } : t))
    case 'remove':
      return state.filter((t) => t.id !== action.id)
    case 'edit':
      return state.map((t) => (t.id === action.id ? { ...t, title: action.title } : t))
    case 'toggleAll':
      // 一次性把每一项都设成同一个 done 值;不必读当前 todos
      return state.map((t) => (t.done === action.done ? t : { ...t, done: action.done }))
    case 'clearDone':
      return state.filter((t) => !t.done)
    default:
      return state
  }
}

// ---------------- 自定义 Hook:把"读一次 + 变化就写"收敛起来 ----------------
function usePersistentTodos(): [Todo[], React.Dispatch<Action>] {
  const [todos, dispatch] = useReducer(todoReducer, undefined, () => {
    try {
      const raw = localStorage.getItem(STORAGE_KEY)
      if (!raw) return [] as Todo[]
      const parsed: unknown = JSON.parse(raw)
      // 数据来自外部,必须校验形状,避免脏数据让页面崩掉
      if (!Array.isArray(parsed)) return []
      return parsed.filter(
        (t): t is Todo =>
          typeof t === 'object' && t !== null && typeof (t as Todo).id === 'number' && typeof (t as Todo).title === 'string',
      )
    } catch {
      return []
    }
  })

  // 首次渲染不写回,避免把"初始化前的空数组"覆盖掉存储里已有的数据
  const mounted = useRef(false)
  useEffect(() => {
    if (!mounted.current) {
      mounted.current = true
      return
    }
    localStorage.setItem(STORAGE_KEY, JSON.stringify(todos))
  }, [todos])

  return [todos, dispatch]
}

// ---------------- 子组件:React.memo + 自定义比较 ----------------
interface TodoItemProps {
  todo: Todo
  onToggle: (id: number) => void
  onRemove: (id: number) => void
  onEdit: (id: number, title: string) => void
}

const TodoItem = memo(
  function TodoItem({ todo, onToggle, onRemove, onEdit }: TodoItemProps) {
    const [editing, setEditing] = useState(false)
    const [draft, setDraft] = useState(todo.title)
    const inputRef = useRef<HTMLInputElement>(null)

    // 进入编辑态后自动聚焦(DOM 副作用,必须放 effect 里)
    useEffect(() => {
      if (editing) inputRef.current?.focus()
    }, [editing])

    function commit() {
      const title = draft.trim()
      if (title) onEdit(todo.id, title) // 空标题不提交,保持原值
      setEditing(false)
    }

    return (
      <li className={todo.done ? 'done' : ''}>
        <input type="checkbox" checked={todo.done} onChange={() => onToggle(todo.id)} />

        {editing ? (
          <input
            ref={inputRef}
            value={draft}
            onChange={(e) => setDraft(e.target.value)}
            onKeyDown={(e) => {
              if (e.key === 'Enter') commit()
              if (e.key === 'Escape') {
                setDraft(todo.title) // 取消:恢复原值
                setEditing(false)
              }
            }}
            onBlur={commit}
          />
        ) : (
          <span onDoubleClick={() => setEditing(true)}>{todo.title}</span>
        )}

        <button onClick={() => (editing ? commit() : setEditing(true))}>{editing ? '保存' : '编辑'}</button>
        <button className="del" onClick={() => onRemove(todo.id)}>
          删除
        </button>
      </li>
    )
  },
  // 只有这三项变化才重渲染;回调的引用稳定性由父组件的 useCallback/useReducer 保证
  (prev, next) =>
    prev.todo.id === next.todo.id && prev.todo.title === next.todo.title && prev.todo.done === next.todo.done,
)

// ---------------- 根组件 ----------------
export default function App() {
  const [todos, dispatch] = usePersistentTodos()
  const [draft, setDraft] = useState('')
  const [filter, setFilter] = useState<Filter>('all')

  // 派生数据一律在渲染时算,不要用 useEffect + useState 同步一份副本
  const remaining = useMemo(() => todos.filter((t) => !t.done).length, [todos])
  const visibleTodos = useMemo(() => {
    switch (filter) {
      case 'active':
        return todos.filter((t) => !t.done)
      case 'done':
        return todos.filter((t) => t.done)
      default:
        return todos
    }
  }, [todos, filter])

  const allDone = todos.length > 0 && todos.every((t) => t.done)

  // 回调用 useCallback 稳定引用,否则 TodoItem 的 memo 完全失效
  const handleToggle = useCallback((id: number) => dispatch({ type: 'toggle', id }), [])
  const handleRemove = useCallback((id: number) => dispatch({ type: 'remove', id }), [])
  const handleEdit = useCallback((id: number, title: string) => dispatch({ type: 'edit', id, title }), [])
  // 注意依赖里只放 allDone(原始值),dispatch 的引用永远稳定,不需要列入
  const toggleAll = useCallback(() => dispatch({ type: 'toggleAll', done: !allDone }), [allDone])

  function addTodo(e: React.FormEvent<HTMLFormElement>) {
    e.preventDefault()
    const title = draft.trim()
    if (!title) return
    dispatch({ type: 'add', title })
    setDraft('')
  }

  return (
    <div className="todo">
      <h2>待办清单(剩余 {remaining} 项)</h2>

      <form className="add" onSubmit={addTodo}>
        <input value={draft} onChange={(e) => setDraft(e.target.value)} placeholder="输入后回车添加" />
        <button type="submit" disabled={!draft.trim()}>
          添加
        </button>
      </form>

      <label className="all">
        <input type="checkbox" checked={allDone} onChange={toggleAll} />
        全部标记为{allDone ? '未完成' : '已完成'}
      </label>

      <ul className="list">
        {visibleTodos.map((todo) => (
          // key 用业务 id,不用索引
          <TodoItem key={todo.id} todo={todo} onToggle={handleToggle} onRemove={handleRemove} onEdit={handleEdit} />
        ))}
      </ul>

      {visibleTodos.length === 0 && <p className="empty">这里还没有内容</p>}

      <div className="footer">
        {(['all', 'active', 'done'] as const).map((f) => (
          <button key={f} className={filter === f ? 'active' : ''} onClick={() => setFilter(f)}>
            {f === 'all' ? '全部' : f === 'active' ? '未完成' : '已完成'}
          </button>
        ))}
        <button onClick={() => dispatch({ type: 'clearDone' })}>清除已完成</button>
      </div>
    </div>
  )
}
/* src/index.css:与 Vue 版共用同一套样式 */
.todo { max-width: 520px; margin: 24px auto; font-family: system-ui, sans-serif; }
.add { display: flex; gap: 8px; margin-bottom: 8px; }
.add input { flex: 1; padding: 6px 8px; }
.list { list-style: none; padding: 0; }
.list li { display: flex; align-items: center; gap: 8px; padding: 6px 0; border-bottom: 1px solid #eee; }
.list li.done span { text-decoration: line-through; color: #999; }
.list li span { flex: 1; cursor: pointer; }
.del { color: #d33; }
.empty { color: #999; text-align: center; }
.footer { display: flex; gap: 8px; margin-top: 12px; }
.footer button.active { font-weight: 700; border-color: #42b883; color: #42b883; }
与 Vue 版 TodoList 的写法差异

同一份需求,两份代码的差别集中在"状态怎么变、界面怎么跟着变":

维度Vue 3(前端-06-Vue.md 的 TodoList)React 19(本篇的 TodoList)
状态声明const todos = ref<Todo[]>([])const [todos, dispatch] = useReducer(...)
读取/写入todos.value.push(x) 直接改dispatch({ type: 'add', title }) 派发动作
派生数据computed(() => todos.value.filter(...))useMemo(() => todos.filter(...), [todos])
列表渲染<li v-for="todo in visibleTodos" :key="todo.id">{visibleTodos.map((todo) => <TodoItem key={todo.id} ... />)}
条件渲染<p v-if="cond"> / v-show{cond && <p>} / 三元
双向绑定<input v-model.trim="draft"><input value={draft} onChange={e => setDraft(e.target.value)}>
子组件入参defineProps<Props>()函数参数 { todo, onToggle }
子组件通知父级emit('toggle', id)调用父组件传下来的回调 onToggle(id)(也可理解为"把事件当 prop 传")
持久化watch(todos, ..., { deep: true }) 自动追踪深层变化useEffect(..., [todos]);必须每次返回新数组才能触发
子组件性能响应式依赖追踪,父组件更新通常不重渲染子组件默认重渲染,需要 memo + 稳定的回调引用
副作用清理onUnmounted(() => ...)useEffect(() => { ...; return () => ... }, [deps])
本地状态ref 写在顶层的任意位置Hook 必须无条件写在组件函数顶层

一句话差异

Vue 是"改数据,框架找出谁受影响";React 是"派发新状态,组件函数重新执行,diff 出变化"。

因此 Vue 的代码更像在操作对象,React 的代码更像在写纯函数与不可变数据流。两者都需要你理解"状态放哪、谁是唯一数据源"。


四、常见坑

十二个高频错误

1. 直接改 state:items.push(x)、obj.a = 1 后 setState(同一个引用),界面不更新;必须不可变更新。

2. setState 后立刻读值:本次执行里 state 变量不会变,这是异步更新 + 快照。

3. 依赖旧值却不用函数式更新:setCount(count + 1) 连写三次只加一;用 setCount(p => p + 1)。

4. useEffect 依赖数组写漏:闭包读到过期 props/state;按 exhaustive-deps 提示补全。

5. effect 里 setState 且该 state 在依赖里:无限循环,控制台报 Maximum update depth exceeded。

6. 依赖写成对象/数组/函数字面量:每次渲染都是新引用,effect 每轮都跑。

7. 忘记清理副作用:定时器、订阅、请求未取消 → 内存泄漏与"更新已卸载组件"的警告。

8. Hook 写在条件/循环里:Hook 顺序错位,状态串位。

9. key 用数组索引:列表增删后组件状态错配;永远用业务 id。

10. memo 配内联函数 prop:浅比较永远失败,memo 形同虚设;回调要 useCallback。

11. 用 effect 同步派生数据:useEffect(() => setTotal(items.length), [items]) → 多一次渲染还可能死循环;直接算或用 useMemo。

12. 0 && <X /> 渲染出 0:用 items.length > 0 && <X />。

调试建议

① 安装 React Developer Tools,用 Components 面板看 props/state,用 Profiler 面板录制交互找出"为什么重渲染";

② 排查重渲染时打开 Profiler 的 "Highlight updates",谁闪谁重渲染;

③ StrictMode 下 effect 跑两次是故意的,别为了"躲开两次执行"而删掉清理函数;那正是它在帮你找 bug。


五、练习题

  1. 基础题:写一个 Tabs 组件:接收 items: { key: string; label: string; content: ReactNode }[],内部用 useState 管理当前选中的 key,点击标签切换内容;要求 content 只在被选中时才渲染(不要用 CSS 隐藏)。
  2. Hooks 辨析题:下面这段代码有什么问题?会导致什么现象?给出两种修法并说明各自代价。

```tsx

function Profile({ userId }: { userId: number }) {

const [user, setUser] = useState<User | null>(null)

useEffect(() => {

fetch(/api/users/${userId}).then((r) => r.json()).then(setUser)

}, [])

return <div>{user?.name}</div>

}

```

  1. 无限循环题:找出下面代码的循环链,并改写为正确版本(要求:只有 filter 变化时才重新计算,且不产生额外渲染)。

```tsx

const [list, setList] = useState<Item[]>([])

const [filter, setFilter] = useState('')

const [filtered, setFiltered] = useState<Item[]>([])

useEffect(() => {

setFiltered(list.filter((i) => i.name.includes(filter)))

}, [list, filter, filtered])

```

  1. 性能优化题:给定一个"1000 行 × 每行一个输入框"的列表,父组件还有一个搜索框。请写出优化方案:说明为什么输入时整个列表会重渲染,并用"把状态往下挪"与 memo + useCallback 两种方式分别实现,比较两者代码复杂度与效果。
  2. 综合题:把 3.11 的 TodoList 改造成 Context + useReducer 版本(拆分 state 与 dispatch 两个 Context),再加一个"撤销删除"(3 秒内可撤销、组件卸载时清理定时器)。回答:为什么把 state 与 dispatch 拆成两个 Context 能减少重渲染?

六、常见问题(FAQ)

Q1:React 和 Vue 我该先学哪个?

A:看目标岗位与生态需求,但不要同时学。想更快做出东西、喜欢模板与官方全家桶,先学 Vue(见 前端-06-Vue);想接触更纯粹的"JS 表达 UI"、目标公司技术栈是 React/Next.js,先学 React。两者的核心概念(组件化、单向数据流、状态提升、列表 key)是通的,学会一个再学另一个主要是语法迁移成本。

Q2:为什么我的组件渲染了两次?

A:三种常见原因:① 开发环境的 <StrictMode> 故意双跑组件函数与 effect(生产不会);② 父组件重渲染导致的正常子渲染(用 Profiler 确认是否可优化);③ setState 里传入的值与旧值不同但触发了额外一轮(例如在 effect 里同步派生数据)。先确认是哪种,再决定要不要优化:StrictMode 的双跑不需要处理。

Q3:useMemo / useCallback 到底要不要加?

A:默认不加,先写正确、清晰的代码。只在以下情况加:① 计算确实昂贵(大数据排序/过滤,可在 Profiler 里看到明显耗时);② 值/函数要作为 effect 依赖,而引用不稳定会导致 effect 反复执行;③ 要传给 memo 包裹的子组件。React 官方明确说明:useMemo 是性能优化手段,不能当作语义保证(缓存可能被丢弃),所以不要把"必须只执行一次"的逻辑放进去。

Q4:什么时候该引入状态管理库?

A:按 3.7.2 的判定顺序走:父子用 props、避免透传用 Context、服务端数据用 TanStack Query/SWR,只有"多个不相关模块读写同一份客户端状态、且需要组件外访问或 DevTools 追踪"时才引入 Zustand / Redux Toolkit。经验标准:如果引入后你要为"选择器粒度""Provider 层级""异步 thunk"写大量模板代码,而业务本身没有复杂到那个程度,说明引入早了。

Q5:useEffect 到底什么时候该用?

A:只有一个判断标准:需要与 React 之外的系统同步。比如订阅浏览器事件/WebSocket、操作 DOM(聚焦、测量、初始化第三方图表)、定时器、发送分析埋点。反之,"根据 props 算一个值""props 变化时重置子组件状态""用户点击后请求数据"都不该用 effect(分别用直接计算、key、事件处理器)。官方文档把这一节命名为"脱围机制(Escape Hatches)",就是提醒你 effect 是例外而非常规。


相关笔记

  • 前端-06-Vue:同一问题的另一套答案,文末有同款 TodoList 的写法对照表,建议两篇对着读
  • 前端-05-TypeScript:props 类型、泛型组件、React.ComponentPropsWithRef 等类型工具的基础
  • 前端-08-构建工具-Vite与Webpack:npm create vite@latest 背后的开发服务器、HMR 与打包流程
  • JavaScript-07-ES6新特性:展开运算符、解构、可选链是不可变更新写法的基础
  • 前端-04-浏览器与HTTP:虚拟 DOM、重排重绘与渲染性能的浏览器侧原理

参考来源

以下链接核实于 2026-10-11,均为官方文档(zh-hans.react.dev 是 React 官方中文文档,内容与英文版同步):

  • React 官方中文文档 · 学习总入口:<https://zh-hans.react.dev/learn>
  • React 官方中文文档 · 描述 UI(组件、JSX、props、条件与列表渲染、纯函数):<https://zh-hans.react.dev/learn/describing-the-ui>
  • React 官方中文文档 · 管理状态(state、状态结构、useReducer、Context):<https://zh-hans.react.dev/learn/managing-state>
  • React 官方中文文档 · 脱围机制(useRef、useEffect、自定义 Hook):<https://zh-hans.react.dev/learn/escape-hatches>
  • React 官方中文文档 · 内置 Hooks API 参考(useMemo / useCallback / useOptimistic 等):<https://zh-hans.react.dev/reference/react/hooks>
  • React 官方中文文档 · Hooks 规则:<https://zh-hans.react.dev/reference/rules>
  • React 官方博客 · React 19 发布说明(Actions、use、ref as prop):<https://zh-hans.react.dev/blog/2024/12/05/react-19>
  • Vite 官方文档(create-vite 脚手架与 React 模板):<https://vite.dev/guide/>

版本说明

本篇对应 React 19.3.0(本库核实时间 2026-10-11)。

其中 ref 作为 prop、Context 作为 Provider、useActionState / useOptimistic / use 等 API 的稳定状态与新增细节,以官方最新文档为准;React 19 的完整变更清单见官方发布说明(链接见上)。

类组件、forwardRef、ReactDOM.render 等旧写法仍向后兼容,但新代码不再使用,本库不作为教学主线。