# Przyspieszyłem listy w React Native 8000 razy

By Tarik Pinarci (https://tarikpinarci.com). Published 2026-06-20. Canonical: https://tarikpinarci.com/pl/blog/improving-flatlist-performance-in-react-native

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](https://www.anthropic.com/news/claude-fable-5-mythos-5). 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](https://github.com/react/react-native/pull/57210). Zmiana usuwa niepotrzebne wyszukiwanie sticky headerów ze ścieżki tworzenia render maski, której używa `VirtualizedList`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flatlist-merged.jpg"
    alt="Oś czasu na GitHubie pokazująca PR z poprawką wydajności FlatList zmerge'owany do React Native"
    style="width:100%; border-radius:14px; border:1px solid rgba(255,255,255,0.12);"
  />
  <figcaption style="margin-top:8px; text-align:center; font-size:0.9rem; color:#9ca3af;">Zmerge'owane do React Native. Nadal trochę w to nie wierzę.</figcaption>
</figure>

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:

```tsx
<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:

```js
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:

```js
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.

![](https://media.giphy.com/media/FASybzL1ElrxpT2rTq/giphy.gif)

### Dlaczego dotyczy to FlatList

Ten fragment łatwo przeoczyć.

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

Więc taki kod:

```tsx
<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.

```js
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.

```js
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:

- [Test benchmarku Fantom](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js)
- [Testy zachowania VirtualizedList](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js)
- [Zmerge'owany PR #57210](https://github.com/react/react-native/pull/57210)

<div style="display:grid; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); gap: 36px; margin: 32px 0 42px; align-items:start; perspective:1400px;">
  <figure style="margin:0; transform:rotateY(10deg) rotateX(3deg); transform-style:preserve-3d;">
    <figcaption style="font-weight:700; color:#fca5a5; margin-bottom:14px; text-align:center;">Przed</figcaption>
    <div style="position:relative; max-width:330px; margin:0 auto; aspect-ratio:985/2008; filter:drop-shadow(32px 34px 46px rgba(0,0,0,0.58));">
    <div style="position:absolute; z-index:3; left:10%; top:5.5%; padding:5px 9px; border-radius:999px; background:rgba(0,0,0,0.68); border:1px solid rgba(255,255,255,0.16); color:#f8fafc; font-size:0.72rem; font-weight:700; pointer-events:none;">▶ wideo z symulatora</div>
    <video
      data-autoplay="viewport"
      autoplay
      controls
      playsinline
      muted
      loop
      preload="metadata"
      style="position:absolute; left:5.19%; top:2.17%; width:89.93%; height:95.66%; border-radius:8.8%/4.1%; object-fit:cover; background:#05080f;"
      src="/videos/blog/flatlist-performance/before-release-simplified.mp4"
    >
      Twoja przeglądarka nie obsługuje tagu video.
    </video>
    <div class="flatlist-video-cursor flatlist-video-cursor-before" aria-hidden="true"></div>
    <img
      src="/images/blog/device-frames/iphone-14-pro-black.png"
      alt=""
      loading="lazy"
      style="position:absolute; inset:0; width:100%; height:100%; pointer-events:none;"
    />
    </div>
  </figure>
  <figure style="margin:0; transform:rotateY(-10deg) rotateX(3deg); transform-style:preserve-3d;">
    <figcaption style="font-weight:700; color:#86efac; margin-bottom:14px; text-align:center;">Po</figcaption>
    <div style="position:relative; max-width:330px; margin:0 auto; aspect-ratio:985/2008; filter:drop-shadow(-32px 34px 46px rgba(0,0,0,0.58));">
    <div style="position:absolute; z-index:3; left:10%; top:5.5%; padding:5px 9px; border-radius:999px; background:rgba(0,0,0,0.68); border:1px solid rgba(255,255,255,0.16); color:#f8fafc; font-size:0.72rem; font-weight:700; pointer-events:none;">▶ wideo z symulatora</div>
    <video
      data-autoplay="viewport"
      autoplay
      controls
      playsinline
      muted
      loop
      preload="metadata"
      style="position:absolute; left:5.19%; top:2.17%; width:89.93%; height:95.66%; border-radius:8.8%/4.1%; object-fit:cover; background:#05080f;"
      src="/videos/blog/flatlist-performance/after-release-simplified.mp4"
    >
      Twoja przeglądarka nie obsługuje tagu video.
    </video>
    <div class="flatlist-video-cursor flatlist-video-cursor-after" aria-hidden="true"></div>
    <img
      src="/images/blog/device-frames/iphone-14-pro-black.png"
      alt=""
      loading="lazy"
      style="position:absolute; inset:0; width:100%; height:100%; pointer-events:none;"
    />
    </div>
  </figure>
</div>

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.

| Przypadek | Jedna aktualizacja przed | Jedna aktualizacja po | Przyspieszenie | 1000 aktualizacji przed | 1000 aktualizacji po |
| --- | ---: | ---: | ---: | ---: | ---: |
| 100 tys. wierszy, bez sticky headerów | 2.664 ms | 0.0034 ms | 780x | 2.66 s | 3.42 ms |
| 100 tys. wierszy, puste sticky headery | 2.632 ms | 0.0033 ms | 800x | 2.63 s | 3.29 ms |
| 100 tys. wierszy, jeden sticky header na górze | 2.705 ms | 0.0054 ms | 499x | 2.71 s | 5.42 ms |
| 250 tys. wierszy, bez sticky headerów | 6.543 ms | 0.0035 ms | 1892x | 6.54 s | 3.46 ms |
| 250 tys. wierszy, puste sticky headery | 6.579 ms | 0.0033 ms | 2024x | 6.58 s | 3.25 ms |
| 250 tys. wierszy, jeden sticky header na górze | 6.796 ms | 0.0053 ms | 1294x | 6.80 s | 5.25 ms |
| 500 tys. wierszy, bez sticky headerów | 13.173 ms | 0.0033 ms | 4002x | 13.17 s | 3.29 ms |
| 500 tys. wierszy, puste sticky headery | 13.073 ms | 0.0033 ms | 3997x | 13.07 s | 3.27 ms |
| 500 tys. wierszy, jeden sticky header na górze | 13.444 ms | 0.0054 ms | 2511x | 13.44 s | 5.35 ms |
| 750 tys. wierszy, bez sticky headerów | 19.524 ms | 0.0033 ms | 6008x | 19.52 s | 3.25 ms |
| 750 tys. wierszy, puste sticky headery | 19.572 ms | 0.0033 ms | 6022x | 19.57 s | 3.25 ms |
| 750 tys. wierszy, jeden sticky header na górze | 20.304 ms | 0.0054 ms | 3778x | 20.30 s | 5.37 ms |
| 1 mln wierszy, bez sticky headerów | 26.190 ms | 0.0033 ms | 8058x | 26.19 s | 3.25 ms |
| 1 mln wierszy, puste sticky headery | 26.039 ms | 0.0033 ms | 8012x | 26.04 s | 3.25 ms |
| 1 mln wierszy, jeden sticky header na górze | 26.855 ms | 0.0053 ms | 5075x | 26.86 s | 5.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:

```sh
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
```

```sh
yarn fantom packages/react-native/Libraries/Lists/__tests__/FlatList-itest.js packages/react-native/Libraries/Lists/__tests__/SectionList-itest.js --runInBand
```

```sh
yarn flow check
```

```sh
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.

