Главная / Статьи

Восемь способов улучшения отрисовки в React, позволяющих сократить количество перерисовок на 80% без переписывания кода.

Сначала настройте профиль, затем примените memo, useMemo, useCallback, транзиции, виртуализацию списков, разделение кода и узкие селекторы для ускорения работы крупной панели управления в React.

Издатель: REACTAPP.TOP5 мин чтения1245 слов

Источники: How I Optimized a Slow React App Without Rewriting It

Представьте демонстрацию панели управления, при которой каждое нажатие на фильтр замораживает экран на целую секунду. Код структурирован и соответствует лучшим практикам, но всё равно работает крайне медленно. В кодовой базе 50 000 строк, и у никого нет бюджета на её полную переработку, поэтому единственный вариант — сделать процесс отрисовки более эффективным без изменения функционала. Приведённые ниже шаги следуют именно этому пути, и в примерном сценарии они сокращают количество повторных отрисовок примерно на 80%.

Измеряйте перед тем, как что-либо менять

Оптимизация вслепую — пустая трата времени, поэтому сначала проводится профилирование. Большую часть работы выполняют три инструмента:

  • React DevTools Profiler для записи взаимодействий и анализа диаграммы нагрузки с целью выявления компонентов, которые отрисовываются зря.
  • why-did-you-render — библиотека, которая фиксирует избыточные повторные отрисовки.
  • Вкладка Performance в Chrome DevTools для получения точных данных о времени отрисовки кадров.

Типичная схема легко распознаваема: родительский компонент обновляет свое состояние, и все дочерние компоненты перерисовываются заново, независимо от того, используют ли они измененные данные. В небольшом приложении это почти не имеет значения. Однако в панели управления с сотнями компонентов одно изменение состояния в верхней части может спровоцировать цепную реакцию перерисовок.

Хранение результатов перерисовки с React.memo

Когда компонент получает одинаковые параметры, он должен генерировать одинаковый результат, и React.memo хранит этот результат в кэше. Разумный подход — начать с «чистых» компонентов, которые чаще всего появляются в списке перерисовок, полученном с помощью инструментов анализа, а не оборачивать в кэширующий слой все компоненты.

const ExpensiveComponent = React.memo(({ data, onUpdate }) => {
  // Component logic
});

Есть один недостаток: React.memo сравнивает пропсы поверхностно. Функция, передаваемая в качестве пропса, создаётся заново при каждой отрисовке, поэтому механизм мемоизации не срабатывает. Для таких случаев предназначен useCallback. Как только мемоизация применяется там, где это действительно важно, компоненты, которые раньше перерисовывались при каждой изменении состояния, теперь делают это только тогда, когда меняются их собственные пропсы.

Совет: не все компоненты извлекут пользу. Полезно это будет только для тех, которые часто перерисовываются с одинаковыми пропсами. Мемоизация всего может навредить, поскольку хранение предыдущих результатов потребляет память.

useMemo и useCallback

React.memo предотвращает повторную отрисовку компонентов. useMemo и useCallback предотвращают повторную обработку данных внутри них.

Возьмём компонент, который вычисляет агрегатную статистику из большого массива. Если он запускается при каждой отрисовке, включая те, когда данные не изменились, это неэффективно. Обёртка этого компонента в useMemo с данными в качестве зависимости означает, что он будет запускаться заново только тогда, когда данные действительно изменятся:

const computedStats = useMemo(() => {
  return expensiveAggregation(data);
}, [data]);

useCallback решает другую проблему. Обработчики событий, передаваемые дочерним элементам, получают новый идентификатор при каждой отрисовке, что сводит на нет косвенное сравнение внутри React.memo. Обертывание обработчика сохраняет его ссылку неизменной:

const handleUpdate = useCallback((id) => {
  updateItem(id);
}, []);

В результате дорогостоящие вычисления перестают повторяться, детали интерфейса больше не перерисовываются зря, и интерфейс становится более отзывчивым.

Поддержание отзывчивости при вводе с помощью useTransition

Нажатие должно вызывать немедленную реакцию, но сложная обработка данных может заморозить браузер до её завершения. Возьмём, к примеру, поле поиска, фильтрующее список из 10 000 элементов: без дополнительных мер каждая нажатия клавиши замедляет работу экрана на сотни миллисекунд.

useTransition отмечает такую обработку как имеющую низкий приоритет, поэтому React продолжает отображать интерфейс, пока тяжёлая работа выполняется на фоне:

const [isPending, startTransition] = useTransition();
const handleSearch = (term) => {
  startTransition(() => {
    setSearchTerm(term);
    // Filtering happens in the background
  });
};

Фильтрация всё равно происходит, только не за счёт ввода текста. Разница становится очевидной сразу после того, как кто-то начинает использовать этот элемент.

Задание значений с задержкой с помощью useDeferredValue

useDeferredValue похож на useTransition, но применяется к значению вместо обновления состояния. Он сообщает React, что значение может отставать, когда происходят более срочные действия.

Представьте динамическую диаграмму, которая перерисовывается каждый раз при изменении данных. Её отрисовка требует много ресурсов и блокирует другие обновления. Задержка обработки полученного значения позволяет React сначала отрисовать более срочные элементы:

const deferredData = useDeferredValue(data);
// Chart receives deferredData and updates only when React has idle time

Графики и визуализации больше не мешают взаимодействию, и приложение остается плавным даже при работе с большими объемами данных.

Виртуализация длинных списков

Пользователь видит в любой момент только небольшую часть списка, поэтому отрисовка всего списка приводит к расточительству ресурсов. Хорошим примером может служить таблица с 500 строками, все из которых добавляются в DOM при каждом обновлении. Замена примитивного map() на react-window, отрисовывающий только видимые строки, изменяет ситуацию:

import { FixedSizeList } from 'react-window';
const Row = ({ index, style }) => (
  <div style={style}>
    {data[index].name}
  </div>
);
<FixedSizeList
  height={400}
  itemCount={data.length}
  itemSize={35}
  width="100%"
>
  {Row}
</FixedSizeList>

В примере таблица отображала примерно 20 строк вместо 500. Использование памяти снизилось, прокрутка стала плавной, а страница загружалась быстрее.

Разделение пакета по маршрутам

Ещё одной распространённой ошибкой является загрузка всего приложения сразу при первом запуске. Если виджеты дашборда, аналитики, настроек и отчётов собираются в один файл JavaScript, первая загрузка занимает много времени. Функции lazy и Suspense из React позволяют разделять пакет по маршрутам, так что каждый виджет загружается тогда, когда пользователь переходит на него:

const Dashboard = lazy(() => import('./views/Dashboard'));
const Analytics = lazy(() => import('./views/Analytics'));
function App() {
  return (
    <Suspense fallback={<Loading />}>
      <Routes>
        <Route path="/" element={<Dashboard />} />
        <Route path="/analytics" element={<Analytics />} />
      </Routes>
    </Suspense>
  );
}

В этом сценарии размер начального пакета сократился с 2,5 МБ до 800 КБ, и скорость первой загрузки заметно улучшилась.

Узкая настройка селекторов состояния

При использовании Redux или Zustand компоненты часто выбирают больше данных состояния, чем им нужно. Если корневой компонент берет весь хранилище данных через useSelector, любые изменения в хранилище приводят к его повторной отрисовке. Решением является выбор только тех частей состояния, которые используются каждым компонентом, а также мемоизация полученных данных с помощью createSelector из Redux Toolkit:

import { createSelector } from '@reduxjs/toolkit';
const selectFilteredData = createSelector(
  (state) => state.items,
  (state) => state.filterTerm,
  (items, term) => items.filter(item =>
    item.name.toLowerCase().includes(term.toLowerCase())
  )
);
// In component:
const filteredData = useSelector(selectFilteredData);

Теперь компоненты перерисовываются только тогда, когда меняются данные, которые они фактически читают, и каскад обновлений прекращается.

До и после

Показатель До После
Среднее количество перерисовок за одну интеракцию 47 9
Время до старта интерактивности 2,3 с 1,1 с
Падения кадров во время анимаций Часто Редко

Это примерно на 80% меньше перерисовок при сохранении той же базы кода и тех же функций.

Что это показывает

Ускорение приложения на React в основном сводится к пониманию проблемы, а не к переписыванию кода. Инструмент профилирования помогает определить место, где искать причины замедления, поэтому усилия не тратятся впустую на случайные компоненты. Каждое изменение решает конкретную проблему и приносит измеримый эффект; большинство из них занимают не более получаса. Это точечные улучшения, а не кардинальные изменения архитектуры.

Кратко говоря, в наборе инструментов есть React.memo для чистых компонентов, useMemo для сложных вычислений, useCallback для стабильных обработчиков, два хука для параллельной обработки задач, которые могут ждать, react-window для длинных списков, техника отложенной загрузки для маршрутов и точные селекторы для управления состоянием хранилища.

При последовательном и систематическом применении этих подходов медленное приложение превращается в такое, которое работает мгновенно. Начните с инструмента профилирования в DevTools, найдите самую серьезную проблему и устраните её в первую очередь.