Need help with p-memoize?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

sindresorhus
249 Stars 26 Forks MIT License 38 Commits 5 Opened issues

Description

Memoize promise-returning & async functions

Services available

!
?

Need anything else?

Contributors list

# 222
exec
test-fr...
nextjs
messeng...
22 commits
# 6,646
chalk
exec
vuejs2
sketch-...
3 commits
# 2,144
GitHub
usersty...
phantom...
iphone
3 commits
# 5,583
TypeScr...
typescr...
iterm2
exec
2 commits
# 199,299
Swift
coreloc...
Sass
sqlciph...
1 commit
# 635,503
TypeScr...
JavaScr...
1 commit
# 93,350
C#
Shell
Node.js
Go
1 commit
# 7,829
TypeScr...
vscode
stringi...
exec
1 commit
# 16,742
catalin...
exec
rhythm-...
travis
1 commit
# 163,614
JavaScr...
bottom-...
Express
Koa
1 commit

p-memoize

Memoize promise-returning & async functions

Useful for speeding up consecutive function calls by caching the result of calls with identical input.

By default, only the memoized function's first argument is considered via strict equality comparison. If you need to cache multiple arguments or cache

object
s by value, have a look at alternative caching strategies below.

This package is similar to mem but with async-specific enhancements; in particular, it allows for asynchronous caches and does not cache rejected promises by default (unless the

cachePromiseRejection
option is set).

Install

$ npm install p-memoize

Usage

import {setTimeout as delay} from 'node:timer/promises';
import pMemoize from 'p-memoize';
import got from 'got';

const memoizedGot = pMemoize(got);

await memoizedGot('https://sindresorhus.com');

// This call is cached await memoizedGot('https://sindresorhus.com');

await delay(2000);

// This call is not cached as the cache has expired await memoizedGot('https://sindresorhus.com');

Caching strategy

Similar to the caching strategy for

mem
with the following exceptions:

  • Promises returned from a memoized function will be cached internally and take priority over
    cache
    if a value exists in both caches. The promise cache does not persist outside of the current instance and properties assigned to a returned promise will not be kept. All cached promises can be cleared with
    pMemoizeClear()
    .
  • .get()
    and
    .has()
    methods on
    cache
    can return a promise instead of returning a value immediately.
  • Instead of
    .set()
    being provided an object with the properties
    value
    and
    maxAge
    , it will only be provided
    value
    as the first argument. If you want to implement time-based expiry, consider doing so in
    cache
    .

API

pMemoize(fn, options?)

Returns a memoized version of the given function.

fn

Type:

Function

Promise-returning or async function to be memoized.

options

Type:

object

See the

mem
options in addition to the below option.

cachePromiseRejection

Type:

boolean
\ Default:
false

Cache rejected promises.

cacheKey

Type:

Function
\ Default:
arguments_ => arguments_[0]
\ Example:
arguments_ => JSON.stringify(arguments_)

Determines the cache key for storing the result based on the function arguments. By default, only the first argument is considered.

A

cacheKey
function can return any type supported by
Map
(or whatever structure you use in the
cache
option).

See the caching strategy section for more information.

cache

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.

See the caching strategy section in the

mem
package for more information.

pMemoizeDecorator(options)

Returns a decorator to memoize class methods or static class methods.

Notes:

  • Only class methods and getters/setters can be memoized, not regular functions (they aren't part of the proposal);
  • Only TypeScript’s decorators are supported, not Babel’s, which use a different version of the proposal;
  • Being an experimental feature, they need to be enabled with
    --experimentalDecorators
    ; follow TypeScript’s docs.

options

Type:

object

Same as options for

pMemoize()
.
import {pMemoizeDecorator} from 'p-memoize';

class Example { index = 0

@pMemoizeDecorator()
async counter() {
    return ++this.index;
}

}

class ExampleWithOptions { index = 0

@pMemoizeDecorator()
async counter() {
    return ++this.index;
}

}

pMemoizeClear(memoized)

Clear all cached data of a memoized function.

It will throw when given a non-memoized function.

Tips

Time-based cache expiration

import pMemoize from 'p-memoize';
import ExpiryMap from 'expiry-map';
import got from 'got';

const cache = new ExpiryMap(10000); // Cached values expire after 10 seconds

const memoizedGot = pMemoize(got, {cache});

Related

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.