package
Simple “Least Recently Used” (LRU) cache
npm install quick-lruGitHub-flavored package documentation.
Across all versions, last 30 days.
237,352,478 in 30 days
Runtime metadata.
Tagged topics.
Useful when you need to cache something and limit memory usage.
See the algorithm section for implementation details.
npm install quick-lruimport QuickLRU from 'quick-lru';
const lru = new QuickLRU({maxSize: 1000});
lru.set('🦄', '🌈');
lru.has('🦄');
//=> true
lru.get('🦄');
//=> '🌈'Returns a new instance.
It's a Map subclass.
Throws a TypeError if an option is invalid.
Type: object
Required
Type: number
The target maximum number of items before evicting the least recently used items. Must be a whole number greater than 0, or Infinity.
[!NOTE] This package uses an algorithm which can store up to
2 × maxSize - 1items for performance reasons..sizeis capped atmaxSize.
Type: number
Default: Infinity
The maximum number of milliseconds an item should remain in the cache. Must be greater than 0. A non-numeric value means no expiration.
By default, maxAge will be Infinity, which means that items will never expire.
Lazy expiration: an expired item is removed when it is next read, iterated, or evicted. Until then, .size counts it.
Individual expiration of an item can be specified by the set(key, value, options) method.
Optional
Type: (key, value) => void
Called when an item is evicted from the cache due to LRU pressure, TTL expiration, resize(), or evict().
Useful for side effects or for items like object URLs that need explicit cleanup (revokeObjectURL).
[!NOTE] This callback is not called for manual removals via
delete()orclear(), or whenset()overwrites an item. The item is already removed when the callback runs. The callback must be synchronous, and it must not write to the cache.
The instance is an Iterable of [key, value] pairs so you can use it directly in a for…of loop, starting with the oldest (ascending in recency). Iterating removes the expired items it walks over. Keys added while iterating are not visited. Iteration copies the keys first, so it costs O(n) even when you stop early.
Both key and value can be of any type.
[!TIP] In TypeScript, the key and value types can only be inferred from
onEviction. Otherwise, specify them:new QuickLRU<string, string>({maxSize: 1000}).
Set an item. Returns the instance.
Individual expiration of an item can be specified with the maxAge option. If not specified, the global maxAge value will be used in case it is specified in the constructor; otherwise, the item will never expire. A value of 0 or less makes the item expire immediately, and a non-numeric or NaN value means no expiration.
Get an item.
Get an item, or set it to value if it does not exist.
import QuickLRU from 'quick-lru';
const lru = new QuickLRU({maxSize: 1000});
lru.set('🦄', '🌈');
lru.getOrInsert('🦄', '💩');
//=> '🌈'
lru.getOrInsert('🦀', '🎀');
//=> '🎀'Get an item, or set it to the result of callback(key) if it does not exist. callback is only called when the item does not exist.
import QuickLRU from 'quick-lru';
const lru = new QuickLRU({maxSize: 1000});
lru.getOrInsertComputed('🦄', () => '🌈');
//=> '🌈'Check if an item exists.
Get an item without marking it as recently used.
Delete an item.
Returns true if the item is removed or false if the item doesn't exist.
Delete all items.
Get the remaining time to live (in milliseconds) for the given item, or undefined if the item is not in the cache.
Infinity if the item has no expiration (maxAge not set for the item and no global maxAge).Update the maxSize, discarding items as necessary. Insertion order is mostly preserved, though this is not a strong guarantee.
Useful for on-the-fly tuning of cache sizes in live systems.
Evict the least recently used items from the cache.
The count parameter specifies how many items to evict. Defaults to 1.
It will always keep at least one item in the cache, unless all items have expired. It walks the whole cache whatever count is, so it is for occasional use, not for a loop.
import QuickLRU from 'quick-lru';
const lru = new QuickLRU({maxSize: 10});
lru.set('a', 1);
lru.set('b', 2);
lru.set('c', 3);
lru.evict(2); // Evicts 'a' and 'b'
console.log(lru.has('a'));
//=> false
console.log(lru.has('c'));
//=> trueIterable for all the keys, starting with the oldest (ascending in recency).
Iterable for all the values, starting with the oldest (ascending in recency).
Iterable for all entries, starting with the oldest (ascending in recency).
Iterable for all entries, starting with the newest (descending in recency).
Iterable for all entries, starting with the oldest (ascending in recency).
This method exists for Map compatibility. Prefer .entriesAscending() instead.
Loop over entries calling the callbackFunction for each entry (ascending in recency).
The callback is called with the value, the key, and the instance. thisArgument is used as this, and defaults to the instance.
This method exists for Map compatibility. Prefer .entriesAscending() instead.
The stored item count, capped at maxSize.
The set max size.
The set max age.
This library implements a variant of the hashlru algorithm using JavaScript's Map for broader key type support.
The algorithm uses a dual-cache approach with two Map objects:
On set() operations:
maxSize, promote it to become the old cache and create a fresh new cacheOn get() operations:
When the new cache is promoted, the previous old cache is discarded as a whole. This is where the speed comes from, and where this differs from a strict LRU. With maxSize 3:
const evicted = [];
const lru = new QuickLRU({maxSize: 3, onEviction: key => evicted.push(key)});
for (const key of ['1', '2', '3', '4', '5', '6']) {
lru.set(key, key);
// The keys held after each write:
// 1
// 1 2
// 1 2 3
// 1 2 3 4
// 1 2 3 4 5
// 4 5 6
}
console.log(evicted);
//=> ['1', '2', '3']A strict LRU drops 1, 2, and 3 one write at a time. Here they are dropped together on the sixth write, so a single write can evict up to maxSize items.
delete operations that can cause performance issues in JavaScript engines0 and 2 × maxSize - 1 items temporarilyChoose this implementation when:
Consider alternatives when:
maxSize items)Estimated unpacked size across 1 packages.
28.3 kB
Includes dependencies.