# Стили в React Native стали быстрее на 66%

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

Да, на 66% быстрее.

Не в смысле «каждый экран вашего приложения рендерится на 66% быстрее». Если бы так было, со мной стало бы невозможно разговаривать.

И да, я понимаю, что в 2026 году это звучит забавно.

Мы живём в эпоху, когда новости об ИИ меняются каждые пять минут. [Claude Fable 5 вышел, а через несколько дней его работу приостановили](https://www.anthropic.com/news/claude-fable-5-mythos-5). Люди спорят о моделях почти уровня AGI, об агентах, о целых сгенерированных приложениях и о том, каким будет следующий безумный бенчмарк.

А я тут радуюсь тому, как React Native «сплющивает» стили.

Справедливо.

Но я всё равно люблю такую работу. Может, это и не «изобретение» в драматичном смысле из трейлера к фильму, но сделать общий путь фреймворка дешевле всё равно настоящий вклад. Очень много приложений стоит на этих крошечных внутренних путях. Когда один из них становится проще и быстрее, этому всё равно стоит порадоваться.

Речь пойдёт об очень конкретном общем пути в React Native: flattening вложенных массивов стилей. Бенчмарк показывает, что этот путь стал гораздо дешевле, а поскольку flattening стилей используется во многих местах, это всё равно важно.

Всё началось с самой обычной для React Native вещи: стилей.

Каждый разработчик на React Native писал что-то такое:

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

Ничего особенного. Просто повседневная жизнь.

Потом вы делаете переиспользуемые компоненты, передаёте стили через props, объединяете внутренние стили с внешними, и вдруг ваш style prop уже не просто массив. Он может стать массивом внутри другого массива, иногда с вложенностью больше одного уровня.

В общем:

> Начинаете вы с аккуратного массива стилей.
>
> Через три компонента он выглядит как чемодан, который закрывали, сидя на нём.

Я внёс улучшение производительности в `react/react-native`, оно смёржено как [PR #57203](https://github.com/react/react-native/pull/57203). Оно улучшает то, как React Native обрабатывает вложенные массивы стилей в `flattenStyle`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flattenstyle-merged.jpg"
    alt="Таймлайн GitHub: pull request с улучшением производительности flattenStyle смёржен в 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;">Маленький фиолетовый ярлык, который сделал мою неделю.</figcaption>
</figure>

Поведение остаётся тем же. Разница в том, что React Native больше не создаёт лишних промежуточных объектов при flattening вложенных массивов.

### Почему flattenStyle важен

Поначалу `flattenStyle` может показаться мелкой вспомогательной функцией.

Можно подумать, что он важен только тогда, когда кто-то вручную вызывает `StyleSheet.flatten`.

Но React Native использует этот путь и внутри себя. Поэтому он может встречаться в таких местах:

- `Text`
- `Image`
- `ImageBackground`
- `TextInput`
- `TouchableOpacity`
- `ScrollView`
- `Animated.ScrollView`
- анимированные props
- публичные инстансы Fabric
- инструменты разработчика, например element inspector и разрешение стилей в React DevTools

Так что если вложенный массив стилей попадает в эти пути, улучшение `flattenStyle` означает, что React Native выполняет меньше работы.

Важное замечание: это не значит, что каждый экран в каждом приложении станет на 66% быстрее.

Было бы здорово. Я бы распечатал бенчмарк и повесил его в рамочку.

Улучшение касается именно flattening вложенных массивов стилей. Но это общий путь, а именно в общих путях маленькие внутренние улучшения и могут иметь значение.

### Откуда берутся вложенные стили

Вот простой пример:

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

Такое естественным образом случается в компонентах дизайн-системы.

Один компонент добавляет базовые стили. Другой добавляет отступы. Третий передаёт `props.style`. Возможно, одно из этих значений уже массив.

Никто не просыпается с мыслью: «Сегодня я создам вложенные массивы стилей».

Это просто происходит.

Затем React Native должен нормализовать всё это в один объект.

Это и есть работа `flattenStyle`.

### Старый подход

До изменения вложенные массивы стилей разворачивались рекурсивно.

Звучит нормально, и работало это корректно.

Проблема была в том, что вложенные массивы могли создавать временные «сплющенные» объекты. Потом React Native приходилось объединять эти временные объекты в итоговый результат.

Упрощённо это выглядело так:

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

То есть для вложенных массивов React Native мог делать лишние аллокации, а затем лишнее копирование.

Тот же результат, больше работы.

Это как распечатать документ, отсканировать его и отправить скан самому себе по почте.

Технически работает.

Эмоционально нет.

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

### Изменение

Новая реализация проходит по вложенным массивам и пишет всё сразу в один объект результата.

Вместо того чтобы разворачивать вложенный массив во временный объект, а потом снова копировать этот объект, рекурсивный шаг записывает данные в тот же целевой результат.

Важное поведение остаётся прежним:

- стили-объекты по-прежнему работают
- falsy-значения по-прежнему игнорируются
- вложенные массивы по-прежнему работают
- более поздние стили по-прежнему перекрывают более ранние

Последний пункт очень важен.

Порядок стилей это часть API React Native. Вот это должно работать ровно так, как ожидают разработчики:

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

Если оба стиля задают один и тот же ключ, побеждать должен `styles.override`.

Производительность это приятно, но не тогда, когда она тихо меняет поведение стилей. Это была бы худшая разновидность «оптимизации».

### Небольшой пример

Возьмём такую структуру стилей:

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

Итоговый результат должен быть таким:

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

Старая реализация могла создавать временные объекты, пока разбирала вложенные массивы.

Новая реализация приходит к тому же результату, записывая всё в один объект.

Тот же вывод.

Меньше работы.

В этом весь смысл.

### Результаты бенчмарка

Я сделал небольшой проект для бенчмарка вне репозитория React Native, чтобы сравнить старую и новую реализации изолированно:

[tarikfp/rn-style-flatten-benchmark](https://github.com/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-элементы
- вложенные массивы стилей
- порядок перекрытия

У приложения с бенчмарком были и свои проверки:

```sh
yarn test
```

```sh
yarn lint
```

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

```sh
yarn bench:compare
```

А команда для тестов React Native была такой:

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

Приложение с бенчмарком также было собрано и установлено на iOS simulator.

### Итоговые мысли

Именно такие изменения в коде фреймворка мне нравятся.

Разработчикам не нужно изучать новый API. Не нужно переписывать компоненты. Не нужно добавлять какой-то волшебный prop и надеяться на лучшее.

React Native просто делает меньше работы в случае, который уже встречается в реальных приложениях.

Никаких изменений поведения.

Никакой миграции.

Никакой драмы.

Просто меньше временных объектов в общем пути.

Иногда в этом и заключается весь выигрыш.

