Blogg

Jag gjorde listor i React Native 8000 gånger snabbare

20 juni 2026 9 min läsning

Så gjorde min mergade PR i React Native arbetet med render-fönstret i FlatList och VirtualizedList upp till 8000 gånger snabbare.

Jag gjorde listor i React Native 8000 gånger snabbare
React NativeFlatListVirtualizedListPrestandaÖppen källkod

Ja, du läste rätt: 8000 gånger snabbare.

Inte snabbare i betydelsen "hela din app är nu 8000 gånger snabbare, gå och köp en yacht". Tyvärr.

Och ja, jag vet att tajmingen är lite komisk.

Vi lever i en tid där AI-nyheterna går så snabbt att något som Claude Fable 5 kan lanseras och sedan stängas av några dagar senare. Folk bråkar om nästan-AGI-modeller, exportkontroller, agenter som gör hela projekt och allt sådant.

Och här sitter jag och pratar om att göra listor i React Native snabbare.

Det låter lite udda när man ställer de två sakerna bredvid varandra. Jag förstår det.

Men jag tycker fortfarande att den här typen av arbete är spännande. "Uppfinning" är kanske ett för stort ord, men att förbättra ett ramverk som används av tusentals appar känns ändå meningsfullt för mig. Allt användbart måste inte se ut som science fiction. Ibland handlar det bara om att ta bort onödigt arbete från en väg som nästan varje mobilapp passerar.

Vinsten ligger i en specifik väg för listor i React Native: arbetet med render-fönstret som avgör vilka celler som ska finnas just nu. I den benchmarken kunde den gamla vägen slösa sekunder på enorma listor, och den nya vägen kapar det till några millisekunder.

För det mesta befinner vi oss på appsidan. Vi använder FlatList, SectionList, navigation, animationer, state-bibliotek och allt det vanliga. Vi klagar på prestandan, testar några props, lägger till memo, kanske getItemLayout, och går sedan vidare med livet.

Men ibland ligger det verkliga problemet ett lager under appkoden.

Det var det som hände här.

Jag bidrog med en prestandaförbättring till react/react-native, mergad som PR #57210. Ändringen tar bort onödigt letande efter sticky headers från vägen som skapar render-masken i VirtualizedList.

GitHub-tidslinje som visar att pull requesten för FlatList-prestanda mergats in i React Native
Mergad in i React Native. Känns fortfarande lite overkligt.

Med vanliga ord: React Native letade ibland efter sticky headers även när listan inte hade några sticky headers.

Ett klassiskt datorögonblick.

Listan: "Jag har inga sticky headers."

React Native: "Toppen, då letar jag bakåt för att hitta en."

Det fina är att den här vägen är delad. Så förbättringen påverkar:

  • VirtualizedList
  • FlatList
  • VirtualizedSectionList
  • SectionList

Och ja, vanlig användning av FlatList kan dra nytta av det även om du inte använder sticky headers alls.

Vad det här faktiskt förbättrar

Innan vi går in i koden är det värt att säga vilken sorts prestanda det handlar om.

Förbättringen ligger i det JavaScript-arbete som React Native gör innan det bestämmer vilka rader som ska renderas.

FlatList håller ett render-fönster. När du scrollar, hoppar, monterar nära ett startindex eller rör dig runt i en stor lista måste React Native avgöra vilka celler som ska renderas och vilka delar som kan förbli tomrum.

Det beslutet går via VirtualizedList._createRenderMask.

Så vinsten är:

  • mindre JS-arbete när listans fönster uppdateras
  • mindre arbete när man hoppar nära slutet av en enorm lista
  • mindre onödig sticky header-logik för listor utan sticky headers
  • snabbare beslut innan listan uppdaterar vad som ska synas på skärmen

I vanliga apptermer hjälper det den del av FlatList som avgör "vilka rader ska finnas just nu?"

För väldigt stora listor, särskilt nära slutet av listan, kan det lilla interna beslutet bli en verklig kostnad.

När den kostnaden försvinner blir uppdateringen av render-fönstret mycket billigare.

Det jag lade märke till

FlatList är en av de komponenter som nästan varje React Native-app använder någon gång.

Utifrån ser den enkel ut:

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

Men under huven går den via VirtualizedList.

VirtualizedList renderar inte hela datakällan. Om du har 100k rader lägger den inte 100k rader på skärmen som en modig men dödsdömd soldat. Den håller ett render-fönster och använder en render-mask för att avgöra vilka celler som ska finnas just nu.

Det är bra.

Problemet låg i steget där render-masken skapas.

React Native stöder också sticky headers. Sticky headers är speciella eftersom det klistrade elementet kan ligga utanför den vanliga viewporten men ändå måste förbli renderat, eftersom det visuellt sitter fast högst upp.

Så React Native behöver logik i stil med:

"Hitta närmaste sticky header före viewporten och håll den renderad."

Den logiken är korrekt.

Det irriterande var att letandet ändå kunde köras när det inte fanns några sticky headers.

Den gamla vägen

Före ändringen byggde VirtualizedList._createRenderMask ett set från stickyHeaderIndices och anropade hjälpfunktionen för sticky headers.

En förenklad version såg ut så här:

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

Sedan gick hjälpfunktionen bakåt från den första synliga cellen:

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

För en liten lista spelar det ingen roll.

För en väldigt stor lista blir det smärtsamt. Om viewporten är nära slutet av en lista med 1 miljon rader, och det inte finns några sticky headers, kan hjälpfunktionen ändå gå bakåt genom nästan hela listan.

Det är i princip en stor sökning för att hitta ingenting.

Inte min favorithobby.

Varför FlatList påverkas

Den här delen är lätt att missa.

Du behöver inte använda VirtualizedList direkt. FlatList är byggd ovanpå den.

Så den här typen av kod:

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

går fortfarande via VirtualizedList._createRenderMask.

Före ändringen kunde en vanlig lista utan stickyHeaderIndices ändå betala för letandet efter sticky headers.

Efter ändringen kontrollerar React Native om sticky headers faktiskt finns innan något sticky header-arbete görs.

Mycket avancerad teknik: kontrollera om saken finns innan du letar efter den.

Ändringen

Den första delen är den viktiga för vanlig FlatList utan sticky headers.

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

Om det inte finns några sticky headers hoppar vi över hjälpfunktionen.

Den andra delen förbättrar även fallet med sticky headers.

I stället för att gå bakåt genom elementens index går hjälpfunktionen igenom de konfigurerade indexen för sticky headers och hittar närmaste giltiga sticky header före viewporten.

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

Så kostnaden ändras från:

"Hur långt är vi från listans början?"

till:

"Hur många sticky headers är konfigurerade?"

Det är en mycket bättre fråga att ställa.

Behålla samma beteende

Det är den här delen som gör att små ändringar i ett ramverk är mindre små än de ser ut.

Du kan inte bara optimera och hoppas att allt fungerar. stickyHeaderIndices kan vara osorterad. Den kan innehålla dubbletter. Den kan innehålla ogiltiga värden. Det kan finnas en ListHeaderComponent, som förskjuter indexet med ett.

Allt det måste fortfarande fungera.

Testerna täcker fall som:

  • ingen stickyHeaderIndices
  • tom stickyHeaderIndices
  • osorterade sticky-index
  • dubblerade sticky-index
  • negativa värden
  • decimalvärden
  • värden efter viewporten
  • hantering av förskjutningen från ListHeaderComponent

Det sista är viktigt. Indexen för sticky headers utgår från barnindexen i den underliggande ScrollView. När det finns en list header är elementindex 0 inte längre barnindex 0.

Små off-by-one-buggar älskar det här området. De bor där gratis.

Resultat från benchmarken

Jag benchmarkade vägen VirtualizedList._createRenderMask direkt med Fantom Hermes, med 100 mätningar per fall.

Den här benchmarken fokuserar på arbetet med att bestämma render-fönstret i VirtualizedList.

Så nej, det betyder inte att varje FlatList i varje app plötsligt scrollar 8000 gånger snabbare. Jag önskar att det var så. Då hade jag redan varit outhärdlig om det.

Det betyder att just den här interna vägen för listfönster blev enormt mycket billigare. Och när benchmarken går från sekunder av bortkastat arbete till några millisekunder är det ändå en väldigt verklig vinst.

Bevis i simulatorn

Jag byggde också en liten bare React Native-app för att jämföra båda implementationerna i iOS-simulatorn.

Samma app. Samma FlatList med 1m rader. Samma uppsättning med no sticky headers.

Den enda skillnaden är vilken implementation av VirtualizedList som är installerad. Det här är riktiga inspelningar från simulatorn inuti telefonramarna, inte statiska mockup-skärmdumpar. Jag lät videokontrollerna synas med flit, och pulsen från markören visar när benchmarkknappen trycks.

Benchmarken och beteendetesterna finns också i den mergade React Native-PR:en:

Före
▶ simulatorvideo
Efter
▶ simulatorvideo

I simulatordemon växer den gamla vägen med listans storlek. För 1k uppdateringar av render-fönstret ser det ut så här:

  • 50k rows: ungefär 1.92 s totalt (1.9196 ms / call)
  • 500k rows: ungefär 18.78 s totalt (18.78 ms / call)
  • 1m rows: ungefär 38.40 s totalt (38.40 ms / call)

Med den optimerade vägen ligger samma demo i princip still:

  • 50k rows: ungefär 3.74 ms totalt (0.0037 ms / call)
  • 500k rows: ungefär 3.67 ms totalt (0.0037 ms / call)
  • 1m rows: ungefär 3.73 ms totalt (0.0037 ms / call)

Värdena per anrop ligger under 1 sekund, så de visas i millisekunder. För 1 000 uppdateringar av render-masken visas värden över 1 sekund i sekunder.

FallEn uppdatering föreEn uppdatering efterUppsnabbning1 000 uppdateringar före1 000 uppdateringar efter
100k rader, inga sticky headers2.664 ms0.0034 ms780x2.66 s3.42 ms
100k rader, tomma sticky headers2.632 ms0.0033 ms800x2.63 s3.29 ms
100k rader, en sticky header överst2.705 ms0.0054 ms499x2.71 s5.42 ms
250k rader, inga sticky headers6.543 ms0.0035 ms1,892x6.54 s3.46 ms
250k rader, tomma sticky headers6.579 ms0.0033 ms2,024x6.58 s3.25 ms
250k rader, en sticky header överst6.796 ms0.0053 ms1,294x6.80 s5.25 ms
500k rader, inga sticky headers13.173 ms0.0033 ms4,002x13.17 s3.29 ms
500k rader, tomma sticky headers13.073 ms0.0033 ms3,997x13.07 s3.27 ms
500k rader, en sticky header överst13.444 ms0.0054 ms2,511x13.44 s5.35 ms
750k rader, inga sticky headers19.524 ms0.0033 ms6,008x19.52 s3.25 ms
750k rader, tomma sticky headers19.572 ms0.0033 ms6,022x19.57 s3.25 ms
750k rader, en sticky header överst20.304 ms0.0054 ms3,778x20.30 s5.37 ms
1m rader, inga sticky headers26.190 ms0.0033 ms8,058x26.19 s3.25 ms
1m rader, tomma sticky headers26.039 ms0.0033 ms8,012x26.04 s3.25 ms
1m rader, en sticky header överst26.855 ms0.0053 ms5,075x26.86 s5.29 ms

Kolumnen med 1 000 uppdateringar gör skillnaden lättare att känna.

Vid 1 miljon rader lägger den gamla vägen utan sticky headers ungefär 26 sekunder i den här hjälpfunktionen för 1 000 uppdateringar av render-masken.

Efter ändringen ligger samma fall på ungefär 3.25 ms.

Det är tid som tas bort från en delad listväg innan React Native avgör vilka celler som ska renderas.

Testplan

Jag ville att det här skulle vara tråkigt på bästa sätt: samma beteende, mindre arbete.

Så bidraget innehöll beteendetester och benchmarktäckning.

De viktigaste kommandona var:

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:en ändrade tre filer:

  • implementationen av VirtualizedList
  • fokuserade tester för VirtualizedList
  • en Fantom-benchmark för render-mask-vägen med sticky headers

Den importerades via Metas process och mergades in i react/react-native.

Avslutande tankar

Det jag gillar med det här bidraget är att apputvecklare inte behöver göra någonting.

Ingen ny prop.

Ingen migrering.

Ingen nödlösning.

Om en app använder en stor FlatList utan sticky headers kan React Native nu slippa letandet efter sticky headers som aldrig behövdes från början.

Det är min favoritsort av förbättring i ett ramverk.

Liten yta. Tydlig benchmark. Ingen ändring i API:et.

Och en vanlig väg blir billigare för alla.