Vue - LRU算法

什么是LRU

• 一般见于操作系统，即“最近最久未使用”算法。就是会在特定时间段将最近最久未使用的页面数据置换出来（或者说淘汰），注入新数据。
• Vue里的LRU算法和keep-alive相关，ka是保存失活组件状态的东西，但它保存的是VNode，所以可能会影响内存空间导致一些性能上的问题。这里的ka用的也就是LRU算法
• 在新实例被创建之前，已缓存组件中最久没有被访问的实例会被销毁掉。

源码

export default {
  name: "keep-alive",
  // 抽象组件属性 ,它在组件实例建立父子关系的时候会被忽略,发生在 initLifecycle 的过程中
  abstract: true, 
  props: {
    // 被缓存组件
    include: patternTypes, 
    // 不被缓存组件
    exclude: patternTypes,
    // 指定缓存大小
    max: [String, Number] 
  },
  created() {
    // 初始化用于存储缓存的 cache 对象
    this.cache = Object.create(null);
    // 初始化用于存储VNode key值的 keys 数组
    this.keys = []; 
  },
  destroyed() {
    for (const key in this.cache) {
      // 删除所有缓存
      pruneCacheEntry(this.cache, key, this.keys);
    }
  },
  mounted() {
    // 监听缓存（include）/不缓存（exclude）组件的变化
    // 在变化时，重新调整 cache
    // pruneCache：遍历 cache，如果缓存的节点名称与传入的规则没有匹配上的话，就把这个节点从缓存中移除
    this.$watch("include", val => {
      pruneCache(this, name => matches(val, name));
    });
    this.$watch("exclude", val => {
      pruneCache(this, name => !matches(val, name));
    });
  },
  render() {
    // 获取第一个子元素的 vnode
    const slot = this.$slots.default;
    const vnode: VNode = getFirstComponentChild(slot);
    const componentOptions: ?VNodeComponentOptions =
      vnode && vnode.componentOptions;
    if (componentOptions) {
      // name 不在 inlcude 中或者在 exlude 中则直接返回 vnode，否则继续进行下一步
      // check pattern
      const name: ?string = getComponentName(componentOptions);
      const { include, exclude } = this;
      if (
        // not included
        (include && (!name || !matches(include, name))) ||
        // excluded
        (exclude && name && matches(exclude, name))
      ) {
        return vnode;
      }
      const { cache, keys } = this;
      // 获取键，优先获取组件的 name 字段，否则是组件的 tag
      const key: ?string =
        vnode.key == null
          ? // same constructor may get registered as different local components
            // so cid alone is not enough (#3269)
            componentOptions.Ctor.cid +
            (componentOptions.tag ? `::${componentOptions.tag}` : "")
          : vnode.key;
      // --------------------------------------------------
      // 下面就是 LRU 算法了，
      // 如果在缓存里有则调整，
      // 没有则放入（长度超过 max，则淘汰最近没有访问的）
      // --------------------------------------------------
      // 如果命中缓存，则从缓存中获取 vnode 的组件实例，并且调整 key 的顺序放入 keys 数组的末尾
      if (cache[key]) {
        vnode.componentInstance = cache[key].componentInstance;
        // make current key freshest
        remove(keys, key);
        keys.push(key);
      }
      // 如果没有命中缓存,就把 vnode 放进缓存
      else {
        cache[key] = vnode;
        keys.push(key);
        // prune oldest entry
        // 如果配置了 max 并且缓存的长度超过了 this.max，还要从缓存中删除第一个
        if (this.max && keys.length > parseInt(this.max)) {
          pruneCacheEntry(cache, keys[0], keys, this._vnode);
        }
      }
      // keepAlive标记位
      vnode.data.keepAlive = true;
    }
    return vnode || (slot && slot[0]);
  }
};

// 移除 key 缓存
function pruneCacheEntry (
  cache: VNodeCache,
  key: string,
  keys: Array<string>,
  current?: VNode
) {
  const cached = cache[key]
  if (cached && (!current || cached.tag !== current.tag)) {
    cached.componentInstance.$destroy()
  }
  cache[key] = null
  remove(keys, key)
}

// remove 方法（shared/util.js）
/**
 * Remove an item from an array.
 */
export function remove (arr: Array<any>, item: any): Array<any> | void {
  if (arr.length) {
    const index = arr.indexOf(item)
    if (index > -1) {
      return arr.splice(index, 1)
    }
  }
}

自己实现一个LRU（JS）

• https://leetcode.cn/problems/lru-cache-lcci/solution/by-yuiyake-3xsq/

/**
 * @param {number} capacity
 */
var LRUCache = function(capacity) {
    // capacity是容量（对应vue的max），head头结点，tail尾结点
    this.capacity = capacity;
    this.head = {};
    this.tail = {};
    this.head.next = this.tail;
    this.tail.pre = this.head;
    this.size = 0
    this.map = new Map();
};

/** 
 * @param {number} key
 * @return {number}
 */
LRUCache.prototype.get = function(key) {
    // 获取数据不用说，主要是要调用一个算法把get过的数字提前（更新最最近久未使用）
    if(this.map.has(key)){
        let node = this.map.get(key);
        this.moveToHead(key, node.value);
        return node.value;
    }
    return -1;
};


/** 
 * @param {number} key 
 * @param {number} value
 * @return {void}
 */
LRUCache.prototype.put = function(key, value) {
    // 先判断是否是同一个key，是的话直接换位置就好；然后判断表是否满，如果没满直接加进去，如果满了要调用delTail把最近最久未使用的结点删掉
    if(this.map.has(key)) {
        this.moveToHead(key, value);
    } else {
        // 没满直接加在头
        if(this.size < this.capacity) {
            this.addHead(key, value);
        } else {        // 满了先删除尾巴（最近最久），然后加在头部
            this.delTail();
            this.addHead(key, value);
        }
    }
};


// 这是删除当前节点
LRUCache.prototype.delNode = function (key) {
    let node = this.map.get(key);
    let preNode = node.pre;
    let nextNode = node.next;
    preNode.next = nextNode;
    nextNode.pre = preNode;
    this.size--;
    this.map.delete(key);
};

// 删除尾结点
LRUCache.prototype.delTail = function () {
    let tailPre = this.tail.pre;
    tailPre.pre.next = this.tail;
    this.tail.pre = tailPre.pre;
    this.size--;
    this.map.delete(tailPre.key);
};

// 加在头部
LRUCache.prototype.addHead = function (key, value) {
    let newNode = {key:key, value:value};
    newNode.next = this.head.next;
    this.head.next.pre = newNode;
    this.head.next = newNode;
    newNode.pre = this.head;
    this.map.set(key, newNode);
    this.size++;
};

// 置换节点
LRUCache.prototype.moveToHead = function (key, value) {
    this.delNode(key);
    this.addHead(key, value);
};