Blog

Przyspieszyłem listy w React Native 8000 razy

20 czerwca 2026 9 min czytania

Jak mój zmergowany PR do React Native przyspieszył pracę nad render window w FlatList i VirtualizedList nawet 8000 razy.

Przyspieszyłem listy w React Native 8000 razy
React NativeFlatListVirtualizedListWydajnośćOpen source

Tak, dobrze czytasz: 8000 razy szybciej.

Niestety nie chodzi o to, że cała Twoja aplikacja jest teraz 8000 razy szybsza i możesz iść kupić jacht.

I tak, wiem, że moment jest zabawny.

Żyjemy w czasach, w których newsy o AI pędzą tak szybko, że coś takiego jak Claude Fable 5 może wystartować, a kilka dni później zostać zawieszone. Ludzie kłócą się o modele bliskie AGI, kontrolę eksportu, agentów robiących całe projekty i tak dalej.

A ja tu sobie opowiadam o przyspieszaniu list w React Native.

Kiedy postawi się te dwie rzeczy obok siebie, brzmi to trochę dziwnie. Rozumiem.

Ale ta praca dalej mnie ekscytuje. Może „wynalazek” to za duże słowo, ale ulepszenie frameworka, którego używają tysiące aplikacji, nadal wydaje mi się czymś ważnym. Nie każda przydatna rzecz musi wyglądać jak science fiction. Czasem chodzi po prostu o usunięcie zbędnej pracy ze ścieżki, przez którą przechodzi prawie każda aplikacja mobilna.

Zysk dotyczy jednej konkretnej ścieżki list w React Native: pracy nad oknem renderowania, która decyduje, które komórki mają istnieć w danej chwili. W tym benchmarku stara ścieżka potrafiła marnować sekundy na ogromnych listach, a nowa skraca to do kilku milisekund.

Zwykle siedzimy po stronie aplikacji. Używamy FlatList, SectionList, nawigacji, animacji, bibliotek do state'u i całej reszty standardowych rzeczy. Narzekamy na wydajność, próbujemy jakichś propsów, dodajemy memo, może getItemLayout, a potem żyjemy dalej.

Ale czasem prawdziwy problem leży warstwę niżej niż kod aplikacji.

Tak było tutaj.

Wniosłem poprawkę wydajności do react/react-native, zmerge'owaną jako PR #57210. Zmiana usuwa niepotrzebne wyszukiwanie sticky headerów ze ścieżki tworzenia render maski, której używa VirtualizedList.

Oś czasu na GitHubie pokazująca PR z poprawką wydajności FlatList zmerge'owany do React Native
Zmerge'owane do React Native. Nadal trochę w to nie wierzę.

Mówiąc normalnie: React Native czasem szukał sticky headerów nawet wtedy, gdy lista nie miała żadnych sticky headerów.

Klasyczny komputerowy moment.

Lista: „Nie mam żadnych sticky headerów.”

React Native: „Spoko, to poszukam jakiegoś, idąc od tyłu.”

Fajne jest to, że ta ścieżka jest współdzielona. Poprawka dotyczy więc:

  • VirtualizedList
  • FlatList
  • VirtualizedSectionList
  • SectionList

I tak, zwykłe użycie FlatList też może na tym zyskać, nawet jeśli w ogóle nie używasz sticky headerów.

Co to właściwie poprawia

Zanim przejdę do kodu, warto powiedzieć, o jaki rodzaj wydajności tu chodzi.

Poprawa dotyczy pracy w JavaScripcie, którą React Native wykonuje, zanim zdecyduje, które wiersze wyrenderować.

FlatList utrzymuje okno renderowania. Kiedy przewijasz, skaczesz, montujesz listę w pobliżu początkowego indeksu albo poruszasz się po dużej liście, React Native musi zdecydować, które komórki wyrenderować, a które części mogą zostać spacerami.

Ta decyzja przechodzi przez VirtualizedList._createRenderMask.

Zysk to więc:

  • mniej pracy w JS przy aktualizacjach okna listy
  • mniej pracy przy skoku w okolice końca ogromnej listy
  • mniej niepotrzebnej logiki sticky headerów dla list bez sticky headerów
  • szybsze decyzje, zanim lista zaktualizuje to, co ma być na ekranie

W języku aplikacji: to pomaga tej części FlatList, która decyduje, „jakie wiersze mają istnieć w tej chwili?”

Przy bardzo dużych listach, zwłaszcza blisko ich końca, ta mała wewnętrzna decyzja może stać się realnym kosztem.

Usunięcie tego kosztu sprawia, że ścieżka aktualizacji okna renderowania jest dużo tańsza.

Co zauważyłem

FlatList to jeden z tych komponentów, których prawie każda aplikacja w React Native w pewnym momencie używa.

Z zewnątrz wygląda prosto:

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

Ale pod spodem przechodzi przez VirtualizedList.

VirtualizedList nie renderuje całego źródła danych. Jeśli masz 100 tys. wierszy, nie wrzuca 100 tys. wierszy na ekran jak dzielny, ale skazany na porażkę żołnierz. Utrzymuje okno renderowania i używa render maski, żeby zdecydować, które komórki mają istnieć w danej chwili.

To dobrze.

Problem siedział w kroku tworzenia render maski.

React Native obsługuje też sticky headery. Są one wyjątkowe, bo sticky element może być poza normalnym viewportem, a mimo to musi pozostać wyrenderowany, bo wizualnie jest przyklejony do góry.

React Native potrzebuje więc logiki w stylu:

„Znajdź najbliższy sticky header przed viewportem i trzymaj go wyrenderowanym.”

Ta logika jest poprawna.

Irytujące było to, że wyszukiwanie mogło się uruchamiać także wtedy, gdy sticky headerów w ogóle nie było.

Stara ścieżka

Przed tą zmianą VirtualizedList._createRenderMask budował zbiór ze stickyHeaderIndices i wywoływał helper do sticky headerów.

W uproszczeniu wyglądało to tak:

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

Potem helper szedł od tyłu, zaczynając od pierwszej widocznej komórki:

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

Przy małej liście to bez znaczenia.

Przy bardzo dużej liście robi się boleśnie. Jeśli viewport jest blisko końca listy z milionem wierszy i nie ma sticky headerów, helper i tak może przejść od tyłu przez prawie całą listę.

To w zasadzie wielkie wyszukiwanie, żeby nic nie znaleźć.

Nie jest to moje ulubione hobby.

Dlaczego dotyczy to FlatList

Ten fragment łatwo przeoczyć.

Nie musisz używać VirtualizedList bezpośrednio. FlatList jest zbudowany na nim.

Więc taki kod:

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

nadal przechodzi przez VirtualizedList._createRenderMask.

Przed zmianą zwykła lista bez stickyHeaderIndices mogła i tak płacić za wyszukiwanie sticky headerów.

Po zmianie React Native najpierw sprawdza, czy sticky headery w ogóle istnieją, a dopiero potem wykonuje związaną z nimi pracę.

Bardzo zaawansowana technologia: sprawdź, czy coś istnieje, zanim zaczniesz tego szukać.

Zmiana

Pierwsza część jest najważniejsza dla zwykłego użycia FlatList bez sticky headerów.

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

Jeśli nie ma sticky headerów, pomijamy helper.

Druga część poprawia także przypadek ze sticky headerami.

Zamiast iść od tyłu po indeksach elementów, helper przegląda skonfigurowane indeksy sticky headerów i znajduje najbliższy poprawny sticky header przed viewportem.

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});
}

Koszt zmienia się więc z:

„Jak daleko jesteśmy od początku listy?”

na:

„Ile sticky headerów jest skonfigurowanych?”

To dużo lepsze pytanie.

Zachowanie bez zmian

To jest ten moment, przez który małe zmiany we frameworku są mniej małe, niż wyglądają.

Nie można po prostu zoptymalizować i liczyć, że wszystko będzie dobrze. stickyHeaderIndices może być nieposortowane. Może zawierać duplikaty. Może zawierać niepoprawne wartości. Może być ListHeaderComponent, który przesuwa indeks o jeden.

Wszystko to nadal musi działać.

Testy pokrywają przypadki takie jak:

  • brak stickyHeaderIndices
  • puste stickyHeaderIndices
  • nieposortowane indeksy sticky
  • zduplikowane indeksy sticky
  • wartości ujemne
  • wartości ułamkowe
  • wartości za viewportem
  • obsługa przesunięcia przez ListHeaderComponent

Ten ostatni jest ważny. Indeksy sticky headerów opierają się na indeksach dzieci w ScrollView pod spodem. Kiedy lista ma header, element o indeksie 0 nie jest już dzieckiem o indeksie 0.

Małe błędy off-by-one uwielbiają to miejsce. Mieszkają tam za darmo.

Wyniki benchmarku

Zbenchmarkowałem ścieżkę VirtualizedList._createRenderMask bezpośrednio przy użyciu Fantom Hermes, ze 100 próbkami na przypadek.

Ten benchmark skupia się na pracy decyzyjnej okna renderowania wewnątrz VirtualizedList.

Więc nie, to nie znaczy, że każda FlatList w każdej aplikacji nagle przewija się 8000 razy szybciej. Chciałbym. Już byłbym nie do zniesienia.

To znaczy, że ta konkretna wewnętrzna ścieżka windowingu list stała się dużo tańsza. A kiedy benchmark schodzi z sekund zmarnowanej pracy do kilku milisekund, to nadal jest bardzo realny zysk.

Dowód na symulatorze

Zrobiłem też małą aplikację w czystym React Native, żeby porównać obie implementacje na iOS Simulator.

Ta sama aplikacja. Ta sama FlatList z 1m wierszy. Ta sama konfiguracja no sticky headers.

Jedyna różnica to zainstalowana implementacja VirtualizedList. To prawdziwe nagrania z symulatora wewnątrz ramek telefonu, a nie statyczne screenshoty z mockupu. Celowo zostawiłem widoczne kontrolki wideo, a pulsujący kursor oznacza tapnięcie przycisku benchmarku.

Benchmark i testy zachowania są też w zmerge'owanym PR do React Native:

Przed
▶ wideo z symulatora
Po
▶ wideo z symulatora

W demo na symulatorze stara ścieżka rośnie razem z rozmiarem listy. Dla 1 tys. aktualizacji okna renderowania wygląda to tak:

  • 50k rows: około 1.92 s łącznie (1.9196 ms / call)
  • 500k rows: około 18.78 s łącznie (18.78 ms / call)
  • 1m rows: około 38.40 s łącznie (38.40 ms / call)

Ze zoptymalizowaną ścieżką to samo demo pozostaje praktycznie płaskie:

  • 50k rows: około 3.74 ms łącznie (0.0037 ms / call)
  • 500k rows: około 3.67 ms łącznie (0.0037 ms / call)
  • 1m rows: około 3.73 ms łącznie (0.0037 ms / call)

Wartości na jedno wywołanie są poniżej 1 sekundy, więc podaję je w milisekundach. Dla 1000 aktualizacji render maski wartości powyżej 1 sekundy podaję w sekundach.

PrzypadekJedna aktualizacja przedJedna aktualizacja poPrzyspieszenie1000 aktualizacji przed1000 aktualizacji po
100 tys. wierszy, bez sticky headerów2.664 ms0.0034 ms780x2.66 s3.42 ms
100 tys. wierszy, puste sticky headery2.632 ms0.0033 ms800x2.63 s3.29 ms
100 tys. wierszy, jeden sticky header na górze2.705 ms0.0054 ms499x2.71 s5.42 ms
250 tys. wierszy, bez sticky headerów6.543 ms0.0035 ms1892x6.54 s3.46 ms
250 tys. wierszy, puste sticky headery6.579 ms0.0033 ms2024x6.58 s3.25 ms
250 tys. wierszy, jeden sticky header na górze6.796 ms0.0053 ms1294x6.80 s5.25 ms
500 tys. wierszy, bez sticky headerów13.173 ms0.0033 ms4002x13.17 s3.29 ms
500 tys. wierszy, puste sticky headery13.073 ms0.0033 ms3997x13.07 s3.27 ms
500 tys. wierszy, jeden sticky header na górze13.444 ms0.0054 ms2511x13.44 s5.35 ms
750 tys. wierszy, bez sticky headerów19.524 ms0.0033 ms6008x19.52 s3.25 ms
750 tys. wierszy, puste sticky headery19.572 ms0.0033 ms6022x19.57 s3.25 ms
750 tys. wierszy, jeden sticky header na górze20.304 ms0.0054 ms3778x20.30 s5.37 ms
1 mln wierszy, bez sticky headerów26.190 ms0.0033 ms8058x26.19 s3.25 ms
1 mln wierszy, puste sticky headery26.039 ms0.0033 ms8012x26.04 s3.25 ms
1 mln wierszy, jeden sticky header na górze26.855 ms0.0053 ms5075x26.86 s5.29 ms

Kolumna z 1000 aktualizacji sprawia, że różnicę łatwiej poczuć.

Przy milionie wierszy stara ścieżka bez sticky headerów spędza w tym helperze około 26 sekund na 1000 aktualizacji render maski.

Po zmianie ten sam przypadek zajmuje około 3,25 ms.

To czas usunięty ze współdzielonej ścieżki list, zanim React Native zdecyduje, jakie komórki wyrenderować.

Plan testów

Chciałem, żeby to było nudne w najlepszym sensie: to samo zachowanie, mniej pracy.

Dlatego wkład obejmował testy zachowania i pokrycie benchmarkiem.

Główne komendy to:

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 zmienił trzy pliki:

  • implementację VirtualizedList
  • dedykowane testy VirtualizedList
  • benchmark Fantom dla ścieżki render maski ze sticky headerami

Został zaimportowany przez proces Meta i zmerge'owany do react/react-native.

Podsumowanie

W tym wkładzie najbardziej lubię to, że deweloperzy aplikacji nie muszą nic robić.

Żadnego nowego propsa.

Żadnej migracji.

Żadnego obejścia.

Jeśli aplikacja używa dużej FlatList bez sticky headerów, React Native może teraz uniknąć wyszukiwania sticky headerów, które od początku było niepotrzebne.

To mój ulubiony rodzaj ulepszeń we frameworku.

Mała powierzchnia zmian. Czytelny benchmark. Żadnej zmiany API.

A często używana ścieżka staje się tańsza dla wszystkich.