# React Native'de Stiller %66 Hızlandı

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

Evet, %66 daha hızlı.

Ama "uygulamanızdaki her ekran %66 daha hızlı render ediliyor" anlamında değil. Öyle olsaydı benimle konuşulmazdı.

Bir de evet, 2026'da bunun kulağa komik geldiğinin farkındayım.

Yapay zeka haberlerinin beş dakikada bir değiştiği bir dönemdeyiz. [Claude Fable 5 yayınlandı ve birkaç gün sonra askıya alındı](https://www.anthropic.com/news/claude-fable-5-mythos-5). İnsanlar AGI'ye yakın modelleri, agent'ları, baştan sona üretilen uygulamaları ve sıradaki çılgın benchmark neyse onu tartışıyor.

Ben de burada React Native'de stil düzleştirme (style flattening) konusunda heyecanlıyım.

Haklısınız.

Ama bu tür işleri yine de seviyorum. Belki film fragmanlarındaki gibi dramatik bir "icat" değil, ama ortak bir framework yolunu daha ucuz hale getirmek yine de gerçek bir katkı. Pek çok uygulama bu küçük iç yolların üzerinde duruyor. Bunlardan biri daha sade ve daha hızlı hale geldiğinde, buna sevinmeye değer.

Bu yazı React Native'deki çok belirli bir ortak yolla ilgili: iç içe stil dizilerini düzleştirmek. Benchmark bu yolun ciddi şekilde ucuzladığını gösteriyor ve stil düzleştirme pek çok yerde kullanıldığı için bu hâlâ önemsenmeye değer.

Her şey React Native'deki çok sıradan bir şeyle başladı: stiller.

Her React Native geliştiricisi şuna benzer bir şey yazmıştır:

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

Özel bir şey yok. Gündelik hayat.

Sonra yeniden kullanılabilir component'ler yazarsınız, stilleri props üzerinden geçirirsiniz, içerideki stilleri dışarıdan gelenlerle birleştirirsiniz ve bir bakmışsınız style prop'unuz artık sadece bir dizi değil. Başka bir dizinin içinde bir dizi olabilir, bazen birden fazla seviye derinlikte.

Kısacası:

> Temiz bir stil dizisiyle başlarsınız.
>
> Üç component sonra, valizi üstüne oturarak kapatmaya çalışan birinin eseri gibi görünür.

`react/react-native` reposuna bir performans iyileştirmesi katkısında bulundum ve [PR #57203](https://github.com/react/react-native/pull/57203) olarak merge edildi. Bu değişiklik, React Native'in `flattenStyle` içinde iç içe stil dizilerini işleme şeklini iyileştiriyor.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flattenstyle-merged.jpg"
    alt="flattenStyle performans pull request'inin React Native'e merge edildiğini gösteren GitHub zaman akışı"
    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;">Haftamı güzelleştiren küçük mor etiket.</figcaption>
</figure>

Davranış aynı kalıyor. Fark şu: React Native artık iç içe dizileri düzleştirirken fazladan ara nesneler oluşturmuyor.

### flattenStyle neden önemli

İlk bakışta `flattenStyle` küçük bir yardımcı fonksiyon gibi gelebilir.

Sadece biri elle `StyleSheet.flatten` çağırdığında önemli olduğunu düşünebilirsiniz.

Ama React Native bu yolu kendi içinde de kullanıyor. Yani şu gibi yerlerde karşınıza çıkabilir:

- `Text`
- `Image`
- `ImageBackground`
- `TextInput`
- `TouchableOpacity`
- `ScrollView`
- `Animated.ScrollView`
- animated props
- Fabric public instance'ları
- element inspector ve React DevTools'un stil çözümlemesi gibi geliştirici araçları

Yani iç içe bir stil dizisi bu yollara ulaşıyorsa, `flattenStyle`'ı iyileştirmek React Native'in daha az iş yapması demek.

Önemli not: bu, her uygulamadaki her ekranın %66 hızlandığı anlamına gelmiyor.

Güzel olurdu. Benchmark'ı basıp çerçeveletirdim.

İyileştirme özellikle iç içe stil dizilerinin düzleştirilmesiyle ilgili. Yine de bu ortak bir yol ve küçük iç iyileştirmelerin fark yaratabildiği yerler tam da ortak yollar.

### İç içe stiller nasıl oluşuyor

Basit bir örnek:

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

Bu tür şeyler design system component'lerinde kendiliğinden oluşabiliyor.

Bir component temel stilleri ekler. Bir diğeri boşlukları ekler. Bir başkası `props.style`'ı geçirir. Belki bu değerlerden biri zaten bir dizidir.

Kimse sabah kalkıp "Bugün iç içe stil dizileri oluşturacağım" demiyor.

Sadece oluyor.

Sonra React Native'in bunu tek bir nesneye normalize etmesi gerekiyor.

`flattenStyle`'ın işi de bu.

### Eski yaklaşım

Değişiklikten önce iç içe stil dizileri recursive olarak düzleştiriliyordu.

Kulağa makul geliyor ve doğru da çalışıyordu.

Sorun şuydu: iç içe diziler geçici, düzleştirilmiş nesneler oluşturabiliyordu. Sonra React Native bu geçici nesneleri nihai sonuca birleştirmek zorunda kalıyordu.

Sadeleştirilmiş hali şöyleydi:

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

Yani iç içe dizilerde React Native fazladan bellek ayırıp (allocation) ardından fazladan kopyalama yapabiliyordu.

Aynı sonuç, daha fazla iş.

Bir belgeyi yazdırıp, taratıp, sonra taranmış halini kendinize e-postayla göndermek gibi.

Teknik olarak çalışıyor.

Duygusal olarak, hayır.

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

### Değişiklik

Yeni implementasyon iç içe dizileri doğrudan tek bir sonuç nesnesine yazarak dolaşıyor.

İç içe bir diziyi önce geçici bir nesneye düzleştirip sonra o nesneyi tekrar kopyalamak yerine, recursive adım aynı hedef sonuca yazıyor.

Önemli davranışlar yine aynı kalıyor:

- nesne stilleri hâlâ çalışıyor
- falsy değerler hâlâ yok sayılıyor
- iç içe diziler hâlâ çalışıyor
- sonraki stiller hâlâ öncekileri eziyor

Sonuncusu çok önemli.

Stil sırası React Native API'sinin bir parçası. Bu kod hâlâ tam olarak geliştiricilerin beklediği gibi çalışmalı:

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

İki stil de aynı key'i tanımlıyorsa `styles.override` kazanmalı.

Performans güzel, ama stil davranışını sessizce değiştiriyorsa değil. Bu, en kötü türden bir "optimizasyon" olurdu.

### Kısa bir örnek

Şu stil yapısını ele alalım:

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

Nihai sonuç şu olmalı:

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

Eski implementasyon iç içe dizileri çözerken geçici nesneler oluşturabiliyordu.

Yeni implementasyon tek bir nesneye yazarak aynı sonuca ulaşıyor.

Aynı çıktı.

Daha az iş.

Bütün mesele bu.

### Benchmark sonuçları

Eski ve yeni implementasyonları izole şekilde karşılaştırabilmek için React Native reposunun dışında küçük bir benchmark projesi hazırladım:

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

PR'daki sonuçlar şunlardı:

| Senaryo | Önce | Sonra | Değişim |
| --- | ---: | ---: | ---: |
| iç içe tekil stil dizisi | 294.79 ms | 98.73 ms | %66.5 daha hızlı |
| iç içe birleştirilmiş stil dizisi | 278.54 ms | 122.06 ms | %56.2 daha hızlı |

Sayılar 1 saniyenin altında olduğu için burada milisaniye okumak daha kolay.

Tekrar söyleyeyim, bu benchmark iç içe stil dizileri için `flattenStyle`'ın yaptığı işi ölçüyor. Tüm uygulamanın render'ının %66 hızlandığını iddia etmiyor.

Bu ayrım önemli.

Benchmark'lar faydalıdır, ama yalnızca neyi ölçtükleri konusunda dürüst olduklarında.

### Doğrulama

Katkı, `flattenStyle` için odaklı unit testler de içeriyordu.

Testler değişmemesi gereken davranışları kapsıyor:

- nesne stilleri
- falsy girdiler
- iç içe stil dizileri
- ezme (override) sırası

Benchmark uygulamasının da kendi kontrolleri vardı:

```sh
yarn test
```

```sh
yarn lint
```

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

```sh
yarn bench:compare
```

React Native test komutu da şuydu:

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

Benchmark uygulaması ayrıca build alınıp iOS simulator'a yüklendi.

### Son düşünceler

Framework kodunda sevdiğim değişiklik türü bu.

Geliştiricilerin yeni bir API öğrenmesi gerekmiyor. Component'leri yeniden yazmaları gerekmiyor. Sihirli bir prop ekleyip en iyisini ummaları gerekmiyor.

React Native, gerçek uygulamalarda zaten var olan bir durum için sadece daha az iş yapıyor.

Davranış değişikliği yok.

Migration yok.

Drama yok.

Ortak bir yolda sadece daha az geçici nesne.

Bazen kazanç tam olarak bundan ibaret.

