Ja, 66 % snabbare.
Inte snabbare i betydelsen "varje skärm i din app renderas 66 % snabbare". Om det hade hänt hade det varit omöjligt att prata med mig.
Och ja, jag vet att det här låter lite komiskt 2026.
Vi lever i en tid där AI-nyheterna rör sig var femte minut. Claude Fable 5 lanserades och stängdes sedan av några dagar senare. Folk bråkar om nästan-AGI-modeller, agenter, hela appar som genereras och vad nästa galna benchmark nu är.
Och här sitter jag, peppad på style flattening i React Native.
Rimligt.
Men jag älskar fortfarande den här typen av arbete. Det är kanske ingen "uppfinning" i den dramatiska filmtrailer-betydelsen, men att göra en delad väg i ett ramverk billigare är ändå ett verkligt bidrag. Väldigt många appar vilar på de här små interna vägarna. När en av dem blir enklare och snabbare är det fortfarande värt att glädjas åt.
Den här handlar om en väldigt specifik delad väg i React Native: att platta till nästlade style-arrayer. Benchmarken visar att den vägen blev mycket billigare, och eftersom style flattening används på många ställen är det fortfarande värt att bry sig om.
Det började med något helt vanligt i React Native: styles.
Varje React Native-utvecklare har skrivit något i stil med det här:
<View style={[styles.container, isActive && styles.active]} />
Inget speciellt. Bara vardag.
Sedan bygger du återanvändbara komponenter, skickar styles via props, slår ihop interna styles med externa, och plötsligt är din style-prop inte bara en array längre. Den kan bli en array inuti en annan array, ibland mer än en nivå djupt.
I princip:
Du börjar med en ren style-array.
Tre komponenter senare ser den ut som när någon packat en resväska genom att sätta sig på den.
Jag bidrog med en prestandaförbättring till react/react-native, mergad som PR #57203. Den förbättrar hur React Native hanterar nästlade style-arrayer i flattenStyle.
Beteendet är detsamma. Skillnaden är att React Native slipper skapa extra mellanliggande objekt när nästlade arrayer plattas till.
Varför flattenStyle spelar roll
Till en början kan flattenStyle låta som en liten hjälpfunktion.
Du kanske tror att den bara spelar roll när någon manuellt anropar StyleSheet.flatten.
Men React Native använder också den här vägen internt. Så den kan dyka upp på ställen som:
TextImageImageBackgroundTextInputTouchableOpacityScrollViewAnimated.ScrollView- animerade props
- publika instanser i Fabric
- utvecklarverktyg som element inspector och style-upplösningen i React DevTools
Så om en nästlad style-array når de här vägarna betyder en förbättring av flattenStyle att React Native gör mindre arbete.
Viktigt: det betyder inte att varje skärm i varje app blir 66 % snabbare.
Det hade varit trevligt. Då hade jag skrivit ut benchmarken och ramat in den.
Förbättringen gäller specifikt tillplattning av nästlade style-arrayer. Ändå är det en delad väg, och det är just i delade vägar som små interna förbättringar kan spela roll.
Hur nästlade styles uppstår
Här är ett enkelt exempel:
<View
style={[
styles.container,
[styles.spacing, isActive && styles.active],
props.style,
]}
/>
Sådant här kan uppstå helt naturligt i komponenter i ett designsystem.
En komponent lägger till grundstyles. En annan lägger till spacing. En tredje skickar vidare props.style. Kanske är ett av de värdena redan en array.
Ingen vaknar på morgonen och tänker: "Idag ska jag skapa nästlade style-arrayer."
Det bara händer.
Sedan måste React Native normalisera det till ett enda objekt.
Det är jobbet för flattenStyle.
Det gamla sättet
Före ändringen plattades nästlade style-arrayer till rekursivt.
Det låter okej, och det fungerade korrekt.
Problemet var att nästlade arrayer kunde skapa tillfälliga tillplattade objekt. Sedan var React Native tvunget att slå ihop de tillfälliga objekten i slutresultatet.
En förenklad version såg ut så här:
const flattened = flattenStyle(style[i]);
if (flattened != null) {
for (const key in flattened) {
result[key] = flattened[key];
}
}
Så för nästlade arrayer kunde React Native göra extra allokeringar och sedan extra kopiering.
Samma resultat, mer arbete.
Det är som att skriva ut ett dokument, skanna det och sedan mejla skanningen till sig själv.
Tekniskt sett fungerar det.
Känslomässigt, nej.

Ändringen
Den nya implementationen går igenom nästlade arrayer och skriver direkt till ett enda resultatobjekt.
I stället för att platta till en nästlad array till ett tillfälligt objekt och sedan kopiera objektet igen skriver det rekursiva steget till samma målobjekt.
Det viktiga beteendet är fortfarande detsamma:
- objekt-styles fungerar fortfarande
- falsy-värden ignoreras fortfarande
- nästlade arrayer fungerar fortfarande
- senare styles skriver fortfarande över tidigare
Det sista är väldigt viktigt.
Ordningen på styles är en del av React Natives API. Det här ska fortfarande fungera exakt som utvecklare förväntar sig:
<View style={[styles.base, styles.override]} />
Om båda styles definierar samma nyckel måste styles.override vinna.
Prestanda är trevligt, men inte om det i tysthet ändrar hur styling beter sig. Det vore den värsta sortens "optimering".
Ett snabbt exempel
Ta den här style-strukturen:
[
{color: "red", margin: 4},
[
{color: "blue"},
[{padding: 8}],
],
]
Slutresultatet ska bli:
{
color: "blue",
margin: 4,
padding: 8,
}
Den gamla implementationen kunde skapa tillfälliga objekt medan den löste upp de nästlade arrayerna.
Den nya implementationen når samma resultat och skriver till ett enda objekt.
Samma output.
Mindre arbete.
Det är hela poängen.
Resultat från benchmarken
Jag gjorde ett litet benchmarkprojekt utanför React Native-repot så att jag kunde jämföra den gamla och den nya implementationen isolerat:
tarikfp/rn-style-flatten-benchmark
Så här såg resultaten ut i PR:en:
| Scenario | Före | Efter | Förändring |
|---|---|---|---|
| nästlad enkel style-array | 294.79 ms | 98.73 ms | 66.5 % snabbare |
| nästlad sammanslagen style-array | 278.54 ms | 122.06 ms | 56.2 % snabbare |
Siffrorna ligger under 1 sekund, så millisekunder är lättare att läsa här.
Än en gång: den här benchmarken mäter arbetet i flattenStyle för nästlade style-arrayer. Den påstår inte att en hel apprendering blir 66 % snabbare.
Den skillnaden spelar roll.
Benchmarks är användbara, men bara när de är ärliga om vad de mäter.
Validering
Bidraget innehöll fokuserade enhetstester för flattenStyle.
Testerna täcker beteendet som inte ska ändras:
- objekt-styles
- falsy-poster
- nästlade style-arrayer
- ordning för överskrivning
Benchmarkappen hade också egna kontroller:
yarn test
yarn lint
yarn workspace style-flatten-benchmark-app tsc --noEmit
yarn bench:compare
Och testkommandot i React Native var:
yarn test packages/react-native/Libraries/StyleSheet/__tests__/flattenStyle-test.js --runInBand
Benchmarkappen byggdes också och installerades i iOS-simulatorn.
Avslutande tankar
Det här är den typen av ändring jag gillar i ramverkskod.
Utvecklare behöver inte lära sig ett nytt API. De behöver inte skriva om komponenter. De behöver inte lägga till någon magisk prop och hoppas på det bästa.
React Native gör helt enkelt mindre arbete i ett fall som redan finns i riktiga appar.
Ingen ändring i beteende.
Ingen migrering.
Inget drama.
Bara färre tillfälliga objekt i en delad väg.
Ibland är det hela vinsten.