# Styles werden 66% sneller in React Native

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

Ja, 66% sneller.

Niet "elk scherm in je app rendert 66% sneller" sneller. Als dat zo was, zou er met mij niet meer te praten zijn.

En ja, ik weet dat dit in 2026 een beetje grappig klinkt.

We leven in een tijd waarin AI-nieuws elke vijf minuten verandert. [Claude Fable 5 werd gelanceerd en een paar dagen later alweer opgeschort](https://www.anthropic.com/news/claude-fable-5-mythos-5). Mensen discussiëren over bijna-AGI-modellen, agents, complete apps die gegenereerd worden en wat de volgende waanzinnige benchmark ook maar is.

En ik zit hier enthousiast te worden van het flattenen van styles in React Native.

Terecht.

Maar ik hou nog steeds van dit soort werk. Misschien is het geen "uitvinding" in de dramatische zin van een filmtrailer, maar een gedeeld pad in een framework goedkoper maken is nog steeds een echte bijdrage. Heel veel apps draaien bovenop deze kleine interne paden. Als een daarvan eenvoudiger en sneller wordt, is dat nog steeds iets om blij mee te zijn.

Dit stuk gaat over een heel specifiek gedeeld pad in React Native: het flattenen van geneste style-arrays. De benchmark laat zien dat dat pad een stuk goedkoper is geworden, en omdat style flattening op veel plekken gebruikt wordt, is dat nog steeds de moeite waard.

Het begon met iets heel gewoons in React Native: styles.

Elke React Native-developer heeft ooit zoiets geschreven:

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

Niets bijzonders. Gewoon het dagelijks leven.

Dan bouw je herbruikbare components, geef je styles door via props, voeg je interne styles samen met externe styles, en ineens is je style-prop niet meer zomaar een array. Het kan een array binnen een andere array worden, soms zelfs meer dan één niveau diep.

Kortom:

> Je begint met een nette style-array.
>
> Drie components later lijkt het alsof iemand een koffer heeft dichtgekregen door erop te gaan zitten.

Ik heb een performanceverbetering bijgedragen aan `react/react-native`, gemerged als [PR #57203](https://github.com/react/react-native/pull/57203). Die verbetert hoe React Native geneste style-arrays afhandelt in `flattenStyle`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flattenstyle-merged.jpg"
    alt="GitHub-tijdlijn waarop de pull request voor de performance van flattenStyle in React Native wordt gemerged"
    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;">Het kleine paarse label dat mijn week goed maakte.</figcaption>
</figure>

Het gedrag blijft hetzelfde. Het verschil is dat React Native geen extra tussenliggende objecten meer aanmaakt bij het flattenen van geneste arrays.

### Waarom flattenStyle ertoe doet

In eerste instantie klinkt `flattenStyle` misschien als een kleine helper.

Je denkt misschien dat het alleen uitmaakt als iemand handmatig `StyleSheet.flatten` aanroept.

Maar React Native gebruikt dit pad ook intern. Het kan dus opduiken op plekken zoals:

- `Text`
- `Image`
- `ImageBackground`
- `TextInput`
- `TouchableOpacity`
- `ScrollView`
- `Animated.ScrollView`
- animated props
- Fabric public instances
- developer tooling zoals de element inspector en het resolven van styles in React DevTools

Als een geneste style-array deze paden bereikt, betekent een betere `flattenStyle` dus dat React Native minder werk doet.

Belangrijk: dit betekent niet dat elk scherm in elke app 66% sneller wordt.

Zou mooi zijn. Dan zou ik de benchmark uitprinten en inlijsten.

De verbetering geldt specifiek voor het flattenen van geneste style-arrays. Toch is dit een gedeeld pad, en juist bij gedeelde paden kunnen kleine interne verbeteringen ertoe doen.

### Hoe geneste styles ontstaan

Hier is een eenvoudig voorbeeld:

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

Zoiets ontstaat vanzelf in components van een design system.

Eén component voegt basisstyles toe. Een ander voegt spacing toe. Weer een ander geeft `props.style` door. Misschien is een van die waarden al een array.

Niemand wordt wakker en zegt: "Vandaag ga ik geneste style-arrays maken."

Het gebeurt gewoon.

Daarna moet React Native het normaliseren tot één object.

Dat is de taak van `flattenStyle`.

### De oude aanpak

Vóór de wijziging werden geneste style-arrays recursief geflattend.

Dat klinkt prima, en het werkte ook correct.

Het probleem was dat geneste arrays tijdelijke geflattende objecten konden aanmaken. Daarna moest React Native die tijdelijke objecten samenvoegen in het eindresultaat.

De vereenvoudigde versie zag er zo uit:

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

Bij geneste arrays kon React Native dus extra allocaties doen en daarna nog extra kopiëren.

Hetzelfde resultaat, meer werk.

Het is alsof je een document uitprint, het inscant en de scan daarna naar jezelf mailt.

Technisch gezien werkt het.

Emotioneel gezien niet.

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

### De wijziging

De nieuwe implementatie loopt geneste arrays direct door en schrijft alles in één resultaatobject.

In plaats van een geneste array eerst te flattenen tot een tijdelijk object en dat object daarna nog eens te kopiëren, schrijft de recursieve stap in hetzelfde doelresultaat.

Het belangrijke gedrag blijft hetzelfde:

- object-styles werken nog steeds
- falsy waarden worden nog steeds genegeerd
- geneste arrays werken nog steeds
- latere styles overschrijven nog steeds eerdere styles

Dat laatste is heel belangrijk.

De volgorde van styles is onderdeel van de API van React Native. Dit moet nog steeds precies werken zoals developers verwachten:

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

Als beide styles dezelfde key definiëren, moet `styles.override` winnen.

Performance is mooi, maar niet als het stilletjes het gedrag van styling verandert. Dat zou de ergste soort "optimalisatie" zijn.

### Een kort voorbeeld

Neem deze style-structuur:

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

Het eindresultaat moet dit zijn:

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

De oude implementatie kon tijdelijke objecten aanmaken tijdens het resolven van de geneste arrays.

De nieuwe implementatie komt tot hetzelfde resultaat en schrijft daarbij in één object.

Dezelfde output.

Minder werk.

Daar draait het om.

### Benchmarkresultaten

Ik heb buiten de React Native-repo een klein benchmarkproject gemaakt, zodat ik de oude en nieuwe implementatie los van elkaar kon vergelijken:

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

Dit waren de resultaten uit de PR:

| Scenario | Voor | Na | Verschil |
| --- | ---: | ---: | ---: |
| geneste enkele style-array | 294.79 ms | 98.73 ms | 66.5% sneller |
| geneste samengevoegde style-array | 278.54 ms | 122.06 ms | 56.2% sneller |

De getallen liggen onder de 1 seconde, dus milliseconden lezen hier makkelijker.

Nogmaals: deze benchmark meet het werk van `flattenStyle` voor geneste style-arrays. Hij beweert niet dat een volledige render van een app 66% sneller is.

Dat onderscheid doet ertoe.

Benchmarks zijn nuttig, maar alleen als ze eerlijk zijn over wat ze meten.

### Validatie

De bijdrage bevatte gerichte unit tests voor `flattenStyle`.

De tests dekken het gedrag dat niet mag veranderen:

- object-styles
- falsy entries
- geneste style-arrays
- volgorde van overschrijven

De benchmark-app had ook eigen checks:

```sh
yarn test
```

```sh
yarn lint
```

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

```sh
yarn bench:compare
```

En het testcommando voor React Native was:

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

De benchmark-app is ook gebouwd en geïnstalleerd op de iOS-simulator.

### Tot slot

Dit is het soort wijziging dat ik graag zie in frameworkcode.

Developers hoeven geen nieuwe API te leren. Ze hoeven geen components te herschrijven. Ze hoeven geen magische prop toe te voegen en op het beste te hopen.

React Native doet gewoon minder werk voor een situatie die al in echte apps voorkomt.

Geen gedragsverandering.

Geen migratie.

Geen drama.

Gewoon minder tijdelijke objecten in een gedeeld pad.

Soms is dat de hele winst.

