闭包对内存的‘隐式持存’：如何避免在 React Hook 中因闭包导致的陈旧值与内存泄漏

闭包与React Hook：驾驭内存的隐式持存，规避陈旧值与内存泄漏

各位开发者，大家好！今天我们将深入探讨一个在前端开发，尤其是React Hook应用中极为重要且常被误解的话题：闭包对内存的“隐式持存”机制，以及由此引发的陈旧值问题和潜在的内存泄漏。我们将以编程专家的视角，剖析其原理，并提供一系列行之有效的避免策略和最佳实践。

闭包与React Hook的共生关系

在JavaScript的世界里，闭包无处不在，它是语言核心特性之一。而在React Hook的范式中，闭包更是扮演着基石的角色。useState、useEffect、useCallback、useMemo等一系列Hook的内部实现，都离不开闭包的强大能力。它允许我们在函数组件的多次渲染之间“记住”一些变量或函数。然而，这种强大的能力也带来了一定的复杂性：如果不充分理解闭包的工作原理，我们可能会遭遇意料之外的陈旧值（stale values）问题，甚至引发难以追踪的内存泄漏。

本讲座将从闭包的基础概念出发，逐步深入到它在React Hook中的具体表现，最终提供一套全面的解决方案，帮助大家写出更健壮、更高效的React应用。

第一章: 闭包的核心机制

要理解闭包带来的问题，我们首先需要理解闭包本身。

什么是闭包？

简而言之，当一个函数能够记住并访问其词法作用域，即使该函数在其词法作用域之外执行时，它就形成了一个闭包。词法作用域（或静态作用域）是指变量和函数的作用域在代码编写时就已经确定，而非在运行时确定。

让我们通过一个简单的JavaScript例子来理解：

function createGreeter(greeting) {
  // greeting 是 createGreeter 函数的局部变量
  function greet(name) {
    // greet 函数内部可以访问到 greeting
    console.log(`${greeting}, ${name}!`);
  }
  return greet; // 返回内部函数 greet
}

const sayHello = createGreeter("Hello"); // sayHello 现在是一个闭包
const sayHi = createGreeter("Hi");     // sayHi 也是一个闭包

sayHello("Alice"); // 输出: Hello, Alice!
sayHi("Bob");    // 输出: Hi, Bob!

在这个例子中：

1. createGreeter 函数被调用时，它创建了一个局部变量 greeting。
2. createGreeter 返回了一个内部函数 greet。
3. 即使 createGreeter 函数已经执行完毕，其执行上下文理应被销毁，但 greet 函数仍然能够访问到 greeting 变量。
4. sayHello 和 sayHi 分别是两次调用 createGreeter 产生的不同的 greet 闭包实例，它们各自“记住”了自己被创建时 greeting 的值（"Hello" 和 "Hi"）。

这就是闭包。它允许函数携带并操作它被定义时所处的环境。

闭包与内存的“隐式持存”

“隐式持存”是理解闭包问题的关键所在。当一个闭包被创建时，它不仅仅是捕获了外部作用域的变量值，它实际上是捕获了对外部作用域中变量的引用（或者说，是变量所处的那个内存环境）。只要这个闭包（内部函数）仍然可访问（即没有被垃圾回收），那么它所捕获的整个词法环境中的变量，也将保持可访问状态，从而阻止这些变量被垃圾回收。

想象一下：JavaScript的垃圾回收机制（Garbage Collection, GC）主要基于“可达性”原则。如果一个对象或变量是可达的（即从根对象，如全局对象或当前执行栈中的变量，可以通过引用链访问到它），那么它就不会被垃圾回收。闭包的内部函数作为可达对象，它所捕获的外部变量也因此变得可达。

这便是“隐式持存”的含义：我们没有显式地将外部变量存储在一个全局数组或对象中，但由于闭包的存在，这些变量的生命周期被延长了，它们被闭包“隐式地”持有。

function createCounter() {
  let count = 0; // count 是局部变量
  return function() {
    count++;
    console.log(count);
  };
}

const counter1 = createCounter();
counter1(); // 1
counter1(); // 2

const counter2 = createCounter();
counter2(); // 1

// 即使 createCounter 已经执行完毕，counter1 和 counter2 仍然各自持有了它们自己的 count 变量的引用
// 只要 counter1 或 counter2 存在，它们各自的 count 就不会被垃圾回收。

在这个计数器例子中，count变量并没有在外部被显式地引用，但它被闭包函数持有，因此得以在多次调用中保持其状态。这种“隐式持存”是闭包力量的源泉，也是潜在问题的根源。

第二章: React Hook 中的闭包：优势与挑战

React Hook 的核心思想是让函数组件能够拥有状态和其他React特性。而实现这一目标，闭包功不可没。

React Hook 如何利用闭包？

1. useState: 当你调用 useState 时，它返回一个状态值和一个更新函数。这个更新函数（setter）就是一个闭包，它捕获了对相应状态变量的引用，并允许你在组件的多次渲染之间修改这个状态。当你调用 setCount 时，它知道要更新的是哪一个 count 变量。

   function Counter() {
     const [count, setCount] = React.useState(0); // setCount 捕获了 count 的引用
   
     const increment = () => {
       setCount(count + 1); // 这里的 count 是当前渲染闭包捕获的 count
     };
   
     return <button onClick={increment}>Count: {count}</button>;
   }

2. useEffect: useEffect 的回调函数是一个典型的闭包。它在每次渲染时被创建，并捕获了当前渲染作用域中的所有变量（props、state、其他函数等）。这意味着 useEffect 总是能访问到创建它时最新的值。

   function DataFetcher({ userId }) {
     const [data, setData] = React.useState(null);
   
     React.useEffect(() => {
       // 这个 effect 闭包捕获了当前的 userId 和 setData
       fetch(`/api/users/${userId}`)
         .then(res => res.json())
         .then(setData);
     }, [userId]); // 依赖数组确保当 userId 改变时，effect 会重新运行
   
     return <div>User Data: {JSON.stringify(data)}</div>;
   }

3. useCallback / useMemo: 这两个Hook的根本目的就是为了缓存函数和值。它们返回的函数或值本身就是闭包，其内部逻辑会捕获其依赖项。它们的存在本身就是为了管理闭包的创建和更新。

   function ParentComponent() {
     const [count, setCount] = React.useState(0);
   
     // incrementCallback 是一个闭包，它捕获了当前的 count 状态
     // 只有当 count 变化时，这个闭包才会被重新创建
     const incrementCallback = React.useCallback(() => {
       setCount(count + 1);
     }, [count]); // 依赖 count
   
     return <ChildComponent onIncrement={incrementCallback} />;
   }

挑战一：陈旧值 (Stale Values)

陈旧值问题是闭包在React Hook中最常见、最令人困惑的陷阱之一。它发生的原因是：闭包会捕获变量在创建时的值。如果外部变量在闭包创建后发生了变化，而闭包本身没有重新创建或重新捕获新值，那么闭包内部访问到的仍然是旧的值。

我们来看一个经典的 useEffect 例子：

function StaleCounter() {
  const [count, setCount] = React.useState(0);

  React.useEffect(() => {
    // 这里的 count 捕获的是 effect 第一次运行时 (count=0) 的值
    const id = setTimeout(() => {
      console.log(`Stale value: ${count}`); // 总是输出 0
      setCount(count + 1); // 这里的 count 也是捕获的旧值
    }, 1000);

    return () => clearTimeout(id);
  }, []); // 空依赖数组意味着这个 effect 只运行一次
          // 因此，setTimeout 内部的闭包也只创建一次，并捕获第一次渲染时的 count (0)
          // 尽管外部的 count 状态在变化，但这个闭包内部的 count 永远是 0。

  return (
    <div>
      <p>Current Count: {count}</p>
      <button onClick={() => setCount(prev => prev + 1)}>Increment Directly</button>
    </div>
  );
}

运行 StaleCounter 组件，你会发现：

1. Current Count 会随着按钮点击正常增加。
2. 但是，每秒输出到控制台的 Stale value: 永远是 0。
3. 更糟糕的是，setCount(count + 1) 这一行，也总是基于 count 的陈旧值 0 进行计算，导致 count 永远停留在 1。

这就是典型的陈旧值问题。useEffect 的回调函数作为闭包，在组件第一次渲染时创建，并捕获了当时 count 的值（即 0）。由于依赖数组为空 []，这个 effect 不会重新运行，因此这个闭包也永远不会重新创建，它内部的 count 变量将永久停留在 0。

挑战二：潜在的内存泄漏

内存泄漏是指程序中已不再需要使用的内存，由于某些原因（如引用仍然存在）未能被垃圾回收机制回收，从而导致系统可用内存不断减少的现象。在React Hook中，闭包不当使用是导致内存泄漏的一个常见原因。

当一个闭包捕获了对大量数据、DOM元素、或外部资源（如WebSocket连接、Subscription对象）的引用，并且这个闭包的生命周期比它所引用的资源更长时，就可能发生内存泄漏。

最典型的场景是 useEffect 中添加了事件监听器或定时器，但没有在清理函数中移除或清除它们：

function LeakyComponent() {
  const [data, setData] = React.useState([]);

  React.useEffect(() => {
    // 这是一个典型的内存泄漏风险点
    // 假设这个组件会被频繁挂载/卸载，或者用户只是短暂停留
    const intervalId = setInterval(() => {
      // 这个闭包捕获了 setData 和 data
      // 如果组件卸载了，这个定时器仍然会每秒执行一次
      // 并且每次执行都会尝试更新一个不存在的组件状态
      // 最关键的是，setInterval 函数本身会一直持有对这个闭包的引用
      // 只要定时器未被清除，这个闭包及其捕获的 data 和 setData 就不会被垃圾回收
      console.log("Fetching data...");
      // 模拟数据获取
      setData(prevData => [...prevData, Math.random()]);
    }, 1000);

    // 🔴 错误：缺少清理函数！
    // 如果组件在 intervalId 被清除前卸载，内存泄漏就会发生。
  }, []);

  return <div>Data Length: {data.length}</div>;
}

在这个例子中，setInterval 的回调函数捕获了 setData 和 data。如果 LeakyComponent 在某个时候被卸载（例如，用户导航到其他页面），但 setInterval 没有被 clearInterval 清除，那么：

1. setInterval 会持续运行，并持有对回调闭包的引用。
2. 这个闭包又持续持有对 data 和 setData 的引用。
3. data 数组可能会持续增长，占用更多内存。
4. 即使组件的DOM节点已经被移除，相关的状态和更新函数仍然存在于内存中，阻止了它们被垃圾回收。

随着时间的推移，如果这种组件被反复挂载和卸载，内存占用将不断累积，最终导致应用性能下降甚至崩溃。

第三章: 避免陈旧值的策略

理解了陈旧值问题，我们就能针对性地采取措施来避免它。核心思想是确保闭包总能访问到最新的值，或者以一种不依赖于捕获值的方式操作状态。

策略一：依赖数组 (Dependency Array) 的精确使用

这是解决 useEffect、useCallback、useMemo 中陈旧值问题的首要且最重要的方法。依赖数组告诉React，只有当数组中的任何一个值发生变化时，才重新创建回调函数或重新计算 memoized 值。

• useEffect: 确保你的 useEffect 依赖数组包含了回调函数内部使用的所有外部变量（props、state、由 useState 或 useRef 创建的函数、其他组件定义的函数等）。

  function FixedStaleCounter() {
    const [count, setCount] = React.useState(0);
  
    React.useEffect(() => {
      // 这里的 count 每次 effect 重新运行时，都会捕获最新的 count 值
      const id = setTimeout(() => {
        console.log(`Latest value: ${count}`);
        setCount(count + 1); // 这里的 count 也是最新的
      }, 1000);
  
      return () => clearTimeout(id);
    }, [count]); // ✅ 依赖数组包含 count
                 // 当 count 变化时，effect 会重新运行，创建新的闭包，捕获最新的 count
  
    return (
      <div>
        <p>Current Count: {count}</p>
        <button onClick={() => setCount(prev => prev + 1)}>Increment Directly</button>
      </div>
    );
  }

  现在，setTimeout 内部的 count 将始终反映当前的 count 值，并且 setCount(count + 1) 也能正确地基于最新值进行更新。

• useCallback / useMemo: 同样，确保它们的依赖数组包含了内部函数或值计算中使用的所有外部变量。

  function ParentComponentFixed() {
    const [count, setCount] = React.useState(0);
  
    const incrementCallback = React.useCallback(() => {
      setCount(count + 1); // 这里的 count 会随着依赖数组变化而更新
    }, [count]); // ✅ 依赖 count
  
    return <ChildComponent onIncrement={incrementCallback} />;
  }

表格：不同 Hook 的依赖数组作用

Hook 名称	作用	依赖数组作用	潜在问题 (无/错用依赖)	解决方案 (依赖数组)
useEffect	执行副作用	决定何时重新运行 effect 函数。当依赖项变化时，上一个 effect 的清理函数会运行，然后重新运行新的 effect。	陈旧值、内存泄漏	包含所有在 effect 回调中使用的外部变量。
useCallback	缓存函数实例	决定何时重新创建函数实例。当依赖项变化时，返回一个新的函数实例。	陈旧值、不必要的渲染	包含所有在回调函数体中使用的外部变量。
useMemo	缓存计算结果	决定何时重新计算值。当依赖项变化时，重新运行计算函数并返回新的值。	陈旧值、不必要的计算	包含所有在计算函数体中使用的外部变量。
useLayoutEffect	与 useEffect 类似	决定何时重新运行 effect 函数（在浏览器绘制之前同步执行）。	陈旧值、内存泄漏	同 useEffect。

重要提示：React 官方推荐并强烈建议使用 eslint-plugin-react-hooks 插件。它会自动检测并警告你，如果你的 Hook 依赖数组中缺少了某些变量。务必开启并遵循它的建议。

策略二：函数式更新 (Functional Updates) for useState

对于 useState 的更新函数，如果新状态的计算依赖于旧状态，始终使用函数式更新（也称为“updater function”）的形式。这可以完全避免捕获陈旧的状态值。

function FunctionalUpdaterCounter() {
  const [count, setCount] = React.useState(0);

  React.useEffect(() => {
    const id = setTimeout(() => {
      // setCount 接收一个函数，这个函数会接收最新的 state 作为参数
      // 这样就不需要从闭包中捕获 count 了
      setCount(prevCount => prevCount + 1); // ✅ 使用函数式更新
      console.log(`Incremented!`);
    }, 1000);

    return () => clearTimeout(id);
  }, []); // ⚠️ 注意：这里即使依赖数组为空，也能正确更新 count！
          // 因为 setCount(prevCount => prevCount + 1) 不需要捕获外部的 count。

  return (
    <div>
      <p>Current Count: {count}</p>
      <button onClick={() => setCount(prev => prev + 1)}>Increment Directly</button>
    </div>
  );
}

通过 setCount(prevCount => prevCount + 1)，我们告诉 React，我们想要基于最新的 count 值来计算新值，而不是基于当前闭包中捕获的那个可能已经陈旧的 count 值。React 会保证传递给 prevCount 的永远是当前最新的状态。

策略三：useRef 引用可变值

useRef 提供了一个在组件多次渲染之间保持同一引用而不会触发重新渲染的方法。它返回一个可变的 ref 对象，其 .current 属性可以用来存储任何可变值。当我们需要在闭包中访问一个总是最新的、但又不想将其作为 useEffect 依赖项（因为它变化时不希望重新运行 effect）的值时，useRef 是一个很好的选择。

function RefCounter() {
  const [count, setCount] = React.useState(0);
  const latestCountRef = React.useRef(count); // 创建一个 ref

  // 在每次渲染时更新 ref 的 .current 属性
  // 这样无论哪个闭包访问 latestCountRef.current，都能拿到最新值
  React.useEffect(() => {
    latestCountRef.current = count;
  }, [count]);

  React.useEffect(() => {
    const id = setTimeout(() => {
      // 访问 ref 的 .current 属性，它总是最新的
      console.log(`Latest count from ref: ${latestCountRef.current}`);
      // 仍然推荐使用函数式更新来修改状态，因为它更安全
      setCount(prevCount => prevCount + 1);
    }, 1000);

    return () => clearTimeout(id);
  }, []); // 依赖数组为空，但通过 ref 访问到了最新值
          // 并且 setCount 仍然使用了函数式更新，确保了状态更新的正确性

  return (
    <div>
      <p>Current Count: {count}</p>
      <button onClick={() => setCount(prev => prev + 1)}>Increment Directly</button>
    </div>
  );
}

何时使用 useRef 来避免陈旧值？

• 当你有一个 useEffect 的回调函数，它需要访问某个状态或 prop 的最新值，但你不希望这个状态或 prop 的变化导致 useEffect 重新运行。

• 例如，在创建一个事件监听器时，你希望它在组件生命周期内只创建一次，但其内部逻辑需要访问最新的状态。

  function EventListenerWithRef() {
    const [count, setCount] = React.useState(0);
    const countRef = React.useRef(count);
  
    React.useEffect(() => {
      countRef.current = count; // 每次 count 变化时更新 ref
  
    }, [count]); // 依赖 count，确保 ref 总是最新的
  
    React.useEffect(() => {
      const handleClick = () => {
        // 在事件监听器内部，通过 ref 访问最新的 count
        console.log(`Button clicked, current count from ref: ${countRef.current}`);
        // 如果需要更新状态，仍然推荐使用函数式更新
        setCount(prevCount => prevCount + 1);
      };
  
      document.addEventListener('click', handleClick);
  
      return () => {
        document.removeEventListener('click', handleClick);
      };
    }, []); // ✅ handleClick 本身不作为依赖，因为它的行为通过 ref 动态获取最新值
  
    return <p>Count: {count}</p>;
  }

策略四：useCallback 和 useMemo 的正确运用

useCallback 和 useMemo 主要用于性能优化，通过缓存函数实例和计算结果来避免不必要的重新渲染或计算。但它们也间接有助于解决陈旧值问题，通过稳定依赖项。

如果一个函数被作为 prop 传递给子组件，或者被用作 useEffect 的依赖项，那么每次父组件渲染时，如果这个函数没有被 useCallback 缓存，它就会被重新创建。这会导致子组件重新渲染，或者 useEffect 重新运行。使用 useCallback 可以在依赖项不变的情况下，保持函数实例的稳定，从而避免下游的陈旧值问题或不必要的更新。

function ParentWithMemoizedCallback() {
  const [count, setCount] = React.useState(0);

  // 这里的 incrementHandler 只有当 count 变化时才会重新创建
  const incrementHandler = React.useCallback(() => {
    setCount(prevCount => prevCount + 1);
  }, []); // ✅ 依赖数组为空，因为使用了函数式更新，不依赖外部 count

  return (
    <div>
      <p>Parent Count: {count}</p>
      {/* ChildComponent 只有当 incrementHandler 实例变化时才会重新渲染 */}
      <ChildComponent onIncrement={incrementHandler} />
    </div>
  );
}

function ChildComponent({ onIncrement }) {
  // 如果 onIncrement 每次都重新创建，那么这个组件也会每次都重新渲染
  // 使用 React.memo 配合 useCallback 可以有效避免不必要的渲染
  console.log("ChildComponent rendered");
  return <button onClick={onIncrement}>Increment from Child</button>;
}

export default React.memo(ChildComponent); // 配合 React.memo

通过 useCallback 稳定 incrementHandler 的引用，我们确保了 ChildComponent 在 ParentWithMemoizedCallback 重新渲染时，不会因为 onIncrement prop 的引用变化而重新渲染（假设 ChildComponent 被 React.memo 包裹）。这虽然不是直接解决陈旧值，但它是在更宏观的组件协作层面上，稳定了闭包的依赖，减少了因依赖变化导致的副作用。

第四章: 防范内存泄漏的实践

避免内存泄漏的关键在于清理。任何在 useEffect 中创建的、可能在组件卸载后仍然存在的资源，都必须被清除。

实践一：useEffect 的清理函数 (Cleanup Function)

useEffect 的回调函数可以返回一个清理函数。这个清理函数会在以下两种情况下被执行：

1. 在组件下一次渲染时，如果依赖项发生变化，旧的 effect 会先被清理，再执行新的 effect。
2. 在组件卸载时。

这是防止内存泄漏的基石。

function CleanComponent() {
  const [data, setData] = React.useState([]);

  React.useEffect(() => {
    console.log("Effect runs!");
    const intervalId = setInterval(() => {
      console.log("Fetching data in interval...");
      setData(prevData => [...prevData, Math.random()]);
    }, 1000);

    // ✅ 返回一个清理函数
    return () => {
      console.log("Cleaning up interval!");
      clearInterval(intervalId); // 清除定时器
    };
  }, []); // 依赖数组为空，effect 只运行一次，但清理函数会确保定时器在组件卸载时被清除

  return <div>Data Length: {data.length}</div>;
}

现在，当 CleanComponent 被卸载时，clearInterval(intervalId) 会被调用，阻止定时器继续运行，从而释放了对闭包及其捕获变量的引用，避免了内存泄漏。

常见的需要清理的场景：

• 定时器: setTimeout, setInterval
• 事件监听器: addEventListener
• 订阅: WebSocket, RxJS subscribe
• 网络请求: fetch 或 axios 等发出的请求，如果组件卸载时请求仍在进行，可能需要取消它。

实践二：避免不必要的闭包捕获

审查你的闭包，看看它们是否捕获了过多的、不必要的变量。每个被捕获的变量都会占用内存，并延长其生命周期。

// 假设有一个非常大的数据对象
const largeDataObject = { /* ... 几兆字节的数据 ... */ };

function MyComponent() {
  const [value, setValue] = React.useState(0);

  // 🔴 不好的实践：这个闭包捕获了整个 largeDataObject，即使它可能只用到了其中一小部分
  React.useEffect(() => {
    const timer = setTimeout(() => {
      console.log(largeDataObject.someSmallProperty); // 假设只用到了一小部分
      setValue(prev => prev + 1);
    }, 1000);
    return () => clearTimeout(timer);
  }, []); // timer 闭包隐式持有了 largeDataObject 的引用

  return <div>Value: {value}</div>;
}

如果 largeDataObject 真的很大，并且它的生命周期需要被闭包延长，那么这将是一个问题。更好的做法是只传递或引用闭包实际需要的数据。

const largeDataObject = { someSmallProperty: 'abc', /* ... 几兆字节的数据 ... */ };

function MyComponentFixed() {
  const [value, setValue] = React.useState(0);
  const smallPropertyRef = React.useRef(largeDataObject.someSmallProperty); // 只引用所需的小部分

  React.useEffect(() => {
    const timer = setTimeout(() => {
      console.log(smallPropertyRef.current); // 访问所需的小部分
      setValue(prev => prev + 1);
    }, 1000);
    return () => clearTimeout(timer);
  }, []);

  return <div>Value: {value}</div>;
}

当然，如果 largeDataObject 是一个 prop 或 state，并且你需要它的最新版本，那么你可能需要将其作为依赖项，或者使用 useRef 来存储其引用。关键在于意识和审慎。

实践三：WeakMap 和 WeakSet (高级话题)

在一些非常特殊的场景下，如果需要创建对对象的引用，但又不希望这个引用阻止对象被垃圾回收，可以使用 WeakMap 或 WeakSet。它们持有的是“弱引用”，这意味着如果对象没有其他强引用，即使被 WeakMap/WeakSet 引用着，也会被垃圾回收。

这在 React Hook 中不常用，但在处理一些缓存或元数据与DOM节点关联的场景时可能有帮助。

const elementMetadata = new WeakMap();

function MyComponentWithWeakMap() {
  const ref = React.useRef(null);

  React.useEffect(() => {
    if (ref.current) {
      // 假设我们为这个 DOM 元素存储一些元数据
      elementMetadata.set(ref.current, { customId: 'some-id', creationTime: Date.now() });
      console.log("Metadata set for element");
    }
  }, []);

  // 当组件卸载，ref.current 指向的 DOM 元素被移除后，
  // 即使 elementMetadata 中有记录，该 DOM 元素也能被垃圾回收
  // 并且 WeakMap 中对应的条目也会自动消失。
  return <div ref={ref}>This is an element.</div>;
}

这是一种更高级的内存管理技术，在大部分 React 应用中并不常见，但了解其存在对处理特定内存挑战很有价值。

实践四：取消异步操作

当组件发起异步操作（如 fetch 请求）时，如果在请求完成之前组件被卸载，那么请求的回调函数可能会尝试更新一个不存在的组件状态，这不仅可能导致错误，也可能造成内存泄漏。

使用 AbortController 是一个现代且有效的方式来取消 fetch 请求：

function AsyncDataFetcher({ userId }) {
  const [data, setData] = React.useState(null);
  const [loading, setLoading] = React.useState(false);

  React.useEffect(() => {
    const controller = new AbortController(); // 创建 AbortController
    const signal = controller.signal; // 获取信号

    setLoading(true);
    fetch(`/api/users/${userId}`, { signal }) // 将信号传递给 fetch
      .then(res => res.json())
      .then(json => {
        // 只有当组件未被卸载且请求未被取消时才更新状态
        if (!signal.aborted) {
          setData(json);
        }
      })
      .catch(error => {
        if (error.name === 'AbortError') {
          console.log('Fetch aborted');
        } else {
          console.error('Fetch error:', error);
        }
      })
      .finally(() => {
        if (!signal.aborted) {
          setLoading(false);
        }
      });

    // ✅ 清理函数中取消请求
    return () => {
      controller.abort(); // 组件卸载时取消请求
      console.log('Request cancelled!');
    };
  }, [userId]);

  if (loading) return <div>Loading user data...</div>;
  return <div>User Data: {JSON.stringify(data)}</div>;
}

通过 AbortController，当 useEffect 的清理函数执行时，我们可以通知正在进行的 fetch 请求停止，避免其回调在组件已卸载后执行，从而防止相关的内存泄漏和潜在的运行时错误。

第五章: 最佳实践与思考

1. 默认开启 eslint-plugin-react-hooks: 这是你防止闭包陷阱的第一道防线。它会强制你遵循 Hook 的规则，尤其是依赖数组的完整性。
2. 理解 React 的渲染机制: 深刻理解组件何时渲染、effect 何时运行、清理函数何时执行，是驾驭闭包和Hook的关键。每次渲染都是一次新的函数调用，都会创建新的闭包。
3. 避免过度优化: useCallback 和 useMemo 是性能优化工具，不应为避免所有闭包捕获而滥用。它们本身也有开销。只有当性能分析显示存在问题，或者为了稳定 useEffect 或子组件的 props 时才使用。
4. Code Review 的重要性: 在团队开发中，相互审查代码可以发现潜在的闭包问题，尤其是那些不明显的陈旧值和清理不当的副作用。

驾驭闭包在React Hook中的“隐式持存”机制，是成为一名优秀React开发者的必经之路。通过精确使用依赖数组、函数式更新、useRef，并严格执行副作用的清理，我们可以有效地避免陈旧值问题，防范内存泄漏，从而构建出更稳定、更高效的React应用。理解这些底层原理，并将其融入日常编码习惯，你的代码将变得更加健壮。