# Ho reso le liste di React Native 8000 volte più veloci

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

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](https://www.anthropic.com/news/claude-fable-5-mythos-5). 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](https://github.com/react/react-native/pull/57210). La modifica elimina la ricerca inutile degli sticky header dal percorso di creazione della render mask usato da `VirtualizedList`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flatlist-merged.jpg"
    alt="Timeline di GitHub che mostra la pull request sulle prestazioni di FlatList mergiata in 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;">Mergiata in React Native. Mi sembra ancora un po' irreale.</figcaption>
</figure>

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:

- `VirtualizedList`
- `FlatList`
- `VirtualizedSectionList`
- `SectionList`

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:

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

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

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

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

### Perché riguarda FlatList

Questa parte è facile da non notare.

Non devi usare `VirtualizedList` direttamente. `FlatList` è costruita sopra di essa.

Quindi un codice come questo:

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

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

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

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`
- `stickyHeaderIndices` vuoto
- 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:

- [Test di benchmark Fantom](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js)
- [Test di comportamento di VirtualizedList](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js)
- [PR #57210 mergiata](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;">Prima</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;">▶ video dal simulatore</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"
    >
      Il tuo browser non supporta il tag 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;">Dopo</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;">▶ video dal simulatore</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"
    >
      Il tuo browser non supporta il tag 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>

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`: circa `1.92 s` in totale (`1.9196 ms / call`)
- `500k rows`: circa `18.78 s` in totale (`18.78 ms / call`)
- `1m rows`: circa `38.40 s` in totale (`38.40 ms / call`)

Con il percorso ottimizzato, la stessa demo resta praticamente piatta:

- `50k rows`: circa `3.74 ms` in totale (`0.0037 ms / call`)
- `500k rows`: circa `3.67 ms` in totale (`0.0037 ms / call`)
- `1m rows`: circa `3.73 ms` in 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:

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

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.

