Головна / Статті

Вісім способів оптимізації відображення в 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 КБ, і швидкість першого завантаження значно покращилась.

Звузьте вибір selektorів стану

За допомогою 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, знайдіть найбільшу перешкоду та виправте її спочатку.