# Les styles sont 66 % plus rapides dans React Native

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

Oui, 66 % plus rapides.

Pas au sens « chaque écran de votre application s’affiche 66 % plus vite ». Si c’était le cas, je deviendrais insupportable.

Et oui, je sais que ça peut faire sourire en 2026.

On vit à une époque où l’actualité de l’IA change toutes les cinq minutes. [Claude Fable 5 est sorti puis a été suspendu quelques jours plus tard](https://www.anthropic.com/news/claude-fable-5-mythos-5). Les gens débattent de modèles presque AGI, d’agents, d’applications entières générées automatiquement et du prochain benchmark délirant.

Et moi, je suis là, tout content à propos du flattening de styles dans React Native.

C’est de bonne guerre.

Mais j’aime toujours ce genre de travail. Ce n’est peut-être pas une « invention » au sens spectaculaire d’une bande-annonce de film, mais rendre moins coûteux un chemin partagé d’un framework reste une vraie contribution. Énormément d’applications reposent sur ces petits chemins internes. Quand l’un d’eux devient plus simple et plus rapide, ça vaut quand même la peine de s’en réjouir.

Celui-ci concerne un chemin partagé très précis de React Native : le flattening des tableaux de styles imbriqués. Le benchmark montre que ce chemin est devenu beaucoup moins coûteux, et comme le flattening de styles est utilisé à de nombreux endroits, ça mérite qu’on s’y intéresse.

Tout est parti d’un élément très banal de React Native : les styles.

Tous les développeurs React Native ont déjà écrit quelque chose comme ça :

```tsx
<View style={[styles.container, isActive && styles.active]} />
```

Rien de spécial. Le quotidien.

Puis vous créez des composants réutilisables, vous passez des styles via les props, vous fusionnez des styles internes avec des styles externes, et soudain votre prop style n’est plus un simple tableau. Elle peut devenir un tableau dans un autre tableau, parfois sur plus d’un niveau.

En gros :

> Vous commencez avec un tableau de styles bien propre.
>
> Trois composants plus tard, on dirait une valise que quelqu’un a fermée en s’asseyant dessus.

J’ai contribué une amélioration de performance à `react/react-native`, mergée sous le nom [PR #57203](https://github.com/react/react-native/pull/57203). Elle améliore la façon dont React Native gère les tableaux de styles imbriqués dans `flattenStyle`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flattenstyle-merged.jpg"
    alt="Timeline GitHub montrant la pull request de performance de flattenStyle 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;">Le petit label violet qui a illuminé ma semaine.</figcaption>
</figure>

Le comportement reste le même. La différence, c’est que React Native évite de créer des objets intermédiaires supplémentaires pendant le flattening des tableaux imbriqués.

### Pourquoi flattenStyle compte

Au premier abord, `flattenStyle` peut ressembler à un petit helper.

Vous pensez peut-être qu’il ne compte que lorsque quelqu’un appelle manuellement `StyleSheet.flatten`.

Mais React Native utilise aussi ce chemin en interne. On peut donc le retrouver à des endroits comme :

- `Text`
- `Image`
- `ImageBackground`
- `TextInput`
- `TouchableOpacity`
- `ScrollView`
- `Animated.ScrollView`
- les props animées
- les instances publiques de Fabric
- les outils de développement comme l’element inspector et la résolution des styles dans React DevTools

Donc, si un tableau de styles imbriqué arrive dans ces chemins, améliorer `flattenStyle` signifie que React Native fait moins de travail.

Remarque importante : ça ne veut pas dire que chaque écran de chaque application devient 66 % plus rapide.

Ce serait bien. J’imprimerais le benchmark et je l’encadrerais.

L’amélioration concerne spécifiquement le flattening des tableaux de styles imbriqués. Mais c’est un chemin partagé, et c’est justement dans les chemins partagés que de petites améliorations internes peuvent compter.

### Comment apparaissent les styles imbriqués

Voici un exemple simple :

```tsx
<View
  style={[
    styles.container,
    [styles.spacing, isActive && styles.active],
    props.style,
  ]}
/>
```

Ce genre de chose arrive naturellement dans les composants d’un design system.

Un composant ajoute des styles de base. Un autre ajoute de l’espacement. Un autre transmet `props.style`. Et l’une de ces valeurs est peut-être déjà un tableau.

Personne ne se lève le matin en se disant : « Aujourd’hui, je vais créer des tableaux de styles imbriqués. »

Ça arrive, tout simplement.

Ensuite, React Native doit normaliser tout ça en un seul objet.

C’est le rôle de `flattenStyle`.

### L’ancienne approche

Avant la modification, les tableaux de styles imbriqués étaient aplatis de manière récursive.

Ça paraît correct, et ça fonctionnait correctement.

Le problème, c’est que les tableaux imbriqués pouvaient créer des objets aplatis temporaires. React Native devait ensuite fusionner ces objets temporaires dans le résultat final.

La version simplifiée ressemblait à ceci :

```js
const flattened = flattenStyle(style[i]);
if (flattened != null) {
  for (const key in flattened) {
    result[key] = flattened[key];
  }
}
```

Pour les tableaux imbriqués, React Native pouvait donc faire des allocations supplémentaires, puis des copies supplémentaires.

Même résultat, plus de travail.

C’est comme imprimer un document, le scanner, puis vous envoyer le scan par e-mail.

Techniquement, ça marche.

Émotionnellement, non.

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

### La modification

La nouvelle implémentation parcourt directement les tableaux imbriqués et écrit dans un seul objet résultat.

Au lieu d’aplatir un tableau imbriqué dans un objet temporaire puis de recopier cet objet, l’étape récursive écrit dans le même résultat cible.

Le comportement important reste le même :

- les styles objets fonctionnent toujours
- les valeurs falsy sont toujours ignorées
- les tableaux imbriqués fonctionnent toujours
- les styles placés après écrasent toujours ceux placés avant

Ce dernier point compte énormément.

L’ordre des styles fait partie de l’API de React Native. Ceci doit toujours fonctionner exactement comme les développeurs s’y attendent :

```tsx
<View style={[styles.base, styles.override]} />
```

Si les deux styles définissent la même clé, `styles.override` doit l’emporter.

La performance, c’est bien, mais pas si elle modifie discrètement le comportement des styles. Ce serait la pire forme d’« optimisation ».

### Un exemple rapide

Prenons cette structure de styles :

```tsx
[
  {color: "red", margin: 4},
  [
    {color: "blue"},
    [{padding: 8}],
  ],
]
```

Le résultat final doit être :

```tsx
{
  color: "blue",
  margin: 4,
  padding: 8,
}
```

L’ancienne implémentation pouvait créer des objets temporaires en résolvant les tableaux imbriqués.

La nouvelle implémentation arrive au même résultat en écrivant dans un seul objet.

Même sortie.

Moins de travail.

C’est tout l’intérêt.

### Résultats du benchmark

J’ai créé un petit projet de benchmark en dehors du repo React Native pour comparer l’ancienne et la nouvelle implémentation de manière isolée :

[tarikfp/rn-style-flatten-benchmark](https://github.com/tarikfp/rn-style-flatten-benchmark)

Voici les résultats présentés dans la PR :

| Scénario | Avant | Après | Évolution |
| --- | ---: | ---: | ---: |
| tableau imbriqué avec un seul style | 294.79 ms | 98.73 ms | 66.5 % plus rapide |
| tableau imbriqué avec styles fusionnés | 278.54 ms | 122.06 ms | 56.2 % plus rapide |

Les valeurs sont inférieures à 1 seconde, donc les millisecondes sont plus lisibles ici.

Encore une fois, ce benchmark mesure le travail de `flattenStyle` sur des tableaux de styles imbriqués. Il ne prétend pas qu’un rendu complet de l’application est 66 % plus rapide.

Cette distinction compte.

Les benchmarks sont utiles, mais seulement s’ils sont honnêtes sur ce qu’ils mesurent.

### Validation

La contribution incluait des tests unitaires ciblés pour `flattenStyle`.

Les tests couvrent le comportement qui ne doit pas changer :

- les styles objets
- les entrées falsy
- les tableaux de styles imbriqués
- l’ordre d’écrasement

L’application de benchmark avait aussi ses propres vérifications :

```sh
yarn test
```

```sh
yarn lint
```

```sh
yarn workspace style-flatten-benchmark-app tsc --noEmit
```

```sh
yarn bench:compare
```

Et la commande de test de React Native était :

```sh
yarn test packages/react-native/Libraries/StyleSheet/__tests__/flattenStyle-test.js --runInBand
```

L’application de benchmark a aussi été buildée et installée sur le simulateur iOS.

### Pour conclure

C’est le genre de modification que j’aime dans le code d’un framework.

Les développeurs n’ont pas besoin d’apprendre une nouvelle API. Ils n’ont pas besoin de réécrire leurs composants. Ils n’ont pas besoin d’ajouter une prop magique en croisant les doigts.

React Native fait simplement moins de travail dans un cas qui existe déjà dans de vraies applications.

Aucun changement de comportement.

Aucune migration.

Aucun drame.

Juste moins d’objets temporaires dans un chemin partagé.

Parfois, c’est ça, toute la victoire.

