React 19.2：用 useEffectEvent 告别闭包陷阱

React 19.2 最让人期待的更新就是正式稳定的 useEffectEvent。这个新钩子专门解决困扰我们已久的闭包问题，从此不用再手动用 useRef 同步状态了。

表单自动保存的痛点

先看一个常见场景：用户输入时，需要实现"停止输入1秒后自动保存"的功能。

import { useState, useEffect } from 'react';

function ProfileEditor() {
  const [formData, setFormData] = useState({
    name: '',
    email: ''
  });
  const [status, setStatus] = useState('idle');

  useEffect(() => {
    const timer = setTimeout(async () => {
      setStatus('saving');
      try {
        // 这里有个坑：formData 可能不是最新的
        await fetch('/api/profile', {
          method: 'POST',
          body: JSON.stringify(formData)
        });
        setStatus('saved');
      } catch (err) {
        setStatus('error');
      }
    }, 1000);

    return () => clearTimeout(timer);
  }, [formData]); // 必须依赖 formData

  return (
    <form>
      <input
        value={formData.name}
        onChange={(e) => setFormData(prev => ({ ...prev, name: e.target.value }))}
      />
      <input
        value={formData.email}
        onChange={(e) => setFormData(prev => ({ ...prev, email: e.target.value }))}
      />
      <div>{status}</div>
    </form>
  );
}

这段代码有个明显问题：每次输入都会重启定时器。用户快速打字时，定时器频繁创建销毁，既浪费性能又可能导致保存顺序错乱。

如果去掉 formData 依赖，又会陷入闭包陷阱------定时器里的 formData 永远是初始值。

之前我们只能用 useRef 来绕过这个问题：

function ProfileEditor() {
  const [formData, setFormData] = useState({ name: '', email: '' });
  const [status, setStatus] = useState('idle');
  const formRef = useRef(formData);

  // 手动同步最新值
  useEffect(() => {
    formRef.current = formData;
  }, [formData]);

  useEffect(() => {
    const timer = setTimeout(async () => {
      setStatus('saving');
      try {
        // 从 ref 获取最新值
        await fetch('/api/profile', {
          method: 'POST',
          body: JSON.stringify(formRef.current)
        });
        setStatus('saved');
      } catch (err) {
        setStatus('error');
      }
    }, 1000);

    return () => clearTimeout(timer);
  }, []); // 依赖可以为空了

  // ... 渲染部分相同
}

这种写法能解决问题，但每次都要手动同步 ref，代码冗余还容易出错。

useEffectEvent 的解决方案

useEffectEvent 的设计很巧妙：把 effect 里的逻辑提取出来，让它能自动获取最新状态，同时不影响 effect 的依赖关系。

用 useEffectEvent 重写上面的例子：

import { useState, useEffect, useEffectEvent } from 'react';

function ProfileEditor() {
  const [formData, setFormData] = useState({ name: '', email: '' });
  const [status, setStatus] = useState('idle');

  // 用 useEffectEvent 包装保存逻辑
  const saveForm = useEffectEvent(async () => {
    setStatus('saving');
    try {
      // 这里总能拿到最新的 formData
      await fetch('/api/profile', {
        method: 'POST', 
        body: JSON.stringify(formData)
      });
      setStatus('saved');
    } catch (err) {
      setStatus('error');
    }
  });

  // effect 只负责定时逻辑
  useEffect(() => {
    const timer = setTimeout(saveForm, 1000);
    return () => clearTimeout(timer);
  }, []); // 依赖为空，effect 只运行一次

  // ... 渲染部分不变
}

这段代码解决了两个关键问题：

1. saveForm 始终能获取最新的 formData
2. useEffect 不会因为 formData 变化而重复执行

实现原理

useEffectEvent 创建的函数有个特殊能力：每次执行时都能穿透到当前的渲染上下文，获取最新的状态和 props。但对 effect 来说，这个函数的引用始终不变，所以不需要加入依赖数组。

使用限制

1. 只能在 effect 内调用 ：useEffectEvent 返回的函数不能在事件处理函数中直接使用，比如 onClick={myEvent} 会报错。

2. 不能作为组件属性传递：React 无法保证函数执行时的上下文一致性。

3. 避免循环依赖 ：如果多个 useEffectEvent 函数相互调用，要小心循环依赖问题。

实战案例：聊天室消息过滤

useEffectEvent 在实时数据处理中特别有用。比如聊天室需要根据当前用户ID过滤消息：

function ChatRoom({ roomId, currentUserId }) {
  const [messages, setMessages] = useState([]);

  const handleNewMessage = useEffectEvent((newMsg) => {
    // 自动获取最新的 currentUserId
    if (newMsg.senderId !== currentUserId) {
      setMessages(prev => [...prev, newMsg]);
    }
  });

  useEffect(() => {
    const socket = new WebSocket(`wss://chat.example.com/${roomId}`);
    socket.onmessage = (e) => {
      const msg = JSON.parse(e.data);
      handleNewMessage(msg);
    };

    return () => socket.close();
  }, [roomId]); // 只在 roomId 变化时重连

  return (
    <div>
      {messages.map(msg => (
        <div key={msg.id}>{msg.content}</div>
      ))}
    </div>
  );
}

这个例子中，即使用户切换账号导致 currentUserId 变化，handleNewMessage 也能拿到最新值，同时不会重建 WebSocket 连接。

与社区方案的对比

在 useEffectEvent 之前，社区常用 useEventCallback：

function useEventCallback(fn) {
  const ref = useRef(fn);
  useEffect(() => { ref.current = fn; }, [fn]);
  return useCallback((...args) => ref.current(...args), []);
}

两种方案的主要区别：

特性	社区版 useEventCallback	useEffectEvent
依赖管理	需要手动声明依赖	自动捕获依赖
执行时机	同步更新，可能有时序问题	React 调度，确保状态最新
并发兼容	可能状态不一致	完全兼容并发渲染
调用限制	无限制	只能在 effect 内使用

社区方案本质是用 ref 模拟，而 useEffectEvent 是 React 原生支持，更适合复杂场景。

React 19.2 的其他更新

Activity 组件：保留状态的条件渲染

之前用 {isOpen && <Component />} 会导致组件卸载和状态丢失。Activity 组件解决了这个问题：

import { Activity } from 'react';

function UserPanel() {
  const [showDetails, setShowDetails] = useState(false);

  return (
    <div>
      <button onClick={() => setShowDetails(!showDetails)}>
        切换详情
      </button>
      {/* 隐藏时不卸载，保留所有状态 */}
      <Activity mode={showDetails ? 'visible' : 'hidden'}>
        <UserDetails /> {/* 表单输入不会丢失 */}
      </Activity>
    </div>
  );
}

缓存信号管理

服务端组件中，cacheSignal 可以管理缓存生命周期：

import { cache, cacheSignal } from 'react';

const fetchUser = cache(async (userId) => {
  const controller = new AbortController();
  const signal = cacheSignal(controller.signal);

  const res = await fetch(`/api/users/${userId}`, { signal });
  return res.json();
});

function UserProfile({ userId }) {
  const user = fetchUser(userId);
  return <h1>{user.name}</h1>;
}

缓存失效时自动中止请求，避免资源浪费。

部分预渲染优化

19.2 改进了部分预渲染，支持先输出静态内容再流式传输动态部分：

import { renderToPipeableStream } from 'react-dom/server';

app.get('/', (req, res) => {
  const stream = renderToPipeableStream(<App />, {
    onShellReady() {
      // 先发送静态框架
      res.writeHead(200, { 'Content-Type': 'text/html' });
      stream.pipe(res);
    }
  });
});

提升首屏加载速度，特别适合内容型网站。

迁移建议

1. 先处理警告 ：用 useEffectEvent 替换有依赖警告的 useRef 代码
2. 精简依赖：迁移后检查并移除不必要的依赖
3. 配合 ESLint ：使用最新版 eslint-plugin-react-hooks 检查使用规范
4. 渐进迁移：不需要一次性重写所有代码，新功能中优先使用

总结

useEffectEvent 虽然只是一个小钩子，但解决了 React 开发中的老大难问题。它的出现让闭包陷阱成为历史，让我们能更专注于业务逻辑。

配合 Activity 组件、缓存信号等新特性，React 19.2 在并发渲染时代提供了更完善的开发体验。如果你还在为 effect 依赖头疼，不妨试试 useEffectEvent------它会成为你的新利器。