Recently used unshift in
Cold cache pop
------>[{key: value}, {key: value},{key: value}......
{key: value}]------>
|                                                |
|<--------------Recently used--------------------|

var cache = [{key: key,value: value,expire: 1000 * 3},{key: key,value: value,expire: 1000 * 3} ...
]

var cache = {key1: {value: "value1",expire: 2000,...},key2: {value: "value2",expire: 2000,...}
}// Get 方法
var get = function (key) {return cache[key];
}

head => key1 <=> key2 <=> key3 <=> ...<=> keyn <= tail

var node = {key: "key",count: 0 //访问次数，供LFU算法使用prev: null,next: null
}

var cache = {key1: {value: "value1",expire: 2000,node: node //在链表中对应位置的引用
    }
}

|  Cache    Algorithm      Link
|
|---set---|---insert---|---unshift(LRU)
|                      |
|                      |---push(LFU)
|                      |
|                      |---pop
|
|---get---|---update---|---moveHead(LRU)
|         |            |
|         |            |---forward(LFU)
|         |            |
|         |            |---backward(LFU)
|         |
|-expire--|---del------|---del

var set = function (key, value, expire) {// 缓存对象var _cache = this.cache;// 索引链表var _queue = this.queue;// 如果已经存在该值，则重新赋值，更新过期时间if (_cache[key]) {// 重新赋值_cache[key].value = value;_cache[key].expire = expire;// 更新之后，同时也要更新索引队列// 但在这里无需关心细节，LRU与LFU的更新规则不同// 只需调用统一的接口
        _queue.update(_cache[key].node);// 如果新插入缓存} else {var returnNode = _queue.insert(key);/*注意上面的returnNode，var returnNode = {node: node, // 新插入索引节点的引用delArr: delArr // 需要删除的缓存key}1. 它并不仅仅返回被插入索引节点的引用2. 它还返回了一个数组，存储了因为插入新节点，而导致链表超长而需要被删除缓存的key*/_cache[key] = {value: value,expire: expire,/*除了value和过期时间外还要存储多余的信息比如插入缓存的时间，以便对比是否过期*/insertTime: +new Date(),node: returnNode.node}        // 删除多余缓存returnNode.delArr.forEach(function (key) {_cache[key] = null;});}
}

var maxRound = 100 * 100 * 20;
(function () {var obj = {};for (var i = 0; i < maxRound; i++) {obj["key_" + i] = "value_"+ i;}var start = +new Date();for (var key in obj) {delete obj[key];//obj[key] = null;
    }var end = +new Date();console.log("Delete | Total cost:", end - start, "ms");
})()

var get = function (key) {var _cache = this.cache;var _queue = this.queue;// 如果存在该值if (_cache[key]) {var insertTime = _cache[key].insertTime;var expire = _cache[key].expire;var node = _cache[key].node;var curTime = +new Date();// 如果不存在过期时间 或者 存在过期时间但尚未过期if (!expire || (expire && curTime - insertTime < expire)) {// 已经使用过，更新索引队列
            _queue.update(node);// 只需返回用户所要的valuereturn _cache[key].value;// 如果已经过期} else if (expire && curTime - insertTime > expire) {// 从队列中删除
            _queue.del(node);return null}} else {return null;}
}

var update = function (node) {// 访问次数+1node.count++;var prevNode = node.prev;var nextNode = node.next;var queue = this.queue;// 高访问频率的节点在队首// 或者说一个节点的前节点的访问次数应该比当前节点高// 如果相反了，表示不需要调换位置// 直到前节点的访问次数应该比当前节点高if (prevNode && prevNode.count < node.count) {while (prevNode && prevNode.count < node.count) {// 与前一个节点调换位置
            queue.forward(node);prevNode = node.prev;}// 情况与上一个if分支刚好相反// 一个节点的后节点的访问次数应该比当前节点低} else if (nextNode && nextNode > node.count) {while (nextNode && nextNode > node.count) {queue.backward(node);nextNode = node.next;}}
}

var Cache_LRU = null, Cache_LFU = null,// Cache_FIN用来指向最终选择的算法Cache_FIN = null;// 统计前3万次
var round = 100 * 100 * 3;var Manage = {// 独立统计每个算法的成功次数// total表示该算法get方法被调用次数// suc表示成功次数"lru": {cache: Cache.createCache("LRU", 100 * 100 * 5),suc: 0,total: 0},"lfu": {cache: Cache.createCache("LFU", 100 * 100 * 5),suc: 0,total: 0}
}exports.set = function (key, value, expire) {// 如果已经结束了统计命中率的前三万轮// 表示已经找到了合适的算法if (!round) {return Cache_FIN.set(key, value, expire);}// 用户的每次get与set实际上同时在对所有的算法同时做// 同时有两份Cache在工作for (var name in Manage) {Manage[name].cache.set(key, value, expire);}
}exports.get = function (key) {// 如果已经结束了统计命中率的前三万轮// 表示已经找到了合适的算法if (!round) {return Cache_FIN.get(key);}var value = null;// 测试每一个算法是否能获得请求的cachefor (var name in Manage) {Manage[name].total++;value = Manage[name].cache.get(key);if (value) {Manage[name].suc++;}}// 如果测试完毕，算出命中率if (!--round) {var hitRate = {},max = {key: "",rate: 0};for (var key in Manage) {// 算法命中率hitRate[key] = Manage[key].suc / parseFloat(Manage[key].total);// 找到最高命中率if (hitRate[key] > max["rate"]) {max.key = key;max.rate = hitRate[key];}}// 找到合适的算法Cache_FIN = Manage[max.key].cache;}return value;
}