前端 实现有时间限制的缓存

首先我们需要创建一个名为TimeLimitedCache的构造函数，然后定义一些方法，如set, get,和count。以下是具体的示例代码：

// 定义 TimeLimitedCache 构造函数
var TimeLimitedCache = function( ) {
    // 初始化一个空的 cache 对象，用于存储将要缓存的数据
    this.cache = {};
};

// 定义 TimeLimitedCache 的各种方法
TimeLimitedCache.prototype = {
    // 设置缓存数据
    set: function(key, value, duration) {
        // 获取当前时间
        const now = Date.now();
        // 将数据和过期时间一起作为一个新对象缓存起来
        const _value = {
            value: value,  // 需要缓存的数据
            duration: duration,  // 所需缓存的时间（ms）
            start: now  // 数据开始缓存的时间
        };

        // 将键值对存入 cache对象
        this.cache[key] = _value;
    },

    // 获取缓存数据
    get: function(key) {
        // 获取当前时间
        const now = Date.now();
        // 使用key从缓存中取出数据
        const { start, duration, value } = this.cache[key];
        
        // 判断数据是否过期
        if (now - start <= duration) {
            // 如果数据没有过期，则返回数据
            return value;
        } else {
            // 如果数据过期了，就从缓存中删除，并返回-1表示数据已失效
            delete this.cache[key];
            return -1;
        }
    },

    // 获取当前还未过期的缓存的数量
    count: function() {
        let cnt = 0;
        for (let key in this.cache) {
            // 如果 get 方法返回的不是-1，说明缓存还未过期
            if (this.get(key) !== -1) {
                cnt++;
            }
        }
        // 返回未过期的缓存数量
        return cnt;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

改已存在且未过期的键的值

// 更新缓存数据
update: function(key, newValue, duration) {
    // 使用 get 方法检查键值是否存在且未过期
    if (this.get(key) != -1) {
        // 存在未过期的键，我们增更新它的值
        this.cache[key].value = newValue;
        // 更新他的过期时间
        if (duration !== undefined) {
            this.cache[key].duration = duration;
            this.cache[key].start = Date.now();
        }
        return true;
    } else {
        // 键不存在或者已经过期，我们返回 false
        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这样你就可以使用 update 方法来更新已经存在的键的值了。如果这个键不存在或者已经过期，update 方法会返回 false，而如果更新成功，它会返回 true。请注意，对于过期的键，我们通常认为它已经不存在，所以在这种情况下，你可能会希望用 set 来重新创建一个新键

设置缓存时自动删除过期的键

可以在 set 方法中添加一个检查并删除过期键的步骤。为了不让这个步骤消耗太多时间，我们可以选择只删除一部分过期的键。

下面的代码表示在每次设置新的缓存之前，都会检查并删除10个过期的键（如果存在的话）：

set: function(key, value, duration) {
    // 在设置新的缓存之前，先删除一些过期的键
    var expiredKeys = Object.keys(this.cache).filter((key) => this.get(key) === -1);
    for (var i = 0; i < Math.min(10, expiredKeys.length); i++) {
        delete this.cache[expiredKeys[i]];
    }

    // 然后设置新的缓存
    const now = Date.now();
    const _value = {
        value: value,
        duration: duration,
        start: now
    };
    this.cache[key] = _value;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这个代码会在每次设置新的缓存之前，先找出所有过期的键，然后删除其中的前10个（如果存在的话）。这样，我们就可以保证每次在设置新的缓存时，都能够尽可能地释放一些空间。同时，由于我们只删除了一部分过期的键，所以这个步骤不会消耗太多时间。

获取缓存时返回剩余时间而不是判断是否过期
可以通过修改 get 方法，在返回缓存值的同时返回剩余的有效时间。修改后的 get 方法如下所示：

// 获取缓存数据
get: function(key) {
    // 获取当前时间
    const now = Date.now();
   
    // 如果键存在
    if(this.cache.hasOwnProperty(key)){
        // 计算剩余的有效时间
        const remainingTime = this.cache[key].duration - (now - this.cache[key].start);

        // 如果剩余的有效时间大于0，返回数据和剩余时间
        if (remainingTime > 0) {
            return { value: this.cache[key].value, remainingTime: remainingTime };
        } else {
            // 如果数据过期了，就从缓存中删除，并返回-1表示数据已失效
            delete this.cache[key];
            return { value: -1, remainingTime: 0 };
        }
    }
    else {
        // 如果键不存在，直接返回-1和剩余时间0
        return { value: -1, remainingTime: 0 };
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这个版本的 get 方法返回了一个包含 value 和 remainingTime 的对象。 value 仍然代表键对应的值，而 remainingTime 代表这个值的剩余有效时间（以毫秒为单位）。如果这个键不存在或已过期， value 会被设置为 -1 ， remainingTime 会被设置为 0 。

以上就是文章全部内容了，如果喜欢这篇文章的话，还希望三连支持一下，感谢！