node-memoizesync
Yet another memoizer for synchronous functions.
var memoizeSync = ; { // ... return result;} var memoized = ;
Now memoized
works exactly like myExpensiveComputation
, except that
the actual computation is only performed once for each unique set of
arguments:
var result = ;// Got the result! var result2 = ;// Got the same result, and much faster this time!
The function returned by memoizeSync
invokes the wrapped function
in the context it's called in itself, so memoizeSync
even works for
memoizing a method that has access to instance variables:
{ thisname = name; thismyMethod = ;}
(Unfortunately setting Foo.prototype.myMethod = memoizeSync(...)
wouldn't work as the memoizer would be shared among all instances of
Foo
).
To distinguish different invocations (whose results need to be cached
separately) memoizeSync
relies on a naive stringification of the
arguments, which is looked up in an internally kept hash. If the
function you're memoizing takes non-primitive arguments you might want
to provide a custom argumentsStringifier
in the options argument to
memoizeSync
. Otherwise all object arguments will be considered equal
because they stringify to [object Object]
:
var memoized =
Had the custom argumentsStringifier
not been provided, the memoized
function would would have returned foo
both times.
If the argumentsStringifier
returns false, the cache will be bypassed.
Check out the custom argumentsStringifier test for another example.
Purging and expiring memoized values
You can forcefully clear a specific memoized value using the purge
method on the memoizer:
var memoized = ;var foo = ;memoized;foo = ; // Will be recomputed
memoizer.purgeAll()
clears all memoized results.
You can also specify a custom ttl (in milliseconds) on the memoized results:
var memoized = ;
In the above example the memoized value will be considered stale one
second after it has been computed, and it will be recomputed next time
memoizeSync
is invoked with the same arguments.
memoizeSync
uses node-lru-cache to
store the memoized values, and it accepts the same parameters in the
options
object.
If you want to use the length
option for lru-cache, note that the
memoized values are arrays: [exception, returnValue]
.
var memoizedFsReadFileSync = ;
The LRU instance is exposed in the cache
property of the memoized
function in case you need to access it.
Installation
Make sure you have node.js and npm installed, then run:
npm install memoizesync
Browser compatibility
memoizeSync
uses the UMD wrapper, so it should also work in
browsers. You should also have the node-lru-cache
included:
lru-cache
uses Object.defineProperty
and doesn't include an UMD
wrapper, but if you define a shims
config it should be possible to
get it memoizeSync working with require.js, at least in newer browsers.
License
3-clause BSD license -- see the LICENSE
file for details.