Big update!Introducing GitHub Bot Commands. Learn more
Socket
Log inBook a demo

mem

Package Overview
Dependencies
2
Maintainers
2
Versions
28
Issues
File Explorer

Advanced tools

mem

Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input

    9.0.2latest

Version published
Maintainers
2
Weekly downloads
7,545,239
decreased by-12.56%

Weekly downloads

Changelog

Source

  • Export missing Options type (#88) 9a937d0

https://github.com/sindresorhus/mem/compare/v9.0.1...v9.0.2

Readme

Source

mem

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 or the cache is cleared.

By default, only the memoized function's first argument is considered via strict equality comparison. If you need to cache multiple arguments or cache objects by value, have a look at alternative caching strategies below.

If you want to memoize Promise-returning functions (like async functions), you might be better served by p-memoize.

Install

$ npm install mem

Usage

import mem from 'mem'; let index = 0; const counter = () => ++index; const memoized = mem(counter); memoized('foo'); //=> 1 // Cached as it's the same argument memoized('foo'); //=> 1 // Not cached anymore as the argument changed memoized('bar'); //=> 2 memoized('bar'); //=> 2 // Only the first argument is considered by default memoized('bar', 'foo'); //=> 2
Works well with Promise-returning functions

But you might want to use p-memoize for more Promise-specific behaviors.

import mem from 'mem'; let index = 0; const counter = async () => ++index; const memoized = mem(counter); console.log(await memoized()); //=> 1 // The return value didn't increase as it's cached console.log(await memoized()); //=> 1 import mem from 'mem'; import got from 'got'; import delay from 'delay'; const memGot = mem(got, {maxAge: 1000}); await memGot('https://sindresorhus.com'); // This call is cached await memGot('https://sindresorhus.com'); await delay(2000); // This call is not cached as the cache has expired await memGot('https://sindresorhus.com');

Caching strategy

By default, only the first argument is compared via exact equality (===) to determine whether a call is identical.

const power = mem((a, b) => Math.power(a, b)); power(2, 2); // => 4, stored in cache with the key 2 (number) power(2, 3); // => 4, retrieved from cache at key 2 (number), it's wrong

You will have to use the cache and cacheKey options appropriate to your function. In this specific case, the following could work:

const power = mem((a, b) => Math.power(a, b), { cacheKey: arguments_ => arguments_.join(',') }); power(2, 2); // => 4, stored in cache with the key '2,2' (both arguments as one string) power(2, 3); // => 8, stored in cache with the key '2,3'

More advanced examples follow.

Example: Options-like argument

If your function accepts an object, it won't be memoized out of the box:

const heavyMemoizedOperation = mem(heavyOperation); heavyMemoizedOperation({full: true}); // Stored in cache with the object as key heavyMemoizedOperation({full: true}); // Stored in cache with the object as key, again // The objects look the same but for JS they're two different objects

You might want to serialize or hash them, for example using JSON.stringify or something like serialize-javascript, which can also serialize RegExp, Date and so on.

const heavyMemoizedOperation = mem(heavyOperation, {cacheKey: JSON.stringify}); heavyMemoizedOperation({full: true}); // Stored in cache with the key '[{"full":true}]' (string) heavyMemoizedOperation({full: true}); // Retrieved from cache

The same solution also works if it accepts multiple serializable objects:

const heavyMemoizedOperation = mem(heavyOperation, {cacheKey: JSON.stringify}); heavyMemoizedOperation('hello', {full: true}); // Stored in cache with the key '["hello",{"full":true}]' (string) heavyMemoizedOperation('hello', {full: true}); // Retrieved from cache
Example: Multiple non-serializable arguments

If your function accepts multiple arguments that aren't supported by JSON.stringify (e.g. DOM elements and functions), you can instead extend the initial exact equality (===) to work on multiple arguments using many-keys-map:

import ManyKeysMap from 'many-keys-map'; const addListener = (emitter, eventName, listener) => emitter.on(eventName, listener); const addOneListener = mem(addListener, { cacheKey: arguments_ => arguments_, // Use *all* the arguments as key cache: new ManyKeysMap() // Correctly handles all the arguments for exact equality }); addOneListener(header, 'click', console.log); // `addListener` is run, and it's cached with the `arguments` array as key addOneListener(header, 'click', console.log); // `addListener` is not run again addOneListener(mainContent, 'load', console.log); // `addListener` is run, and it's cached with the `arguments` array as key

Better yet, if your function’s arguments are compatible with WeakMap, you should use deep-weak-map instead of many-keys-map. This will help avoid memory leaks.

API

mem(fn, options?)

fn

Type: Function

Function to be memoized.

options

Type: object

maxAge

Type: number
Default: Infinity

Milliseconds until the cache expires.

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).

Refer to the caching strategies 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.

Refer to the caching strategies section for more information.

memDecorator(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 mem().

import {memDecorator} from 'mem'; class Example { index = 0 @memDecorator() counter() { return ++this.index; } } class ExampleWithOptions { index = 0 @memDecorator({maxAge: 1000}) counter() { return ++this.index; } }

memClear(fn)

Clear all cached data of a memoized function.

fn

Type: Function

Memoized 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
import mem from 'mem'; import StatsMap from 'stats-map'; import got from 'got'; const cache = new StatsMap(); const memGot = mem(got, {cache}); await memGot('https://sindresorhus.com'); await memGot('https://sindresorhus.com'); await memGot('https://sindresorhus.com'); console.log(cache.stats); //=> {hits: 2, misses: 1}
  • p-memoize - Memoize promise-returning & async functions

Get professional support for this package with a Tidelift subscription
Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies.

Keywords

FAQs

What is mem?

Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input

Is mem popular?

The npm package mem receives a total of 7,196,434 weekly downloads. As such, mem popularity was classified as popular.

Is mem well maintained?

We found that mem demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago.It has 2 open source maintainers collaborating on the project.

Last updated on 15 Jan 2022

Did you know?

Socket installs a Github app to automatically flag issues on every pull request and report the health of your dependencies. Find out what is inside your node modules and prevent malicious activity before you update the dependencies.

Install Socket
Socket

Product

Subscribe to our newsletter

Get open source security insights delivered straight into your inbox. Be the first to learn about new features and product updates.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc