# Style w React Native są szybsze o 66%

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

Tak, szybsze o 66%.

Ale nie w sensie „każdy ekran w twojej aplikacji renderuje się o 66% szybciej”. Gdyby tak było, nie dałoby się ze mną wytrzymać.

I tak, wiem, że w 2026 roku brzmi to zabawnie.

Żyjemy w czasach, w których newsy o AI zmieniają się co pięć minut. [Claude Fable 5 wystartował, a kilka dni później został zawieszony](https://www.anthropic.com/news/claude-fable-5-mythos-5). Ludzie kłócą się o modele prawie jak AGI, o agentów, o całe aplikacje generowane od zera i o kolejny szalony benchmark.

A ja się tu ekscytuję spłaszczaniem styli w React Native.

No cóż.

Ale i tak kocham taką pracę. Może to nie jest „wynalazek” w dramatycznym sensie jak z trailera filmowego, ale sprawienie, że wspólna ścieżka we frameworku jest tańsza, to wciąż realny wkład. Mnóstwo aplikacji opiera się na takich małych wewnętrznych ścieżkach. Kiedy jedna z nich staje się prostsza i szybsza, to nadal jest powód do radości.

Ten tekst dotyczy bardzo konkretnej, wspólnej ścieżki w React Native: spłaszczania zagnieżdżonych tablic styli. Benchmark pokazuje, że ta ścieżka stała się dużo tańsza, a ponieważ spłaszczanie styli jest używane w wielu miejscach, nadal warto się tym przejmować.

Zaczęło się od czegoś zupełnie normalnego w React Native: od styli.

Każdy deweloper React Native napisał kiedyś coś takiego:

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

Nic specjalnego. Zwykła codzienność.

Potem budujesz komponenty wielokrotnego użytku, przekazujesz style przez propsy, łączysz wewnętrzne style z zewnętrznymi i nagle twój prop style nie jest już zwykłą tablicą. Może się zmienić w tablicę w innej tablicy, czasem zagnieżdżoną na więcej niż jeden poziom.

W skrócie:

> Zaczynasz od czystej tablicy styli.
>
> Trzy komponenty później wygląda jak walizka, którą ktoś domknął, siadając na niej.

Dołożyłem poprawkę wydajności do `react/react-native`, zmergowaną jako [PR #57203](https://github.com/react/react-native/pull/57203). Usprawnia ona sposób, w jaki React Native obsługuje zagnieżdżone tablice styli w `flattenStyle`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flattenstyle-merged.jpg"
    alt="Oś czasu na GitHubie pokazująca pull request z poprawką wydajności flattenStyle zmergowany do 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;">Mała fioletowa etykieta, która zrobiła mi tydzień.</figcaption>
</figure>

Zachowanie pozostaje takie samo. Różnica polega na tym, że React Native nie tworzy dodatkowych obiektów pośrednich podczas spłaszczania zagnieżdżonych tablic.

### Dlaczego flattenStyle ma znaczenie

Na pierwszy rzut oka `flattenStyle` może wyglądać na drobny helper.

Możesz pomyśleć, że ma znaczenie tylko wtedy, gdy ktoś ręcznie wywołuje `StyleSheet.flatten`.

Ale React Native używa tej ścieżki także wewnętrznie. Może się więc pojawić na przykład w:

- `Text`
- `Image`
- `ImageBackground`
- `TextInput`
- `TouchableOpacity`
- `ScrollView`
- `Animated.ScrollView`
- animowanych propsach
- publicznych instancjach Fabric
- narzędziach deweloperskich, takich jak element inspector i rozwiązywanie styli w React DevTools

Jeśli więc zagnieżdżona tablica styli trafi do tych ścieżek, usprawnienie `flattenStyle` oznacza, że React Native wykonuje mniej pracy.

Ważna uwaga: to nie znaczy, że każdy ekran w każdej aplikacji staje się o 66% szybszy.

Byłoby miło. Wydrukowałbym benchmark i oprawił go w ramkę.

Usprawnienie dotyczy konkretnie spłaszczania zagnieżdżonych tablic styli. Mimo to jest to wspólna ścieżka, a właśnie we wspólnych ścieżkach małe wewnętrzne usprawnienia mogą mieć znaczenie.

### Skąd się biorą zagnieżdżone style

Oto prosty przykład:

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

Takie rzeczy dzieją się naturalnie w komponentach design systemu.

Jeden komponent dodaje style bazowe. Inny dodaje odstępy. Jeszcze inny przekazuje `props.style`. Może któraś z tych wartości już jest tablicą.

Nikt nie budzi się rano z myślą: „Dziś stworzę zagnieżdżone tablice styli”.

To się po prostu dzieje.

A potem React Native musi to znormalizować do jednego obiektu.

Tym właśnie zajmuje się `flattenStyle`.

### Stare podejście

Przed zmianą zagnieżdżone tablice styli były spłaszczane rekurencyjnie.

Brzmi rozsądnie i działało poprawnie.

Problem polegał na tym, że zagnieżdżone tablice mogły tworzyć tymczasowe spłaszczone obiekty. Potem React Native musiał scalać te tymczasowe obiekty w wynik końcowy.

Uproszczona wersja wyglądała tak:

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

Przy zagnieżdżonych tablicach React Native mógł więc wykonywać dodatkowe alokacje, a potem dodatkowe kopiowanie.

Ten sam wynik, więcej pracy.

To jak wydrukować dokument, zeskanować go, a potem wysłać skan mailem do samego siebie.

Technicznie działa.

Emocjonalnie nie.

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

### Zmiana

Nowa implementacja przechodzi przez zagnieżdżone tablice i zapisuje wszystko bezpośrednio do jednego obiektu wynikowego.

Zamiast spłaszczać zagnieżdżoną tablicę do tymczasowego obiektu, a potem ponownie go kopiować, krok rekurencyjny zapisuje do tego samego docelowego wyniku.

Ważne zachowanie pozostaje bez zmian:

- style w postaci obiektów nadal działają
- wartości falsy są nadal ignorowane
- zagnieżdżone tablice nadal działają
- późniejsze style nadal nadpisują wcześniejsze

Ten ostatni punkt ma ogromne znaczenie.

Kolejność styli jest częścią API React Native. To powinno nadal działać dokładnie tak, jak oczekują deweloperzy:

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

Jeśli oba style definiują ten sam klucz, `styles.override` musi wygrać.

Wydajność jest miła, ale nie wtedy, gdy po cichu zmienia zachowanie styli. To byłby najgorszy rodzaj „optymalizacji”.

### Szybki przykład

Weźmy taką strukturę styli:

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

Wynik końcowy powinien wyglądać tak:

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

Stara implementacja mogła tworzyć tymczasowe obiekty podczas rozwiązywania zagnieżdżonych tablic.

Nowa implementacja dochodzi do tego samego wyniku, zapisując wszystko do jednego obiektu.

Ten sam wynik.

Mniej pracy.

O to właśnie chodzi.

### Wyniki benchmarku

Zrobiłem mały projekt benchmarkowy poza repozytorium React Native, żeby porównać starą i nową implementację w izolacji:

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

Oto wyniki z PR:

| Scenariusz | Przed | Po | Zmiana |
| --- | ---: | ---: | ---: |
| zagnieżdżona pojedyncza tablica styli | 294.79 ms | 98.73 ms | szybciej o 66.5% |
| zagnieżdżona scalana tablica styli | 278.54 ms | 122.06 ms | szybciej o 56.2% |

Wartości są poniżej 1 sekundy, więc milisekundy są tu czytelniejsze.

Jeszcze raz: ten benchmark mierzy pracę `flattenStyle` dla zagnieżdżonych tablic styli. Nie twierdzi, że cały render aplikacji jest o 66% szybszy.

To rozróżnienie ma znaczenie.

Benchmarki są przydatne, ale tylko wtedy, gdy uczciwie mówią, co mierzą.

### Weryfikacja

Kontrybucja zawierała ukierunkowane testy jednostkowe dla `flattenStyle`.

Testy obejmują zachowanie, które nie powinno się zmienić:

- style w postaci obiektów
- wartości falsy
- zagnieżdżone tablice styli
- kolejność nadpisywania

Aplikacja benchmarkowa miała też własne sprawdzenia:

```sh
yarn test
```

```sh
yarn lint
```

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

```sh
yarn bench:compare
```

A komenda testów React Native wyglądała tak:

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

Aplikację benchmarkową zbudowałem też i zainstalowałem na symulatorze iOS.

### Końcowe przemyślenia

To jest rodzaj zmiany, który lubię w kodzie frameworka.

Deweloperzy nie muszą uczyć się nowego API. Nie muszą przepisywać komponentów. Nie muszą dodawać jakiegoś magicznego propsa i liczyć, że zadziała.

React Native po prostu wykonuje mniej pracy w przypadku, który już występuje w prawdziwych aplikacjach.

Bez zmiany zachowania.

Bez migracji.

Bez dramy.

Po prostu mniej tymczasowych obiektów we wspólnej ścieżce.

Czasem to cała wygrana.

