В React 19.2 стабильным стал хук useEffectEvent - функция, которую можно использовать в эффекте, не добавляя в зависимости, и которая при этом всегда видит свежие пропсы, состояние и контекст. Всегда - кроме одного случая: если компонент обёрнут в memo или forwardRef, функция навсегда остаётся со значениями из первого рендера. Исправление вошло только в React 19.3.0, в ветку 19.2 его не перенесли: в последней на сегодня 19.2.9 баг по-прежнему есть. Разберём, каких компонентов это касается, почему так происходит и как обойти, если обновиться пока нельзя.

Всё ниже проверено на react-dom 19.2.9 и 19.3.0: по исходникам и на небольшом стенде.


Зачем нужен useEffectEvent

Если вы ещё не пользовались этим хуком - он решает старую проблему с зависимостями useEffect. Разберём её на примере из документации: чат подключается к комнате, а когда соединение установлено, показывает уведомление в цвете текущей темы.

function ChatRoom({ roomId }) {
  const theme = useContext(ThemeContext);

  useEffect(() => {
    const connection = createConnection(roomId);
    connection.on("connected", () => {
      showNotification("Подключено", theme);
    });
    connection.connect();
    return () => connection.disconnect();
  }, [roomId, theme]);

  // ...
}

Эффект читает theme, значит, theme должна быть в зависимостях - иначе эффект запомнит тему из того рендера, в котором запустился, и линтер об этом предупредит. Но с theme в зависимостях другая беда: при каждой смене темы чат отключается от комнаты и подключается заново, хотя комната не менялась.

Получается, что в эффекте смешаны две вещи. Подключение к комнате должно реагировать на roomId: сменилась комната - переподключаемся. А уведомление показывается при каждом подключении - в том числе после смены комнаты, - но смена темы не должна вызывать переподключение. Тему уведомление только читает: берёт ту, что актуальна в момент подключения. Так ведут себя обработчики событий вроде onClick: они читают текущие пропсы и состояние, но сами по себе ничего не запускают.

До React 19.2 это решали через useRef - в нём хранили свежую версию функции:

function ChatRoom({ roomId }) {
  const theme = useContext(ThemeContext);

  const callback = () => {
    showNotification("Подключено", theme);
  };
  const ref = useRef(callback);
  useLayoutEffect(() => {
    ref.current = callback;
  });

  useEffect(() => {
    const connection = createConnection(roomId);
    connection.on("connected", () => ref.current());
    connection.connect();
    return () => connection.disconnect();
  }, [roomId]);

  // ...
}

На каждом рендере создаётся новый callback со свежей theme, и после рендера он записывается в ref.current. Ref - это объект, который живёт между рендерами, а изменение ref.current ничего не перерисовывает и эффекты не перезапускает. Эффект при подключении вызывает то, что сейчас лежит в ref, - то есть всегда последнюю версию функции. Сам объект ref один и тот же на всех рендерах, поэтому линтер не требует добавлять его в зависимости, и в них остаётся только roomId.

Записываем в useLayoutEffect, а не прямо в рендере: рендер может быть прерван и выброшен, и тогда в ref попала бы функция со значениями, которых никогда не было на экране.

Этот приём настолько распространён, что в 2022 году команда React предложила встроить его в библиотеку - сначала под именем useEvent. Из этого предложения и вырос useEffectEvent.

С ним тот же код выглядит так:

function ChatRoom({ roomId }) {
  const theme = useContext(ThemeContext);

  const onConnected = useEffectEvent(() => {
    showNotification("Подключено", theme);
  });

  useEffect(() => {
    const connection = createConnection(roomId);
    connection.on("connected", onConnected);
    connection.connect();
    return () => connection.disconnect();
  }, [roomId]);

  // ...
}

Теперь в зависимостях только roomId. Функция onConnected всегда видит свежую theme, но смена темы эффект не перезапускает. При этом onConnected - не стабильная функция, как у useCallback: React возвращает новую обёртку на каждом рендере. Будь она в зависимостях, эффект перезапускался бы после каждого рендера. Поэтому её туда не добавляют вовсе, а eslint-plugin-react-hooks даже считает это ошибкой: «Functions returned from useEffectEvent must not be included in the dependency array».

У хука есть ограничения: вызывать такую функцию можно только из эффектов (при вызове во время рендера React бросит ошибку), а передавать её в другие компоненты документация не рекомендует.

По сути это тот же приём с ref, только React делает его сам. Это нам ещё пригодится.

Ломаем

Обернём компонент в memo - например, чтобы он не ререндерился вместе с родителем:

const ChatRoom = memo(function ChatRoom({ roomId }) {
  // тот же код
});

Меняем тему, потом переходим в другую комнату. Эффект переподключается, вызывает onConnected - и уведомление показывается в старой теме, той, что была до смены.

Тема из контекста тут просто пример. Так же устаревают пропсы и состояние - всё, что читает функция внутри useEffectEvent.

Проверим это на тесте. Добавим в ChatRoom кнопку, которая увеличивает счётчик, а onConnected пусть выводит и тему, и счётчик:

const ChatRoom = memo(function ChatRoom({ roomId }) {
  const theme = useContext(ThemeContext);
  const [count, setCount] = useState(0);

  const onConnected = useEffectEvent(() => {
    console.log(theme, count);
  });

  useEffect(() => {
    // то же подключение, что и раньше
  }, [roomId]);

  return <button onClick={() => setCount(count + 1)}>+1</button>;
});

Тест идёт в четыре шага:

  1. Первый рендер: тема light, счётчик 0. Чат подключается к комнате.

  2. Где-то выше по дереву провайдер ThemeContext переключает тему на dark. Компонент перерендеривается, но комната та же, поэтому эффект не перезапускается.

  3. Нажимаем кнопку - счётчик становится 1. Снова ререндер, и снова без перезапуска эффекта.

  4. Переходим в другую комнату. roomId изменился, эффект переподключается и вызывает onConnected. Она должна вывести текущие значения: dark 1.

Прогоним тест для четырёх вариантов ChatRoom на двух версиях React. В ячейке - что вывела onConnected на шаге 4, при переходе в другую комнату:

Как объявлен ChatRoom

19.2.9

19.3.0

без обёртки

dark 1

dark 1

memo(ChatRoom)

light 0 ❌

dark 1

forwardRef(ChatRoom)

light 0 ❌

dark 1

memo(ChatRoom, compare) - со своей функцией сравнения пропсов

dark 1

dark 1

В 19.2.9 внутри memo и forwardRef функция видит значения из первого рендера, будто тема и счётчик не менялись. А memo с функцией сравнения работает правильно - почему, разберём ниже.

Почему так

Вот ещё раз приём с useRef из начала статьи, только самое главное:

const ref = useRef(callback);
useLayoutEffect(() => {
  ref.current = callback;
});
// а в эффекте вызываем ref.current()

useEffectEvent устроен так же: React хранит для него объект { impl } - так же, как useRef хранит { current }: в memoizedState своего хука, в списке хуков компонента. Свежая функция лежит в поле impl. Разница в том, что useRef отдаёт объект нам, а useEffectEvent прячет его и отдаёт только функцию-обёртку:

// упрощённо: useEffectEvent внутри React
function useEffectEvent(callback) {
  const ref = hook.memoizedState; // { impl }, живёт между рендерами
  // callback пока только запоминаем - в ref.impl он попадёт позже
  return (...args) => ref.impl(...args);
}

Возвращённая функция всегда вызывает то, что сейчас лежит в ref.impl. Весь вопрос в том, когда туда попадает новый callback.

В варианте с useRef выше функция записывается в useLayoutEffect, а не прямо в рендере: рендер может быть прерван и выброшен, и тогда в ref попала бы функция со значениями, которых не было на экране. React поступает так же. Во время рендера он только запоминает новый callback, а в ref.impl переносит его на коммите - этапе, когда результат рендера применяется к DOM и уже точно попадёт на экран.

Вот тут и ошибка. Для каждого компонента React хранит внутренний объект - файбер, а в нём тег: что это за компонент. Код коммита, который переносит callback в ref.impl, смотрит на этот тег. В 19.2.9 он выглядит так (упрощённо):

switch (fiber.tag) {
  case FunctionComponent:   // обычный компонент
    ref.impl = callback;    // переносим новую функцию
    break;
  case ForwardRef:          // forwardRef
  case SimpleMemoComponent: // memo без функции сравнения
    break;                  // ничего не делаем
}

Для обычного компонента новая функция переносится на каждом коммите. Для forwardRef и memo - нет: ref.impl так и остаётся функцией из первого рендера, со значениями того рендера. Отсюда light 0 в таблице.

Почему тогда memo с функцией сравнения работает? Для memo у React два вида файберов. Если функции сравнения нет, React для скорости рендерит компонент прямо в файбере memo, с тегом SimpleMemoComponent - и попадает в ветку «ничего не делаем». Если функция сравнения есть, файбер memo только сравнивает пропсы, а сам компонент рендерится в отдельном дочернем файбере с тегом FunctionComponent. Хуки живут в нём, и перенос работает. Но только если внутри memo обычная функция: в memo(forwardRef(...), compare) дочерний файбер получит тег ForwardRef, и функция сравнения уже не спасёт.

В 19.3.0 перенос делается для всех видов функциональных компонентов: обычных, forwardRef и обоих видов memo.

Кто захочет посмотреть сам: в react-dom/cjs/react-dom-client.development.js версии 19.2.9 перенос находится в функции commitBeforeMutationEffects (поиск по nextImpl), а в 19.3.0 - в commitMutationEffectsOnFiber.

Что делать

Обновиться до 19.3. Баг живёт в reconciler - части React, которую встраивает в себя каждый рендерер; на вебе это react-dom. Но react и react-dom всё равно обновляются вместе.

Если обновиться нельзя:

  • forwardRef - просто убрать. В React 19 ref - обычный проп, обёртка больше не нужна:

    function Input({ ref, ...props }) {
      // useEffectEvent здесь работает
    }
    
  • memo - вынести хук в обычный дочерний компонент. memo остаётся снаружи, а хуки уходят во внутренний компонент со своим файбером FunctionComponent:

    const ChatRoom = memo(function ChatRoom(props) {
      return <ChatRoomInner {...props} />;
    });
    
    function ChatRoomInner({ roomId }) {
      // useEffectEvent здесь работает
    }
    

    Можно и передать в memo функцию сравнения - это тоже уводит компонент в дочерний файбер (если внутри не forwardRef). Но выглядит как случайность и сломается у того, кто потом «упростит» код, поэтому лучше явная обёртка.

  • Если таких мест много - своя замена хука на тот же приём с useRef, что и до useEffectEvent, только вынесенный в хук:

    function useEventPolyfill(callback) {
      const ref = useRef(callback);
      useLayoutEffect(() => {
        ref.current = callback;
      });
      return useCallback((...args) => ref.current(...args), []);
    }
    

    Обёртку здесь делаем стабильной через useCallback: линтер не знает, что наш хук работает как useEffectEvent, и потребует добавить его результат в зависимости эффекта. Стабильная функция в зависимостях ничего не перезапускает.

    После обновления до 19.3 её легко заменить обратно поиском по проекту.

Как проверить свой проект

  1. npm ls react-dom - если версия от 19.2.0 до 19.2.9, баг есть. В React Native рендерер вшит в сам react-native и собран под конкретную версию react - ориентируйтесь на неё. На RN я не проверял, но reconciler там тот же.

  2. Найти компоненты, которые одновременно вызывают useEffectEvent и обёрнуты в memo без функции сравнения или в forwardRef. Линтер тут не поможет: с точки зрения правил хуков код корректен.


Итог

  • В React 19.2.x useEffectEvent внутри memo(Component) и forwardRef всегда видит значения из первого рендера: пропсы, состояние и контекст.

  • Причина - коммит переносит новую функцию в ref.impl только для обычных функциональных компонентов.

  • memo с функцией сравнения не задет, если внутри не forwardRef: там компонент рендерится в отдельном обычном файбере.

  • Исправлено в 19.3.0. До обновления - убрать forwardRef, вынести хуки из memo во внутренний компонент или временно заменить хук на useRef.

Если встречали этот баг в своём проекте или знаете другие обходы - пишите в комментариях.