Мемоизация в React: когда PureComponent и memo спасают, а когда только шумят

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

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

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

Тема к этому моменту уже достаточно зрелая, чтобы перестать говорить о ней как о наборе магических трюков. Да, PureComponent и React.memo действительно могут ощутимо помочь. Но они помогают не всегда. Самая вредная реакция на медленный экран — услышать слово «мемоизация» и решить, что достаточно обернуть пару компонентов, чтобы проблема ушла. В неудачном месте обертка легко превращается в шум: создает ложное ощущение оптимизации, усложняет код и маскирует настоящую архитектурную проблему вместо того, чтобы решать ее.

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

Поэтому первый вопрос при разговоре о PureComponent или memo должен звучать не как «можно ли поставить это сюда», а как «какую именно лишнюю работу мы сейчас пытаемся сократить». Слишком часто мемоизацию добавляют почти рефлекторно: есть родительский компонент, есть дочерний, значит, вдруг стоит сделать дочерний PureComponent; есть функциональный компонент — давайте обернем его в memo. Формально это может даже сработать в отдельных местах. Но если за решением нет ясного понимания источника нагрузки, очень легко начать оптимизировать не то, что действительно тормозит, а то, что просто удобно было обернуть. В результате код становится умнее на вид, но не обязательно быстрее по сути.

Сам механизм прост, и именно это делает его опасно привлекательным

На базовом уровне идея PureComponent и React.memo довольно проста. Если компонент получает одни и те же входные данные, нет особого смысла повторно выполнять его render-логику и проходить через дальнейшее согласование. Значит, можно сравнить текущие props с предыдущими и, если они не изменились поверхностно, пропустить обновление. Для классов это долгое время выражалось через PureComponent, а для функциональных компонентов теперь есть React.memo, появившийся в React 16.6 буквально на днях.

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

А это уже сильно зависит от архитектуры родительского компонента: от того, как создаются объекты и массивы, как передаются callback-функции, как устроено состояние и как именно распространяются props по дереву. Если родитель на каждый рендер создает новые объекты, новые массивы и новые функции, дочерний PureComponent или memo почти ничего не выиграет. Формально данные могут быть логически теми же, но на уровне ссылок — уже новыми. Значит, shallow compare скажет: props изменились. И компонент все равно пойдет в рендер.

Мемоизация — не замена хорошей архитектуры, а ее усилитель

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

Поэтому самый важный тезис здесь звучит так: мемоизация — это не замена хорошей архитектуры, а ее усилитель. Если структура потока данных в приложении уже относительно спокойная, то PureComponent и memo помогают это спокойствие использовать. Если же архитектура шумная, мемоизация редко сможет одна сделать ее тихой.

Более того, иногда она только запутывает картину. Разработчик видит, что компонент уже обернут в оптимизацию, и начинает искать проблему где-то еще, хотя на самом деле корень все тот же: нестабильные props, слишком высокий state, тяжеловесный родитель или неудачно организованная логика обновлений. Обертка не отменяет дисциплины — она ее предполагает.

В списках и тяжелых компонентах выигрыш реален — при правильных входах

Очень хорошо мемоизация работает в списках и повторяющихся структурах, но только при правильных условиях. Это тот случай, где разговор обычно и начинается. Есть, например, экран с сотней карточек, таблица строк, список результатов поиска, лента элементов, галерея превью. Если изменение где-то наверху дерева постоянно заставляет все дочерние элементы заново проходить через рендер, экран начинает ощущаться тяжелым. И вот здесь PureComponent или memo действительно могут дать очень хороший выигрыш: карточка, строка или элемент списка получает те же props, значит, ее можно не трогать. Но срабатывает это только тогда, когда каждая карточка действительно получает те же props, а не новый объект данных, собранный на лету, или новый callback, созданный в render родителя.

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

Есть и другой класс ситуаций, где PureComponent и memo действительно спасают: тяжелые визуальные компоненты, которые сами по себе недешево рендерятся. Большие формы с множеством полей, сложные панели с графикой, виджеты с насыщенной разметкой, крупные табличные строки, блоки, где в render есть заметные вычисления. Если такой компонент часто получает одни и те же props, предотвращение лишних обновлений дает реальную экономию. Здесь важно не обманывать себя: мемоизация особенно полезна тогда, когда пропуск рендера экономит что-то ощутимое. Если компонент сам по себе очень легкий, а обновляется не так уж часто, мемоизация может не дать заметного выигрыша вообще. Она принесет разве что дополнительную когнитивную стоимость чтения кода.

Мемоизация начинает шуметь в трех типовых случаях

Вот мы и подходим к той части, где мемоизация начинает шуметь. Шум появляется в трех случаях особенно часто. Первый — когда оптимизируют крошечные и дешевые компоненты просто по привычке. Маленькая иконка, простая кнопка, текстовый блок с парой условий, элемент, который и так почти ничего не делает. Формально можно обернуть его в memo, но реальная экономия будет микроскопической, а дополнительный уровень ментальной нагрузки останется. Код становится чуть более «умным», но не обязательно более понятным или реально более быстрым. Это уже достаточно распространенная болезнь: вокруг производительности слишком много правильных слов, и потому хочется применять их там, где цена проблемы еще не достигла уровня, оправдывающего вмешательство.

Второй тип шума — когда мемоизацию используют как замену нормальной работе с данными. Скажем, есть компонент, который получает огромный объект состояния целиком. Вместо того чтобы сузить контракт и передавать только нужные данные, его просто делают PureComponent. Или есть родитель, который без причины пересобирает структуры данных, но вместо пересмотра этого поведения разработчик начинает оборачивать всех детей подряд в memo. Или есть проблема слишком высоко поднятого state, но ее пытаются лечить через запреты рендера внизу дерева. Это очень характерный архитектурный самообман. Внешне кажется, что производительность «оптимизируют». На деле происходит попытка подавить симптом без анализа причины.

Третий тип шума — это кастомные сравнения, добавляемые слишком рано или слишком широко. React.memo позволяет передавать собственную функцию сравнения props, и на бумаге это выглядит чрезвычайно привлекательно. Если shallow compare недостаточно точен, давайте напишем свой areEqual и будем сравнивать только нужные поля. Технически это вполне рабочий инструмент. Но он очень быстро становится дорогим, если используется без ясной необходимости. Во-первых, кастомное сравнение само стоит вычислений. Во-вторых, его нужно поддерживать, и оно должно оставаться синхронизированным с реальным контрактом компонента. В-третьих, оно может сделать поведение компонента менее очевидным: теперь нужно помнить не только, какие props он получает, но и по каким именно правилам он считает их «изменившимися».

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

Вопрос «ставить ли memo» — это на самом деле вопрос о форме данных

Очень важный слой этой темы — отношения мемоизации с иммутабельностью и формой данных. На практике PureComponent особенно хорошо дружит с подходом, где новые значения действительно создаются как новые объекты, а неизменившиеся остаются стабильными ссылками. Не случайно разговоры про React-производительность так часто пересекаются с разговорами про Redux, нормализацию данных и immutable mindset.

Если состояние приложения организовано так, что компонентам легко получать устойчивые куски данных, поверхностное сравнение становится удивительно сильным инструментом. Если же данные мутируют на месте или наоборот без надобности пересобираются заново целыми ветками, мемоизация теряет большую часть своего смысла. То есть вопрос «ставить ли memo» очень часто на самом деле является продолжением вопроса «насколько спокойно и предсказуемо у нас вообще устроены данные».

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

Чаще полезнее спросить не «как пропустить рендер», а «где должна жить работа»

Есть еще одна важная сторона вопроса: мемоизация в React не должна подменять разговор о том, где вообще должна жить работа. Иногда компонент тормозит не потому, что часто рендерится, а потому что внутри render делает слишком много. Форматирует тяжелые данные, сортирует, фильтрует, агрегирует, строит производные структуры, создает сложные представления на лету. В таком случае PureComponent может немного помочь, если лишние рендеры действительно есть. Но куда полезнее спросить: а почему эта работа находится здесь? нельзя ли вычислить результат раньше? нельзя ли сузить вход? нельзя ли вынести derived data на другой уровень? Если об этом не подумать, очень легко начать оптимизировать пропуски рендера, тогда как настоящая проблема — неудачное распределение вычислений по компонентам.

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

Мемоизация хороша там, где архитектура уже более или менее вменяема и нужно отполировать поведение. Если архитектура сама производит лишний шум обновлений, бороться только внизу дерева — не самый здоровый путь. Это снова та же фигура: не «memo против рендеров», а «memo на фоне уже наведенного порядка».

Каждая обертка — это маленький долг на чтение, который платит вся команда

Есть и тонкая проблема читаемости. React-код в больших проектах и так быстро обрастает уровнями абстракции: контейнеры, HOC, селекторы, провайдеры, типы, контексты, render-функции, эффекты, утилиты. Если поверх этого без разбора добавить PureComponent и memo почти ко всему, код становится чуть менее прямым для чтения. Это, конечно, не катастрофа. Но в крупной команде подобные маленькие усложнения накапливаются. Поэтому разумная мемоизация почти всегда избирательна. Она появляется там, где реально помогает или хотя бы хорошо объяснима. А не как обязательный религиозный слой «на всякий случай».

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

Почему это так важно? Потому что каждая обертка — это маленький долг на чтение, который платит вся команда, а не только тот, кто ее поставил. И этот долг должен возвращаться измеримой пользой, иначе он просто копится.

Что мемоизация не чинит, как бы ни хотелось

Иногда разработчики боятся, что без тотальной мемоизации React-приложение обязательно станет неэффективным. Это лишний страх. React вполне нормально переживает большое количество обычных рендеров, если сами компоненты разумно устроены, props стабильны, вычисления не раздуты, а состояние организовано внятно. Производительность редко ломается только от самого факта повторного вызова render. Она ломается от сочетания: тяжелый компонент, широкое обновление, нестабильные входы, лишняя работа, глубокая разметка, иногда плохая верстка и изображения. Мемоизация может отрезать часть этого пути. Но не должна становиться единственным языком разговора о производительности.

Стоит помнить, что PureComponent и memo — это оптимизация поведения компонента на границе его props, а не универсальная оптимизация всей системы. Они не решают вопрос загрузки данных, не уменьшают размер DOM сами по себе, не исправляют плохие ключи в списках, не делают тяжелую CSS-разметку легче, не спасают от дорогостоящих эффектов и не чинят лишние обновления контекста одним своим существованием. Когда об этом забывают, мемоизация превращается в символическую меру: вроде бы про производительность подумали, но реальный профиль нагрузки может оставаться почти тем же.

Мемоизация — это точный инструмент, а не амулет

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

Но мемоизация начинает шуметь, когда ее используют как ритуал вместо анализа, как замену нормальной структуре потока данных, как оправдание для слишком широких props, как пластырь на чрезмерно высокий state или как попытку спрятать тяжелую логику render под ковер. В таких случаях PureComponent и memo не делают приложение зрелее. Они просто создают впечатление, будто производительность уже взята под контроль, хотя настоящая причина тормозов может жить совсем в другом слое.

Поэтому лучший вопрос при добавлении мемоизации звучит не «можно ли тут оптимизировать», а «что именно мы здесь экономим и почему это нельзя или не стоит решить архитектурно раньше». Если на этот вопрос есть ясный ответ, PureComponent и memo действительно спасают. Если ответа нет, они почти наверняка только шумят.

Если сформулировать совсем прямо: не оборачивайте компонент в PureComponentили memo, пока не можете назвать конкретную лишнюю работу, которую обертка отрежет, — а если можете, сначала проверьте, не дешевле ли убрать эту работу через стабильные props, узкий контракт и правильно расположенное состояние.

Автор

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

Обновлено

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