lru-cache vs keyv vs redis vs node-cache vs cache-manager vs levelup vs memory-cache vs node-persist
Node.js Caching Libraries Comparison
Search packages..
1 Year
lru-cachekeyvredisnode-cachecache-managerlevelupmemory-cachenode-persistSimilar Packages:
What's Node.js Caching Libraries?

Caching libraries in Node.js are designed to improve application performance by temporarily storing data in memory or other storage mediums, reducing the need for repeated data retrieval from slower sources like databases or APIs. These libraries offer various caching strategies and storage options, allowing developers to optimize data access patterns and enhance the responsiveness of their applications.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
lru-cache223,662,9945,590820 kB103 months agoISC
keyv51,439,6552,90693.4 kB15 days agoMIT
redis5,210,30017,210247 kB3649 days agoMIT
node-cache3,907,9082,335-735 years agoMIT
cache-manager2,392,1321,81951.2 kB27 days agoMIT
levelup1,396,2324,088-04 years agoMIT
memory-cache755,1291,599-328 years agoBSD-2-Clause
node-persist141,66473040.1 kB175 months agoMIT
Feature Comparison: lru-cache vs keyv vs redis vs node-cache vs cache-manager vs levelup vs memory-cache vs node-persist

Storage Options

  • lru-cache:

    lru-cache is strictly an in-memory cache, focusing on speed and efficiency with an LRU eviction policy to manage memory usage effectively.

  • keyv:

    keyv offers a simple interface with support for various backends like memory, Redis, and SQLite, making it easy to switch storage solutions without changing your code significantly.

  • redis:

    redis is an in-memory data structure store that offers various data types and persistence options, making it suitable for high-performance applications requiring complex data operations.

  • node-cache:

    node-cache is also an in-memory cache, but it includes features like TTL and automatic expiration, making it easy to manage cached data lifecycle.

  • cache-manager:

    cache-manager supports multiple storage backends, including in-memory, Redis, Memcached, and more, allowing for flexible caching strategies depending on your application's needs.

  • levelup:

    levelup is built on top of LevelDB, providing a persistent key-value store that is efficient for read and write operations, ideal for applications needing durable storage.

  • memory-cache:

    memory-cache is a pure in-memory cache, providing fast access to cached data without any persistence, suitable for temporary data storage.

  • node-persist:

    node-persist provides file-based persistent storage, allowing data to be saved across application restarts, suitable for lightweight persistence needs.

Eviction Policies

  • lru-cache:

    lru-cache implements a least-recently-used (LRU) eviction policy, automatically removing the least recently accessed items when the cache reaches its size limit.

  • keyv:

    keyv does not enforce a specific eviction policy but allows you to implement your own logic for managing cached data expiration.

  • redis:

    redis supports various eviction policies (like LRU, LFU, etc.), allowing you to configure how data is managed in memory based on your application's needs.

  • node-cache:

    node-cache supports TTL for cache entries, automatically expiring items after a specified duration, simplifying cache management.

  • cache-manager:

    cache-manager allows you to implement custom eviction policies based on your application's caching strategy, giving you control over how cached data is managed.

  • levelup:

    levelup does not have built-in eviction policies, as it focuses on persistent storage; however, you can implement your own logic for managing data retention.

  • memory-cache:

    memory-cache does not have built-in eviction policies, making it suitable for simple caching scenarios where manual management is acceptable.

  • node-persist:

    node-persist does not have eviction policies, as it focuses on persistent storage; data remains until explicitly removed or overwritten.

Performance

  • lru-cache:

    lru-cache is optimized for speed, providing fast in-memory access and efficient memory management through its LRU eviction policy.

  • keyv:

    keyv is designed for performance, especially when using in-memory backends; it offers fast access times and low overhead for caching operations.

  • redis:

    redis is known for its high performance, offering low-latency access to data and supporting complex operations, making it ideal for scalable applications.

  • node-cache:

    node-cache provides good performance for in-memory caching, with features like TTL ensuring efficient data management without significant overhead.

  • cache-manager:

    cache-manager's performance depends on the underlying storage backend; in-memory storage provides the fastest access, while external backends may introduce latency.

  • levelup:

    levelup provides high performance for read and write operations due to its LevelDB foundation, making it suitable for applications with large datasets.

  • memory-cache:

    memory-cache offers quick access to cached data, making it suitable for lightweight applications where performance is critical.

  • node-persist:

    node-persist's performance is slower than in-memory solutions due to file I/O, but it is suitable for applications needing persistent storage without high performance demands.

Use Cases

  • lru-cache:

    lru-cache is perfect for scenarios where memory usage is a concern, such as caching API responses or expensive computations in memory-limited environments.

  • keyv:

    keyv is ideal for applications that require a simple caching solution with the ability to switch between memory and persistent storage easily, such as microservices.

  • redis:

    redis is ideal for high-performance applications requiring complex data structures, real-time analytics, or pub/sub messaging systems.

  • node-cache:

    node-cache is useful for caching frequently accessed data in web applications, such as user sessions or configuration data, with automatic expiration.

  • cache-manager:

    cache-manager is versatile and can be used in various scenarios, including web applications, API response caching, and session storage, due to its support for multiple backends.

  • levelup:

    levelup is suitable for applications needing a persistent key-value store, such as data logging, user sessions, or caching large datasets that require durability.

  • memory-cache:

    memory-cache is best for temporary data storage in lightweight applications or during development, where persistence is not required.

  • node-persist:

    node-persist is designed for applications needing simple file-based persistence, such as configuration storage or lightweight data logging.

Learning Curve

  • lru-cache:

    lru-cache is simple to implement and understand, making it accessible for developers looking for an efficient in-memory caching solution.

  • keyv:

    keyv is easy to learn and use, with a straightforward API that allows developers to quickly implement caching in their applications.

  • redis:

    redis has a steeper learning curve due to its rich feature set and advanced data structures, but it offers extensive documentation and community support.

  • node-cache:

    node-cache is straightforward to use, with clear documentation and examples, making it easy for developers to integrate caching into their applications.

  • cache-manager:

    cache-manager has a moderate learning curve due to its flexibility and multiple backend support, but its unified API simplifies usage across different storage solutions.

  • levelup:

    levelup may require some understanding of LevelDB concepts, but it is generally easy to use for developers familiar with key-value stores.

  • memory-cache:

    memory-cache has a very low learning curve, suitable for quick implementations in simple applications or prototypes.

  • node-persist:

    node-persist is easy to learn, especially for those familiar with file I/O operations, providing a simple API for persistent storage.

How to Choose: lru-cache vs keyv vs redis vs node-cache vs cache-manager vs levelup vs memory-cache vs node-persist
  • lru-cache:

    Use lru-cache when you need an in-memory cache with a least-recently-used eviction policy. This is particularly useful for applications where memory usage is a concern, and you want to automatically manage cache size based on usage patterns.

  • keyv:

    Select keyv for a simple and lightweight caching solution that supports various backends, including memory, Redis, and more. It's great for projects where you want a straightforward API and the ability to switch backends easily without significant changes to your code.

  • redis:

    Choose Redis if you need a powerful, in-memory data structure store that supports advanced caching strategies, pub/sub messaging, and persistence options. It's ideal for high-performance applications that require complex data operations and scalability.

  • node-cache:

    Select node-cache if you need a straightforward in-memory caching solution with features like time-to-live (TTL) and automatic expiration. It's suitable for applications that require basic caching capabilities without the need for persistence.

  • cache-manager:

    Choose cache-manager if you need a versatile caching solution that supports multiple backends (like Redis, Memcached, etc.) and provides a unified API. It's ideal for applications that require flexibility in caching strategies and backend storage.

  • levelup:

    Opt for levelup if you are looking for a persistent key-value store that works with LevelDB. It's suitable for applications that require durable storage with fast read and write capabilities, especially when dealing with large datasets.

  • memory-cache:

    Choose memory-cache for a simple in-memory caching solution without complex features. It's ideal for lightweight applications or prototyping where you want quick access to cached data without the overhead of persistent storage.

  • node-persist:

    Opt for node-persist when you need a simple file-based persistent storage solution. It's useful for applications that require data persistence across restarts without the complexity of a full database.

Similar Npm Packages to lru-cache

lru-cache is a popular caching library for Node.js and JavaScript applications that implements a Least Recently Used (LRU) caching strategy. This means that it automatically removes the least recently accessed items from the cache when it reaches its maximum size, ensuring that the most frequently used data remains available. This makes lru-cache an excellent choice for optimizing performance in applications that require quick access to frequently used data.

While lru-cache is a robust solution for caching, there are several alternatives available that also provide caching capabilities. Here are a few notable options:

  • memory-cache is a simple and lightweight caching library for Node.js applications. It allows you to store key-value pairs in memory with an optional expiration time. Unlike lru-cache, memory-cache does not implement an LRU eviction policy, making it a straightforward choice for applications that require basic caching without the complexity of eviction strategies. It's ideal for small projects or scenarios where caching needs are minimal.

  • node-cache is another caching library designed specifically for Node.js applications. It provides a simple API for storing and retrieving data in memory, along with features like time-to-live (TTL) for cache entries. While it does not implement an LRU eviction policy by default, it offers a more comprehensive set of features compared to memory-cache, making it suitable for applications that require more control over caching behavior.

  • quick-lru is a lightweight and fast LRU cache implementation for JavaScript. It is designed to be simple and efficient, providing a minimal API for managing cached items. quick-lru is an excellent choice for developers looking for a straightforward LRU caching solution without the overhead of additional features. Its performance and simplicity make it a great alternative for applications that need efficient caching without unnecessary complexity.

To see how lru-cache compares with memory-cache, node-cache, and quick-lru, check out the comparison: Comparing lru-cache vs memory-cache vs node-cache vs quick-lru.

Similar Npm Packages to keyv

keyv is a simple and powerful key-value store for Node.js that supports various backends, including memory, Redis, and more. It provides a straightforward API for storing and retrieving data, making it an excellent choice for applications that require caching or temporary storage of key-value pairs. With its promise-based interface, keyv allows for asynchronous operations, making it easy to integrate into modern JavaScript applications.

While keyv is a robust solution for key-value storage, there are several alternatives available, each with its own strengths:

  • cache-manager is a multi-store caching library that provides a unified API for various caching stores, including memory, Redis, and more. It allows developers to create a caching layer that can be easily switched between different storage backends. If you need a flexible caching solution that can work with multiple stores, cache-manager is a great option.
  • levelup is a simple wrapper around LevelDB, a fast key-value storage engine. It provides a straightforward API for storing and retrieving data, making it suitable for applications that require persistent storage. If you are looking for a persistent key-value store with a focus on performance, levelup is worth considering.
  • lru-cache is an in-memory cache implementation that uses the Least Recently Used (LRU) eviction policy. It is designed for scenarios where you need a fast and efficient caching solution that automatically removes the least recently used items when the cache reaches its limit. If you need a lightweight in-memory caching solution, lru-cache is an excellent choice.
  • memory-cache is a simple in-memory caching library for Node.js. It allows you to store key-value pairs in memory with a straightforward API. If you need a basic caching solution without the complexity of additional features, memory-cache is a good option.
  • node-cache is another in-memory caching library that offers features like time-to-live (TTL) for cached items. It is easy to use and provides a simple API for managing cached data. If you require a caching solution with TTL support, node-cache is a solid choice.
  • node-persist is a simple and lightweight library for persistent storage in Node.js applications. It allows you to store key-value pairs on the file system, making it suitable for applications that require data persistence without the complexity of a full database. If you need a straightforward way to persist data, node-persist is worth exploring.
  • redis is a powerful in-memory data structure store that can be used as a database, cache, and message broker. It offers high performance and supports various data types, making it suitable for a wide range of applications. If you require a robust and scalable caching solution, using Redis with keyv or directly is an excellent choice.

To see how these packages compare, check out the comparison: Comparing cache-manager vs keyv vs levelup vs lru-cache vs memory-cache vs node-cache vs node-persist vs redis.

Similar Npm Packages to redis

redis is a popular Node.js client for interacting with Redis, an in-memory data structure store that is commonly used as a database, cache, and message broker. The redis package provides a simple and efficient way to connect to a Redis server, perform CRUD operations, and manage data in various formats such as strings, hashes, lists, and sets. It is widely used in applications that require fast data access and real-time data processing.

One notable alternative to the redis package is ioredis. ioredis is another powerful Redis client for Node.js that offers a more feature-rich and robust experience compared to the standard redis package. It supports advanced features such as clustering, pipelining, and Lua scripting, making it suitable for applications that require high availability and scalability. Additionally, ioredis provides better support for handling large datasets and offers a more flexible API, which can be beneficial for developers working on complex applications.

For a detailed comparison of these two packages, you can check out the following link: Comparing ioredis vs redis.

Similar Npm Packages to node-cache

node-cache is a simple and efficient caching module for Node.js applications. It provides an easy-to-use API for storing and retrieving cached data in memory, making it ideal for scenarios where quick access to frequently used data is required. With features like time-to-live (TTL) for cache entries and automatic cleanup of expired items, node-cache helps improve application performance by reducing the need for repeated data fetching or computation.

While node-cache is a solid choice for in-memory caching, there are several alternatives that offer different features and capabilities. Here are a few notable options:

  • lru-cache is a popular caching library that implements a Least Recently Used (LRU) caching strategy. This means that when the cache reaches its limit, it automatically removes the least recently accessed items to make space for new ones. lru-cache is particularly useful for applications that require efficient memory management and want to ensure that frequently accessed data remains available. Its flexibility and performance make it a great choice for caching scenarios where memory constraints are a concern.

  • memory-cache is another lightweight caching library for Node.js that provides a simple API for in-memory caching. It allows developers to store key-value pairs with optional expiration times. While memory-cache is straightforward and easy to use, it does not implement advanced caching strategies like LRU. It is best suited for smaller applications or scenarios where simplicity is preferred over complex caching mechanisms.

  • node-persist is a persistent storage library for Node.js that allows you to store data in a file-based cache. Unlike in-memory caching solutions, node-persist provides durability by saving data to the filesystem, making it suitable for applications that require data persistence across restarts. It offers a simple API for storing and retrieving data, along with features like automatic serialization and deserialization of JavaScript objects.

To compare these caching libraries, check out the following link: Comparing lru-cache vs memory-cache vs node-cache vs node-persist.

Similar Npm Packages to cache-manager

cache-manager is a versatile caching library for Node.js applications. It provides a simple and consistent API for managing caching across different storage engines, such as memory, Redis, and more. With cache-manager, developers can easily implement caching strategies to improve application performance and reduce the load on backend services. While cache-manager is a robust solution for caching, there are several alternatives available that cater to different use cases. Here are a few notable options:

  • apicache is a lightweight caching middleware for Express.js applications. It allows developers to cache API responses easily, improving response times and reducing server load. apicache is particularly useful for applications that require quick access to frequently requested data, as it can significantly enhance performance with minimal configuration. If you're building an API with Express and want a straightforward way to implement caching, apicache is an excellent choice.

  • cacheable-request is a caching wrapper for HTTP requests. It allows developers to cache responses from HTTP requests, making it a great option for applications that rely heavily on external APIs. By using cacheable-request, developers can reduce the number of requests made to external services, thereby improving performance and reducing costs. This library is particularly useful for applications that need to fetch data from APIs frequently and can benefit from caching those responses.

  • lru-cache is a simple and efficient implementation of a Least Recently Used (LRU) cache. It is designed to store a limited number of items in memory, automatically evicting the least recently used items when the cache reaches its size limit. lru-cache is ideal for scenarios where memory usage is a concern, and you want to ensure that your application only retains the most relevant data in cache. Its straightforward API makes it easy to integrate into any Node.js application.

  • memory-cache is a simple in-memory caching library for Node.js. It provides a straightforward API for storing and retrieving data in memory, making it suitable for applications that require quick access to cached data without the overhead of more complex caching solutions. If you need a lightweight and easy-to-use caching solution for your Node.js application, memory-cache is a solid option.

  • node-cache is another in-memory caching library for Node.js that offers a simple key-value store. It supports features like time-to-live (TTL) for cache entries, allowing developers to control how long data remains in the cache. node-cache is useful for applications that require a straightforward caching mechanism without the complexity of external storage solutions.

To explore how these caching libraries compare, check out the comparison: Comparing apicache vs cache-manager vs cacheable-request vs lru-cache vs memory-cache vs node-cache.

Similar Npm Packages to memory-cache

memory-cache is a simple and efficient caching library for Node.js applications. It allows developers to store key-value pairs in memory, providing a fast way to access frequently used data without the need for repeated calculations or database queries. While memory-cache is a great choice for in-memory caching, there are several alternatives that offer similar functionality. Here are a few noteworthy options:

  • lru-cache is a popular caching library that implements a Least Recently Used (LRU) cache algorithm. This means that it automatically removes the least recently accessed items when the cache reaches its limit, making it ideal for applications where memory usage needs to be optimized. lru-cache is particularly useful for scenarios where you want to maintain a limited amount of cached data while ensuring that the most frequently accessed items remain available. Its flexibility and efficiency make it a preferred choice for many developers looking for a robust caching solution.
  • node-cache is another caching library designed specifically for Node.js applications. It provides a simple API for storing and retrieving cached data, along with features like time-to-live (TTL) for cache entries, allowing developers to set expiration times for cached items. node-cache is well-suited for applications that require a straightforward caching mechanism with the ability to manage cache lifetimes effectively. Its ease of use and built-in expiration features make it a solid choice for many caching scenarios.
  • quick-lru is a lightweight and efficient LRU caching library that focuses on performance. It is designed to be simple and fast, making it an excellent choice for applications that require a minimalistic approach to caching. quick-lru allows developers to easily set limits on the cache size and provides a straightforward API for adding and retrieving cached items. If you are looking for a high-performance caching solution without unnecessary complexity, quick-lru is worth considering.

To see how memory-cache compares with lru-cache, node-cache, and quick-lru, check out the comparison: Comparing lru-cache vs memory-cache vs node-cache vs quick-lru.

Similar Npm Packages to node-persist

node-persist is a simple and lightweight persistent storage library for Node.js applications. It allows developers to store data in a file system using a straightforward API, making it easy to save and retrieve data across application restarts. While node-persist is a great option for local storage needs, there are several alternatives that offer different features and capabilities. Here are a few notable alternatives:

  • levelup is a powerful and flexible wrapper around LevelDB, a fast key-value storage library. Levelup provides a simple API for interacting with LevelDB, allowing developers to perform CRUD operations with ease. It is well-suited for applications that require high-performance storage solutions and can handle large datasets. If you need a more robust and scalable solution for data storage, levelup is an excellent choice.
  • localforage is a library that provides a simple API for storing data in various storage backends, including IndexedDB, WebSQL, and localStorage. It is designed to work seamlessly across different browsers and platforms, making it a great choice for web applications that require persistent storage. Localforage is particularly useful for applications that need to store large amounts of data in a client-side environment.
  • lowdb is a small local JSON database powered by Lodash. It is designed for simplicity and ease of use, allowing developers to store data in a JSON file and interact with it using a familiar API. Lowdb is ideal for small projects or applications that require lightweight data storage without the overhead of a full database system.
  • nedb is a lightweight embedded database for Node.js applications. It provides a MongoDB-like API and is designed to be easy to use and integrate into applications. NeDB is suitable for small to medium-sized applications that require a simple database solution without the complexity of a full-fledged database system.
  • pouchdb is an open-source JavaScript database that syncs with CouchDB. It allows developers to create applications that can work offline and sync data with a remote database when a connection is available. PouchDB is particularly useful for applications that require offline capabilities and seamless data synchronization across devices.

To see how node-persist compares with levelup, localforage, lowdb, nedb, and pouchdb, check out the comparison: Comparing levelup vs localforage vs lowdb vs nedb vs node-persist vs pouchdb.

README for lru-cache

lru-cache

A cache object that deletes the least-recently-used items.

Specify a max number of the most recently used items that you want to keep, and this cache will keep that many of the most recently accessed items.

This is not primarily a TTL cache, and does not make strong TTL guarantees. There is no preemptive pruning of expired items by default, but you may set a TTL on the cache or on a single set. If you do so, it will treat expired items as missing, and delete them when fetched. If you are more interested in TTL caching than LRU caching, check out @isaacs/ttlcache.

As of version 7, this is one of the most performant LRU implementations available in JavaScript, and supports a wide diversity of use cases. However, note that using some of the features will necessarily impact performance, by causing the cache to have to do more work. See the "Performance" section below.

Installation

npm install lru-cache --save

Usage

// hybrid module, either works
import { LRUCache } from 'lru-cache'
// or:
const { LRUCache } = require('lru-cache')
// or in minified form for web browsers:
import { LRUCache } from 'http://unpkg.com/lru-cache@9/dist/mjs/index.min.mjs'

// At least one of 'max', 'ttl', or 'maxSize' is required, to prevent
// unsafe unbounded storage.
//
// In most cases, it's best to specify a max for performance, so all
// the required memory allocation is done up-front.
//
// All the other options are optional, see the sections below for
// documentation on what each one does.  Most of them can be
// overridden for specific items in get()/set()
const options = {
  max: 500,

  // for use with tracking overall storage size
  maxSize: 5000,
  sizeCalculation: (value, key) => {
    return 1
  },

  // for use when you need to clean up something when objects
  // are evicted from the cache
  dispose: (value, key, reason) => {
    freeFromMemoryOrWhatever(value)
  },

  // for use when you need to know that an item is being inserted
  // note that this does NOT allow you to prevent the insertion,
  // it just allows you to know about it.
  onInsert: (value, key, reason) => {
    logInsertionOrWhatever(key, value)
  },

  // how long to live in ms
  ttl: 1000 * 60 * 5,

  // return stale items before removing from cache?
  allowStale: false,

  updateAgeOnGet: false,
  updateAgeOnHas: false,

  // async method to use for cache.fetch(), for
  // stale-while-revalidate type of behavior
  fetchMethod: async (
    key,
    staleValue,
    { options, signal, context }
  ) => {},
}

const cache = new LRUCache(options)

cache.set('key', 'value')
cache.get('key') // "value"

// non-string keys ARE fully supported
// but note that it must be THE SAME object, not
// just a JSON-equivalent object.
var someObject = { a: 1 }
cache.set(someObject, 'a value')
// Object keys are not toString()-ed
cache.set('[object Object]', 'a different value')
assert.equal(cache.get(someObject), 'a value')
// A similar object with same keys/values won't work,
// because it's a different object identity
assert.equal(cache.get({ a: 1 }), undefined)

cache.clear() // empty the cache

If you put more stuff in the cache, then less recently used items will fall out. That's what an LRU cache is.

For full description of the API and all options, please see the LRUCache typedocs

Storage Bounds Safety

This implementation aims to be as flexible as possible, within the limits of safe memory consumption and optimal performance.

At initial object creation, storage is allocated for max items. If max is set to zero, then some performance is lost, and item count is unbounded. Either maxSize or ttl must be set if max is not specified.

If maxSize is set, then this creates a safe limit on the maximum storage consumed, but without the performance benefits of pre-allocation. When maxSize is set, every item must provide a size, either via the sizeCalculation method provided to the constructor, or via a size or sizeCalculation option provided to cache.set(). The size of every item must be a positive integer.

If neither max nor maxSize are set, then ttl tracking must be enabled. Note that, even when tracking item ttl, items are not preemptively deleted when they become stale, unless ttlAutopurge is enabled. Instead, they are only purged the next time the key is requested. Thus, if ttlAutopurge, max, and maxSize are all not set, then the cache will potentially grow unbounded.

In this case, a warning is printed to standard error. Future versions may require the use of ttlAutopurge if max and maxSize are not specified.

If you truly wish to use a cache that is bound only by TTL expiration, consider using a Map object, and calling setTimeout to delete entries when they expire. It will perform much better than an LRU cache.

Here is an implementation you may use, under the same license as this package:

// a storage-unbounded ttl cache that is not an lru-cache
const cache = {
  data: new Map(),
  timers: new Map(),
  set: (k, v, ttl) => {
    if (cache.timers.has(k)) {
      clearTimeout(cache.timers.get(k))
    }
    cache.timers.set(
      k,
      setTimeout(() => cache.delete(k), ttl)
    )
    cache.data.set(k, v)
  },
  get: k => cache.data.get(k),
  has: k => cache.data.has(k),
  delete: k => {
    if (cache.timers.has(k)) {
      clearTimeout(cache.timers.get(k))
    }
    cache.timers.delete(k)
    return cache.data.delete(k)
  },
  clear: () => {
    cache.data.clear()
    for (const v of cache.timers.values()) {
      clearTimeout(v)
    }
    cache.timers.clear()
  },
}

If that isn't to your liking, check out @isaacs/ttlcache.

Storing Undefined Values

This cache never stores undefined values, as undefined is used internally in a few places to indicate that a key is not in the cache.

You may call cache.set(key, undefined), but this is just an alias for cache.delete(key). Note that this has the effect that cache.has(key) will return false after setting it to undefined.

cache.set(myKey, undefined)
cache.has(myKey) // false!

If you need to track undefined values, and still note that the key is in the cache, an easy workaround is to use a sigil object of your own.

import { LRUCache } from 'lru-cache'
const undefinedValue = Symbol('undefined')
const cache = new LRUCache(...)
const mySet = (key, value) =>
  cache.set(key, value === undefined ? undefinedValue : value)
const myGet = (key, value) => {
  const v = cache.get(key)
  return v === undefinedValue ? undefined : v
}

Performance

As of January 2022, version 7 of this library is one of the most performant LRU cache implementations in JavaScript.

Benchmarks can be extremely difficult to get right. In particular, the performance of set/get/delete operations on objects will vary wildly depending on the type of key used. V8 is highly optimized for objects with keys that are short strings, especially integer numeric strings. Thus any benchmark which tests solely using numbers as keys will tend to find that an object-based approach performs the best.

Note that coercing anything to strings to use as object keys is unsafe, unless you can be 100% certain that no other type of value will be used. For example:

const myCache = {}
const set = (k, v) => (myCache[k] = v)
const get = k => myCache[k]

set({}, 'please hang onto this for me')
set('[object Object]', 'oopsie')

Also beware of "Just So" stories regarding performance. Garbage collection of large (especially: deep) object graphs can be incredibly costly, with several "tipping points" where it increases exponentially. As a result, putting that off until later can make it much worse, and less predictable. If a library performs well, but only in a scenario where the object graph is kept shallow, then that won't help you if you are using large objects as keys.

In general, when attempting to use a library to improve performance (such as a cache like this one), it's best to choose an option that will perform well in the sorts of scenarios where you'll actually use it.

This library is optimized for repeated gets and minimizing eviction time, since that is the expected need of a LRU. Set operations are somewhat slower on average than a few other options, in part because of that optimization. It is assumed that you'll be caching some costly operation, ideally as rarely as possible, so optimizing set over get would be unwise.

If performance matters to you:

  1. If it's at all possible to use small integer values as keys, and you can guarantee that no other types of values will be used as keys, then do that, and use a cache such as lru-fast, or mnemonist's LRUCache which uses an Object as its data store.

  2. Failing that, if at all possible, use short non-numeric strings (ie, less than 256 characters) as your keys, and use mnemonist's LRUCache.

  3. If the types of your keys will be anything else, especially long strings, strings that look like floats, objects, or some mix of types, or if you aren't sure, then this library will work well for you.

    If you do not need the features that this library provides (like asynchronous fetching, a variety of TTL staleness options, and so on), then mnemonist's LRUMap is a very good option, and just slightly faster than this module (since it does considerably less).

  4. Do not use a dispose function, size tracking, or especially ttl behavior, unless absolutely needed. These features are convenient, and necessary in some use cases, and every attempt has been made to make the performance impact minimal, but it isn't nothing.

Breaking Changes in Version 7

This library changed to a different algorithm and internal data structure in version 7, yielding significantly better performance, albeit with some subtle changes as a result.

If you were relying on the internals of LRUCache in version 6 or before, it probably will not work in version 7 and above.

Breaking Changes in Version 8

  • The fetchContext option was renamed to context, and may no longer be set on the cache instance itself.
  • Rewritten in TypeScript, so pretty much all the types moved around a lot.
  • The AbortController/AbortSignal polyfill was removed. For this reason, Node version 16.14.0 or higher is now required.
  • Internal properties were moved to actual private class properties.
  • Keys and values must not be null or undefined.
  • Minified export available at 'lru-cache/min', for both CJS and MJS builds.

Breaking Changes in Version 9

  • Named export only, no default export.
  • AbortController polyfill returned, albeit with a warning when used.

Breaking Changes in Version 10

  • cache.fetch() return type is now Promise<V | undefined> instead of Promise<V | void>. This is an irrelevant change practically speaking, but can require changes for TypeScript users.

For more info, see the change log.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.