Блог

Я зробив списки в React Native у 8000 разів швидшими

20 червня 2026 р. 9 хв читання

Як мій змерджений PR у React Native зробив роботу з render-вікном у FlatList і VirtualizedList до 8000 разів швидшою.

Я зробив списки в React Native у 8000 разів швидшими
React NativeFlatListVirtualizedListПродуктивністьВідкритий код

Так, ви правильно прочитали: у 8000 разів швидше.

Не в стилі «увесь ваш застосунок тепер у 8000 разів швидший, ідіть купуйте яхту». На жаль.

І так, я знаю, що час для цього кумедний.

Ми живемо в епоху, коли новини про AI рухаються так швидко, що Claude Fable 5 може вийти, а за кілька днів його призупинять. Люди сперечаються про моделі майже рівня AGI, експортний контроль, агентів, які роблять цілі проєкти, і все таке.

А я тут розповідаю, як зробити списки в React Native швидшими.

Якщо поставити ці дві речі поруч, звучить трохи дивно. Я розумію.

Але мене така робота досі захоплює. Можливо, «винахід» це завелике слово, але покращувати фреймворк, яким користуються тисячі застосунків, для мене все одно має сенс. Не все корисне мусить виглядати як наукова фантастика. Іноді це просто прибрати зайву роботу зі шляху, через який проходить майже кожен мобільний застосунок.

Виграш стосується одного конкретного шляху списків у React Native: роботи з render-вікном, яка вирішує, які комірки мають існувати саме зараз. У цьому бенчмарку старий шлях міг марнувати секунди на величезних списках, а новий скорочує це до кількох мілісекунд.

Здебільшого ми працюємо на боці застосунку. Використовуємо FlatList, SectionList, навігацію, анімації, бібліотеки стану і все звичне. Скаржимося на продуктивність, пробуємо якісь пропси, додаємо memo, можливо getItemLayout, і живемо далі.

Але іноді справжня проблема лежить на рівень нижче коду застосунку.

Саме так сталося тут.

Я зробив внесок у react/react-native з покращенням продуктивності, його змерджили як PR #57210. Ця зміна прибирає непотрібний пошук sticky headers зі шляху створення render mask, яким користується VirtualizedList.

Таймлайн GitHub, де pull request з покращенням продуктивності FlatList змерджено в React Native
Змерджено в React Native. Досі здається трохи нереальним.

Простими словами: React Native іноді шукав sticky headers навіть тоді, коли в списку їх не було взагалі.

Класичний момент з компʼютерами.

Список: «У мене немає sticky headers.»

React Native: «Чудово, зараз пошукаю один, пройшовшись назад.»

Приємно те, що цей шлях спільний. Тож покращення стосується:

  • VirtualizedList
  • FlatList
  • VirtualizedSectionList
  • SectionList

І так, звичайний FlatList теж отримує користь, навіть якщо ви взагалі не використовуєте sticky headers.

Що саме це покращує

Перш ніж переходити до коду, варто сказати, про яку саме продуктивність ідеться.

Покращення стосується роботи JavaScript, яку React Native виконує, перш ніж вирішити, які рядки рендерити.

FlatList тримає render-вікно. Коли ви скролите, перестрибуєте, монтуєте список біля початкового індексу або рухаєтеся великим списком, React Native має вирішити, які комірки рендерити, а які частини можна залишити як порожні проміжки.

Це рішення проходить через VirtualizedList._createRenderMask.

Тож виграш такий:

  • менше роботи JS під час оновлення вікна списку
  • менше роботи під час стрибка ближче до кінця величезного списку
  • менше зайвої логіки sticky headers для списків без sticky headers
  • швидші рішення, перш ніж список оновить те, що має бути на екрані

Мовою звичайного застосунку, це допомагає тій частині FlatList, яка вирішує: «які рядки мають існувати саме зараз?»

Для дуже великих списків, особливо ближче до кінця, це маленьке внутрішнє рішення може стати реальною вартістю.

Якщо цю вартість прибрати, шлях оновлення render-вікна стає набагато дешевшим.

Що я помітив

FlatList належить до тих компонентів, якими рано чи пізно користується майже кожен застосунок на React Native.

Ззовні він виглядає просто:

<FlatList data={items} renderItem={renderItem} />

Але під капотом він проходить через VirtualizedList.

VirtualizedList не рендерить усе джерело даних. Якщо у вас 100k рядків, він не виводить на екран 100k рядків, як хоробрий, але приречений солдат. Він тримає render-вікно і використовує render mask, щоб вирішити, які комірки мають існувати саме зараз.

І це добре.

Проблема була всередині кроку створення render mask.

React Native також підтримує sticky headers. Вони особливі, бо sticky елемент може бути поза звичайною видимою областю, але його все одно треба рендерити, бо візуально він закріплений угорі.

Тому React Native потрібна логіка на кшталт:

«Знайди найближчий sticky header перед видимою областю і залиш його відрендереним.»

Ця логіка правильна.

Прикро було те, що пошук міг запускатися навіть тоді, коли sticky headers не було.

Старий шлях

До цієї зміни VirtualizedList._createRenderMask будував множину з stickyHeaderIndices і викликав допоміжну функцію для sticky headers.

Спрощено це виглядало так:

const stickyIndicesSet = new Set(props.stickyHeaderIndices);
VirtualizedList._ensureClosestStickyHeader(
  props,
  stickyIndicesSet,
  renderMask,
  cellsAroundViewport.first,
);

Потім допоміжна функція йшла назад від першої видимої комірки:

for (let itemIdx = cellIdx - 1; itemIdx >= 0; itemIdx--) {
  if (stickyIndicesSet.has(itemIdx + stickyOffset)) {
    renderMask.addCells({first: itemIdx, last: itemIdx});
    break;
  }
}

Для маленького списку це байдуже.

Для дуже великого списку це стає болем. Якщо видима область біля кінця списку з 1 мільйона рядків, а sticky headers немає, допоміжна функція все одно може пройти назад майже через увесь список.

По суті, це великий пошук, щоб нічого не знайти.

Не моє улюблене хобі.

Чому це стосується FlatList

Цю частину легко пропустити.

Вам не треба використовувати VirtualizedList напряму. FlatList побудований поверх нього.

Тож такий код:

<FlatList
  data={bigData}
  renderItem={renderItem}
/>

все одно проходить через VirtualizedList._createRenderMask.

До зміни звичайний список без stickyHeaderIndices усе одно міг платити за пошук sticky headers.

Після зміни React Native спершу перевіряє, чи sticky headers взагалі існують, і лише тоді виконує з ними роботу.

Дуже передова технологія: перевірити, чи річ існує, перш ніж її шукати.

Зміна

Перша частина найважливіша для звичайного FlatList без sticky.

const stickyHeaderIndices = props.stickyHeaderIndices;
if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
  VirtualizedList._ensureClosestStickyHeader(
    props,
    stickyHeaderIndices,
    renderMask,
    cellsAroundViewport.first,
  );
}

Якщо sticky headers немає, ми пропускаємо допоміжну функцію.

Друга частина покращує і випадок зі sticky headers.

Замість того щоб іти назад по індексах елементів, допоміжна функція перебирає задані індекси sticky headers і знаходить найближчий коректний sticky header перед видимою областю.

const stickyOffset = props.ListHeaderComponent ? 1 : 0;
const targetStickyIndex = cellIdx + stickyOffset;
let closestStickyIndex = null;

for (let itemIdx = 0; itemIdx < stickyHeaderIndices.length; itemIdx++) {
  const stickyIndex = stickyHeaderIndices[itemIdx];
  if (
    Number.isInteger(stickyIndex) &&
    stickyIndex < targetStickyIndex &&
    stickyIndex >= stickyOffset &&
    (closestStickyIndex == null || stickyIndex > closestStickyIndex)
  ) {
    closestStickyIndex = stickyIndex;
  }
}

if (closestStickyIndex != null) {
  const itemIdx = closestStickyIndex - stickyOffset;
  renderMask.addCells({first: itemIdx, last: itemIdx});
}

Тож вартість змінюється з:

«Як далеко ми від початку списку?»

на:

«Скільки sticky headers задано?»

Це набагато краще питання.

Поведінка лишається тією самою

Саме через це маленькі зміни у фреймворку менш маленькі, ніж здаються.

Не можна просто оптимізувати і сподіватися, що все буде гаразд. stickyHeaderIndices можуть бути невідсортованими. Вони можуть містити дублікати. Можуть містити некоректні значення. Може бути ListHeaderComponent, який зсуває індекс на одиницю.

Усе це має працювати й далі.

Тести покривають такі випадки:

  • без stickyHeaderIndices
  • порожній stickyHeaderIndices
  • невідсортовані sticky індекси
  • дублікати sticky індексів
  • відʼємні значення
  • дробові значення
  • значення після видимої області
  • обробка зсуву через ListHeaderComponent

Останній пункт важливий. Індекси sticky headers базуються на індексах дочірніх елементів ScrollView. Коли є заголовок списку, елемент з індексом 0 уже не дочірній елемент з індексом 0.

Маленькі помилки на одиницю обожнюють це місце. Живуть там безкоштовно.

Результати бенчмарку

Я заміряв шлях VirtualizedList._createRenderMask напряму у Fantom Hermes, по 100 вимірів на кожен випадок.

Цей бенчмарк зосереджений на рішеннях щодо render-вікна всередині VirtualizedList.

Тож ні, це не означає, що кожен FlatList у кожному застосунку раптом скролиться у 8000 разів швидше. Хотілося б. Я б уже був нестерпним з цього приводу.

Це означає, що цей конкретний внутрішній шлях віконного рендерингу списків став набагато дешевшим. А коли бенчмарк переходить від секунд змарнованої роботи до кількох мілісекунд, це все одно цілком реальний виграш.

Доказ на симуляторі

Я також зробив невеликий bare застосунок на React Native, щоб порівняти обидві реалізації в iOS Simulator.

Той самий застосунок. Той самий FlatList на 1m рядків. Те саме налаштування no sticky headers.

Єдина відмінність у встановленій реалізації VirtualizedList. Це справжні записи з симулятора всередині рамок телефона, а не статичні скриншоти макетів. Я навмисно залишив видимими елементи керування відео, а пульсація курсора позначає натискання кнопки бенчмарку.

Бенчмарк і тести поведінки також є в змердженому PR у React Native:

До
▶ відео з симулятора
Після
▶ відео з симулятора

У демо на симуляторі старий шлях зростає разом з розміром списку. Для 1k оновлень render-вікна це виглядає так:

  • 50k rows: разом близько 1.92 s (1.9196 ms / call)
  • 500k rows: разом близько 18.78 s (18.78 ms / call)
  • 1m rows: разом близько 38.40 s (38.40 ms / call)

З оптимізованим шляхом те саме демо лишається майже пласким:

  • 50k rows: разом близько 3.74 ms (0.0037 ms / call)
  • 500k rows: разом близько 3.67 ms (0.0037 ms / call)
  • 1m rows: разом близько 3.73 ms (0.0037 ms / call)

Значення на один виклик менші за 1 секунду, тому вони наведені в мілісекундах. Для 1000 оновлень render mask значення понад 1 секунду наведені в секундах.

ВипадокОдне оновлення доОдне оновлення післяПрискорення1000 оновлень до1000 оновлень після
100k рядків, без sticky headers2.664 ms0.0034 ms780x2.66 s3.42 ms
100k рядків, порожні sticky headers2.632 ms0.0033 ms800x2.63 s3.29 ms
100k рядків, один sticky header угорі2.705 ms0.0054 ms499x2.71 s5.42 ms
250k рядків, без sticky headers6.543 ms0.0035 ms1,892x6.54 s3.46 ms
250k рядків, порожні sticky headers6.579 ms0.0033 ms2,024x6.58 s3.25 ms
250k рядків, один sticky header угорі6.796 ms0.0053 ms1,294x6.80 s5.25 ms
500k рядків, без sticky headers13.173 ms0.0033 ms4,002x13.17 s3.29 ms
500k рядків, порожні sticky headers13.073 ms0.0033 ms3,997x13.07 s3.27 ms
500k рядків, один sticky header угорі13.444 ms0.0054 ms2,511x13.44 s5.35 ms
750k рядків, без sticky headers19.524 ms0.0033 ms6,008x19.52 s3.25 ms
750k рядків, порожні sticky headers19.572 ms0.0033 ms6,022x19.57 s3.25 ms
750k рядків, один sticky header угорі20.304 ms0.0054 ms3,778x20.30 s5.37 ms
1m рядків, без sticky headers26.190 ms0.0033 ms8,058x26.19 s3.25 ms
1m рядків, порожні sticky headers26.039 ms0.0033 ms8,012x26.04 s3.25 ms
1m рядків, один sticky header угорі26.855 ms0.0053 ms5,075x26.86 s5.29 ms

Стовпчик з 1000 оновлень допомагає краще відчути різницю.

На 1 мільйоні рядків старий шлях без sticky витрачає в цій допоміжній функції близько 26 секунд на 1000 оновлень render mask.

Після зміни той самий випадок займає близько 3.25 ms.

Це час, прибраний зі спільного шляху списків ще до того, як React Native вирішує, які комірки рендерити.

План тестування

Я хотів, щоб це було нудно в найкращому сенсі: та сама поведінка, менше роботи.

Тож внесок містив тести поведінки та бенчмарки.

Основні команди були такі:

yarn jest packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js packages/virtualized-lists/Lists/__tests__/VirtualizedSectionList-test.js packages/react-native/Libraries/Lists/__tests__/FlatList-test.js --runInBand
yarn fantom packages/react-native/Libraries/Lists/__tests__/FlatList-itest.js packages/react-native/Libraries/Lists/__tests__/SectionList-itest.js --runInBand
yarn flow check
yarn fantom --benchmarks packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js --runInBand

PR змінив три файли:

  • реалізацію VirtualizedList
  • цільові тести VirtualizedList
  • бенчмарк Fantom для шляху render mask зі sticky headers

Його імпортували через процес Meta і змерджили в react/react-native.

Підсумки

Що мені подобається в цьому внеску: розробникам застосунків нічого не треба робити.

Жодного нового пропса.

Жодної міграції.

Жодних обхідних рішень.

Якщо застосунок використовує великий FlatList без sticky headers, React Native тепер може уникнути пошуку sticky headers, який з самого початку був непотрібним.

Це мій улюблений вид покращень фреймворку.

Мала площа змін. Зрозумілий бенчмарк. Жодних змін в API.

І поширений шлях стає дешевшим для всіх.