为Vue的惰性加载加一个进度条

简介

通常用 Vue.js 编写单页应用(SPA)时，当加载页面时，所有必需的资源(如 JavaScript 和 CSS 文件)都会被一起加载。在处理大文件时，这可能会导致用户体验不佳。

借助 Webpack，可以用 import() 函数而不是 import 关键字在 Vue.js 中按需加载页面。

为什么要按需加载?

Vue.js 中 SPA 的典型工作方式是将所有功能和资源打包一并交付，这样可以使用户无需刷新页面即可使用你的应用。如果你没有为了按需加载页面针对自己的应用进行明确的设计，那么所有的页面会被立即加载，或者提前使用大量内存进行不必要的预加载。

这对有许多页面的大型 SPA 非常不利，会导致使用低端手机和低网速的用户体验会很差。如果通过按需加载，用户将不需要下载他们当前不需要的资源。

Vue.js 没有为动态模块提供任何加载指示器相关的控件。即使进行了预取和预加载，也没有对应的空间让用户知道加载的过程，所以还需要通过添加进度条来改善用户体验。

准备项目

首先需要一种让进度条与 Vue Router 通信的方法。事件总线模式比较合适。

事件总线是一个 Vue 实例的单例。由于所有 Vue 实例都有一个使用 $on和 $emit的事件系统，因此可以用它在应用中的任何地方传递事件。

首先在 components 目录中创建一个新文件 eventHub.js：

 
 
 
 
    
  
  
  
  
  1. import Vue from 'vue' 
    2. 
  
  
  
  
  2. export default new Vue() 
    3.

然后把 Webpack 配置为禁用预取和预加载，这样就可以针对每个函数单独执行此类操作，当然你也可以全局禁用它。在根文件夹中创建一个 vue.config.js 文件并添加禁用预取和预加载的相关配置：

 
 
 
 
    
  
  
  
  
  1. module.exports = { 
    2. 
  
  
  
  
  2.     chainWebpack: (config) => { 
    3. 
  
  
  
  
  3.         // 禁用预取和预加载 
    4. 
  
  
  
  
  4.         config.plugins.delete('prefetch') 
    5. 
  
  
  
  
  5.         config.plugins.delete('preload') 
    6. 
  
  
  
  
  6.     }, 
    7. 
  
  
  
  
  7. } 
    8.

添加路由和页面

用 npx 安装 Vue router 并使用：

 
 
 
 
    
  
  
  
  
  1. $ npx vue add router 
    2.

编辑位于 router/index.js 下的 router 文件并更新路由，以便可以用 import() 函数代替 import 语句：

以下默认配置：

 
 
 
 
    
  
  
  
  
  1. import About from '../views/About.vue' 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3.     path: '/about', 
    4. 
  
  
  
  
  4.     name: 'About', 
    5. 
  
  
  
  
  5.     component: About 
    6. 
  
  
  
  
  6. }, 
    7.

将其改为：

 
 
 
 
    
  
  
  
  
  1. { 
    2. 
  
  
  
  
  2.     path: '/about', 
    3. 
  
  
  
  
  3.     name: 'About', 
    4. 
  
  
  
  
  4.     component: () => import('../views/About.vue') 
    5. 
  
  
  
  
  5. }, 
    6.

如果希望可以选择按需加载某些页面，而不是全局禁用预取和预加载，可以用特殊的 Webpack 注释，不要在 vue.config.js 中配置 Webpack：

 
 
 
 
    
  
  
  
  
  1. import( 
    2. 
  
  
  
  
  2.     /* webpackPrefetch: true */ 
    3. 
  
  
  
  
  3.     /* webpackPreload: true */ 
    4. 
  
  
  
  
  4.     '../views/About.vue' 
    5. 
  
  
  
  
  5. ) 
    6.

import() 和 import 之间的主要区别是在运行时加载由 import() 加载的 ES 模块，在编译时加载由 import 加载的 ES 模块。这就意味着可以用 import() 延迟模块的加载，并仅在必要时加载。

实现进度条

由于无法准确估算页面的加载时间(或完全加载)，因此我们无法真正的去创建进度条。也没有办法检查页面已经加载了多少。不过可以创建一个进度条，并使它在页面加载时完成。

由于不能真正反映进度，所以描绘的进度只是进行了随机跳跃。

先安装 lodash.random，因为在生成进度条的过程中将会用这个包产生一些随机数：

 
 
 
 
    
  
  
  
  
  1. $ npm i lodash.random 
    2.

然后，创建一个 Vue 组件 components/ProgressBar.vue：

 
 
 
 
    
  
  
  
  
  1.  
    2.

接下来向该组件添加脚本。在脚本中先导入 random 和 $eventHub，后面会用到：

 
 
 
 
    
  
  
  
  
  1.  
    2.

导入之后，在脚本中定义一些后面要用到的变量：

 
 
 
 
    
  
  
  
  
  1. // 假设加载将在此时间内完成。 
    2. 
  
  
  
  
  2. const defaultDuration = 8000  
    3. 
  
  
  
  
  3. // 更新频率 
    4. 
  
  
  
  
  4. const defaultInterval = 1000  
    5. 
  
  
  
  
  5. // 取值范围 0 - 1. 每个时间间隔进度增长多少 
    6. 
  
  
  
  
  6. const variation = 0.5  
    7. 
  
  
  
  
  7. // 0 - 100. 进度条应该从多少开始。 
    8. 
  
  
  
  
  8. const startingPoint = 0  
    9. 
  
  
  
  
  9. // 限制进度条到达加载完成之前的距离 
    10. 
  
  
  
  
  10. const endingPoint = 90  
    11.

然后编码实现异步加载组件的逻辑：

 
 
 
 
    
  
  
  
  
  1. export default { 
    2. 
  
  
  
  
  2.     name: 'ProgressBar', 
    3. 
  
  
  
  
  3.      
    4. 
  
  
  
  
  4.     data: () => ({ 
    5. 
  
  
  
  
  5.         isLoading: true, // 加载完成后，开始逐渐消失 
    6. 
  
  
  
  
  6.         isVisible: false, // 完成动画后，设置 display: none 
    7. 
  
  
  
  
  7.         progress: startingPoint, 
    8. 
  
  
  
  
  8.         timeoutId: undefined, 
    9. 
  
  
  
  
  9.     }), 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.     mounted() { 
    12. 
  
  
  
  
  12.         $eventHub.$on('asyncComponentLoading', this.start) 
    13. 
  
  
  
  
  13.         $eventHub.$on('asyncComponentLoaded', this.stop) 
    14. 
  
  
  
  
  14.     }, 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16.     methods: { 
    17. 
  
  
  
  
  17.         start() { 
    18. 
  
  
  
  
  18.             this.isLoading = true 
    19. 
  
  
  
  
  19.             this.isVisible = true 
    20. 
  
  
  
  
  20.             this.progress = startingPoint 
    21. 
  
  
  
  
  21.             this.loop() 
    22. 
  
  
  
  
  22.         }, 
    23. 
  
  
  
  
  23.  
    24. 
  
  
  
  
  24.         loop() { 
    25. 
  
  
  
  
  25.             if (this.timeoutId) { 
    26. 
  
  
  
  
  26.                 clearTimeout(this.timeoutId) 
    27. 
  
  
  
  
  27.             } 
    28. 
  
  
  
  
  28.             if (this.progress >= endingPoint) { 
    29. 
  
  
  
  
  29.                 return 
    30. 
  
  
  
  
  30.             } 
    31. 
  
  
  
  
  31.             const size = (endingPoint - startingPoint) / (defaultDuration / defaultInterval) 
    32. 
  
  
  
  
  32.             const p = Math.round(this.progress + random(size * (1 - variation), size * (1 + variation))) 
    33. 
  
  
  
  
  33.             this.progress = Math.min(p, endingPoint) 
    34. 
  
  
  
  
  34.             this.timeoutId = setTimeout( 
    35. 
  
  
  
  
  35.                 this.loop, 
    36. 
  
  
  
  
  36.                 random(defaultInterval * (1 - variation), defaultInterval * (1 + variation)) 
    37. 
  
  
  
  
  37.             ) 
    38. 
  
  
  
  
  38.         }, 
    39. 
  
  
  
  
  39.  
    40. 
  
  
  
  
  40.         stop() { 
    41. 
  
  
  
  
  41.             this.isLoading = false 
    42. 
  
  
  
  
  42.             this.progress = 100 
    43. 
  
  
  
  
  43.             clearTimeout(this.timeoutId) 
    44. 
  
  
  
  
  44.             const self = this 
    45. 
  
  
  
  
  45.             setTimeout(() => { 
    46. 
  
  
  
  
  46.                 if (!self.isLoading) { 
    47. 
  
  
  
  
  47.                     self.isVisible = false 
    48. 
  
  
  
  
  48.                 } 
    49. 
  
  
  
  
  49.             }, 200) 
    50. 
  
  
  
  
  50.         }, 
    51. 
  
  
  
  
  51.     }, 
    52. 
  
  
  
  
  52. } 
    53.

在 mounted() 函数中，用事件总线来侦听异步组件的加载。一旦路由告诉我们已经导航到尚未加载的页面，它将会开始加载动画。

最后其添加一些样式：

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2. .loading-container { 
    3. 
  
  
  
  
  3.     font-size: 0; 
    4. 
  
  
  
  
  4.     position: fixed; 
    5. 
  
  
  
  
  5.     top: 0; 
    6. 
  
  
  
  
  6.     left: 0; 
    7. 
  
  
  
  
  7.     height: 5px; 
    8. 
  
  
  
  
  8.     width: 100%; 
    9. 
  
  
  
  
  9.     opacity: 0; 
    10. 
  
  
  
  
  10.     display: none; 
    11. 
  
  
  
  
  11.     z-index: 100; 
    12. 
  
  
  
  
  12.     transition: opacity 200; 
    13. 
  
  
  
  
  13. } 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. .loading-container.visible { 
    16. 
  
  
  
  
  16.     display: block; 
    17. 
  
  
  
  
  17. } 
    18. 
  
  
  
  
  18. .loading-container.loading { 
    19. 
  
  
  
  
  19.     opacity: 1; 
    20. 
  
  
  
  
  20. } 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22. .loader { 
    23. 
  
  
  
  
  23.     background: #23d6d6; 
    24. 
  
  
  
  
  24.     display: inline-block; 
    25. 
  
  
  
  
  25.     height: 100%; 
    26. 
  
  
  
  
  26.     width: 50%; 
    27. 
  
  
  
  
  27.     overflow: hidden; 
    28. 
  
  
  
  
  28.     border-radius: 0 0 5px 0; 
    29. 
  
  
  
  
  29.     transition: 200 width ease-out; 
    30. 
  
  
  
  
  30. } 
    31. 
  
  
  
  
  31.  
    32. 
  
  
  
  
  32. .loader > .light { 
    33. 
  
  
  
  
  33.     float: right; 
    34. 
  
  
  
  
  34.     height: 100%; 
    35. 
  
  
  
  
  35.     width: 20%; 
    36. 
  
  
  
  
  36.     background-image: linear-gradient(to right, #23d6d6, #29ffff, #23d6d6); 
    37. 
  
  
  
  
  37.     animation: loading-animation 2s ease-in infinite; 
    38. 
  
  
  
  
  38. } 
    39. 
  
  
  
  
  39.  
    40. 
  
  
  
  
  40. .glow { 
    41. 
  
  
  
  
  41.     display: inline-block; 
    42. 
  
  
  
  
  42.     height: 100%; 
    43. 
  
  
  
  
  43.     width: 30px; 
    44. 
  
  
  
  
  44.     margin-left: -30px; 
    45. 
  
  
  
  
  45.     border-radius: 0 0 5px 0; 
    46. 
  
  
  
  
  46.     box-shadow: 0 0 10px #23d6d6; 
    47. 
  
  
  
  
  47. } 
    48. 
  
  
  
  
  48.  
    49. 
  
  
  
  
  49. @keyframes loading-animation { 
    50. 
  
  
  
  
  50.     0% { 
    51. 
  
  
  
  
  51.         margin-right: 100%; 
    52. 
  
  
  
  
  52.     } 
    53. 
  
  
  
  
  53.     50% { 
    54. 
  
  
  
  
  54.         margin-right: 100%; 
    55. 
  
  
  
  
  55.     } 
    56. 
  
  
  
  
  56.     100% { 
    57. 
  
  
  
  
  57.         margin-right: -10%; 
    58. 
  
  
  
  
  58.     } 
    59. 
  
  
  
  
  59. } 
    60. 
  
  
  
  
  60.  
    61.

最后将 ProgressBar 添加到 App.vue 或布局组件中，只要它与路由视图位于同一组件中即可，它在应用的整个生命周期中都可用：

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.  
    4.

然后你就可以在页面顶端看到一个流畅的进度条：

页面顶端的进度条

为延迟加载触发进度条现在 ProgressBar 正在事件总线上侦听异步组件加载事件。当某些资源以这种方式加载时应该触发动画。现在向路由添加一个路由守护来接收以下事件：

 
 
 
 
    
  
  
  
  
  1. import $eventHub from '../components/eventHub' 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. router.beforeEach((to, from, next) => { 
    4. 
  
  
  
  
  4.     if (typeof to.matched[0]?.components.default === 'function') { 
    5. 
  
  
  
  
  5.         $eventHub.$emit('asyncComponentLoading', to) // 启动进度条 
    6. 
  
  
  
  
  6.     } 
    7. 
  
  
  
  
  7.     next() 
    8. 
  
  
  
  
  8. }) 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. router.beforeResolve((to, from, next) => { 
    11. 
  
  
  
  
  11.     $eventHub.$emit('asyncComponentLoaded') // 停止进度条 
    12. 
  
  
  
  
  12.     next() 
    13. 
  
  
  
  
  13. }) 
    14.

为了检测页面是否被延迟加载了，需要检查组件是不是被定义为动态导入的，也就是应该为 component:() => import('...') 而不是component:MyComponent。

这是通过 typeof to.matched[0]?.components.default === 'function'完成的。带有 import 语句的组件不会被归为函数。

总结

在本文中，我们禁用了在 Vue 应用中的预取和预加载功能，并创建了一个进度条组件，该组件可显示以模拟加载页面时的实际进度。

本文名称：为Vue的惰性加载加一个进度条
本文URL：http://www.shufengxianlan.com/qtweb/news15/448015.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

全网营销推广知识

行业网站建设

成都标牌标识牌制作公司　　 　乐至网站建设　　 　盐亭做网站　　 　php空间　　 　南充做网站　　 　晟和广告　　 　鳄鱼养殖　　 　网站设计　　 　小谭建站　　 　广安网站制作公司　　 　江油网站建设　　 　成都网络推广　　 　成都微商城　　 　草坪音箱　　 　成都网站设计　　 　成都网站设计　　 　网站搜索引擎优化　　 　四川國際商會　　 　深圳纱窗安装　　 　成都企业网站建设