# Gli stili sono diventati più veloci del 66% in React Native

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

Sì, il 66% più veloci.

Non nel senso di "ogni schermata della tua app fa il render il 66% più veloce". Se succedesse, diventerei insopportabile.

E sì, lo so che nel 2026 fa un po' ridere.

Siamo nell'epoca in cui le notizie sull'AI cambiano ogni cinque minuti. [Claude Fable 5 è uscito ed è stato sospeso pochi giorni dopo](https://www.anthropic.com/news/claude-fable-5-mythos-5). La gente discute di modelli quasi AGI, di agenti, di app intere generate da zero e del prossimo benchmark folle di turno.

E io sono qui, entusiasta per il flattening degli stili in React Native.

Giusto.

Ma questo tipo di lavoro mi piace ancora. Forse non è un'"invenzione" nel senso drammatico da trailer cinematografico, ma rendere più economico un percorso condiviso di un framework è comunque un contributo reale. Tantissime app poggiano su questi minuscoli percorsi interni. Quando uno di loro diventa più semplice e più veloce, vale comunque la pena esserne contenti.

Questo riguarda un percorso condiviso molto specifico di React Native: il flattening degli array di stili annidati. Il benchmark mostra che quel percorso è diventato molto più economico, e dato che il flattening degli stili si usa in tanti punti, vale comunque la pena interessarsene.

Tutto è partito da una cosa normalissima in React Native: gli stili.

Ogni sviluppatore React Native ha scritto qualcosa del genere:

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

Niente di speciale. Vita di tutti i giorni.

Poi costruisci componenti riutilizzabili, passi gli stili tramite le props, unisci gli stili interni con quelli esterni, e all'improvviso la tua prop style non è più solo un array. Può diventare un array dentro un altro array, a volte con più di un livello di annidamento.

In pratica:

> Parti con un array di stili pulito.
>
> Tre componenti dopo, sembra una valigia chiusa sedendocisi sopra.

Ho contribuito con un miglioramento delle prestazioni a `react/react-native`, mergiato come [PR #57203](https://github.com/react/react-native/pull/57203). Migliora il modo in cui React Native gestisce gli array di stili annidati in `flattenStyle`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flattenstyle-merged.jpg"
    alt="Timeline di GitHub che mostra la pull request sulle prestazioni di flattenStyle mergiata in 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;">La piccola etichetta viola che mi ha fatto la settimana.</figcaption>
</figure>

Il comportamento resta lo stesso. La differenza è che React Native evita di creare oggetti intermedi in più durante il flattening degli array annidati.

### Perché flattenStyle conta

All'inizio `flattenStyle` può sembrare un piccolo helper.

Potresti pensare che conti solo quando qualcuno chiama a mano `StyleSheet.flatten`.

Ma React Native usa questo percorso anche internamente. Quindi può comparire in punti come:

- `Text`
- `Image`
- `ImageBackground`
- `TextInput`
- `TouchableOpacity`
- `ScrollView`
- `Animated.ScrollView`
- props animate
- istanze pubbliche di Fabric
- strumenti per sviluppatori come l'element inspector e la risoluzione degli stili in React DevTools

Quindi, se un array di stili annidato arriva a questi percorsi, migliorare `flattenStyle` significa che React Native lavora di meno.

Nota importante: questo non significa che ogni schermata di ogni app diventi il 66% più veloce.

Sarebbe bello. Stamperei il benchmark e lo incornicerei.

Il miglioramento riguarda nello specifico il flattening degli array di stili annidati. È comunque un percorso condiviso, e i percorsi condivisi sono proprio i punti in cui piccoli miglioramenti interni possono contare.

### Come nascono gli stili annidati

Ecco un esempio semplice:

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

Cose del genere capitano in modo naturale nei componenti di un design system.

Un componente aggiunge gli stili di base. Un altro aggiunge la spaziatura. Un altro passa `props.style`. Magari uno di questi valori è già un array.

Nessuno si sveglia la mattina dicendo: "Oggi creerò array di stili annidati".

Succede e basta.

Poi React Native deve normalizzare tutto in un solo oggetto.

È il compito di `flattenStyle`.

### L'approccio precedente

Prima della modifica, gli array di stili annidati venivano appiattiti in modo ricorsivo.

Sembra ragionevole, e funzionava correttamente.

Il problema era che gli array annidati potevano creare oggetti appiattiti temporanei. Poi React Native doveva unire quegli oggetti temporanei nel risultato finale.

La versione semplificata era così:

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

Quindi, per gli array annidati, React Native poteva fare allocazioni in più e poi copie in più.

Stesso risultato, più lavoro.

È come stampare un documento, scansionarlo e poi mandarti la scansione per email.

Tecnicamente funziona.

Emotivamente, no.

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

### La modifica

La nuova implementazione percorre gli array annidati scrivendo direttamente in un unico oggetto risultato.

Invece di appiattire un array annidato in un oggetto temporaneo e poi copiare di nuovo quell'oggetto, il passo ricorsivo scrive nello stesso risultato di destinazione.

Il comportamento importante resta lo stesso:

- gli stili oggetto funzionano ancora
- i valori falsy vengono ancora ignorati
- gli array annidati funzionano ancora
- gli stili successivi sovrascrivono ancora quelli precedenti

Quest'ultimo punto conta molto.

L'ordine degli stili fa parte dell'API di React Native. Questo deve continuare a funzionare esattamente come gli sviluppatori si aspettano:

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

Se entrambi gli stili definiscono la stessa chiave, deve vincere `styles.override`.

Le prestazioni sono belle, ma non se cambiano di nascosto il comportamento degli stili. Sarebbe il peggior tipo di "ottimizzazione".

### Un esempio veloce

Prendiamo questa struttura di stili:

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

Il risultato finale dovrebbe essere:

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

La vecchia implementazione poteva creare oggetti temporanei mentre risolveva gli array annidati.

La nuova implementazione arriva allo stesso risultato scrivendo in un solo oggetto.

Stesso output.

Meno lavoro.

Il punto è tutto qui.

### Risultati del benchmark

Ho creato un piccolo progetto di benchmark fuori dal repo di React Native, per confrontare la vecchia e la nuova implementazione in isolamento:

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

Questi erano i risultati riportati nella PR:

| Scenario | Prima | Dopo | Variazione |
| --- | ---: | ---: | ---: |
| array di stili annidato singolo | 294.79 ms | 98.73 ms | 66.5% più veloce |
| array di stili annidato unito | 278.54 ms | 122.06 ms | 56.2% più veloce |

I numeri sono sotto il secondo, quindi qui i millisecondi si leggono meglio.

Ripeto: questo benchmark misura il lavoro di `flattenStyle` sugli array di stili annidati. Non sostiene che il render di un'intera app sia il 66% più veloce.

Questa distinzione conta.

I benchmark sono utili, ma solo quando sono onesti su cosa misurano.

### Verifica

Il contributo includeva test unitari mirati per `flattenStyle`.

I test coprono il comportamento che non deve cambiare:

- stili oggetto
- voci falsy
- array di stili annidati
- ordine di sovrascrittura

Anche l'app di benchmark aveva i suoi controlli:

```sh
yarn test
```

```sh
yarn lint
```

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

```sh
yarn bench:compare
```

E il comando di test di React Native era:

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

L'app di benchmark è stata anche compilata e installata sul simulatore iOS.

### Considerazioni finali

È il tipo di modifica che mi piace nel codice di un framework.

Gli sviluppatori non devono imparare una nuova API. Non devono riscrivere i componenti. Non devono aggiungere qualche prop magica e sperare per il meglio.

React Native semplicemente lavora di meno in un caso che esiste già nelle app reali.

Nessun cambio di comportamento.

Nessuna migrazione.

Nessun dramma.

Solo meno oggetti temporanei in un percorso condiviso.

A volte la vittoria è tutta lì.

