说说你对keep-alive的理解是什么？ - 图1

一、Keep-alive 是什么

keep-alive是vue中的内置组件，能在组件切换过程中将状态保留在内存中，防止重复渲染DOM

keep-alive 包裹动态组件时，会缓存不活动的组件实例，而不是销毁它们

keep-alive可以设置以下props属性：

  • include - 字符串或正则表达式。只有名称匹配的组件会被缓存
  • exclude - 字符串或正则表达式。任何名称匹配的组件都不会被缓存
  • max - 数字。最多可以缓存多少组件实例

关于keep-alive的基本用法：

  1. <keep-alive>
  2.   <component :is="view"></component>
  3. </keep-alive>

使用includes和exclude：

  1. <keep-alive include="a,b">
  2.   <component :is="view"></component>
  3. </keep-alive>
  4. <!-- 正则表达式 (使用 `v-bind`) -->
  5. <keep-alive :include="/a|b/">
  6.   <component :is="view"></component>
  7. </keep-alive>
  8. <!-- 数组 (使用 `v-bind`) -->
  9. <keep-alive :include="['a', 'b']">
  10.   <component :is="view"></component>
  11. </keep-alive>

匹配首先检查组件自身的 name 选项，如果 name 选项不可用，则匹配它的局部注册名称 (父组件 components 选项的键值)，匿名组件不能被匹配

设置了 keep-alive 缓存的组件，会多出两个生命周期钩子（activated与deactivated）：

  • 首次进入组件时：beforeRouteEnter > beforeCreate > created> mounted > activated > … … > beforeRouteLeave > deactivated
  • 再次进入组件时：beforeRouteEnter >activated > … … > beforeRouteLeave > deactivated

二、使用场景

使用原则：当我们在某些场景下不需要让页面重新加载时我们可以使用keepalive
举个栗子:
当我们从首页–>列表页–>商详页–>再返回，这时候列表页应该是需要keep-alive

从首页–>列表页–>商详页–>返回到列表页(需要缓存)–>返回到首页(需要缓存)–>再次进入列表页(不需要缓存)，这时候可以按需来控制页面的keep-alive

在路由中设置keepAlive属性判断是否需要缓存

  1. {
  2.   path: 'list',
  3.     name: 'itemList', // 列表页
  4.     component (resolve) {
  5.     require(['@/pages/item/list'], resolve)
  6.   },
  7.   meta: {
  8.     keepAlive: true,
  9.       title: '列表页'
  10.   }
  11. }

使用<keep-alive>

  1. <div id="app" class='wrapper'>
  2.     <keep-alive>
  3.         <!-- 需要缓存的视图组件 --> 
  4.         <router-view v-if="$route.meta.keepAlive"></router-view>
  5.      </keep-alive>
  6.       <!-- 不需要缓存的视图组件 -->
  7.      <router-view v-if="!$route.meta.keepAlive"></router-view>
  8. </div>

三、原理分析

keep-alive是vue中内置的一个组件

源码位置：src/core/components/keep-alive.js

  1. export default {
  2.   name: 'keep-alive',
  3.   abstract: true,
  4.   props: {
  5.     include: [String, RegExp, Array],
  6.     exclude: [String, RegExp, Array],
  7.     max: [String, Number]
  8.   },
  9.   created () {
  10.     this.cache = Object.create(null)
  11.     this.keys = []
  12.   },
  13.   destroyed () {
  14.     for (const key in this.cache) {
  15.       pruneCacheEntry(this.cache, key, this.keys)
  16.     }
  17.   },
  18.   mounted () {
  19.     this.$watch('include', val => {
  20.       pruneCache(this, name => matches(val, name))
  21.     })
  22.     this.$watch('exclude', val => {
  23.       pruneCache(this, name => !matches(val, name))
  24.     })
  25.   },
  26.   render() {
  27.     /* 获取默认插槽中的第一个组件节点 */
  28.     const slot = this.$slots.default
  29.     const vnode = getFirstComponentChild(slot)
  30.     /* 获取该组件节点的componentOptions */
  31.     const componentOptions = vnode && vnode.componentOptions
  32.     if (componentOptions) {
  33.       /* 获取该组件节点的名称，优先获取组件的name字段，如果name不存在则获取组件的tag */
  34.       const name = getComponentName(componentOptions)
  35.       const { include, exclude } = this
  36.       /* 如果name不在inlcude中或者存在于exlude中则表示不缓存，直接返回vnode */
  37.       if (
  38.         (include && (!name || !matches(include, name))) ||
  39.         // excluded
  40.         (exclude && name && matches(exclude, name))
  41.       ) {
  42.         return vnode
  43.       }
  44.       const { cache, keys } = this
  45.       /* 获取组件的key值 */
  46.       const key = vnode.key == null
  47.         // same constructor may get registered as different local components
  48.         // so cid alone is not enough (#3269)
  49.         ? componentOptions.Ctor.cid + (componentOptions.tag ? `::${componentOptions.tag}` : '')
  50.         : vnode.key
  51.      /*  拿到key值后去this.cache对象中去寻找是否有该值，如果有则表示该组件有缓存，即命中缓存 */
  52.       if (cache[key]) {
  53.         vnode.componentInstance = cache[key].componentInstance
  54.         // make current key freshest
  55.         remove(keys, key)
  56.         keys.push(key)
  57.       }
  58.         /* 如果没有命中缓存，则将其设置进缓存 */
  59.         else {
  60.         cache[key] = vnode
  61.         keys.push(key)
  62.         // prune oldest entry
  63.         /* 如果配置了max并且缓存的长度超过了this.max，则从缓存中删除第一个 */
  64.         if (this.max && keys.length > parseInt(this.max)) {
  65.           pruneCacheEntry(cache, keys[0], keys, this._vnode)
  66.         }
  67.       }
  68.       vnode.data.keepAlive = true
  69.     }
  70.     return vnode || (slot && slot[0])
  71.   }
  72. }

可以看到该组件没有template，而是用了render，在组件渲染的时候会自动执行render函数

this.cache是一个对象，用来存储需要缓存的组件，它将以如下形式存储：

  1. this.cache = {
  2.     'key1':'组件1',
  3.     'key2':'组件2',
  4.     // ...
  5. }

在组件销毁的时候执行pruneCacheEntry函数

  1. function pruneCacheEntry (
  2.   cache: VNodeCache,
  3.   key: string,
  4.   keys: Array<string>,
  5.   current?: VNode
  6. ) {
  7.   const cached = cache[key]
  8.   /* 判断当前没有处于被渲染状态的组件，将其销毁*/
  9.   if (cached && (!current || cached.tag !== current.tag)) {
  10.     cached.componentInstance.$destroy()
  11.   }
  12.   cache[key] = null
  13.   remove(keys, key)
  14. }

在mounted钩子函数中观测 include 和 exclude 的变化，如下：

  1. mounted () {
  2.     this.$watch('include', val => {
  3.         pruneCache(this, name => matches(val, name))
  4.     })
  5.     this.$watch('exclude', val => {
  6.         pruneCache(this, name => !matches(val, name))
  7.     })
  8. }

如果include 或exclude 发生了变化，即表示定义需要缓存的组件的规则或者不需要缓存的组件的规则发生了变化，那么就执行pruneCache函数，函数如下：

  1. function pruneCache (keepAliveInstance, filter) {
  2.   const { cache, keys, _vnode } = keepAliveInstance
  3.   for (const key in cache) {
  4.     const cachedNode = cache[key]
  5.     if (cachedNode) {
  6.       const name = getComponentName(cachedNode.componentOptions)
  7.       if (name && !filter(name)) {
  8.         pruneCacheEntry(cache, key, keys, _vnode)
  9.       }
  10.     }
  11.   }
  12. }

在该函数内对this.cache对象进行遍历，取出每一项的name值，用其与新的缓存规则进行匹配，如果匹配不上，则表示在新的缓存规则下该组件已经不需要被缓存，则调用pruneCacheEntry函数将其从this.cache对象剔除即可

关于keep-alive的最强大缓存功能是在render函数中实现

首先获取组件的key值：

  1. const key = vnode.key == null? 
  2. componentOptions.Ctor.cid + (componentOptions.tag ? `::${componentOptions.tag}` : '')
  3. : vnode.key

拿到key值后去this.cache对象中去寻找是否有该值，如果有则表示该组件有缓存，即命中缓存，如下：

  1. /* 如果命中缓存，则直接从缓存中拿 vnode 的组件实例 */
  2. if (cache[key]) {
  3.     vnode.componentInstance = cache[key].componentInstance
  4.     /* 调整该组件key的顺序，将其从原来的地方删掉并重新放在最后一个 */
  5.     remove(keys, key)
  6.     keys.push(key)
  7. }

直接从缓存中拿 vnode 的组件实例，此时重新调整该组件key的顺序，将其从原来的地方删掉并重新放在this.keys中最后一个

this.cache对象中没有该key值的情况，如下：

  1. /* 如果没有命中缓存，则将其设置进缓存 */
  2. else {
  3.     cache[key] = vnode
  4.     keys.push(key)
  5.     /* 如果配置了max并且缓存的长度超过了this.max，则从缓存中删除第一个 */
  6.     if (this.max && keys.length > parseInt(this.max)) {
  7.         pruneCacheEntry(cache, keys[0], keys, this._vnode)
  8.     }
  9. }

表明该组件还没有被缓存过，则以该组件的key为键，组件vnode为值，将其存入this.cache中，并且把key存入this.keys中

此时再判断this.keys中缓存组件的数量是否超过了设置的最大缓存数量值this.max，如果超过了，则把第一个缓存组件删掉

四、思考题：缓存后如何获取数据

解决方案可以有以下两种：

  • beforeRouteEnter
  • actived

beforeRouteEnter

每次组件渲染的时候，都会执行beforeRouteEnter

  1. beforeRouteEnter(to, from, next){
  2.     next(vm=>{
  3.         console.log(vm)
  4.         // 每次进入路由执行
  5.         vm.getData()  // 获取数据
  6.     })
  7. },

actived

在keep-alive缓存的组件被激活的时候，都会执行actived钩子

  1. activated(){
  2.    this.getData() // 获取数据
  3. },

注意：服务器端渲染期间avtived不被调用

参考文献