Class QuickLRU<KeyType, ValueType>

Type Parameters

KeyType
ValueType

Implements

Iterable<[KeyType, ValueType]>

Hierarchy

Map<KeyType, ValueType>
- QuickLRU

Index

Constructors

Accessors

Methods

[iterator] clear delete entries entriesAscending entriesDescending expiresIn forEach get has keys peek resize set values

Properties

[toStringTag] [species]

Constructors

constructor

new QuickLRU<KeyType, ValueType>(
options: Options<KeyType, ValueType>,
): QuickLRU<KeyType, ValueType>
Simple "Least Recently Used" (LRU) cache.

The instance is an Iterable of [key, value] pairs so you can use it directly in a for…of loop.
Type Parameters
- KeyType
- ValueType
Parameters
- options: Options<KeyType, ValueType>
Returns QuickLRU<KeyType, ValueType>
Example
```
import { QuickLRU } from '#runtime/data/struct/cache/quick-lru';

const lru = new QuickLRU({maxSize: 1000});

lru.set('🦄', '🌈');

lru.has('🦄');
//=> true

lru.get('🦄');
//=> '🌈'
```
Overrides Map<KeyType, ValueType>.constructor

Accessors

maxSize

get maxSize(): number
The set max size.

Returns number

size

get size(): number
The stored item count.

Returns number
Overrides Map.size

Methods

[iterator]

"[iterator]"(): IterableIterator<[KeyType, ValueType]>
Returns IterableIterator<[KeyType, ValueType]>
Implementation of Iterable.[iterator]
Overrides Map.[iterator]

clear

clear(): void
Delete all items.

Returns void
Overrides Map.clear

delete

delete(key: KeyType): boolean
Delete an item.
Parameters
- key: KeyType
Returns boolean
true if the item is removed or false if the item doesn't exist.

Overrides Map.delete

entries

entries(): MapIterator<[KeyType, ValueType]>
Returns an iterable of key, value pairs for every entry in the map.

Returns MapIterator<[KeyType, ValueType]>
Inherited from Map.entries

entriesAscending

entriesAscending(): IterableIterator<[KeyType, ValueType]>
Iterable for all entries, starting with the oldest (ascending in recency).

Returns IterableIterator<[KeyType, ValueType]>

entriesDescending

entriesDescending(): IterableIterator<[KeyType, ValueType]>
Iterable for all entries, starting with the newest (descending in recency).

Returns IterableIterator<[KeyType, ValueType]>

expiresIn

expiresIn(key: KeyType): number
Get the remaining time to live (in milliseconds) for the given item, or undefined when the item is not in the cache.
- Does not mark the item as recently used.
- Does not trigger lazy expiration or remove the entry when it is expired.
- Returns Infinity if the item has no expiration.
- May return a negative number if the item is already expired but not yet lazily removed.
Parameters
- key: KeyType
Returns number
Remaining time to live in milliseconds when set, Infinity when there is no expiration, or undefined when the item does not exist.

forEach

forEach(
    callbackfn: (
        value: ValueType,
        key: KeyType,
        map: Map<KeyType, ValueType>,
    ) => void,
    thisArg?: any,
): void
Executes a provided function once per each key/value pair in the Map, in insertion order.
Parameters
- callbackfn: (value: ValueType, key: KeyType, map: Map<KeyType, ValueType>) => void
- OptionalthisArg: any
Returns void
Inherited from Map.forEach

get

get(key: KeyType): ValueType
Get an item.
Parameters
- key: KeyType
Returns ValueType
The stored item or undefined.

Overrides Map.get

has

has(key: KeyType): boolean
Check if an item exists.
Parameters
- key: KeyType
Returns boolean
Overrides Map.has

keys

keys(): IterableIterator<KeyType>
Iterable for all the keys.

Returns IterableIterator<KeyType>
Overrides Map.keys

peek

peek(key: KeyType): ValueType
Get an item without marking it as recently used.
Parameters
- key: KeyType
Returns ValueType
The stored item or undefined.

resize

resize(maxSize: number): void
Update the maxSize in-place, 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.
Parameters
- maxSize: number
Returns void

set

set(key: KeyType, value: ValueType, options?: { maxAge?: number }): this
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.
Parameters
- key: KeyType
- value: ValueType
- Optionaloptions: { maxAge?: number }
Returns this
The cache instance.

Overrides Map.set

values

values(): IterableIterator<ValueType>
Iterable for all the values.

Returns IterableIterator<ValueType>
Overrides Map.values

Properties

`Readonly`[toStringTag]

"[toStringTag]": string

`Static` `Readonly`[species]

"[species]": MapConstructor