React Compiler в проде: можно ли наконец выбросить useMemo и useCallback
Текст написан с позиции августа 2026 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
У ручной мемоизации в React всегда была странная репутация. Все знали, что useMemo и useCallback нужны, почти никто не мог уверенно сказать, где именно, и в итоге в большинстве кодовых баз они расставлялись по принципу «на всякий случай». Половина этих обёрток ничего не давала, часть ломалась от первого же нового пропса без стабильной ссылки, а ревью превращалось в спор о том, нужен ли здесь useCallback, вместо разговора о том, что делает код.
React Compiler должен был закрыть эту тему. Стабильная версия 1.0 вышла в октябре 2025 года, и с тех пор он перестал быть экспериментом из доклада: Next.js 16 включает его одной опцией reactCompiler в конфиге, шаблоны Expo поставляются с ним по умолчанию, для Vite он подключается как Babel-плагин. У нас компилятор работает в production-приложении уже несколько месяцев — достаточно, чтобы пережить первые восторги, наступить на неочевидные грабли и посмотреть на цифры, а не на обещания.
Зафиксирую сразу, чтобы не было ложных ожиданий. Ответ на вопрос из заголовка — «в основном да, но не везде». Компилятор действительно снимает с команды большую часть ручной мемоизации в render-слое. Но мемоизация как идея никуда не делась: она переехала туда, где ей и место, — на границы с внешним кодом и в слой данных. И это не упрощение, а перераспределение ответственности, которое полезно понимать явно.
Что компилятор на самом деле делает с компонентом
React Compiler — это build-time трансформация. Он разбирает функцию компонента или хука, строит граф зависимостей между значениями и вставляет кэширование на уровне отдельных выражений: JSX-поддеревьев, вычисленных объектов, колбэков, результатов вызовов. Если входы не поменялись, на следующем рендере берётся закэшированное значение. Технически это ближе к тому, что делал бы очень дисциплинированный инженер, обернувший в useMemo каждое выражение, но без шума в исходнике и без ошибок в массивах зависимостей.
Важная деталь, которую часто упускают: компилятор мемоизирует гранулярнее, чем это реально сделать руками. Ручной useMemo обычно оборачивает крупный кусок, а компилятор может закэшировать JSX-ветку после раннего return или внутри условия — там, где хуки вызывать вообще нельзя. Поэтому дочерние компоненты получают стабильные пропсы и пропускают рендер без того, чтобы кто-то вручную расставлял React.memo по всему дереву.
В DevTools это видно по бейджу «Memo ✨» у компонентов, которые компилятор обработал. Первое, что мы сделали после включения, — прошлись по ключевым экранам и посмотрели, где бейджа нет. Это оказался самый честный индикатор того, насколько код соответствует правилам React, — честнее любого линтера, который мы до этого настраивали.
Компилятор молча отступает там, где вы нарушаете правила
Самая вредная реакция на компилятор — включить его, увидеть, что сборка прошла, и решить, что теперь всё мемоизировано. Компилятор устроен консервативно: если он не может доказать, что трансформация безопасна, он пропускает функцию целиком и оставляет её как есть. Это bail out, и по умолчанию он происходит тихо. Приложение работает ровно как раньше, просто без выигрыша.
Причины почти всегда одни и те же — нарушения Rules of React. Мутация пропсов или state на месте. Чтение ref.current во время рендера. Запись в переменную, объявленную вне компонента. Условный вызов хуков. Мутация объекта после того, как он ушёл в JSX. Многие из этих вещей годами жили в коде без видимых последствий, потому что React их просто терпел. Компилятор их не терпит: он не ломает поведение, он отказывается оптимизировать.
Отсюда практический вывод: включать компилятор без линтера бессмысленно. В eslint-plugin-react-hooks теперь есть правила, которые используют тот же анализ, что и компилятор, и подсвечивают ровно те места, где он сдастся. Мы сначала прогнали их по всей кодовой базе в режиме предупреждений и получили честную карту долга. Примерно десятая часть компонентов нарушала правила так или иначе, и почти всегда это был старый код, написанный до хуков или в спешке.
Отдельно стоит сказать про стороннюю реактивность. Библиотеки, которые полагаются на мутацию объектов и подписку через прокси, плохо сочетаются с моделью компилятора: он видит обычный объект, считает его неизменным между рендерами и кэширует то, что кэшировать нельзя. Для таких мест есть директива "use no memo", которая исключает конкретный компонент из обработки. Это не элегантно, но предсказуемо, и мы держим каждое такое исключение с комментарием о причине.
Внедрять по одной папке, а не одним коммитом
На большом приложении включать компилятор сразу на всё — плохая идея, даже если тесты зелёные. Проблема не в том, что что-то упадёт, а в том, что что-то тонко поменяется: эффект начнёт срабатывать реже, потому что зависимость стала стабильной, или, наоборот, компонент, который полагался на мутацию, перестанет обновляться. Такие регрессии не ловятся юнит-тестами и выплывают через неделю в виде странных багов.
Мы шли так. Сначала compilationMode: 'annotation': компилятор обрабатывает только функции с директивой "use memo". Это позволило включить его на нескольких изолированных экранах и посмотреть на поведение в проде. Затем — переход на режим по умолчанию, но с фильтром по путям через настройки плагина: одна feature-папка за другой, каждая отдельным релизом. Когда покрытие дошло до большей части приложения, фильтр убрали, а оставшиеся исключения перевели на точечный "use no memo".
Почему это важно? Потому что при поэтапном включении каждая регрессия имеет короткий список подозреваемых. Если что-то поменялось после релиза, где компилятор впервые покрыл модуль оплаты, — смотреть надо в модуль оплаты. Если включить всё сразу, подозреваемым становится всё приложение. Это не перестраховка, а экономия времени на отладке.
Ручные useMemo можно удалять, но не все и не сразу
Компилятор понимает существующие useMemo и useCallback и не ломается от них. Официальная позиция команды React — новые писать не нужно, а старые можно оставить и удалять осторожно, потому что их удаление может поменять поведение. Это не формальность. Если ручной useMemo стабилизировал значение, от которого зависит эффект, а компилятор по своему анализу решит мемоизировать иначе, эффект может начать срабатывать в другие моменты.
Мы приняли простое правило: в новом коде ручной мемоизации в render-слое нет, если нет конкретной причины, записанной рядом в комментарии. Старую не трогаем массово, а удаляем, когда всё равно правим компонент и можем проверить его поведение руками. За несколько месяцев так ушло больше половины обёрток, и ни одна из этих правок не дала регрессии — потому что каждую делал человек, который в тот момент держал компонент в голове.
Где ссылочная стабильность всё ещё ваша забота
Самая интересная часть начинается на границах. Компилятор отвечает за то, что происходит внутри скомпилированных компонентов. Но как только значение уходит наружу — в стороннюю библиотеку, в эффект, в подписку, в некомпилированный код, — гарантии становятся слабее, и думать о стабильности снова приходится самому.
Первый случай — зависимости эффектов. Компилятор мемоизирует значения, но семантика useEffect не меняется: эффект перезапустится, когда изменится любая зависимость. Если в зависимости уходит объект, собранный из пропсов, и компилятор по какой-то причине не смог его закэшировать — например, компонент вылетел в bail out, — эффект будет срабатывать на каждом рендере. Раньше это было видно по отсутствию useMemo. Теперь это видно только если смотреть на результат компиляции. Поэтому для эффектов, которые делают что-то дорогое или побочное — подписки, сетевые запросы, инициализацию сторонних виджетов, — мы по-прежнему предпочитаем явные примитивные зависимости вместо объектов.
Второй случай — библиотеки, которые сравнивают пропсы или опции по ссылке. Таблицы, графики, карты, редакторы часто внутри делают что-то вроде «если объект конфигурации поменялся — пересоздать инстанс». Если эта библиотека сама не скомпилирована, а конфиг формируется в вашем компоненте, всё работает, пока компонент обрабатывается компилятором. Стоит ему вылететь в bail out из-за правки в соседней строке — и график начинает пересоздаваться на каждый ввод в поле поиска. Для таких мест мы оставляем явный useMemo как контракт: не потому что компилятор не справится, а потому что стабильность здесь — требование API, а не оптимизация.
Это ключевое различие, которое стоит проговорить прямо: мемоизация как оптимизация — работа компилятора, мемоизация как контракт — работа инженера. Если без стабильной ссылки код становится не медленнее, а неправильнее, это контракт, и его лучше выразить явно.
Почему селекторы стора компилятор не заменит
Отдельная путаница возникает вокруг state-менеджеров. После включения компилятора у нас всплыл вопрос: раз компилятор всё мемоизирует, может, можно выбросить reselect и createSelector из Redux Toolkit? Нет, и причина архитектурная, а не техническая.
Компилятор работает в render-слое: он кэширует значения между рендерами одного экземпляра компонента. Селектор работает в слое данных: он кэширует производные данные между вызовами с одним и тем же состоянием стора, независимо от того, кто и сколько раз его вызывает. Когда useSelector возвращает новый массив после filter на каждый вызов, проблема не в рендере, а в подписке: стор сравнивает результат по ссылке, видит новый массив и заставляет компонент перерисоваться при любом изменении состояния, даже не относящемся к делу. Компилятор тут ничего не может сделать, потому что сравнение происходит до компонента, внутри подписки.
То же касается дорогих вычислений, которые не принадлежат конкретному компоненту: агрегации, нормализация, построение индексов по большим спискам. Компилятор закэширует результат внутри одного экземпляра, но если тот же расчёт нужен в трёх местах экрана, он будет выполнен трижды. Мемоизированный селектор или вычисление на уровне query-кэша выполнят его один раз. Это не конкуренция инструментов, а разделение слоёв: данные готовятся в слое данных, render-слой их только отображает.
Если сформулировать совсем прямо: компилятор убрал мемоизацию из компонентов, но сделал ещё заметнее её отсутствие в слое данных. Мы после включения компилятора как раз нашли несколько селекторов, которые никогда не были мемоизированы, — раньше их маскировали useMemo в компонентах, теперь маскировать стало нечем.
Как понять, что стало быстрее, а не просто иначе
Публичные цифры от Meta звучали внушительно: заметно более быстрая начальная загрузка и ускорение отдельных взаимодействий в разы на их приложениях. Но переносить чужие цифры на свой продукт бессмысленно. Выигрыш от компилятора сильно зависит от того, сколько лишних рендеров было в приложении до него. Если команда годами аккуратно мемоизировала руками, прирост будет скромным. Если код был написан без оглядки на рендеры, — заметным.
Мы мерили тремя способами. Первый — React Profiler на фиксированных сценариях: ввод в поле фильтра на списке из нескольких тысяч строк, переключение вкладок, открытие тяжёлой модалки. Записывали число коммитов и суммарное время рендера до и после включения на каждом модуле. Второй — полевые метрики, прежде всего INP, по данным реальных пользователей с разбивкой по устройствам. Третий — размер бандла, потому что компилятор добавляет код: кэш-слоты и проверки на каждом скомпилированном компоненте.
Результат получился честным и скучным. На тяжёлых интерактивных экранах число лишних рендеров упало в разы, и INP на слабых Android-устройствах заметно улучшился. На простых страницах разница в пределах шума. Бандл вырос на несколько процентов — это реальная цена, и на проектах, где каждый килобайт на счету, её стоит учитывать. Никакого скачка, о котором можно было бы написать в пресс-релизе, не было. Был ровный, предсказуемый выигрыш там, где проблема и была.
Главный выигрыш оказался не в миллисекундах
Если оценивать компилятор только по метрикам производительности, картина получится средней: полезно, но не революция. Настоящая польза оказалась в другом месте — в когнитивной нагрузке. Из ревью почти исчезли разговоры о мемоизации. Новые разработчики перестали гадать, нужно ли оборачивать обработчик в useCallback. Компоненты стали короче и читаются как описание того, что показать, а не как смесь логики и инструкций для оптимизатора.
Важнее даже другое: поведение стало предсказуемее. Раньше производительность компонента зависела от того, насколько внимателен был тот, кто его писал, и тот, кто правил его последним. Одна забытая зависимость или новый инлайновый объект в пропсах — и React.memo на ребёнке превращался в пустую обёртку. Теперь базовая мемоизация не зависит от дисциплины отдельного человека. Она становится свойством сборки, а не свойством ревью.
Но у этой предсказуемости есть условие: код должен соответствовать правилам React. Компилятор не прощает нарушения — он их молча обходит. Поэтому в нашей практике линтер с правилами компилятора стал обязательной частью CI, а не рекомендацией. Без него выигрыш постепенно размывается: каждый новый компонент с мутацией или чтением ref во время рендера тихо выпадает из оптимизации, и через полгода от компилятора остаётся меньше, чем кажется.
Чего компилятор не исправит ни при каком конфиге
Важно не свалиться в другую крайность и не начать считать компилятор лекарством от любых проблем с производительностью. Он убирает лишние рендеры, но не делает медленный рендер быстрым. Если компонент рисует десять тысяч строк без виртуализации, он будет рисовать их и с компилятором — просто реже. Если состояние поднято слишком высоко и любое изменение инвалидирует половину дерева, компилятор сократит работу на каждом уровне, но не исправит саму структуру.
Не решает он и проблемы загрузки: размер JavaScript, водопады запросов, отсутствие code splitting. Не влияет на тяжёлые вычисления в обработчиках событий — они вообще вне рендера. И не помогает коду, который он не видит: сторонние некомпилированные библиотеки остаются такими, какими были.
Есть и организационная цена. Отладка стала немного другой: когда что-то не обновляется, приходится держать в голове вариант «компилятор закэшировал то, что мутируется в обход React». Результат компиляции читать сложнее, чем исходник, и иногда ради понимания приходится открывать playground и смотреть, что именно он сгенерировал. Это нечастая ситуация, но она есть, и делать вид, что её нет, — нечестно.
Итог
После нескольких месяцев в проде я бы описал React Compiler так: это не оптимизатор, который делает приложение быстрым, а инструмент, который убирает целый класс ручной работы и делает базовую производительность свойством сборки. useMemo и useCallback в render-слое действительно можно перестать писать по умолчанию. Но они остаются там, где стабильность ссылки — это контракт с внешним API или с эффектом, а мемоизация производных данных остаётся в слое данных, в селекторах и кэше запросов.
Внедрять его стоит постепенно: линтер с правилами компилятора первым, затем режим аннотаций на нескольких экранах, затем включение по модулям с замером до и после. Старую ручную мемоизацию удалять по ходу работы, а не массовым коммитом. Исключения через "use no memo" держать с объяснением причины.
Главный практический вывод совсем прямо: компилятор забирает мемоизацию как оптимизацию, но оставляет вам мемоизацию как контракт — и чем чище код соблюдает правила React, тем больше работы он реально берёт на себя.