Javascript 中的 LRU 缓存实现

Question

Java 有 gets you 99% there to an LRU cache 的 LinkedHashMap。

是否有 LRU 缓存的 Javascript 实现，最好来自信誉良好的来源，即：

1. 可以理解
2. 高效（摊销 O(1) 获取/放置/删除）

？我一直在网上搜索，但找不到；我以为我在 Ajax Design Patterns 上找到了一个，但它掩盖了 sendToTail() 方法并且具有 O(n) 性能（大概是因为队列和关联数组是分开的）。

我想我可以自己写，但我已经明白，为核心算法重新发明轮子可能会危害一个人的健康：/

Answer 1

这个：

https://github.com/monsur/jscache

似乎适合你的情况，尽管setItem（即put）在最坏的情况下是O（N），如果缓存在插入时被填满，就会发生这种情况。在这种情况下，将搜索缓存以清除过期项目或最近最少使用的项目。 getItem 是 O(1) 并且过期在 getItem 操作上处理（即，如果正在获取的项目已过期，则将其删除并返回 null）。

代码足够紧凑，易于理解。

附：向构造函数添加指定 fillFactor 的选项可能很有用，该选项固定为 0.75（这意味着当缓存被清除时，它的大小至少减少到最大大小的 3/4）

Answer 2

这不是 LRU 缓存，但我有 my own linked map implementation。由于它使用 JS 对象作为存储，因此它具有相似的性能特征（包装对象和散列函数会带来性能损失）。

目前，文档是basically non-existant，但有一个related SO answer。

each() 方法将传递当前键、当前值和一个布尔值，指示是否有更多元素作为回调函数的参数。

或者，循环可以通过手动完成

for(var i = map.size; i--; map.next()) {
    var currentKey = map.key();
    var currentValue = map.value();
}

Answer 3

monsur.com 实现仅在插入时为 O(n)，因为它的项目实际上在现实世界时间到期。它不是一个简单的 LRU。如果您只关心维护最近使用的项目而不考虑实际时间，则可以在 O(1) 中完成。队列，实现为双向链表，从末尾插入或删除的时间为 O(1)，这就是缓存所需的全部内容。至于查找，一个 javascript 让哈希表变得非常容易的哈希映射应该适用于几乎 O(1) 的查找（假设 javascript 引擎使用一个好的哈希映射，这当然取决于实现）。所以你有一个项目的链接列表，其中包含一个指向项目的哈希映射。根据需要操作链表的两端，将新项目和请求项目放在一端，并从另一端移除旧项目。

Answer 4

我知道这是一个老问题，但添加了一个链接以供将来参考。 查看https://github.com/monmohan/dsjslib。除了一些其他数据结构之外，它还有一个 LRU 缓存实现。这样的缓存（以及这个缓存）以 LRU 顺序维护缓存条目的双向链表，即条目在被访问时移动到头部，并在它们被回收时从尾部移除（比如到期或达到大小限制）。它的 O(1)，因为它只涉及恒定数量的指针操作。

Answer 5

这值得一提： https://github.com/rsms/js-lru

核心函数集是 O(1) 并且代码被大量注释（还有 ASCII 艺术！）

Answer 6

Map should be O(1) in most implementations average case。由于 Map 保持插入顺序，因此在其周围添加一些代码将为您提供 LRU，并且对于大多数用途来说，这应该非常快。

我需要一个简单的 LRU 缓存来执行少量昂贵的操作（1 秒）。我觉得复制粘贴一些小代码而不是引入外部代码感觉更好，但由于我没有找到它，所以我写了它：

class LRU {
    constructor(max = 10) {
        this.max = max;
        this.cache = new Map();
    }

    get(key) {
        let item = this.cache.get(key);
        if (item) {
            // refresh key
            this.cache.delete(key);
            this.cache.set(key, item);
        }
        return item;
    }

    set(key, val) {
        // refresh key
        if (this.cache.has(key)) this.cache.delete(key);
        // evict oldest
        else if (this.cache.size == this.max) this.cache.delete(this.first());
        this.cache.set(key, val);
    }

    first() {
        return this.cache.keys().next().value;
    }
}

用法：

> let cache = new LRU(3)
> [1, 2, 3, 4, 5].forEach(v => cache.set(v, 'v:'+v))
> cache.get(2)
undefined
> cache.get(3)
"v:3"
> cache.set(6, 6)
> cache.get(4)
undefined
> cache.get(3)
"v:3"

Answer 7

由于我们需要 O(1) 中的读、写、更新和删除操作，我们使用两种数据结构。

1. JavaScript 中的对象（或映射）在 O(1) 中提供检索。
2. 双向链表（我们创建的自定义数据结构）在 O(1) 中实现以下功能
   • 将最常用元素的位置更改为顶部
   • 在达到缓存限制时从缓存中删除最少使用的元素。

Doubly LinkedList和最近最少使用缓存的自定义实现，下面给出了清晰的解释。

https://medium.com/dsinjs/implementing-lru-cache-in-javascript-94ba6755cda9

Answer 8

这个库runtime-memcache 在 javascript 中实现了 lru 和其他一些缓存方案。

它使用修改后的双向链表来实现 get、set 和 remove 的 O(1)。您可以查看非常简单的实现。

Answer 9

不需要外部包/库，我们可以自己编写代码用javascript实现LRU，详情请参考https://dev.to/udayvunnam/implementing-lru-cache-in-javascript-3c8g站点。