Reselect vs re-reselect: когда селекторам нужен нормальный кеш по ключу

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

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

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

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

Именно здесь начинается реальное сравнение reselect и re-reselect. Первое — это стандартный инструмент для memoized selectors. Второе — надстройка, которая хранит не один мемоизированный результат, а кеш инстансов селектора по cacheKey, который возвращает keySelector. В документации re-reselect это описано прямо: cached selectors keep a cache of reselect selectors stored by cacheKey, а уникальный persisting selector instance используется для каждого ключа 1:1.

Почему вообще возникает проблема с кешем селекторов

На бумаге идея Reselect выглядит очень элегантно. Есть input selectors, есть result function, и если входы не изменились, вычисление не повторяется. Это прекрасная модель для derived data. Она отлично работает, пока у вас один и тот же селектор вызывается повторно с одними и теми же аргументами или пока жизненный цикл вызовов хорошо укладывается в простую memoization-схему.

Проблемы начинаются тогда, когда селектор используется как параметризованная функция. Например, есть список товаров, и для каждого элемента вы вызываете селектор вида selectItemById(state, id). Или есть таблица, где один и тот же селектор получает state, userId, tab или filter. Или у вас есть общий вычислитель для карточек, который зависит от state и внешнего ключа. В такой ситуации селектор уже не живет в режиме «одно вычисление на один сценарий». Он становится сервисом вычисления для множества разных ключей.

И тут оказывается, что обычная мемоизация последнего вызова — слишком слабая стратегия. Если сегодня селектор вызвали для ключа A, потом для ключа B, потом снова для A, то без keyed cache предыдущий результат для A уже потерян. Именно такой пример re-reselect приводит в документации: вызовы getData(state, itemId, 'dataA'), потом getData(state, itemId, 'dataB'), потом снова 'dataA' приводят к тому, что третий аргумент каждый раз invalidates reselect cache.

Что умеет Reselect и за что его любят

Было бы неправильно начинать сравнение с критики. Reselect популярен не случайно. Это очень удачная библиотека для memoized selector functions, она хорошо интегрируется с Redux-мышлением, позволяет хранить в состоянии минимально необходимый набор данных и вычислять derived data только тогда, когда это реально нужно. Именно за это ее и используют в Redux-приложениях уже много лет.

У Reselect сильная сторона в другом: он делает селектор не просто функцией доступа к полю стора, а вычислительным слоем. Селектор может быть composed, может переиспользоваться как вход для других селекторов, может инкапсулировать знания о форме state и может защищать интерфейс от лишних пересчетов. В простых и средних сценариях этого более чем достаточно.

Если у вас один экран, один селектор, один набор входов и predictable call pattern, никакой дополнительный keyed cache обычно не нужен. Более того, подключать отдельную библиотеку в таком случае бессмысленно. Проблема начинается не потому, что Reselect плох, а потому, что у некоторых классов задач сама форма использования селектора другая.

Где классический Reselect начинает проигрывать

Самый типичный сценарий — один селектор используется многократно с разными аргументами в рамках одного рендера или короткой последовательности ререндеров. Скажем, на странице 50 карточек, и для каждой карточки вы дергаете общий параметризованный селектор. Формально селектор остается memoized. Практически — кеш постоянно «сбивается» между разными вызовами.

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

Именно поэтому в старых обсуждениях Reselect тема размера кеша всплывала регулярно. Еще в issue о cache size пользователи прямо упирались в то, что cache size 1 не покрывает реальные сценарии фильтрации и многократного вызова с разными аргументами.

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

Почему «сделать селектор на каждый компонент» не всегда нормальный ответ

На этом этапе обычно предлагают обходной путь: создавать factory selector, то есть отдельный инстанс селектора на каждый компонент или на каждый useMemo. В некоторых случаях это действительно работает. Но это не универсальное решение, а скорее компромисс.

Во-первых, factory-подход перекладывает проблему с кеша на жизненный цикл компонентов. Вы как будто говорите: «Раз селектор не умеет нормально кешировать по ключу, я создам отдельный селектор под каждый кейс». Во-вторых, это создает дополнительный слой wiring-кода. В-третьих, если один и тот же ключ должен использоваться в разных местах, переиспользование становится менее естественным. И самое неприятное — архитектурная идея keyed cache никуда не исчезает, вы просто вручную эмулируете ее через селекторные фабрики.

Поэтому factory selectors — нормальный инструмент, но не полноценная замена keyed cache. Когда проблема действительно в том, что один selector service должен эффективно обслуживать множество ключей, ручное порождение селекторов начинает выглядеть как workaround, а не как решение.

Что делает re-reselect и почему это принципиально другой подход

re-reselect важен не как «еще один memoization helper», а как смена модели. Он не просто хранит последний результат, а создает кеш инстансов Reselect-селектора по ключу. Иначе говоря, у вас есть один публичный селектор, но под капотом он разворачивается в набор отдельных memoized selectors, каждый из которых закреплен за своим cacheKey. В документации это описано буквально: a unique persisting reselect selector instance stored in cache is used to compute data for a given cacheKey (1:1).

Это меняет все. Теперь вызов для dataA не уничтожает кеш для dataB, а вызов для user42 не ломает memoization для user17. У каждого ключа появляется собственная история вычислений. По сути, это уже не «один селектор с одним кешем», а keyed selector registry, завернутый в удобный API.

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

Почему keyed cache особенно важен в списках и таблицах

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

Представим таблицу, где для каждой строки надо получить derived status, permissions, decorated fields и набор видимых actions. С точки зрения архитектуры хочется иметь один выразительный селектор на задачу. Но с точки зрения memoization нагрузка выглядит как постоянная смена аргументов: строка 1, строка 2, строка 3, строка 4. Обычный кеш быстро теряет эффективность. Кеш по ключу, наоборот, идеально ложится на такую модель.

Поэтому именно в data-heavy интерфейсах re-reselect часто производит впечатление не «мелкой оптимизации», а наконец правильного инструмента под фактическую форму задачи.

Селекторам нужен не просто кеш, а кеш правильной формы

Это главный тезис всей темы. В производительности frontend-приложений многие проблемы возникают не потому, что кеша нет, а потому, что кеш выбран не той формы. Можно иметь memoization и все равно постоянно пересчитывать. Можно иметь cache size и все равно промахиваться мимо реального паттерна вызовов. Можно иметь derived data layer и не получать от него максимальной выгоды, потому что единица кеширования не совпадает с единицей использования.

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

Что насчет современного Reselect и нового кеша

Здесь нужна важная оговорка. В Reselect 5 появился weakMapMemoize, а затем он стал дефолтным memoizer для createSelector. Официальные релиз-ноты и документация описывают это как effectively infinite cache size, построенный на внутреннем дереве WeakMap/Map. При этом у него есть свои trade-offs: нет настройки custom equality, а срок жизни кеша определяется ссылками и garbage collection.

Но в рамках этого сравнения важно другое. Во-первых, очень много кода в реальных проектах по-прежнему мыслит категориями «классического» поведения Reselect и старой модели кеширования. Во-вторых, даже с новым memoizer проблема keyed selector semantics не всегда исчезает автоматически. У re-reselect сильная сторона не только в размере кеша, но и в самой идее selector instance reuse по cacheKey. Именно это, кстати, отдельно обсуждалось и в roadmap-дискуссиях Reselect, где re-reselect упоминали как довольно чистое решение проблем cache size и selector instance reuse.

То есть если не брать самый свежий слой вокруг нового weak-map кеширования, сравнение остается абсолютно актуальным. А если брать — вопрос просто становится тоньше: не «есть ли вообще кеш», а «какую именно форму кеша и управления selector instances вы хотите получить».

Почему re-reselect удобен именно как архитектурный инструмент

Есть разница между низкоуровневой оптимизацией и архитектурным улучшением. Низкоуровневая оптимизация говорит: «Вот здесь у нас слишком много recomputations». Архитектурное улучшение говорит: «Форма нашей задачи предполагает keyed derivation, значит, и абстракция должна быть keyed».

re-reselect хорош именно вторым. Он позволяет сформулировать селектор как сущность, зависящую не только от state, но и от логического ключа кеша. Благодаря этому код становится ближе к предметной модели. Вы больше не «надеетесь, что memoization повезет», а явно говорите: для каждого такого ключа у нас должен быть свой устойчивый селекторный кеш.

Это особенно полезно в больших проектах, где один и тот же pattern встречается снова и снова. Если команда регулярно строит селекторы по id, tab, filter, category, scope или pageKey, keyed caching перестает быть локальной оптимизацией и становится повторяющейся архитектурной потребностью.

Когда Reselect все еще достаточно

Чтобы сравнение было честным, нужно проговорить и противоположную сторону. Не каждому селектору нужен re-reselect. Если селектор вызывается редко, если у него нет реального параметризованного fan-out, если expensive computation не критична, если конкретный selector factory уже аккуратно решает задачу, а сложность keyed cache не окупается — обычного Reselect может быть вполне достаточно.

Более того, не стоит тащить keyed cache везде подряд. Он нужен там, где действительно есть повторяющиеся вызовы по разным ключам и где стабильность результата между вызовами приносит ощутимую пользу. Если такой нагрузки нет, добавление еще одного слоя абстракции может быть лишним.

Но тут важна честность: «можно жить без keyed cache» и «keyed cache не нужен» — не одно и то же. Во многих приложениях долго живут с селекторами, которые работают приемлемо, хотя уже давно просятся на более правильную модель кеширования.

Когда re-reselect почти наверняка оправдан

Есть несколько надежных признаков. Первый: один и тот же параметризованный селектор вызывается с множеством разных ключей в пределах одного экрана. Второй: вы видите лишние recomputations и потерю ссылочной стабильности в списках и таблицах. Третий: приходится плодить selector factories только ради того, чтобы обойти ограниченность обычного кеша. Четвертый: компонентный код уже начал учитывать особенности мемоизации вручную, вместо того чтобы получать их от селекторного слоя.

Пятый признак особенно характерный: вы постоянно думаете не о логике derived data, а о том, как не «сломать кеш» очередным вызовом селектора с другим параметром. Это почти всегда сигнал, что форма memoization выбрана неверно.

Дело не в моде на библиотеку, а в соответствии задаче

Спор Reselect vs re-reselect легко превратить в бессмысленное противопоставление, будто одна библиотека «лучше», а другая «хуже». На самом деле правильнее смотреть так: они решают похожую, но не идентичную задачу.

Reselect — это базовый слой мемоизированных селекторов. Он силен в derived data, композиции и обычной memoization-модели. re-reselect — это ответ на ситуацию, когда селектор должен эффективно жить в мире множества ключей. Он не заменяет всю идею Reselect, а расширяет ее до keyed cache и selector instance reuse.

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

Заключение

В 2024 году проблема селекторов давно уже не сводится к простому «мемоизировано или нет». Настоящий вопрос глубже: правильно ли выбрана стратегия кеширования для конкретной формы нагрузки. Reselect остается фундаментальным инструментом Redux-экосистемы и прекрасно решает задачу derived data в огромном числе случаев. Но там, где один и тот же селектор используется как параметризованный вычислитель для множества ключей, классическая модель кеша быстро начинает уступать.

Именно в этих сценариях re-reselect показывает свою силу. Он дает не просто еще одну мемоизацию, а кеш инстансов селектора по cacheKey. Это делает вычисления устойчивыми между разными ключами, снижает лишние recomputations, улучшает ссылочную стабильность и возвращает селектору ту форму кеша, которая действительно соответствует его использованию. Официальная документация прямо строится вокруг этой идеи keyed cache для reselect selectors.

Поэтому если сравнивать без опоры на свежие изменения вокруг default cache в актуальном Reselect, вывод очень прямой: когда селекторы работают по ключу, им и нужен нормальный кеш по ключу. И в этой задаче re-reselect не выглядит факультативным дополнением. Он выглядит как логичное продолжение той самой memoization-модели, которой базовому селектору давно не хватает.

Автор

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

Обновлено

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