@omni-tools/mem v6.0.0-alpha.4
Mem
(Memory Expirable Memoize) :floppy_disk:
Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input
Memory is automatically released when an item expires.
:loudspeaker: This is a fork of @Sindresorhus mem
package. It adds possibility to have non static max age, and a extend max age on access. (with a throttle mecanism)
So far its still kind of experiment, but It might end up to be merged :slightly_smiling_face:
Install
$ npm install @omni-tools/mem
Usage
const mem = require('@omni-tools/mem');
let i = 0;
const counter = () => ++i;
const memoized = mem(counter);
memoized('foo'); //=> 1
// Cached as it's the same arguments
memoized('foo'); //=> 1
// Not cached anymore as the arguments changed
memoized('bar'); //=> 2
memoized('bar'); //=> 2
Works fine with promise returning functions
const mem = require('@omni-tools/mem');
let i = 0;
const counter = async () => ++i;
const memoized = mem(counter);
(async () => {
console.log(await memoized()); //=> 1
// The return value didn't increase as it's cached
console.log(await memoized()); //=> 1
})();
const mem = require('@omni-tools/mem');
const got = require('got');
const delay = require('delay');
const memGot = mem(got, {maxAge: 1000});
(async () => {
await memGot('sindresorhus.com');
// This call is cached
await memGot('sindresorhus.com');
await delay(2000);
// This call is not cached as the cache has expired
await memGot('sindresorhus.com');
})();
API
mem(fn, options?)
fn
: Function to be memoized. (Type:Function
)options
: Diverses option to customize memoizing behavior (Type:object
, default:{}
) you'll find bellow the different available options
maxAge
Configuration for the maxAge
configuration mecanism
Originaly just the Milliseconds until the cache expires.
- Type: (
number
|function
|object
) - Default:
Infinity
More complex options can be now used, as you can now provide as maxAge
:
- a
function
: this one will be injected thekey
and should return the moment(timestamp) at which the item should expire - an
object
: this one is necessary to configure the refresh mecanism on acessttl
: the ttl attached to new item. (this is the equivalent for simplenumber
maxAge
)expirationDate
: function to compute the expiration data for new item with givenkey
(value returned bycacheKey
function)extendOnAccess
: increment to be added tomaxAge
of item being accessed (Type:number
)setOnAccess
: Function that will determine the newmaxAge
for the object being accessed. (Type:(key:string, currentMaxAge:number) => future_max_age:numver
)extensionThrottle
: throttle the extension ofmaxAge
of the object being accessed (Type:number|boolean
) if value istrue
, default throttle value of 1 second will be applied. if some number is given, any access to the item will not cause amaxAge
extension until the end of this cooldown (in millisecond)
cacheKey
Determines the cache key for storing the result based on the function arguments.
- Type:
Function
By default, if there's only one argument and it's a primitive, it's used directly as a key (if it's a function
, its reference will be used as key), otherwise it's all the function arguments JSON stringified as an array.
You could for example change it to only cache on the first argument x => JSON.stringify(x)
.
cache
Specify the cache object to use
- Type:
object
- Default:
new Map()
Use a different cache storage. Must implement the following methods: .has(key)
, .get(key)
, .set(key, value)
, .delete(key)
, and optionally .clear()
. You could for example use a WeakMap
instead or quick-lru
for a LRU cache.
cachePromiseRejection
Cache rejected promises.
- Type:
boolean
- Default:
true
mem.clear(fn)
Clear all cached data of a memoized function.
fn
: Some Memoized function.(Type:Function
)
Tips
Cache statistics
If you want to know how many times your cache had a hit or a miss, you can make use of stats-map as a replacement for the default cache.
Example
const mem = require('@omni-tools/mem');
const StatsMap = require('stats-map');
const got = require('got');
const cache = new StatsMap();
const memGot = mem(got, {cache});
(async () => {
await memGot('sindresorhus.com');
await memGot('sindresorhus.com');
await memGot('sindresorhus.com');
console.log(cache.stats); //=> {hits: 2, misses: 1}
})();
Related
- p-memoize - Memoize promise-returning & async functions
5 years ago
5 years ago
5 years ago
5 years ago
5 years ago