Блог

Я ускорил списки в React Native в 8000 раз

20 июня 2026 г. 9 мин чтения

Как мой смёрженный PR в React Native ускорил работу с render window в FlatList и VirtualizedList до 8000 раз.

Я ускорил списки в React Native в 8000 раз
React NativeFlatListVirtualizedListПроизводительностьOpen Source

Да, вы всё правильно прочитали: в 8000 раз быстрее.

Увы, не в смысле «всё ваше приложение теперь в 8000 раз быстрее, идите покупайте яхту».

И да, я понимаю, что момент выбран забавно.

Мы живём в эпоху, когда новости об ИИ меняются так быстро, что Claude Fable 5 может выйти, а через несколько дней его работу приостанавливают. Люди спорят о моделях почти уровня AGI, экспортном контроле, агентах, которые делают целые проекты, и обо всём остальном.

А я тут рассказываю, как сделать списки в React Native быстрее.

Если поставить эти две вещи рядом, звучит немного странно. Понимаю.

Но мне такая работа всё равно интересна. Может, «изобретение» слишком громкое слово, но улучшение фреймворка, которым пользуются тысячи приложений, по-прежнему кажется мне чем-то значимым. Не всё полезное должно выглядеть как научная фантастика. Иногда это просто удаление лишней работы из пути, через который проходит почти каждое мобильное приложение.

Выигрыш находится внутри одного конкретного пути списков в React Native: работы над render window, которая решает, какие ячейки должны существовать прямо сейчас. В этом бенчмарке старый путь мог тратить впустую секунды на огромных списках, а новый сокращает это до нескольких миллисекунд.

Большую часть времени мы находимся на стороне приложения. Мы используем FlatList, SectionList, навигацию, анимации, библиотеки для state и всё остальное как обычно. Жалуемся на производительность, пробуем какие-то props, добавляем 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 window. Пока вы скроллите, прыгаете, монтируете список рядом с начальным индексом или перемещаетесь по большому списку, React Native должен решить, какие ячейки рендерить, а какие части могут остаться спейсерами.

Это решение проходит через VirtualizedList._createRenderMask.

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

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

В терминах обычного приложения это помогает той части FlatList, которая решает: «какие строки должны существовать прямо сейчас?»

Для очень больших списков, особенно ближе к концу, это маленькое внутреннее решение может стать реальной нагрузкой.

Если убрать эту нагрузку, путь обновления render window становится гораздо дешевле.

Что я заметил

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

Снаружи он выглядит просто:

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

Но под капотом он работает через VirtualizedList.

VirtualizedList не рендерит весь источник данных. Если у вас 100 тысяч строк, он не выставляет на экран все 100 тысяч, как храбрый, но обречённый солдат. Он держит render window и использует render mask, чтобы решить, какие ячейки должны существовать прямо сейчас.

Это хорошо.

Проблема была внутри шага создания render mask.

React Native также поддерживает sticky headers. Они особенные, потому что закреплённый элемент может находиться за пределами обычного viewport, но всё равно должен оставаться отрендеренным, ведь визуально он прилип к верху.

Поэтому React Native нужна логика вроде:

«Найти ближайший sticky header перед viewport и оставить его отрендеренным».

Эта логика правильная.

Неприятно было то, что поиск мог запускаться, даже когда sticky headers не было вообще.

Старый путь

До этого изменения VirtualizedList._createRenderMask строил set из 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;
  }
}

Для маленького списка это ерунда.

Для очень большого списка это становится болезненным. Если viewport находится у конца списка из 1 миллиона строк и sticky headers нет, вспомогательная функция всё равно может пройти назад почти через весь список.

По сути это большой поиск, чтобы ничего не найти.

Не самое любимое моё занятие.

Почему это касается FlatList

Эту часть легко упустить.

Вам не нужно использовать VirtualizedList напрямую. FlatList построен поверх него.

Поэтому такой код:

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

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

До изменения обычный список без stickyHeaderIndices всё равно мог платить за поиск sticky headers.

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

Очень продвинутая технология: проверить, существует ли вещь, прежде чем её искать.

Изменение

Первая часть важна для обычного использования FlatList без sticky headers.

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 перед viewport.

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 headers
  • повторяющиеся индексы sticky headers
  • отрицательные значения
  • дробные значения
  • значения после viewport
  • обработка смещения из-за ListHeaderComponent

Последний пункт важен. Индексы sticky headers основаны на индексах дочерних элементов нижележащего ScrollView. Когда есть заголовок списка, индекс элемента 0 больше не равен индексу дочернего элемента 0.

Ошибки на единицу обожают это место. Живут там как у себя дома.

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

Я замерял путь VirtualizedList._createRenderMask напрямую с помощью Fantom Hermes, по 100 замеров на каждый случай.

Этот бенчмарк сосредоточен на работе по выбору render window внутри VirtualizedList.

Так что нет, это не значит, что каждый FlatList в каждом приложении вдруг скроллится в 8000 раз быстрее. Хотелось бы. Тогда со мной уже было бы невозможно разговаривать.

Это значит, что конкретный внутренний путь виртуализации списка стал радикально дешевле. А когда бенчмарк показывает переход от секунд лишней работы к нескольким миллисекундам, это всё равно очень реальный выигрыш.

Доказательство на симуляторе

Я также сделал небольшое голое приложение на React Native, чтобы сравнить обе реализации в iOS Simulator.

То же приложение. Тот же FlatList на 1m строк. Та же конфигурация no sticky headers.

Единственная разница в установленной реализации VirtualizedList. Внутри рамок телефонов настоящие записи с симулятора, а не статичные скриншоты макетов. Я специально оставил видимыми элементы управления видео, а пульсирующий курсор отмечает нажатие на кнопку бенчмарка.

Бенчмарк и тесты поведения тоже есть в смёрженном PR в React Native:

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

В демо на симуляторе старый путь растёт вместе с размером списка. Для 1 тысячи обновлений render window это выглядит так:

  • 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 секунды, поэтому они показаны в миллисекундах. Для 1 000 обновлений render mask значения больше 1 секунды показаны в секундах.

СлучайОдно обновление доОдно обновление послеУскорение1 000 обновлений до1 000 обновлений после
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

Столбец с 1 000 обновлений помогает лучше почувствовать разницу.

На 1 миллионе строк старый путь без sticky headers тратит в этой вспомогательной функции около 26 секунд на 1 000 обновлений 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.

Итоговые мысли

Что мне нравится в этом вкладе: разработчикам приложений не нужно ничего делать.

Никакого нового prop.

Никакой миграции.

Никаких обходных путей.

Если приложение использует большой FlatList без sticky headers, React Native теперь может избежать поиска sticky headers, который изначально был не нужен.

Это мой любимый вид улучшений во фреймворке.

Маленькая площадь изменений. Понятный бенчмарк. Никаких изменений API.

И частый путь становится дешевле для всех.