# J’ai rendu les listes React Native 8000 fois plus rapides

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

Oui, vous avez bien lu : 8000 fois plus rapides.

Pas au sens « toute votre application est maintenant 8000 fois plus rapide, allez vous acheter un yacht ». Malheureusement.

Et oui, je sais que le timing est amusant.

On vit à une époque où l’actualité de l’IA va si vite que quelque chose comme [Claude Fable 5 peut sortir puis être suspendu quelques jours plus tard](https://www.anthropic.com/news/claude-fable-5-mythos-5). Les gens débattent de modèles presque AGI, de contrôles à l’exportation, d’agents qui réalisent des projets entiers, et ainsi de suite.

Et moi, je suis là à parler de rendre les listes React Native plus rapides.

Mis côte à côte, ça peut paraître un peu étrange. Je comprends.

Mais je trouve toujours ce genre de travail passionnant. « Invention » est peut-être un bien grand mot, mais améliorer un framework utilisé par des milliers d’applications a encore du sens pour moi. Tout ce qui est utile n’a pas besoin de ressembler à de la science-fiction. Parfois, il s’agit simplement de supprimer du travail inutile dans un chemin que presque toutes les applications mobiles empruntent.

Le gain se trouve dans un chemin précis des listes React Native : le calcul de la fenêtre de rendu, qui décide quelles cellules doivent exister à un instant donné. Dans ce benchmark, l’ancien chemin pouvait gaspiller des secondes sur d’énormes listes, et le nouveau ramène ça à quelques millisecondes.

La plupart du temps, on est du côté de l’application. On utilise `FlatList`, `SectionList`, la navigation, les animations, les bibliothèques de state et tout le reste. On se plaint des performances, on essaie quelques props, on ajoute `memo`, peut-être `getItemLayout`, puis on passe à autre chose.

Mais parfois, le vrai problème se trouve une couche en dessous du code de l’application.

C’est ce qui s’est passé ici.

J’ai contribué une amélioration de performance à `react/react-native`, mergée sous le nom [PR #57210](https://github.com/react/react-native/pull/57210). La modification supprime une recherche de sticky headers inutile dans le chemin de création du render mask utilisé par `VirtualizedList`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flatlist-merged.jpg"
    alt="Timeline GitHub montrant la pull request de performance de FlatList mergée dans 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;">Mergée dans React Native. J’ai encore un peu de mal à y croire.</figcaption>
</figure>

En termes simples : React Native cherchait parfois des sticky headers alors que la liste n’en avait aucun.

Un grand classique de l’informatique.

> La liste : « Je n’ai aucun sticky header. »
>
> React Native : « Parfait, laisse-moi remonter toute la liste pour en trouver un. »

Le bon côté, c’est que ce chemin est partagé. L’amélioration concerne donc :

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

Et oui, une utilisation classique de `FlatList` peut en profiter même si vous n’utilisez aucun sticky header.

### Ce que ça améliore concrètement

Avant d’entrer dans le code, il faut préciser de quel type de performance on parle.

L’amélioration porte sur le travail JavaScript que fait React Native avant de décider quelles lignes doivent être rendues.

`FlatList` maintient une fenêtre de rendu. Quand vous scrollez, sautez à une position, montez la liste près d’un index initial ou vous déplacez dans une grande liste, React Native doit décider quelles cellules rendre et quelles parties peuvent rester de simples espaces vides.

Cette décision passe par `VirtualizedList._createRenderMask`.

Le gain, c’est donc :

- moins de travail JS pendant les mises à jour de la fenêtre de la liste
- moins de travail quand on saute vers la fin d’une énorme liste
- moins de logique de sticky headers inutile pour les listes qui n’en ont pas
- des décisions plus rapides avant que la liste ne mette à jour ce qui doit être à l’écran

Côté application, ça aide la partie de `FlatList` qui décide « quelles lignes doivent exister maintenant ? »

Pour les très grandes listes, surtout près de la fin, cette petite décision interne peut devenir un vrai coût.

Supprimer ce coût rend le chemin de mise à jour de la fenêtre de rendu beaucoup moins cher.

### Ce que j’ai remarqué

`FlatList` fait partie de ces composants que presque toutes les applications React Native utilisent à un moment ou à un autre.

Vu de l’extérieur, il paraît simple :

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

Mais sous le capot, il passe par `VirtualizedList`.

`VirtualizedList` ne rend pas toute la source de données. Si vous avez 100k lignes, il ne met pas 100k lignes à l’écran comme un soldat courageux mais condamné. Il maintient une fenêtre de rendu et utilise un render mask pour décider quelles cellules doivent exister à cet instant.

C’est une bonne chose.

Le problème se trouvait dans l’étape de création du render mask.

React Native prend aussi en charge les sticky headers. Ils sont particuliers, parce que l’élément sticky peut se trouver en dehors du viewport normal tout en devant rester rendu, puisqu’il est visuellement collé en haut.

React Native a donc besoin d’une logique du type :

« Trouver le sticky header le plus proche avant le viewport et le garder rendu. »

Cette logique est correcte.

Ce qui était agaçant, c’est que la recherche pouvait quand même s’exécuter en l’absence de sticky headers.

### L’ancien chemin

Avant cette modification, `VirtualizedList._createRenderMask` construisait un set à partir de `stickyHeaderIndices` et appelait le helper des sticky headers.

La version simplifiée ressemblait à ceci :

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

Ensuite, le helper remontait à partir de la première cellule visible :

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

Pour une petite liste, peu importe.

Pour une très grande liste, ça devient pénible. Si le viewport est proche de la fin d’une liste d’un million de lignes, et qu’il n’y a aucun sticky header, le helper peut quand même remonter presque toute la liste.

En gros, une grosse recherche pour ne rien trouver.

Pas mon passe-temps préféré.

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

### Pourquoi FlatList est concerné

C’est un point facile à manquer.

Vous n’avez pas besoin d’utiliser `VirtualizedList` directement. `FlatList` est construit par-dessus.

Donc ce genre de code :

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

passe quand même par `VirtualizedList._createRenderMask`.

Avant la modification, une liste normale sans `stickyHeaderIndices` pouvait quand même payer le coût de la recherche de sticky headers.

Après la modification, React Native vérifie si des sticky headers existent réellement avant de faire ce travail.

Une technologie très avancée : vérifier qu’une chose existe avant de la chercher.

### La modification

La première partie est la plus importante pour l’utilisation classique de `FlatList` sans sticky headers.

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

S’il n’y a pas de sticky headers, on saute le helper.

La seconde partie améliore aussi le cas avec sticky headers.

Au lieu de remonter les index des éléments un par un, le helper parcourt les index de sticky headers configurés et trouve le sticky header valide le plus proche avant le 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});
}
```

Le coût passe donc de :

« À quelle distance sommes-nous du début de la liste ? »

à :

« Combien de sticky headers sont configurés ? »

C’est une bien meilleure question à se poser.

### Garder le même comportement

C’est ce qui rend les petites modifications de framework moins petites qu’elles n’en ont l’air.

On ne peut pas simplement optimiser en espérant que tout aille bien. `stickyHeaderIndices` peut ne pas être trié. Il peut contenir des doublons. Il peut contenir des valeurs invalides. Il peut y avoir un `ListHeaderComponent`, qui décale l’index de un.

Tout cela doit continuer à fonctionner.

Les tests couvrent des cas comme :

- aucun `stickyHeaderIndices`
- un `stickyHeaderIndices` vide
- des index sticky non triés
- des index sticky en double
- des valeurs négatives
- des valeurs décimales
- des valeurs situées après le viewport
- la gestion du décalage dû à `ListHeaderComponent`

Ce dernier point est important. Les index de sticky headers se basent sur les index des enfants du `ScrollView` sous-jacent. Quand un header de liste existe, l’index d’élément `0` n’est plus l’index d’enfant `0`.

Les petites erreurs de décalage de un adorent cette zone. Elles y sont comme chez elles.

### Résultats du benchmark

J’ai mesuré directement le chemin `VirtualizedList._createRenderMask` avec Fantom Hermes, avec 100 échantillons par cas.

Ce benchmark se concentre sur le travail de décision de la fenêtre de rendu dans `VirtualizedList`.

Donc non, ça ne veut pas dire que chaque `FlatList` de chaque application scrolle soudain 8000 fois plus vite. J’aimerais bien. Je serais déjà insupportable à ce sujet.

Ça veut dire que ce chemin interne précis de fenêtrage des listes est devenu énormément moins coûteux. Et quand le benchmark passe de plusieurs secondes de travail gaspillé à quelques millisecondes, c’est quand même un gain bien réel.

### Preuve sur le simulateur

J’ai aussi créé une petite application React Native bare pour comparer les deux implémentations sur le simulateur iOS.

Même application. Même `FlatList` de `1m` lignes. Même configuration `no sticky headers`.

La seule différence est l’implémentation de `VirtualizedList` installée. Ce sont de vrais enregistrements du simulateur dans les cadres de téléphone, pas des captures d’écran de maquette statiques. J’ai volontairement laissé les contrôles vidéo visibles, et l’impulsion du curseur marque l’appui sur le bouton du benchmark.

Le benchmark et les tests de comportement se trouvent aussi dans la PR React Native mergée :

- [Test de benchmark Fantom](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js)
- [Tests de comportement de VirtualizedList](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js)
- [PR #57210 mergée](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;">Avant</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;">▶ vidéo du simulateur</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"
    >
      Votre navigateur ne prend pas en charge la balise vidéo.
    </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;">Après</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;">▶ vidéo du simulateur</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"
    >
      Votre navigateur ne prend pas en charge la balise vidéo.
    </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>

Dans la démo sur simulateur, l’ancien chemin grandit avec la taille de la liste. Pour 1k mises à jour de la fenêtre de rendu, ça donne :

- `50k rows` : environ `1.92 s` au total (`1.9196 ms / call`)
- `500k rows` : environ `18.78 s` au total (`18.78 ms / call`)
- `1m rows` : environ `38.40 s` au total (`38.40 ms / call`)

Avec le chemin optimisé, la même démo reste pratiquement constante :

- `50k rows` : environ `3.74 ms` au total (`0.0037 ms / call`)
- `500k rows` : environ `3.67 ms` au total (`0.0037 ms / call`)
- `1m rows` : environ `3.73 ms` au total (`0.0037 ms / call`)

Les valeurs par appel sont inférieures à 1 seconde, elles sont donc indiquées en millisecondes. Pour 1,000 mises à jour du render mask, les valeurs supérieures à 1 seconde sont indiquées en secondes.

| Cas | Une mise à jour avant | Une mise à jour après | Accélération | 1,000 mises à jour avant | 1,000 mises à jour après |
| --- | ---: | ---: | ---: | ---: | ---: |
| 100k lignes, sans sticky headers | 2.664 ms | 0.0034 ms | 780x | 2.66 s | 3.42 ms |
| 100k lignes, sticky headers vides | 2.632 ms | 0.0033 ms | 800x | 2.63 s | 3.29 ms |
| 100k lignes, un sticky header en haut | 2.705 ms | 0.0054 ms | 499x | 2.71 s | 5.42 ms |
| 250k lignes, sans sticky headers | 6.543 ms | 0.0035 ms | 1,892x | 6.54 s | 3.46 ms |
| 250k lignes, sticky headers vides | 6.579 ms | 0.0033 ms | 2,024x | 6.58 s | 3.25 ms |
| 250k lignes, un sticky header en haut | 6.796 ms | 0.0053 ms | 1,294x | 6.80 s | 5.25 ms |
| 500k lignes, sans sticky headers | 13.173 ms | 0.0033 ms | 4,002x | 13.17 s | 3.29 ms |
| 500k lignes, sticky headers vides | 13.073 ms | 0.0033 ms | 3,997x | 13.07 s | 3.27 ms |
| 500k lignes, un sticky header en haut | 13.444 ms | 0.0054 ms | 2,511x | 13.44 s | 5.35 ms |
| 750k lignes, sans sticky headers | 19.524 ms | 0.0033 ms | 6,008x | 19.52 s | 3.25 ms |
| 750k lignes, sticky headers vides | 19.572 ms | 0.0033 ms | 6,022x | 19.57 s | 3.25 ms |
| 750k lignes, un sticky header en haut | 20.304 ms | 0.0054 ms | 3,778x | 20.30 s | 5.37 ms |
| 1m lignes, sans sticky headers | 26.190 ms | 0.0033 ms | 8,058x | 26.19 s | 3.25 ms |
| 1m lignes, sticky headers vides | 26.039 ms | 0.0033 ms | 8,012x | 26.04 s | 3.25 ms |
| 1m lignes, un sticky header en haut | 26.855 ms | 0.0053 ms | 5,075x | 26.86 s | 5.29 ms |

La colonne des 1,000 mises à jour rend la différence plus concrète.

Avec 1 million de lignes, l’ancien chemin sans sticky headers passe environ 26 secondes dans ce helper pour 1,000 mises à jour du render mask.

Après la modification, le même cas tourne autour de 3.25 ms.

C’est du temps supprimé dans un chemin partagé des listes, avant que React Native ne décide quelles cellules rendre.

### Plan de test

Je voulais que ce soit ennuyeux dans le meilleur sens du terme : même comportement, moins de travail.

La contribution incluait donc des tests de comportement et une couverture par benchmark.

Les principales commandes étaient :

```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 modifiait trois fichiers :

- l’implémentation de `VirtualizedList`
- des tests ciblés de `VirtualizedList`
- un benchmark Fantom pour le chemin du render mask avec sticky headers

Elle a été importée via le processus de Meta et mergée dans `react/react-native`.

### Pour conclure

Ce que j’aime dans cette contribution, c’est que les développeurs d’applications n’ont rien à faire.

Aucune nouvelle prop.

Aucune migration.

Aucun contournement.

Si une application utilise une grande `FlatList` sans sticky headers, React Native peut désormais éviter une recherche de sticky headers qui n’avait aucune raison d’être.

C’est mon type d’amélioration de framework préféré.

Une petite surface de changement. Un benchmark clair. Aucun changement d’API.

Et un chemin courant devient moins coûteux pour tout le monde.

