# Style Jadi 66% Lebih Cepat di React Native

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

Ya, 66% lebih cepat.

Bukan dalam arti "setiap layar di aplikasimu dirender 66% lebih cepat". Kalau itu yang terjadi, saya pasti jadi orang yang tidak bisa diajak bicara.

Dan ya, saya tahu ini terdengar lucu di tahun 2026.

Kita hidup di era ketika berita AI berganti setiap lima menit. [Claude Fable 5 diluncurkan lalu ditangguhkan beberapa hari kemudian](https://www.anthropic.com/news/claude-fable-5-mythos-5). Orang-orang berdebat soal model yang mendekati AGI, agent, aplikasi utuh yang di-generate, dan benchmark gila apa pun yang muncul berikutnya.

Dan saya di sini, bersemangat soal style flattening di React Native.

Wajar.

Tapi saya tetap suka pekerjaan seperti ini. Mungkin ini bukan "penemuan" dalam arti dramatis ala trailer film, tetapi membuat jalur kode bersama di sebuah framework jadi lebih murah tetaplah kontribusi nyata. Banyak aplikasi berdiri di atas jalur internal kecil seperti ini. Saat salah satunya jadi lebih sederhana dan lebih cepat, itu tetap layak disyukuri.

Yang ini tentang satu jalur bersama yang sangat spesifik di React Native: flattening style array yang bersarang. Benchmark menunjukkan jalur itu jadi jauh lebih murah, dan karena style flattening dipakai di banyak tempat, hal itu tetap layak diperhatikan.

Semuanya berawal dari hal yang sangat biasa di React Native: style.

Setiap developer React Native pernah menulis sesuatu seperti ini:

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

Tidak ada yang istimewa. Kehidupan sehari-hari saja.

Lalu kamu membuat komponen yang reusable, meneruskan style lewat props, menggabungkan style internal dengan style eksternal, dan tiba-tiba prop style kamu bukan lagi sekadar array. Prop itu bisa menjadi array di dalam array lain, kadang lebih dari satu level.

Pada dasarnya:

> Kamu mulai dengan style array yang rapi.
>
> Tiga komponen kemudian, bentuknya seperti koper yang ditutup dengan cara didudukin.

Saya menyumbangkan peningkatan performa ke `react/react-native`, yang di-merge sebagai [PR #57203](https://github.com/react/react-native/pull/57203). Perubahan ini memperbaiki cara React Native menangani style array bersarang di `flattenStyle`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flattenstyle-merged.jpg"
    alt="Timeline GitHub yang menunjukkan pull request performa flattenStyle sudah di-merge ke 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;">Label ungu kecil yang membuat minggu saya menyenangkan.</figcaption>
</figure>

Perilakunya tetap sama. Bedanya, React Native tidak lagi membuat objek perantara tambahan saat melakukan flattening pada array bersarang.

### Kenapa flattenStyle penting

Awalnya, `flattenStyle` mungkin terdengar seperti helper kecil.

Kamu mungkin mengira ini hanya penting saat seseorang memanggil `StyleSheet.flatten` secara manual.

Tapi React Native juga memakai jalur ini secara internal. Jadi jalur ini bisa muncul di tempat seperti:

- `Text`
- `Image`
- `ImageBackground`
- `TextInput`
- `TouchableOpacity`
- `ScrollView`
- `Animated.ScrollView`
- animated props
- public instance Fabric
- tooling developer seperti element inspector dan resolusi style di React DevTools

Jadi kalau style array bersarang sampai ke jalur ini, memperbaiki `flattenStyle` berarti React Native melakukan lebih sedikit pekerjaan.

Catatan penting: ini tidak berarti setiap layar di setiap aplikasi jadi 66% lebih cepat.

Pasti menyenangkan kalau iya. Saya akan mencetak benchmark-nya dan membingkainya.

Peningkatannya khusus untuk flattening style array yang bersarang. Meski begitu, ini adalah jalur bersama, dan jalur bersama adalah tempat di mana peningkatan internal kecil bisa berdampak.

### Bagaimana style bersarang terjadi

Berikut contoh sederhananya:

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

Hal seperti ini bisa terjadi secara alami di komponen design system.

Satu komponen menambahkan style dasar. Komponen lain menambahkan spacing. Komponen lain lagi meneruskan `props.style`. Mungkin salah satu nilai itu sudah berupa array.

Tidak ada orang yang bangun tidur lalu berkata, "Hari ini saya akan membuat style array bersarang."

Itu terjadi begitu saja.

Lalu React Native harus menormalkannya menjadi satu objek.

Itulah tugas `flattenStyle`.

### Pendekatan lama

Sebelum perubahan ini, style array bersarang di-flatten secara rekursif.

Kedengarannya baik, dan memang berjalan dengan benar.

Masalahnya, array bersarang bisa membuat objek hasil flatten sementara. Setelah itu React Native harus menggabungkan objek sementara tersebut ke hasil akhir.

Versi sederhananya terlihat seperti ini:

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

Jadi untuk array bersarang, React Native bisa melakukan alokasi tambahan lalu penyalinan tambahan.

Hasilnya sama, kerjanya lebih banyak.

Seperti mencetak dokumen, memindainya, lalu mengirim hasil pindaian itu ke email sendiri.

Secara teknis berhasil.

Secara emosional, tidak.

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

### Perubahannya

Implementasi baru menelusuri array bersarang langsung ke satu objek hasil.

Alih-alih melakukan flatten pada array bersarang ke objek sementara lalu menyalin objek itu lagi, langkah rekursifnya menulis ke objek hasil yang sama.

Perilaku pentingnya tetap sama:

- style berupa objek tetap berfungsi
- nilai falsy tetap diabaikan
- array bersarang tetap berfungsi
- style yang belakangan tetap menimpa style sebelumnya

Poin terakhir itu sangat penting.

Urutan style adalah bagian dari API React Native. Ini harus tetap berjalan persis seperti yang diharapkan developer:

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

Kalau kedua style mendefinisikan key yang sama, `styles.override` harus menang.

Performa memang menyenangkan, tetapi tidak kalau diam-diam mengubah perilaku styling. Itu jenis "optimasi" yang paling buruk.

### Contoh singkat

Ambil struktur style ini:

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

Hasil akhirnya seharusnya:

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

Implementasi lama bisa membuat objek sementara saat me-resolve array bersarang.

Implementasi baru mencapai hasil yang sama sambil menulis ke satu objek.

Output sama.

Kerja lebih sedikit.

Itulah intinya.

### Hasil benchmark

Saya membuat proyek benchmark kecil di luar repo React Native supaya bisa membandingkan implementasi lama dan baru secara terisolasi:

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

Berikut hasil dari PR tersebut:

| Skenario | Sebelum | Sesudah | Perubahan |
| --- | ---: | ---: | ---: |
| style array tunggal bersarang | 294.79 ms | 98.73 ms | 66.5% lebih cepat |
| style array gabungan bersarang | 278.54 ms | 122.06 ms | 56.2% lebih cepat |

Angkanya di bawah 1 detik, jadi milidetik lebih mudah dibaca di sini.

Sekali lagi, benchmark ini mengukur kerja `flattenStyle` untuk style array bersarang. Benchmark ini tidak mengklaim bahwa render aplikasi secara keseluruhan jadi 66% lebih cepat.

Perbedaan itu penting.

Benchmark memang berguna, tetapi hanya kalau jujur tentang apa yang diukurnya.

### Validasi

Kontribusi ini menyertakan unit test yang terfokus untuk `flattenStyle`.

Test tersebut mencakup perilaku yang tidak boleh berubah:

- style berupa objek
- entri falsy
- style array bersarang
- urutan override

Aplikasi benchmark juga punya pengecekan sendiri:

```sh
yarn test
```

```sh
yarn lint
```

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

```sh
yarn bench:compare
```

Dan perintah test React Native-nya adalah:

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

Aplikasi benchmark juga di-build dan dipasang di simulator iOS.

### Penutup

Inilah jenis perubahan yang saya suka di kode framework.

Developer tidak perlu mempelajari API baru. Mereka tidak perlu menulis ulang komponen. Mereka tidak perlu menambahkan prop ajaib lalu berharap semuanya beres.

React Native cukup melakukan lebih sedikit pekerjaan untuk kasus yang memang sudah ada di aplikasi nyata.

Tanpa perubahan perilaku.

Tanpa migrasi.

Tanpa drama.

Hanya lebih sedikit objek sementara di jalur bersama.

Kadang, itulah seluruh kemenangannya.

