# Styles sind in React Native 66 % schneller geworden

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

Ja, 66 % schneller.

Nicht im Sinne von "jeder Screen in deiner App rendert 66 % schneller". Wenn das passiert wäre, könnte man mit mir nicht mehr reden.

Und ja, ich weiß, dass das 2026 ein bisschen lustig klingt.

Wir leben in einer Zeit, in der sich KI-News alle fünf Minuten überschlagen. [Claude Fable 5 kam heraus und wurde ein paar Tage später wieder ausgesetzt](https://www.anthropic.com/news/claude-fable-5-mythos-5). Die Leute streiten über fast AGI-artige Modelle, Agents, komplett generierte Apps und den nächsten verrückten Benchmark.

Und ich sitze hier und freue mich über das Flattening von Styles in React Native.

Fair.

Trotzdem liebe ich diese Art von Arbeit. Vielleicht ist es keine "Erfindung" im dramatischen Kinotrailer-Sinn, aber einen gemeinsam genutzten Framework-Pfad günstiger zu machen, ist trotzdem ein echter Beitrag. Viele Apps bauen auf diesen winzigen internen Pfaden auf. Wenn einer davon einfacher und schneller wird, darf man sich darüber freuen.

Hier geht es um einen ganz bestimmten gemeinsam genutzten Pfad in React Native: das Flattening verschachtelter Style-Arrays. Der Benchmark zeigt, dass dieser Pfad deutlich günstiger geworden ist, und weil Style-Flattening an vielen Stellen verwendet wird, lohnt es sich, darauf zu achten.

Angefangen hat alles mit etwas ganz Normalem in React Native: Styles.

Jeder React-Native-Entwickler hat schon einmal so etwas geschrieben:

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

Nichts Besonderes. Einfach Alltag.

Dann baust du wiederverwendbare Komponenten, reichst Styles über Props weiter, mischst interne Styles mit externen Styles, und plötzlich ist dein Style-Prop nicht mehr nur ein Array. Es kann ein Array in einem anderen Array werden, manchmal sogar mehr als eine Ebene tief.

Im Grunde:

> Du fängst mit einem sauberen Style-Array an.
>
> Drei Komponenten später sieht es aus, als hätte jemand einen Koffer gepackt, indem er sich draufgesetzt hat.

Ich habe eine Performance-Verbesserung zu `react/react-native` beigetragen, gemergt als [PR #57203](https://github.com/react/react-native/pull/57203). Sie verbessert, wie React Native verschachtelte Style-Arrays in `flattenStyle` verarbeitet.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flattenstyle-merged.jpg"
    alt="GitHub-Timeline, die zeigt, wie der Pull Request zur flattenStyle-Performance in React Native gemergt wurde"
    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;">Das kleine lila Label, das meine Woche gerettet hat.</figcaption>
</figure>

Das Verhalten bleibt gleich. Der Unterschied ist, dass React Native beim Flattening verschachtelter Arrays keine zusätzlichen Zwischenobjekte mehr erzeugt.

### Warum flattenStyle wichtig ist

Auf den ersten Blick klingt `flattenStyle` wie ein kleiner Helfer.

Man könnte denken, es spielt nur eine Rolle, wenn jemand `StyleSheet.flatten` von Hand aufruft.

Aber React Native nutzt diesen Pfad auch intern. Er taucht also an Stellen auf wie:

- `Text`
- `Image`
- `ImageBackground`
- `TextInput`
- `TouchableOpacity`
- `ScrollView`
- `Animated.ScrollView`
- animierte Props
- öffentliche Fabric-Instanzen
- Entwickler-Tools wie der Element Inspector und die Style-Auflösung in den React DevTools

Wenn also ein verschachteltes Style-Array bei diesen Pfaden ankommt, bedeutet ein besseres `flattenStyle`, dass React Native weniger Arbeit hat.

Wichtiger Hinweis: Das heißt nicht, dass jeder Screen in jeder App 66 % schneller wird.

Wäre schön. Ich würde den Benchmark ausdrucken und einrahmen.

Die Verbesserung betrifft speziell das Flattening verschachtelter Style-Arrays. Trotzdem ist es ein gemeinsam genutzter Pfad, und genau dort können kleine interne Verbesserungen etwas bewirken.

### Wie verschachtelte Styles entstehen

Hier ein einfaches Beispiel:

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

So etwas passiert ganz natürlich in Komponenten eines Design Systems.

Eine Komponente fügt Basis-Styles hinzu. Eine andere fügt Abstände hinzu. Eine weitere reicht `props.style` durch. Vielleicht ist einer dieser Werte schon ein Array.

Niemand wacht morgens auf und sagt: "Heute baue ich verschachtelte Style-Arrays."

Es passiert einfach.

Dann muss React Native das Ganze zu einem einzigen Objekt normalisieren.

Genau das ist die Aufgabe von `flattenStyle`.

### Der alte Ansatz

Vor der Änderung wurden verschachtelte Style-Arrays rekursiv geflattet.

Das klingt in Ordnung, und es hat auch korrekt funktioniert.

Das Problem war, dass verschachtelte Arrays temporäre, bereits geflattete Objekte erzeugen konnten. Danach musste React Native diese temporären Objekte in das Endergebnis mergen.

Vereinfacht sah das so aus:

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

Bei verschachtelten Arrays konnte React Native also zusätzliche Allokationen und danach zusätzliches Kopieren verursachen.

Gleiches Ergebnis, mehr Arbeit.

Das ist, als würdest du ein Dokument ausdrucken, es einscannen und dir den Scan dann selbst per E-Mail schicken.

Technisch funktioniert es.

Emotional nicht.

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

### Die Änderung

Die neue Implementierung läuft verschachtelte Arrays direkt durch und schreibt alles in ein einziges Ergebnisobjekt.

Statt ein verschachteltes Array in ein temporäres Objekt zu flatten und dieses Objekt dann noch einmal zu kopieren, schreibt der rekursive Schritt direkt in dasselbe Zielobjekt.

Das wichtige Verhalten bleibt gleich:

- Objekt-Styles funktionieren weiterhin
- falsy Werte werden weiterhin ignoriert
- verschachtelte Arrays funktionieren weiterhin
- spätere Styles überschreiben weiterhin frühere Styles

Der letzte Punkt ist besonders wichtig.

Die Reihenfolge der Styles ist Teil der React-Native-API. Das hier muss weiterhin genau so funktionieren, wie Entwickler es erwarten:

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

Wenn beide Styles denselben Key definieren, muss `styles.override` gewinnen.

Performance ist schön, aber nicht, wenn sie heimlich das Styling-Verhalten verändert. Das wäre die schlimmste Art von "Optimierung".

### Ein kurzes Beispiel

Nimm diese Style-Struktur:

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

Das Endergebnis sollte so aussehen:

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

Die alte Implementierung konnte beim Auflösen der verschachtelten Arrays temporäre Objekte erzeugen.

Die neue Implementierung kommt zum selben Ergebnis und schreibt dabei in ein einziges Objekt.

Gleiche Ausgabe.

Weniger Arbeit.

Darum geht es.

### Benchmark-Ergebnisse

Ich habe ein kleines Benchmark-Projekt außerhalb des React-Native-Repos gebaut, um die alte und die neue Implementierung isoliert vergleichen zu können:

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

Das waren die Ergebnisse aus dem PR:

| Szenario | Vorher | Nachher | Änderung |
| --- | ---: | ---: | ---: |
| verschachteltes einzelnes Style-Array | 294.79 ms | 98.73 ms | 66,5 % schneller |
| verschachteltes gemergtes Style-Array | 278.54 ms | 122.06 ms | 56,2 % schneller |

Die Werte liegen unter einer Sekunde, deshalb sind Millisekunden hier leichter zu lesen.

Noch einmal: Dieser Benchmark misst die Arbeit von `flattenStyle` für verschachtelte Style-Arrays. Er behauptet nicht, dass ein kompletter App-Render 66 % schneller ist.

Diese Unterscheidung ist wichtig.

Benchmarks sind nützlich, aber nur, wenn sie ehrlich sagen, was sie messen.

### Validierung

Der Beitrag enthielt gezielte Unit-Tests für `flattenStyle`.

Die Tests decken das Verhalten ab, das sich nicht ändern darf:

- Objekt-Styles
- falsy Einträge
- verschachtelte Style-Arrays
- Reihenfolge beim Überschreiben

Die Benchmark-App hatte außerdem eigene Checks:

```sh
yarn test
```

```sh
yarn lint
```

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

```sh
yarn bench:compare
```

Und der Testbefehl für React Native war:

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

Die Benchmark-App wurde außerdem gebaut und im iOS-Simulator installiert.

### Fazit

Das ist die Art von Änderung, die ich in Framework-Code mag.

Entwickler müssen keine neue API lernen. Sie müssen keine Komponenten umschreiben. Sie müssen kein magisches Prop hinzufügen und auf das Beste hoffen.

React Native macht einfach weniger Arbeit für einen Fall, den es in echten Apps längst gibt.

Keine Verhaltensänderung.

Keine Migration.

Kein Drama.

Einfach weniger temporäre Objekte in einem gemeinsam genutzten Pfad.

Manchmal ist genau das der ganze Gewinn.

