Sì, hai letto bene: 8000 volte più veloci.
Non nel senso di "ora tutta la tua app è 8000 volte più veloce, vai a comprarti uno yacht". Purtroppo.
E sì, lo so che il momento è buffo.
Viviamo in un'epoca in cui le notizie sull'AI corrono così veloci che qualcosa come Claude Fable 5 può uscire ed essere sospeso pochi giorni dopo. La gente discute di modelli quasi AGI, di controlli sulle esportazioni, di agenti che realizzano progetti interi, e così via.
E io sono qui a parlare di come rendere più veloci le liste di React Native.
Messe una accanto all'altra, le due cose suonano un po' strane. Lo capisco.
Ma questo tipo di lavoro continua a entusiasmarmi. Forse "invenzione" è una parola troppo grossa, ma migliorare un framework usato da migliaia di app per me ha ancora un significato. Non tutto ciò che è utile deve sembrare fantascienza. A volte si tratta solo di togliere lavoro sprecato da un percorso che quasi ogni app mobile attraversa.
Il guadagno sta in un percorso specifico delle liste di React Native: il lavoro sulla finestra di render che decide quali celle devono esistere in questo momento. In quel benchmark, il vecchio percorso poteva sprecare secondi su liste enormi, e quello nuovo li riduce a pochi millisecondi.
Di solito stiamo dal lato dell'app. Usiamo FlatList, SectionList, la navigazione, le animazioni, le librerie di state e tutto il resto. Ci lamentiamo delle prestazioni, proviamo qualche prop, aggiungiamo memo, magari getItemLayout, e poi andiamo avanti con la nostra vita.
Ma a volte il vero problema sta un livello sotto il codice dell'app.
È quello che è successo qui.
Ho contribuito con un miglioramento delle prestazioni a react/react-native, mergiato come PR #57210. La modifica elimina la ricerca inutile degli sticky header dal percorso di creazione della render mask usato da VirtualizedList.
In parole semplici: a volte React Native cercava gli sticky header anche quando la lista non ne aveva.
Classico momento da computer.
Lista: "Non ho sticky header."
React Native: "Perfetto, fammi scorrere all'indietro per trovarne uno."
La parte bella è che questo percorso è condiviso. Quindi il miglioramento riguarda:
VirtualizedListFlatListVirtualizedSectionListSectionList
E sì, anche l'uso normale di FlatList può trarne vantaggio, pure se non usi affatto gli sticky header.
Cosa migliora davvero
Prima di entrare nel codice, vale la pena dire di che tipo di prestazioni si tratta.
Il miglioramento riguarda il lavoro JavaScript che React Native fa prima di decidere quali righe renderizzare.
FlatList mantiene una finestra di render. Mentre scorri, salti, monti la lista vicino a un indice iniziale o ti muovi in una lista grande, React Native deve decidere quali celle renderizzare e quali parti possono restare semplici spaziatori.
Questa decisione passa da VirtualizedList._createRenderMask.
Quindi il guadagno è:
- meno lavoro JS durante gli aggiornamenti della finestra della lista
- meno lavoro quando si salta verso la fine di una lista enorme
- meno logica inutile sugli sticky header per le liste che non ne hanno
- decisioni più rapide prima che la lista aggiorni cosa mostrare sullo schermo
In termini di app normale, aiuta la parte di FlatList che decide "quali righe devono esistere adesso?".
Per liste molto grandi, soprattutto vicino alla fine, quella piccola decisione interna può diventare un costo reale.
Eliminare quel costo rende molto più economico il percorso di aggiornamento della finestra di render.
Cosa ho notato
FlatList è uno di quei componenti che quasi ogni app React Native usa prima o poi.
Da fuori sembra semplice:
<FlatList data={items} renderItem={renderItem} />
Ma sotto il cofano passa da VirtualizedList.
VirtualizedList non renderizza tutta la sorgente dati. Se hai 100k righe, non mette 100k righe sullo schermo come un soldato coraggioso ma condannato. Mantiene una finestra di render e usa una render mask per decidere quali celle devono esistere in questo momento.
Ed è una buona cosa.
Il problema era nel passaggio di creazione della render mask.
React Native supporta anche gli sticky header. Gli sticky header sono speciali perché l'elemento sticky può trovarsi fuori dalla viewport normale, ma deve restare renderizzato perché visivamente resta bloccato in alto.
Quindi React Native ha bisogno di una logica del tipo:
"Trova lo sticky header più vicino prima della viewport e tienilo renderizzato."
Quella logica è corretta.
La parte fastidiosa era che la ricerca poteva partire anche quando non c'erano sticky header.
Il vecchio percorso
Prima di questa modifica, VirtualizedList._createRenderMask costruiva un set da stickyHeaderIndices e chiamava l'helper degli sticky header.
La versione semplificata era così:
const stickyIndicesSet = new Set(props.stickyHeaderIndices);
VirtualizedList._ensureClosestStickyHeader(
props,
stickyIndicesSet,
renderMask,
cellsAroundViewport.first,
);
Poi l'helper scorreva all'indietro a partire dalla prima cella visibile:
for (let itemIdx = cellIdx - 1; itemIdx >= 0; itemIdx--) {
if (stickyIndicesSet.has(itemIdx + stickyOffset)) {
renderMask.addCells({first: itemIdx, last: itemIdx});
break;
}
}
Per una lista piccola, poco importa.
Per una lista molto grande diventa doloroso. Se la viewport è vicino alla fine di una lista da 1 milione di righe e non ci sono sticky header, l'helper può comunque scorrere all'indietro quasi tutta la lista.
In pratica è una grande ricerca per non trovare niente.
Non è il mio hobby preferito.

Perché riguarda FlatList
Questa parte è facile da non notare.
Non devi usare VirtualizedList direttamente. FlatList è costruita sopra di essa.
Quindi un codice come questo:
<FlatList
data={bigData}
renderItem={renderItem}
/>
passa comunque da VirtualizedList._createRenderMask.
Prima della modifica, una lista normale senza stickyHeaderIndices poteva comunque pagare il lavoro di ricerca degli sticky header.
Dopo la modifica, React Native controlla se gli sticky header esistono davvero prima di fare qualsiasi lavoro su di essi.
Tecnologia avanzatissima: controllare che una cosa esista prima di cercarla.
La modifica
La prima parte è quella importante per l'uso normale di FlatList senza sticky header.
const stickyHeaderIndices = props.stickyHeaderIndices;
if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
VirtualizedList._ensureClosestStickyHeader(
props,
stickyHeaderIndices,
renderMask,
cellsAroundViewport.first,
);
}
Se non ci sono sticky header, saltiamo l'helper.
La seconda parte migliora anche il caso con gli sticky header.
Invece di scorrere all'indietro gli indici degli elementi, l'helper esamina gli indici degli sticky header configurati e trova lo sticky header valido più vicino prima della 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});
}
Quindi il costo passa da:
"Quanto siamo lontani dall'inizio della lista?"
a:
"Quanti sticky header sono configurati?"
È una domanda molto migliore da porsi.
Mantenere lo stesso comportamento
Questa è la parte che rende le piccole modifiche a un framework meno piccole di quanto sembrino.
Non puoi semplicemente ottimizzare e sperare che vada tutto bene. stickyHeaderIndices può essere non ordinato. Può contenere valori duplicati. Può contenere valori non validi. Può esserci un ListHeaderComponent, che sposta l'indice di uno.
Tutto questo deve continuare a funzionare.
I test coprono casi come:
- nessun
stickyHeaderIndices stickyHeaderIndicesvuoto- indici sticky non ordinati
- indici sticky duplicati
- valori negativi
- valori frazionari
- valori dopo la viewport
- gestione dello scostamento di
ListHeaderComponent
Quest'ultimo è importante. Gli indici degli sticky header si basano sugli indici dei figli dello ScrollView sottostante. Quando c'è un header della lista, l'elemento con indice 0 non è più il figlio con indice 0.
I piccoli bug di uno in più o uno in meno adorano questa zona. Ci vivono senza pagare l'affitto.
Risultati del benchmark
Ho misurato direttamente il percorso VirtualizedList._createRenderMask con Fantom Hermes, usando 100 campioni per caso.
Questo benchmark si concentra sul lavoro di decisione della finestra di render dentro VirtualizedList.
Quindi no, non significa che ogni FlatList di ogni app scorra all'improvviso 8000 volte più veloce. Magari. Sarei già insopportabile.
Significa che questo specifico percorso interno di windowing delle liste è diventato enormemente più economico. E quando il benchmark passa da secondi di lavoro sprecato a pochi millisecondi, resta una vittoria molto concreta.
La prova sul simulatore
Ho anche creato una piccola app React Native bare per confrontare le due implementazioni sul simulatore iOS.
Stessa app. Stessa FlatList da 1m righe. Stessa configurazione no sticky headers.
L'unica differenza è l'implementazione di VirtualizedList installata. Sono vere registrazioni del simulatore dentro le cornici del telefono, non screenshot statici di mockup. Ho lasciato apposta visibili i controlli del video, e l'impulso del cursore segna il tocco sul pulsante del benchmark.
Il benchmark e i test di comportamento sono anche nella PR di React Native mergiata:
Nella demo sul simulatore, il vecchio percorso cresce con la dimensione della lista. Per 1k aggiornamenti della finestra di render, il risultato è questo:
50k rows: circa1.92 sin totale (1.9196 ms / call)500k rows: circa18.78 sin totale (18.78 ms / call)1m rows: circa38.40 sin totale (38.40 ms / call)
Con il percorso ottimizzato, la stessa demo resta praticamente piatta:
50k rows: circa3.74 msin totale (0.0037 ms / call)500k rows: circa3.67 msin totale (0.0037 ms / call)1m rows: circa3.73 msin totale (0.0037 ms / call)
I valori per singola chiamata sono sotto il secondo, quindi sono indicati in millisecondi. Per 1.000 aggiornamenti della render mask, i valori sopra il secondo sono indicati in secondi.
| Caso | Un aggiornamento prima | Un aggiornamento dopo | Accelerazione | 1.000 aggiornamenti prima | 1.000 aggiornamenti dopo |
|---|---|---|---|---|---|
| 100k righe, nessuno sticky header | 2.664 ms | 0.0034 ms | 780x | 2.66 s | 3.42 ms |
| 100k righe, sticky header vuoti | 2.632 ms | 0.0033 ms | 800x | 2.63 s | 3.29 ms |
| 100k righe, uno sticky header in cima | 2.705 ms | 0.0054 ms | 499x | 2.71 s | 5.42 ms |
| 250k righe, nessuno sticky header | 6.543 ms | 0.0035 ms | 1,892x | 6.54 s | 3.46 ms |
| 250k righe, sticky header vuoti | 6.579 ms | 0.0033 ms | 2,024x | 6.58 s | 3.25 ms |
| 250k righe, uno sticky header in cima | 6.796 ms | 0.0053 ms | 1,294x | 6.80 s | 5.25 ms |
| 500k righe, nessuno sticky header | 13.173 ms | 0.0033 ms | 4,002x | 13.17 s | 3.29 ms |
| 500k righe, sticky header vuoti | 13.073 ms | 0.0033 ms | 3,997x | 13.07 s | 3.27 ms |
| 500k righe, uno sticky header in cima | 13.444 ms | 0.0054 ms | 2,511x | 13.44 s | 5.35 ms |
| 750k righe, nessuno sticky header | 19.524 ms | 0.0033 ms | 6,008x | 19.52 s | 3.25 ms |
| 750k righe, sticky header vuoti | 19.572 ms | 0.0033 ms | 6,022x | 19.57 s | 3.25 ms |
| 750k righe, uno sticky header in cima | 20.304 ms | 0.0054 ms | 3,778x | 20.30 s | 5.37 ms |
| 1m righe, nessuno sticky header | 26.190 ms | 0.0033 ms | 8,058x | 26.19 s | 3.25 ms |
| 1m righe, sticky header vuoti | 26.039 ms | 0.0033 ms | 8,012x | 26.04 s | 3.25 ms |
| 1m righe, uno sticky header in cima | 26.855 ms | 0.0053 ms | 5,075x | 26.86 s | 5.29 ms |
La colonna dei 1.000 aggiornamenti rende la differenza più facile da percepire.
Con 1 milione di righe, il vecchio percorso senza sticky header passa circa 26 secondi in questo helper per 1.000 aggiornamenti della render mask.
Dopo la modifica, lo stesso caso si aggira intorno ai 3.25 ms.
È tempo tolto a un percorso condiviso delle liste, prima che React Native decida quali celle renderizzare.
Piano di test
Volevo che fosse noioso nel senso migliore: stesso comportamento, meno lavoro.
Quindi il contributo includeva test di comportamento e copertura con benchmark.
I comandi principali erano:
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
La PR modificava tre file:
- l'implementazione di
VirtualizedList - test mirati per
VirtualizedList - un benchmark Fantom per il percorso della render mask con sticky header
È stata importata attraverso il processo di Meta e mergiata in react/react-native.
Considerazioni finali
Quello che mi piace di questo contributo è che gli sviluppatori di app non devono fare niente.
Nessuna nuova prop.
Nessuna migrazione.
Nessun workaround.
Se un'app usa una FlatList grande senza sticky header, React Native ora può evitare un lavoro di ricerca degli sticky header che non serviva fin dall'inizio.
È il mio tipo preferito di miglioramento a un framework.
Superficie ridotta. Benchmark chiaro. Nessun cambio di API.
E un percorso comune diventa più economico per tutti.