В 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>; });
Тест идёт в четыре шага:
Первый рендер: тема
light, счётчик0. Чат подключается к комнате.Где-то выше по дереву провайдер
ThemeContextпереключает тему наdark. Компонент перерендеривается, но комната та же, поэтому эффект не перезапускается.Нажимаем кнопку - счётчик становится
1. Снова ререндер, и снова без перезапуска эффекта.Переходим в другую комнату.
roomIdизменился, эффект переподключается и вызываетonConnected. Она должна вывести текущие значения:dark 1.
Прогоним тест для четырёх вариантов ChatRoom на двух версиях React. В ячейке - что вывела onConnected на шаге 4, при переходе в другую комнату:
Как объявлен |
19.2.9 |
19.3.0 |
|---|---|---|
без обёртки |
|
|
|
|
|
|
|
|
|
|
|
В 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 19ref- обычный проп, обёртка больше не нужна: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 её легко заменить обратно поиском по проекту.
Как проверить свой проект
npm ls react-dom- если версия от 19.2.0 до 19.2.9, баг есть. В React Native рендерер вшит в самreact-nativeи собран под конкретную версиюreact- ориентируйтесь на неё. На RN я не проверял, но reconciler там тот же.Найти компоненты, которые одновременно вызывают
useEffectEventи обёрнуты вmemoбез функции сравнения или вforwardRef. Линтер тут не поможет: с точки зрения правил хуков код корректен.
Итог
В React 19.2.x
useEffectEventвнутриmemo(Component)иforwardRefвсегда видит значения из первого рендера: пропсы, состояние и контекст.Причина - коммит переносит новую функцию в
ref.implтолько для обычных функциональных компонентов.memoс функцией сравнения не задет, если внутри неforwardRef: там компонент рендерится в отдельном обычном файбере.Исправлено в 19.3.0. До обновления - убрать
forwardRef, вынести хуки изmemoво внутренний компонент или временно заменить хук наuseRef.
Если встречали этот баг в своём проекте или знаете другие обходы - пишите в комментариях.

Mox
Я так и не понял почему они не сделали обычный useEvent, я чет думаю уже самому просто вот ту реализацию с ref втащить
manastack Автор
useEventиз RFC задумывался шире: стабильная функция, которую можно отдавать и вonClick, и в дочерние компоненты. По сути это тот же приём с ref:Наружу отдаётся стабильная обёртка, которая вызывает то, что сейчас лежит в
ref.current. Свежийcallbackпопадает туда вuseLayoutEffect, то есть после коммита. На этом и споткнулись: если вызвать такую функцию во время рендера, она вернёт старые значения. Например:Нажимаем кнопку -
countстановится1, а в заголовке «Нажато 0 раз». Вот что происходит после клика:Рендерится
Counterсcount = 1и создаёт новыйcallback, но вref.currentпока старый.Рендерится
Titleи вызываетformat(), а та вызываетref.current- старую функцию, отсюда0.Коммит, срабатывает
useLayoutEffect: вref.currentкладётся новыйcallback.Запускаются эффекты - здесь
format()вернула бы уже1.Свежей функция становится только на шаге 3. Значит, безопасно звать её можно только после коммита, то есть из эффектов. До этого места
useEffectEventи сузили. Внутри он устроен так же, только обновляет функцию сам. Если в том же коде заменитьuseEventнаuseEffectEvent,Titleсразу упадёт с ошибкой «нельзя вызывать во время рендера», а не будет тихо показывать старое. А для заголовка функция и не нужна: достаточно передать вTitleсамcount.Втащить такую реализацию к себе - нормальный вариант, в статье она как раз есть как обход. Только у неё нет этой защиты: пример выше с ней тихо сломается. Для обработчиков событий и эффектов работает.