Creates a new instance of the LRUCache.
// No options.
const cache = new LRUCache();
// With options.
const cache = new LRUCache({
entryExpirationTimeInMS: 10000
});
Optional options: LRUCacheOptions<TKey, TValue>Additional configuration options for the LRUCache.
Gets or sets the maxSize of the cache. This will evict the least recently used entries if needed to reach new maxSize.
const cache = new LRUCache({ maxSize: 10 });
cache.set('testKey', 'testValue');
// Will be 10
const maxSize = cache.maxSize;
// Set new maxSize to 5. If there are more than 5 items in the cache, the least recently used entries will be removed until cache size is 5.
cache.maxSize = 5;
Returns the most recently used (newest) entry in the cache. This will not mark the entry as recently used. If the newest node is expired, it will be removed.
The most recently used (newest) entry in the cache.
const cache = new LRUCache({ maxSize: 10 });
cache.set('testKey', 'testValue');
const newest = cache.newest;
// Will log testValue
console.log(newest.value);
// Will log testKey
console.log(newest.key);
Returns the least recently used (oldest) entry in the cache. This will not mark the entry as recently used. If the oldest node is expired, it will be removed.
The least recently used (oldest) entry in the cache.
const cache = new LRUCache({ maxSize: 10 });
cache.set('testKey', 'testValue');
const oldest = cache.oldest;
// Will log testValue
console.log(oldest.value);
// Will log testKey
console.log(oldest.key);
Returns the number of entries that can still be added to the LRUCache without evicting existing entries.
The number of entries that can still be added without evicting existing entries.
const cache = new LRUCache({ maxSize: 10 });
cache.set('testKey', 'testValue');
const remainingSize = cache.remainingSize;
// Will log 9 due to 9 spots remaining before reaching maxSize of 10.
console.log(remainingSize);
Returns the number of entries in the LRUCache object. If the cache has entryExpirationTimeInMS set, expired entries will be removed before the size is returned.
The number of entries in the cache.
const cache = new LRUCache();
cache.set('testKey', 'testValue');
const size = cache.size;
// Will log 1
console.log(size);
Creates a Generator which can be used with for ... of ... to iterate over the cache entries. Iterates in order from most recently accessed entry to least recently. Expired entries will be skipped (and removed). No entry will be marked as accessed.
A Generator for the cache entries.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
for (const entry of cache) {
const { key, value } = entry;
// do something with the entry
}
Removes all entries in the cache.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
// Clear cache.
cache.clear();
Deletes the entry for the passed in key.
True if an element in the LRUCache object existed and has been removed, or false if the element does not exist.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
// Will be true
const wasDeleted = cache.delete('testKey');
// Will be false
const wasDeleted2 = cache.delete('keyNotInCache');
The key of the entry to delete
Creates a Generator which can be used with for ... of ... to iterate over the cache entries. Iterates in order from most recently accessed entry to least recently. Expired entries will be skipped (and removed). No entry will be marked as accessed.
A Generator for the cache entries.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
for (const entry of cache.entries()) {
const { key, value } = entry;
// do something with the entry
}
Searches the cache for an entry matching the passed in condition. Expired entries will be skipped (and removed). If multiply entries in the cache match the condition, the most recently used entry will be returned. If an entry is returned, this marks the returned entry as the most recently used entry.
The first cache entry to match the condition. Null if none match.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
// item will be { key: 'testKey', value: 'testValue }
const item = cache.find(entry => {
const { key, value } = entry;
if (key === 'testKey' || value === 'something') {
return true;
}
return false;
});
// item2 will be null
const item2 = cache.find(entry => entry.key === 'notInCache');
The condition to apply to each entry in the
Iterates over and applies the callback function to each entry in the cache. Iterates in order from most recently accessed entry to least recently. Expired entries will be skipped (and removed). No entry will be marked as recently used.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
cache.forEach((key, value, index) => {
// do something with key, value, and/or index
});
the callback function to apply to the entry
Returns the value associated to the key, or null if there is none or if the entry is expired. If an entry is returned, this marks the returned entry as the most recently used entry.
The cached value or null.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
// Will be 'testValue'. Entry will now be most recently used.
const item1 = cache.get('testKey');
// Will be null
const item2 = cache.get('keyNotInCache');
The key of the entry to get.
Returns a boolean asserting whether a value has been associated to the key in the LRUCache object or not. This does not mark the entry as recently used. If the cache has a key but the entry is expired, it will be removed and false will be returned.
true if the cache contains the supplied key. False if not.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
// Will be true
const wasDeleted = cache.has('testKey');
// Will be false
const wasDeleted2 = cache.has('keyNotInCache');
The key of the entry to check if exists
Creates a Generator which can be used with for ... of ... to iterate over the cache keys. Iterates in order from most recently accessed entry to least recently. Expired entries will be skipped (and removed). No entry will be marked as accessed.
A Generator for the cache keys.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
for (const key of cache.keys()) {
// do something with the key
}
Returns the value associated to the key, or null if there is none or if the entry is expired. If an entry is returned, this will not mark the entry as most recently accessed. Useful if a value is needed but the order of the cache should not be changed.
The cached value or null.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
// Will be 'testValue'
const item1 = cache.peek('testKey');
// Will be null
const item2 = cache.peek('keyNotInCache');
The key of the entry to get.
Sets the value for the key in the LRUCache object. Returns the LRUCache object. This marks the newly added entry as the most recently used entry. If adding the new entry makes the cache size go above maxSize, this will evict the least recently used entries until size is equal to maxSize.
The LRUCache instance.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
// Set the key key2 to value value2. Pass in optional options.
cache.set('key2', 'value2', { entryExpirationTimeInMS: 10 });
The key of the entry.
The value to set for the key.
Optional entryOptions: LRUCacheSetEntryOptions<TKey, TValue>Additional configuration options for the cache entry.
Creates a Generator which can be used with for ... of ... to iterate over the cache values. Iterates in order from most recently accessed entry to least recently. Expired entries will be skipped (and removed). No entry will be marked as accessed.
A Generator for the cache values.
const cache = new LRUCache();
// Set the key testKey to value testValue
cache.set('testKey', 'testValue');
for (const value of cache.values()) {
// do something with the value
}
Generated using TypeDoc
A key value cache that implements the LRU policy.
Typeparam
TKey The type of the keys in the cache. Defaults to
string.Typeparam
TValue The type of the values in the cache. Defaults to
any.See
https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)