Да, на 66% быстрее.
Не в смысле «каждый экран вашего приложения рендерится на 66% быстрее». Если бы так было, со мной стало бы невозможно разговаривать.
И да, я понимаю, что в 2026 году это звучит забавно.
Мы живём в эпоху, когда новости об ИИ меняются каждые пять минут. Claude Fable 5 вышел, а через несколько дней его работу приостановили. Люди спорят о моделях почти уровня AGI, об агентах, о целых сгенерированных приложениях и о том, каким будет следующий безумный бенчмарк.
А я тут радуюсь тому, как React Native «сплющивает» стили.
Справедливо.
Но я всё равно люблю такую работу. Может, это и не «изобретение» в драматичном смысле из трейлера к фильму, но сделать общий путь фреймворка дешевле всё равно настоящий вклад. Очень много приложений стоит на этих крошечных внутренних путях. Когда один из них становится проще и быстрее, этому всё равно стоит порадоваться.
Речь пойдёт об очень конкретном общем пути в React Native: flattening вложенных массивов стилей. Бенчмарк показывает, что этот путь стал гораздо дешевле, а поскольку flattening стилей используется во многих местах, это всё равно важно.
Всё началось с самой обычной для React Native вещи: стилей.
Каждый разработчик на React Native писал что-то такое:
<View style={[styles.container, isActive && styles.active]} />
Ничего особенного. Просто повседневная жизнь.
Потом вы делаете переиспользуемые компоненты, передаёте стили через props, объединяете внутренние стили с внешними, и вдруг ваш style prop уже не просто массив. Он может стать массивом внутри другого массива, иногда с вложенностью больше одного уровня.
В общем:
Начинаете вы с аккуратного массива стилей.
Через три компонента он выглядит как чемодан, который закрывали, сидя на нём.
Я внёс улучшение производительности в react/react-native, оно смёржено как PR #57203. Оно улучшает то, как React Native обрабатывает вложенные массивы стилей в flattenStyle.
Поведение остаётся тем же. Разница в том, что React Native больше не создаёт лишних промежуточных объектов при flattening вложенных массивов.
Почему flattenStyle важен
Поначалу flattenStyle может показаться мелкой вспомогательной функцией.
Можно подумать, что он важен только тогда, когда кто-то вручную вызывает StyleSheet.flatten.
Но React Native использует этот путь и внутри себя. Поэтому он может встречаться в таких местах:
TextImageImageBackgroundTextInputTouchableOpacityScrollViewAnimated.ScrollView- анимированные props
- публичные инстансы Fabric
- инструменты разработчика, например element inspector и разрешение стилей в React DevTools
Так что если вложенный массив стилей попадает в эти пути, улучшение flattenStyle означает, что React Native выполняет меньше работы.
Важное замечание: это не значит, что каждый экран в каждом приложении станет на 66% быстрее.
Было бы здорово. Я бы распечатал бенчмарк и повесил его в рамочку.
Улучшение касается именно flattening вложенных массивов стилей. Но это общий путь, а именно в общих путях маленькие внутренние улучшения и могут иметь значение.
Откуда берутся вложенные стили
Вот простой пример:
<View
style={[
styles.container,
[styles.spacing, isActive && styles.active],
props.style,
]}
/>
Такое естественным образом случается в компонентах дизайн-системы.
Один компонент добавляет базовые стили. Другой добавляет отступы. Третий передаёт props.style. Возможно, одно из этих значений уже массив.
Никто не просыпается с мыслью: «Сегодня я создам вложенные массивы стилей».
Это просто происходит.
Затем React Native должен нормализовать всё это в один объект.
Это и есть работа flattenStyle.
Старый подход
До изменения вложенные массивы стилей разворачивались рекурсивно.
Звучит нормально, и работало это корректно.
Проблема была в том, что вложенные массивы могли создавать временные «сплющенные» объекты. Потом React Native приходилось объединять эти временные объекты в итоговый результат.
Упрощённо это выглядело так:
const flattened = flattenStyle(style[i]);
if (flattened != null) {
for (const key in flattened) {
result[key] = flattened[key];
}
}
То есть для вложенных массивов React Native мог делать лишние аллокации, а затем лишнее копирование.
Тот же результат, больше работы.
Это как распечатать документ, отсканировать его и отправить скан самому себе по почте.
Технически работает.
Эмоционально нет.

Изменение
Новая реализация проходит по вложенным массивам и пишет всё сразу в один объект результата.
Вместо того чтобы разворачивать вложенный массив во временный объект, а потом снова копировать этот объект, рекурсивный шаг записывает данные в тот же целевой результат.
Важное поведение остаётся прежним:
- стили-объекты по-прежнему работают
- falsy-значения по-прежнему игнорируются
- вложенные массивы по-прежнему работают
- более поздние стили по-прежнему перекрывают более ранние
Последний пункт очень важен.
Порядок стилей это часть API React Native. Вот это должно работать ровно так, как ожидают разработчики:
<View style={[styles.base, styles.override]} />
Если оба стиля задают один и тот же ключ, побеждать должен styles.override.
Производительность это приятно, но не тогда, когда она тихо меняет поведение стилей. Это была бы худшая разновидность «оптимизации».
Небольшой пример
Возьмём такую структуру стилей:
[
{color: "red", margin: 4},
[
{color: "blue"},
[{padding: 8}],
],
]
Итоговый результат должен быть таким:
{
color: "blue",
margin: 4,
padding: 8,
}
Старая реализация могла создавать временные объекты, пока разбирала вложенные массивы.
Новая реализация приходит к тому же результату, записывая всё в один объект.
Тот же вывод.
Меньше работы.
В этом весь смысл.
Результаты бенчмарка
Я сделал небольшой проект для бенчмарка вне репозитория React Native, чтобы сравнить старую и новую реализации изолированно:
tarikfp/rn-style-flatten-benchmark
Вот результаты из PR:
| Сценарий | До | После | Изменение |
|---|---|---|---|
| вложенный одиночный массив стилей | 294.79 ms | 98.73 ms | на 66.5% быстрее |
| вложенный объединённый массив стилей | 278.54 ms | 122.06 ms | на 56.2% быстрее |
Значения меньше 1 секунды, поэтому здесь удобнее читать миллисекунды.
Ещё раз: этот бенчмарк измеряет работу flattenStyle для вложенных массивов стилей. Он не утверждает, что полный рендер приложения стал на 66% быстрее.
Это различие важно.
Бенчмарки полезны, но только когда честно говорят, что именно они измеряют.
Проверка
Вклад включал точечное покрытие юнит-тестами для flattenStyle.
Тесты покрывают поведение, которое не должно меняться:
- стили-объекты
- falsy-элементы
- вложенные массивы стилей
- порядок перекрытия
У приложения с бенчмарком были и свои проверки:
yarn test
yarn lint
yarn workspace style-flatten-benchmark-app tsc --noEmit
yarn bench:compare
А команда для тестов React Native была такой:
yarn test packages/react-native/Libraries/StyleSheet/__tests__/flattenStyle-test.js --runInBand
Приложение с бенчмарком также было собрано и установлено на iOS simulator.
Итоговые мысли
Именно такие изменения в коде фреймворка мне нравятся.
Разработчикам не нужно изучать новый API. Не нужно переписывать компоненты. Не нужно добавлять какой-то волшебный prop и надеяться на лучшее.
React Native просто делает меньше работы в случае, который уже встречается в реальных приложениях.
Никаких изменений поведения.
Никакой миграции.
Никакой драмы.
Просто меньше временных объектов в общем пути.
Иногда в этом и заключается весь выигрыш.