You're Invited:Meet the Socket Team at BlackHat and DEF CON in Las Vegas, Aug 7-8.RSVP
Socket
Socket
Sign inDemoInstall

lru-memoizer

Package Overview
Dependencies
2
Maintainers
1
Versions
27
Alerts
File Explorer

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

lru-memoizer

Memoize functions results using an lru-cache.


Version published
Maintainers
1
Created

Package description

What is lru-memoizer?

The lru-memoizer npm package is a utility for memoizing function results with an LRU (Least Recently Used) cache. This helps in optimizing performance by storing the results of expensive function calls and reusing them when the same inputs occur again, while also managing memory usage by discarding the least recently used items when the cache limit is reached.

What are lru-memoizer's main functionalities?

Basic Memoization

This feature allows you to memoize a function so that its results are cached. Subsequent calls with the same arguments will return the cached result, improving performance.

const memoizer = require('lru-memoizer');

const slowFunction = (num) => {
  // Simulate a slow computation
  for (let i = 0; i < 1e6; i++);
  return num * 2;
};

const memoizedFunction = memoizer({ load: slowFunction, max: 100 });

console.log(memoizedFunction(5)); // First call, slow
console.log(memoizedFunction(5)); // Second call, fast (cached)

Custom Cache Key

This feature allows you to define a custom cache key for the memoized function. This is useful when the function arguments are complex objects and you want to control how they are hashed for caching.

const memoizer = require('lru-memoizer');

const slowFunction = (obj) => {
  // Simulate a slow computation
  for (let i = 0; i < 1e6; i++);
  return obj.value * 2;
};

const memoizedFunction = memoizer({
  load: slowFunction,
  max: 100,
  hash: (obj) => obj.key // Custom cache key
});

console.log(memoizedFunction({ key: 'a', value: 5 })); // First call, slow
console.log(memoizedFunction({ key: 'a', value: 5 })); // Second call, fast (cached)

Cache Statistics

This feature provides statistics about the cache usage, such as the number of hits, misses, and the current number of keys in the cache. This can be useful for monitoring and debugging.

const memoizer = require('lru-memoizer');

const slowFunction = (num) => {
  // Simulate a slow computation
  for (let i = 0; i < 1e6; i++);
  return num * 2;
};

const memoizedFunction = memoizer({ load: slowFunction, max: 100 });

memoizedFunction(5);
memoizedFunction(5);

console.log(memoizedFunction.cache.stats); // { hits: 1, misses: 1, keys: 1 }

Other packages similar to lru-memoizer

Readme

Source

Memoize functions results using an lru-cache.

Installation

npm i lru-memoizer --save

Intro

This module uses an lru-cache internally to cache the results of an async function.

The load function can have N parameters and the last one must be a callback. The callback should be an errback (first parameter is err).

The hash function purpose is generate a custom hash for storing results. It has all the arguments applied to it minus the callback, and must return an string synchronous.

The disable function allows you to conditionally disable the use of the cache. Useful for test environments.

The freeze option (defaults to false) allows you to deep-freeze the result of the async function.

The clone option (defaults to false) allows you to deep-clone the result every time is returned from the cache.

Usage


var memoizer = require('lru-memoizer');

var memoizedGet = memoizer({
  //defines how to load the resource when
  //it is not in the cache.
  load: function (options, callback) {
    request.get(options, callback);
  },

  //defines how to create a cache key from the params.
  hash: function (options) {
    return options.url + qs.stringify(options.qs);
  },

  //don't cache in test environment
  disable: isTestEnv(),

  //all other params for the LRU cache.
  max: 100,
  maxAge: 1000 * 60
});

memoizedGet({
  url: 'https://google.com',
  qs: { foo: 123 }
}, function (err, result, body) {
 //console.log(body);
})

Sync lru-memoizer

Use memoizer.sync to cache things that are slow to calculate or methods returning promises.

var memoizer = require('lru-memoizer');
var memoizedGet = memoizer.sync({
  //defines how to load the resource when
  //it is not in the cache.
  load: function (params) {
    //return something_hard_to_compute;s
  },

  //defines how to create a cache key from the params.
  hash: function (params) {
    return params.foo;
  },

  //all other params for the LRU cache.
  max: 100,
  maxAge: 1000 * 60
});

Similar modules

This module is very similar to async-cache, the main difference is the hash function.

License

MIT 2016 - José F. Romaniello

Keywords

FAQs

Package last updated on 15 May 2024

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc