re-reselect is a lightweight wrapper around Reselect meant to enhance selectors with deeper memoization and cache management.
Switching between different arguments using standard reselect selectors causes cache invalidation since default reselect cache has a limit of one.
re-reselect forwards different calls to different reselect selectors stored in cache, so that computed/memoized values are retained.
re-reselect selectors work as normal reselect selectors but they are able to determine when creating a new selector or querying a cached one on the fly, depending on the supplied arguments.
Useful to:
- retain selector's cache when sequentially called with one/few different arguments (example)
- join similar selectors into one
- share selectors with props across multiple component instances (see reselect example and re-reselect solution)
- instantiate selectors on runtime
import createCachedSelector from 're-reselect';
// Normal reselect routine: declare "inputSelectors" and "resultFunc"
const selectorA = state => state.a;
const selectorB = (state, itemName) => state.items[itemName];
const cachedSelector = createCachedSelector(
// inputSelectors
selectorA,
selectorB,
// resultFunc
(A, B) => expensiveComputation(A, B)
)(
// keySelector
// Instruct re-reselect to use "itemName" as cacheKey
(state, itemName) => itemName
);
// Use the cached selector like a normal selector:
const fooResult = cachedSelector(state, 'foo');
const barResult = cachedSelector(state, 'bar');
// 2 reselect selectors were created, called and cached behind the scenes
const fooResultAgain = cachedSelector(state, 'foo');
// fooResult === fooResultAgain
// Cache was not invalidated by calling "cachedSelector(state, 'bar')"
// "expensiveComputation" totally called twicenpm install reselect -S
npm install re-reselect -SI found myself wrapping a library of data elaboration (quite heavy stuff) with reselect selectors (getPieceOfData in the example).
On each store update, I had to repeatedly call the selector in order to retrieve all the pieces of data needed by my UI. Like this:
getPieceOfData(state, itemId, 'dataA');
getPieceOfData(state, itemId, 'dataB');
getPieceOfData(state, itemId, 'dataC');What happens, here? getPieceOfData selector cache is invalidated on each call because of the different 3rd 'dataX' argument.
re-reselect selectors keep a cache of reselect selectors and store/retrieve them by cacheKey.
cacheKey is by default a string or number but can be anything depending on the chosen cache strategy (see cache objects docs).
cacheKey is the output of keySelector, declared at selector initialization.
keySelector is a custom function which:
- takes the same arguments as the final selector (in the example:
state,itemId,'dataX') - returns a
cacheKey.
Note that the same reselect selector instance stored in cache will be used for computing data for the same cacheKey (1:1).
Back to the example, re-reselect retrieves data by querying one of the cached selectors using the 3rd argument as cacheKey, allowing cache invalidation only when state or itemId change (but not dataType):
const getPieceOfData = createCachedSelector(
state => state,
(state, itemId) => itemId,
(state, itemId, dataType) => dataType,
(state, itemId, dataType) => expensiveComputation(state, itemId, dataType)
)(
(state, itemId, dataType) => dataType // Use dataType as cacheKey
);createCachedSelector returns a selector with the same signature as a normal reselect selector.
But now, each time the selector is called, the following happens behind the scenes:
- Evaluate the
cacheKeyfor current call by executingkeySelector - Retrieve from cache the
reselectselector stored under the givencacheKey - Return found selector or create a new one if no selector was found
- Call returned selector with provided arguments
re-reselect stays completely optional and consumes your installed reselect module (reselect is declared as peer dependency).
Easy, but doesn't scale. See "join similar selectors" example.
The solution suggested in Reselect docs is fine, but it has a few downsides:
- Bloats your code by exposing both
getselectors andmakeGetselector factories - Needs to import/call selector factory instead of directly using selector
- Two different instances given the same arguments, will individually store and recompute the same result (read this)
3- Wrap your makeGetPieceOfData selector factory into a memoizer function and call the returning memoized selector
This is what re-reselect actually does! :-) It's quite verbose (since has to be repeated for each selector), that's why re-reselect is here.
Given your reselect selectors:
import {createSelector} from 'reselect';
export const getMyData = createSelector(
selectorA,
selectorB,
selectorC,
(A, B, C) => doSomethingWith(A, B, C)
);...add keySelector in the second function call:
import createCachedSelector from 're-reselect';
export const getMyData = createCachedSelector(
selectorA,
selectorB,
selectorC,
(A, B, C) => doSomethingWith(A, B, C)
)(
(state, arg1, arg2) => arg2 // Use arg2 as cacheKey
);Voilร , getMyData is ready for use!
const myData = getMyData(state, 'foo', 'bar');cacheKey is the return value of keySelector.
keySelector receives the same arguments of your inputSelectors and (by default) must return a string or number.
A few good examples and a bonus:
// Basic usage: use a single argument as cacheKey
createCachedSelector(
// ...
)(
(state, arg1, arg2, arg3) => arg3
)
// Use multiple arguments and chain them into a string
createCachedSelector(
// ...
)(
(state, arg1, arg2, arg3) => `${arg1}:${arg3}`
)
// Extract properties from an object
createCachedSelector(
// ...
)(
(state, props) => `${props.a}:${props.b}`
)Use a cacheObject which provides that feature by supplying a cacheObject option.
You can also write your own cache strategy!
How to share a selector across multiple components while passing in props and retaining memoization?
This example shows how re-reselect would solve the scenario described in reselect docs.
Just like a normal reselect selector!
re-reselect selectors expose the same reselect testing methods:
dependenciesresultFuncrecomputationsresetRecomputations
Read more about testing selectors on reselect docs.
Each re-reselect selector exposes a getMatchingSelector method which returns the underlying matching selector instance for the given arguments, instead of the result.
getMatchingSelector expects the same arguments as a normal selector call BUT returns the instance of the cached selector itself.
Once you get a selector instance you can call its public methods.
import createCachedSelector from 're-reselect';
export const getMyData = createCachedSelector(
selectorA,
selectorB,
(A, B) => doSomethingWith(A, B)
)(
(state, arg1) => arg1 // cacheKey
);
// Call your selector
const myFooData = getMyData(state, 'foo');
const myBarData = getMyData(state, 'bar');
// Call getMatchingSelector method to retrieve underlying reselect selectors
// which generated "myFooData" and "myBarData" results
const myFooDataSelector = getMyData.getMatchingSelector(state, 'foo');
const myBarDataSelector = getMyData.getMatchingSelector(state, 'bar');
// Call reselect's selectors methods
myFooDataSelector.recomputations();
myFooDataSelector.resetRecomputations();import createCachedSelector from 're-reselect';
createCachedSelector(
// ...reselect's `createSelector` arguments
)(
keySelector,
{ options }
)createCachedSelector accepts the same arguments as reselect's createSelector and returns a new function which accepts 2 arguments:
keySelector{ options }(optional)
Returns a selector instance.
import { createStructuredCachedSelector } from 're-reselect';
createStructuredCachedSelector(
// ...reselect's `createStructuredSelector` arguments
)(
keySelector,
{ options }
)createStructuredCachedSelector accepts the same arguments as reselect's createStructuredSelector and returns a new function which accepts 2 arguments:
keySelector{ options }(optional)
Returns a selector instance.
keySelector is a custom function receiving the same arguments as your selectors (and inputSelectors) and returning a cacheKey.
cacheKey is by default a string or number but can be anything depending on the chosen cache strategy (see cacheObject option).
The keySelector idea comes from Lodash's .memoize.
options is an optional object with the following properties:
Default: FlatObjectCache
An optional custom cache strategy object to handle the caching behaviour.
Read more about re-reselect's custom cache here.
An optional function describing a custom selectors. By default it uses reselect's createSelector.
A selector function providing the same API as a standard reselect selectors.
The followings are advanced methods and you won't need them for basic usage!
Retrieve the selector responding to the given arguments.
Remove from the cache the selector responding to the given arguments.
Get cacheObject instance being used by the selector (for advanced caching operations like this).
Clear whole selector cache.
Get an array containing the provided inputSelectors. Refer to relevant discussion on Reselect repo.
Get resultFunc for easily testing composed selectors.
Return the number of times the selector's result function has been recomputed.
Reset recomputations count.
Get keySelector for utility compositions or testing.
- re-reselect your whole redux state
- Understanding reselect and re-reselect
- Advanced Redux patterns: selectors
- Be selective with your state
- A swift developerโs React Native experience
- 5 key Redux libraries to improve code reuse
- Rematch's docs
- Redux re-reselect playground
- Improve TS tests readability
- More examples
Thanks to you all (emoji key):
