React-производительность: где на самом деле тормозит интерфейс с сотней карточек

•
Опубликовано
•
17 мин чтения

Текст написан с позиции декабря 2016 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

Разговор о производительности в React очень быстро обрастает мифами. Как только интерфейс начинает вести себя тяжело, особенно если на экране появляется большая сетка карточек, подозрение почти автоматически падает на сам React. Кажется, что проблема очевидна: слишком много компонентов, слишком много виртуального DOM, слишком много перерисовок, а значит, тормозит именно библиотека. Самая вредная реакция на этот опыт — услышать слово «тормозит», увидеть сотню карточек и решить, что виноват инструмент.

Но если посмотреть на реальные интерфейсы внимательнее, становится заметно, что источник проблем обычно гораздо прозаичнее и интереснее одновременно. React действительно может участвовать в замедлении, но в большинстве случаев он оказывается не первопричиной, а усилителем уже неудачно организованного UI. Это важное различие: не React плох на ста карточках, а каждый неаккуратный слой между данными и пикселем стоит денег, и React просто делает эту стоимость видимой.

Сотня карточек — хороший пример именно потому, что это число выглядит психологически внушительно, но технически не является чем-то фантастическим. Если приложение показывает сто элементов, это еще не огромный каталог на тысячи записей и не бесконечная лента. Это вполне типичный экран: галерея, список товаров, подборка материалов, сетка пользователей, доска с превью, административный список. Если уже на таком масштабе интерфейс начинает заметно вязнуть, полезно не повторять общий рефрен про «React тормозит», а разложить проблему по слоям. Обычно выясняется, что тормозит не сама идея компонентного рендера, а то, как именно устроены данные, карточки, обновления и сопутствующая логика.

Зафиксируем сразу: цель этого текста не в том, чтобы реабилитировать React любой ценой. У компонентного подхода есть своя цена, и мы к ней вернемся. Цель — приземлить расплывчатое «у нас тормозит список» до конкретных, исправимых участков. Потому что от того, где именно сидит bottleneck, зависит, какое лечение вообще имеет смысл.

«Тормозит список» — это не диагноз, а набор очень разных сценариев

Первая ошибка почти всегда состоит в том, что производительность начинают обсуждать слишком абстрактно. В реальном интерфейсе тормозить могут очень разные вещи. Может быть медленным первичное появление списка. Может тормозить прокрутка. Может лагать реакция на фильтр или поиск. Может быть тяжелым открытие превью. Может происходить слишком долгая перерисовка при изменении одного элемента. Может задыхаться браузер из-за изображений, теней и сложной верстки. Все это внешне ощущается как «тормозит список карточек», но технически это совершенно разные сценарии. А если причины разные, то и лечение не может быть одним и тем же.

Именно поэтому первый шаг в разговоре о React-производительности должен быть очень трезвым: нужно понять, в какой момент пользователь видит проблему. Если карточки появляются медленно только при первом заходе на экран, а потом работают нормально, это одна история. Если страница изначально загружается быстро, но начинает подлагивать при прокрутке, это другая история. Если список нормален сам по себе, но любое изменение фильтра вызывает заметный рывок, это уже третья.

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

Чаще всего тормозит не рендер карточки, а работа до рендера

Очень часто самый большой вклад в тормоза дает не рендеринг карточек как таковой, а избыточная работа до рендера. Допустим, у вас есть список из ста объектов. Перед тем как показать их на экране, вы для каждого элемента вычисляете форматированные строки, сортируете, фильтруете, склеиваете классы, проходите по вложенным структурам, строите derived data, а часть вычислений еще и повторяется при каждом изменении состояния, даже если сами данные почти не изменились. Внешне кажется, что React долго рисует карточки. На деле он часто просто получает уже очень тяжелую подготовительную работу на каждый цикл обновления. Бессмысленно ругать библиотеку за медленный вывод, если проблема начинается еще до того, как JSX превратился в элементы.

Именно здесь становится важным простой вопрос: что делает ваш код на каждый рендер списка? Многие интерфейсы с сотней карточек тормозят потому, что разработчик невольно превратил рендер в место для побочных и дорогих вычислений. Внутри обхода массива начинают происходить форматирование дат, вычисление статусов, поиск по связанным данным, агрегация тегов, сортировка внутренних коллекций, создание новых функций и объектов, построение сложных инлайн-структур. Когда это происходит один раз, кажется, что все безобидно. Когда это повторяется для ста карточек при каждом изменении фильтра, размера окна, состояния поиска или выбора одного элемента, цена начинает ощущаться очень быстро.

Отсюда первый практический вывод: карточка должна получать максимально подготовленные данные и делать как можно меньше тяжелой работы сама. Чем более «глупой» в хорошем смысле является карточка, тем легче ей жить в большом списке. Если форматирование можно выполнить раньше — лучше выполнить раньше. Если список можно один раз подготовить на уровне контейнера — лучше сделать это там. Если производные значения зависят только от части данных и не меняются при каждом рендере — им не место внутри каждой карточки. React работает лучше всего там, где представление действительно получается из уже понятных и относительно дешевых входных данных, а не там, где рендер используют как кухню для переработки состояния.

Проблема списка почти всегда начинается с архитектуры состояния

Следующий частый источник тормозов — лишние перерисовки всей коллекции из-за слишком широкого обновления состояния. Это особенно заметно в приложениях, где список карточек живет рядом с поиском, фильтрами, выбором активного элемента, состоянием загрузки и какими-то UI-флагами. Если любое изменение в верхнем компоненте приводит к тому, что заново проходят через render все сто карточек, приложение очень быстро начинает ощущаться тяжелым. При этом разработчик может быть уверен, что изменилось всего одно маленькое поле. Формально так и есть. Но если дерево компонентов устроено так, что новое состояние доходит до всей коллекции без достаточных границ, React послушно запускает новый проход по значительной части списка.

Здесь нужно особенно аккуратно понимать, что означает «перерисовка». Вокруг этого слова много путаницы. React не обязательно каждый раз заново трогает реальный DOM во всей полноте. Но сам факт повторного запуска рендер-логики для большого количества карточек уже может быть ощутимым, если внутри карточек есть какая-то работа, если структура сложная или если обновления происходят часто. Поэтому разговор не сводится к упрощенной формуле «React же умный, значит, все хорошо». Да, механизм согласования помогает. Но если вы постоянно дергаете большое поддерево компонентов, он не превращает это в бесплатную операцию.

Один из самых практичных способов уменьшать такую нагрузку — внимательнее относиться к тому, как распространяется state и какие компоненты действительно должны обновляться. Если меняется строка поиска, нужно ли заново рендерить весь список мгновенно на каждый символ? Если изменилось hover-состояние одного элемента, зачем это знание поднимать слишком высоко? Если открыт модальный просмотр карточки, обязательно ли это изменение должно влиять на все карточки списка? Очень часто тормоза появляются именно потому, что состояние интерфейса организовано не по зонам ответственности, а по принципу «пусть верхний компонент знает все». В маленьком приложении это терпимо. В интерфейсе с сотней карточек — уже нет.

Отсюда второй важный вывод: производительность React-экрана почти всегда начинается с архитектуры состояния. Если данные и UI-флаги подняты слишком высоко, если любая мелочь делает корневой список «грязным», если компоненты получают новые props чаще, чем это нужно, никакие точечные оптимизации не дадут столь заметного эффекта, как более аккуратное распределение ответственности. Многие проблемы с производительностью — это на самом деле проблемы с тем, как организован поток данных, а не с тем, что карточек на экране слишком много по определению.

Стабильность props — это не эстетика, а экономика обновлений

Очень характерная ошибка в таких интерфейсах — нестабильные ссылки на данные и функции. Контейнер на каждом обновлении создает новые массивы, новые объекты конфигурации, новые callback-функции и передает их вниз в карточки. С точки зрения JavaScript это обычная практика. С точки зрения производительности списка это может стать скрытым раздражителем. Если карточка завязана на простые сравнения или просто вынуждена получать постоянно новые значения, даже когда содержательно ничего не изменилось, сохранить спокойствие списка становится сложнее. Внешне проблема может проявляться как «карточки постоянно шевелятся» в вычислительном смысле, хотя бизнес-данные почти не изменяются.

Поэтому стабильность входных данных для карточек — не абстрактная красота, а очень практическая вещь. Хорошо, когда компонент списка не пересобирает все подряд без нужды. Хорошо, когда карточка получает ровно то, что ей нужно, а не большой объект «на всякий случай». Хорошо, когда передаваемые обработчики не создаются без причины внутри плотного цикла. Хорошо, когда derived data вычисляются на более высоком уровне осмысленно, а не заново собираются внутри каждого рендера. Это уже не выглядит как экзотическая микрооптимизация, особенно если UI действительно насыщен.

Карточка — это не React-компонент, а толстое DOM-дерево

Но было бы ошибкой сводить все к JavaScript-логике. Огромная доля тормозов в интерфейсах с карточками связана с самим DOM и визуальным устройством карточек. Очень часто карточка в дизайне оказывается гораздо тяжелее, чем кажется на макете. У нее может быть много вложенных узлов, несколько уровней оберток, бейджи, иконки, счетчики, динамические подписи, элементы управления, фоновые изображения, тени, анимации наведения, обрезка текста, вычисляемые размеры и так далее. Сто карточек, каждая из которых содержит слишком толстую разметку, — это уже довольно серьезная нагрузка на браузер, даже если React как библиотека ведет себя вполне предсказуемо. И если поверх этого еще есть изображения или сложные стили, источник тормозов легко смещается в сторону layout, paint и общего поведения браузерного движка.

Это особенно заметно при прокрутке. Пользователь может воспринимать дерганую прокрутку как «React не справляется с карточками», хотя на самом деле bottleneck находится в отрисовке тяжелых DOM-деревьев, пересчете стилей или в том, как браузер обращается с изображениями и декоративными эффектами. Если каждая карточка перегружена тенями, полупрозрачностями, сложными наложениями и большими картинками, никакая компонентная модель сама по себе не спасет экран от тяжести. Здесь React выступает всего лишь поставщиком дерева интерфейса, а реальная нагрузка ложится уже на браузер.

Отсюда третий важный вывод: производительность списка карточек нельзя обсуждать отдельно от дизайна и верстки. Карточка — это не абстрактный React-компонент, а конкретный набор DOM-узлов, стилей и изображений. Иногда лучший выигрыш достигается не через трюки с shouldComponentUpdate, а через упрощение самой карточки. Меньше лишних оберток, меньше декоративного шума, аккуратнее с тяжелыми визуальными эффектами, разумнее работа с изображениями — и экран вдруг начинает ощущаться куда легче. Если смотреть только на JS-часть, этот слой проблем легко упустить.

Изображения часто оказываются не фоном проблемы, а ее центром

Отдельный разговор — изображения. Для карточек это почти всегда больная тема. Часто список включает миниатюры, превью, аватары, обложки или фотографии. И очень легко недооценить, насколько именно они портят общее ощущение производительности. Даже если React быстро построил структуру компонентов, браузеру еще нужно загрузить картинки, декодировать их, встроить в layout, иногда масштабировать. Если в список попадают слишком большие исходники, если изображения загружаются без нужного контроля, если для ста карточек сразу начинают тянуться тяжелые ресурсы, интерфейс почти неизбежно будет ощущаться грузным. Разработчик при этом может долго крутить prop-оптимизации, не замечая, что главная тяжесть лежит в медиа-слое.

Интерфейс с большим количеством изображений должен быть осторожным с тем, что и когда он показывает. Не обязательно загружать все максимально возможное сразу. Не обязательно тащить изображения большего размера, чем нужно карточке. Не обязательно считать, что сеть и декодирование бесплатны. Когда список карточек тормозит при появлении или при быстрой прокрутке, изображение часто оказывается не фоном ситуации, а ее центральным участником.

Точечные оптимизации помогают, но не заменяют здравой структуры

Еще один популярный миф — надежда на то, что достаточно добавить несколько точечных оптимизаций, и все станет быстро без пересмотра структуры. В React-сообществе уже хорошо известны идеи вроде shouldComponentUpdate или подходов с более строгим сравнением props. Это действительно важные инструменты. Но они дают максимальный эффект не тогда, когда ими пытаются компенсировать плохую архитектуру, а когда они накладываются на уже разумную модель данных и компонентов. Если карточка получает громоздкий объект, если родитель постоянно пересоздает ей входные параметры, если внутри render идет лишняя работа, если список в целом организован тяжело, простое добавление очередной проверки обновления редко становится чудом.

И здесь стоит честно проговорить цену. shouldComponentUpdate — это не бесплатная оптимизация: сравнение props тоже выполняется на каждый цикл, а ручные проверки легко написать с ошибкой, из-за которой карточка перестанет обновляться, когда должна. Чем агрессивнее вы вмешиваетесь в решение React о перерисовке, тем больше скрытой логики появляется в местах, которые потом трудно отлаживать. Поэтому точечные оптимизации стоит включать там, где есть измеренная, реальная нагрузка, а не там, где просто хочется почувствовать, что вы «оптимизировали».

Перегруженная карточка дорого обходится при каждом массовом обновлении

Интерфейс со ста карточками часто страдает от того, что в карточку постепенно запихивают слишком много ответственности. Она перестает быть просто блоком представления и начинает знать про выделение, асинхронные действия, меню, внутренние вычисления, трекинг, форматирование, дополнительные подзагрузки, контекстные правила. Кажется, что это удобно: ведь все относится к одному визуальному элементу. Но для производительности это тяжелое решение. Чем больше логики и вложенности внутри карточки, тем выше цена любого массового обновления списка. И наоборот, чем проще и дисциплинированнее карточка как единица UI, тем меньше проблем она создает в коллекции.

Это не значит, что карточка должна быть тупым шаблоном без взаимодействий. Но значит, что ей полезно иметь ясные границы. Если в карточке есть локальное состояние, оно должно быть действительно локальным. Если есть тяжелая логика, ее стоит вынести. Если есть повторяющиеся derived values, их лучше подготовить заранее. Если есть разница между данными и представлением, их не стоит смешивать. Производительность здесь тесно связана с модульностью: хорошо спроектированная карточка обычно и работает лучше, и сопровождается легче.

Вопрос не только в том, как рендерить список, но и как часто

Еще одна характерная зона тормозов — работа с фильтрами и поиском. Пользователь вводит текст в поле, а список из ста карточек при каждом символе полностью пересчитывается, пересортировывается, заново мапится и передается вниз. В небольших наборах данных это еще может быть терпимо. Но как только карточки становятся тяжелее, а фильтрация включает что-то сложнее прямого сравнения строк, интерфейс начинает ощутимо дергаться. Проблема опять же не в абстрактном существовании React, а в том, что изменения приходят слишком часто и тянут за собой слишком много работы.

Во многих случаях разумнее оптимизировать сам сценарий обновления, а не пытаться в лоб ускорить уже тяжелую операцию. Иногда полезнее не пересчитывать весь экран буквально на каждый микрошаг, если это не требуется пользовательским опытом. Иногда выигрыш дает более узкий набор данных для немедленного обновления. Иногда — более грамотное хранение производных значений. Важно увидеть, что производительность интерфейса — это не только скорость кода, но и частота работы, которую вы заставляете его выполнять. Это два разных рычага, и второй часто недооценивают.

Нельзя не упомянуть и ключи в списках. На первый взгляд это техническая деталь из документации, но в реальном экране с карточками она сильно влияет на предсказуемость обновлений. Если ключи выбраны плохо, если они нестабильны или зависят от позиции в списке в неподходящих сценариях, React труднее сохранять соответствие между предыдущим и следующим состоянием списка. Это не обязательно единственная причина лагов, но это одна из тех вещей, которые делают обновления менее спокойными, чем могли бы быть. В списках, где часто меняются фильтры, сортировка или состав элементов, корректные ключи перестают быть формальностью и становятся частью общей производительной дисциплины.

Иногда лучший рендер — это не рендерить то, что не видно

Все яснее видно и то, что большой список — это не всегда список, который нужно целиком держать на экране сразу. Хотя сто карточек еще не выглядят экстремальным числом, интерфейс все равно может выиграть от того, что в каждый момент времени живет не вся потенциальная масса элементов. Особенно если карточки тяжелые, изображения крупные, а видимая область ограничена. Идея рендерить только то, что действительно нужно пользователю прямо сейчас, постепенно становится все более практичной — не как экзотическая оптимизация для гигантских таблиц, а как здравый способ не перекладывать лишнюю работу на браузер.

Но и здесь нужно быть честным до конца. Рендерить только видимое — это не магическая кнопка «сделать быстро». За такой подход приходится платить усложнением: появляется логика расчета видимой области, возникают вопросы со скроллом, с фокусом, с доступностью, с поведением при изменении размеров. Поэтому сначала нужно честно ответить на вопрос: действительно ли проблема в количестве элементов, а не в качестве архитектуры одной карточки? Очень часто оказывается, что виртуализация лечила бы симптом, тогда как настоящая причина — толстый DOM и лишняя работа в render, которые остались бы на месте.

Производительность большого UI — это накопленная сумма мелких компромиссов

Есть и психологическая ловушка. Разработчик часто замечает тормоза только тогда, когда интерфейс уже выглядит богато: красивые карточки, много состояния, анимации, фильтры, hover-эффекты, выделения, бейджи, превью. Все это создает ощущение зрелого продукта, и потому особенно неприятно признавать, что главный источник тяжести может быть не в React и не в браузере, а в накопившихся компромиссах. Но именно так и бывает чаще всего.

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

Это превращается в небольшой набор честных вопросов к своему экрану:

  • Где вычисляются данные и не дублируются ли эти вычисления на каждый рендер?
  • Как часто обновляется список и обязаны ли все обновления быть мгновенными?
  • Насколько тяжела карточка как DOM-структура и что делают изображения?
  • Как организовано состояние и какие изменения действительно должны затрагивать всю сетку?
  • Получают ли карточки стабильные входные данные и не скрывается ли внутри render лишняя кухня?

Вывод

Если подвести итог совсем прямо, то интерфейс с сотней карточек в React чаще всего тормозит не потому, что React «не рассчитан» на такой сценарий. Он тормозит там, где смешались тяжелые карточки, лишние массовые обновления, неудачно поднятое состояние, дорогие вычисления на каждый рендер, нестабильные props, перегруженная верстка и беззаботная работа с изображениями. React лишь делает эту картину видимой, потому что организует интерфейс как систему обновлений. Но первичные проблемы почти всегда лежат в проектировании UI и данных.

И это, пожалуй, хорошая новость. Если бы причина действительно сводилась к тому, что «React не может нормально показать сто карточек», поле для улучшения было бы намного уже. На практике же возможностей много: упростить карточку, сократить лишнюю работу в render, стабилизировать входные данные, сузить область обновлений, осторожнее обращаться с изображениями, спокойнее проектировать state, использовать механизмы предотвращения лишних обновлений там, где они действительно оправданы. Разговоры про «виртуальный DOM тормозит» чаще всего оказываются слишком грубым объяснением для куда более земной и исправимой картины.

Прежде чем винить React за медленный список из ста карточек, измерьте, в какой именно момент и над какой именно работой тратится время: почти всегда тормозит не библиотека, а толстая карточка, слишком широкое обновление состояния и дорогие вычисления, которые вы заставляете повторяться на каждый рендер.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

Читайте также