我的编程空间,编程开发者的网络收藏夹
学习永远不晚

webpack的异步加载原理及分包策略

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

webpack的异步加载原理及分包策略

webpack ensure 有人称它为异步加载,也有人称为代码切割,他其实就是将 js 模块给独立导出一个.js 文件,然后使用这个模块的时候,再创建一个 script 对象,加入到 document.head 对象中,浏览器会自动帮我们发起请求,去请求这个 js 文件,然后写个回调函数,让请求到的 js 文件做一些业务操作。

举个例子

需求:main.js 依赖两个 js 文件:A.js 是点击 aBtn 按钮后,才执行的逻辑,B.js 是点击 bBtn 按钮后,才执行的逻辑。

webpack.config.js,我们先来写一下 webpack 打包的配置的代码 

  1. const path = require('path') // 路径处理模块  
  2. const HtmlWebpackPlugin = require('html-webpack-plugin')  
  3. const { CleanWebpackPlugin } = require('clean-webpack-plugin') // 引入CleanWebpackPlugin插件  
  4. module.exports = {  
  5.   entry: { 
  6.      index: path.join(__dirname, '/class="lazy" data-src/main.js'),  
  7.   },  
  8.   output: { 
  9.      path: path.join(__dirname, '/dist'),  
  10.     filename: 'index.js',  
  11.   },  
  12.   plugins: [  
  13.     new HtmlWebpackPlugin({  
  14.       template: path.join(__dirname, '/index.html'),  
  15.     }),  
  16.     new CleanWebpackPlugin(), // 所要清理的文件夹名称  
  17.   ],  

index.html 代码如下 

  1. >  
  2. <html lang="en">  
  3.   <head>  
  4.     <meta charset="UTF-8" />  
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0" />  
  6.     <title>webpacktitle>  
  7.   head>  
  8.   <body>  
  9.     <div id="app">  
  10.       <button id="aBtn">按钮Abutton>  
  11.       <button id="bBtn">按钮Bbutton>  
  12.     div>  
  13.   body>  
  14. html> 

入口文件 main.js 如下 

  1. import A from './A'  
  2. import B from './B'  
  3. document.getElementById('aBtn').onclick = function () {  
  4.   alert(A)  
  5.  
  6. document.getElementById('bBtn').onclick = function () {  
  7.   alert(B)  

A.js 和 B.js 的代码分别如下 

  1. // A.js  
  2. const A = 'hello A'  
  3. module.exports = A  
  4. // B.js  
  5. const B = 'hello B'  
  6. module.exports = B 

此时,我们对项目进行 npm run build, 打包出来的只有两个文件

  •  index.html
  •  index.js

由此可见,此时 webpack 把 main.js 依赖的两个文件都同时打包到同一个 js 文件,并在 index.html 中引入。但是 A.js 和 B.js 都是点击相应按钮才会执行的逻辑,如果用户并没有点击相应按钮,而且这两个文件又是比较大的话,这样是不是就导致首页默认加载的 js 文件太大,从而导致首页渲染较慢呢?那么有能否实现当用户点击按钮的时候再加载相应的依赖文件呢?

webpack.ensure 就解决了这个问题。

require.ensure 异步加载

下面我们将 main.js 改成异步加载的方式 

  1. document.getElementById('aBtn').onclick = function () {  
  2.   //异步加载A  
  3.   require.ensure([], function () {  
  4.     let A = require('./A.js')  
  5.     alert(A)  
  6.   })  
  7.   
  8. document.getElementById('bBtn').onclick = function () {  
  9.   //异步加载b  
  10.   require.ensure([], function () {  
  11.     let B = require('./B.js')  
  12.     alert(B)  
  13.   })  

此时,我们再进行一下打包,发现多了 1.index.js 和 2.index.js 两个文件。而我们打开页面时只引入了 index.js 一个文件,当点击按钮 A 的时候才引入 1.index.js 文件,点击按钮 B 的时候才引入 2.index.js 文件。这样就满足了我们按需加载的需求。

require.ensure 这个函数是一个代码分离的分割线,表示回调里面的 require 是我们想要进行分割出去的,即 require('./A.js'),把 A.js 分割出去,形成一个 webpack 打包的单独 js 文件。它的语法如下 

  1. require.ensure(dependencies: String[], callback: function(require), chunkName: String) 

我们打开 1.index.js 文件,发现它的代码如下 

  1. (windowwindow.webpackJsonp = window.webpackJsonp || []).push([  
  2.   [1],  
  3.   [  
  4.     ,  
  5.     function (o, n) {  
  6.       o.exports = 'hello A'  
  7.     },  
  8.   ],  
  9. ]) 

由上面的代码可以看出:

  1.  异步加载的代码,会保存在一个全局的 webpackJsonp 中。
  2.  webpackJsonp.push 的的值,两个参数分别为异步加载的文件中存放的需要安装的模块对应的 id 和异步加载的文件中存放的需要安装的模块列表。
  3.  在满足某种情况下,会执行具体模块中的代码。

import() 按需加载

webpack4 官方文档提供了模块按需切割加载,配合 es6 的按需加载 import() 方法,可以做到减少首页包体积,加快首页的请求速度,只有其他模块,只有当需要的时候才会加载对应 js。

import()的语法十分简单。该函数只接受一个参数,就是引用包的地址,并且使用了 promise 式的回调,获取加载的包。在代码中所有被 import()的模块,都将打成一个单独的包,放在 chunk 存储的目录下。在浏览器运行到这一行代码时,就会自动请求这个资源,实现异步加载。

下面我们将上述代码改成 import()方式。 

  1. document.getElementById('aBtn').onclick = function () {  
  2.   //异步加载A  
  3.   import('./A').then((data) => {  
  4.     alert(data.A)  
  5.   })  
  6.  
  7. document.getElementById('bBtn').onclick = function () {  
  8.   //异步加载b  
  9.   import('./B').then((data) => {  
  10.     alert(data.B)  
  11.   })  

此时打包出来的文件和 webpack.ensure 方法是一样的。

路由懒加载

为什么需要懒加载?

像 vue 这种单页面应用,如果没有路由懒加载,运用 webpack 打包后的文件将会很大,造成进入首页时,需要加载的内容过多,出现较长时间的白屏,运用路由懒加载则可以将页面进行划分,需要的时候才加载页面,可以有效的分担首页所承担的加载压力,减少首页加载用时。

vue 路由懒加载有以下三种方式

  •  vue 异步组件
  •  ES6 的 import()
  •  webpack 的 require.ensure()

vue 异步组件

这种方法主要是使用了 resolve 的异步机制,用 require 代替了 import 实现按需加载 

  1. export default new Router({  
  2.   routes: [  
  3.     {  
  4.       path: '/home',',  
  5.       component: (resolve) => require(['@/components/home'], resolve),  
  6.     },  
  7.     {  
  8.       path: '/about',',  
  9.       component: (resolve) => require(['@/components/about'], resolve),  
  10.     },  
  11.   ],  
  12. }) 

require.ensure

这种模式可以通过参数中的 webpackChunkName 将 js 分开打包。 

  1. export default new Router({  
  2.   routes: [ 
  3.      {  
  4.       path: '/home',  
  5.       component: (resolve) => require.ensure([], () => resolve(require('@/components/home')), 'home'), 
  6.     },  
  7.     {  
  8.       path: '/about',  
  9.       component: (resolve) => require.ensure([], () => resolve(require('@/components/about')), 'about'),  
  10.     },  
  11.   ],  
  12. }) 

ES6 的 import()

vue-router 在官网提供了一种方法,可以理解也是为通过 Promise 的 resolve 机制。因为 Promise 函数返回的 Promise 为 resolve 组件本身,而我们又可以使用 import 来导入组件。 

  1. export default new Router({  
  2.   routes: [  
  3.     {  
  4.       path: '/home',  
  5.       component: () => import('@/components/home'),  
  6.     },  
  7.     {  
  8.       path: '/about',  
  9.       component: () => import('@/components/home'),  
  10.     },  
  11.   ], 
  12. }) 

webpack 分包策略

在 webpack 打包过程中,经常出现 vendor.js, app.js 单个文件较大的情况,这偏偏又是网页最先加载的文件,这就会使得加载时间过长,从而使得白屏时间过长,影响用户体验。所以我们需要有合理的分包策略。

CommonsChunkPlugin

在 Webapck4.x 版本之前,我们都是使用 CommonsChunkPlugin 去做分离 

  1. plugins: [  
  2.   new webpack.optimize.CommonsChunkPlugin({  
  3.     name: 'vendor',  
  4.     minChunks: function (module, count) {  
  5.       return (  
  6.         module.resource &&  
  7.         /.js$/.test(module.resource) &&  
  8.         module.resource.indexOf(path.join(__dirname, './node_modules')) === 0  
  9.       )  
  10.     },  
  11.   }),  
  12.   new webpack.optimize.CommonsChunkPlugin({  
  13.     name: 'common',  
  14.     chunks: 'initial',  
  15.     minChunks: 2,  
  16.   }),  

我们把以下文件单独抽离出来打包

  •  node_modules 文件夹下的,模块
  •  被 3 个 入口 chunk 共享的模块

optimization.splitChunks

webpack 4 最大的改动就是废除了 CommonsChunkPlugin 引入了 optimization.splitChunks。如果你的 mode 是 production,那么 webpack4 就会自动开启 Code Splitting。

它内置的代码分割策略是这样的:

  •  新的 chunk 是否被共享或者是来自 node_modules 的模块
  •  新的 chunk 体积在压缩之前是否大于 30kb
  •  按需加载 chunk 的并发请求数量小于等于 5 个
  •  页面初始加载时的并发请求数量小于等于 3 个

虽然在 webpack4 会自动开启 Code Splitting,但是随着项目工程的最大,这往往不能满足我们的需求,我们需要再进行个性化的优化。

应用实例

我们先找到一个优化空间较大的项目来进行操作。这是一个后台管理系统项目,大部分内容由 3-4 个前端开发,平时开发周期较短,且大部分人没有优化意识,只是写好业务代码完成需求,日子一长,造成打包出来的文件较大,大大影响性能。

我们先用 webpack-bundle-analyzer 分析打包后的模块依赖及文件大小,确定优化的方向在哪。

然后我们再看下打包出来的 js 文件

看到这两张图的时候,我内心是崩溃的,槽点如下

  •  打包后生成多个将近 1M 的 js 文件,其中不乏 vendor.js 首页必须加载的大文件
  •  xlsx.js 这样的插件没必要使用,导出 excel 更好的方法应该是后端返回文件流格式给前端处理
  •  echart 和 iview 文件太大,应该使用 cdn 引入的方法

吐槽完之后我们就要开始做正事了。正是因为有这么多槽点,我们才更好用来验证我们优化方法的可行性。

抽离 echart 和 iview

由上面分析可知,echart 和 iview 文件太大,此时我们就用到 webpack4 的 optimization.splitChunks 进行代码分割了,把他们单独抽离打包成文件。(为了更好地呈现优化效果,我们先把 xlsx.js 去掉)

vue.config.js 修改如下: 

  1. chainWebpack: config => {  
  2.     config.optimization.splitChunks({  
  3.       chunks: 'all',  
  4.       cacheGroups: {  
  5.         vendors: {  
  6.           name: 'chunk-vendors',  
  7.           test: /[/]node_modules[/]/,  
  8.           priority: 10,  
  9.           chunks: 'initial'  
  10.         },  
  11.         iview: {  
  12.           name: 'chunk-iview',  
  13.           priority: 20,  
  14.           test: /[/]node_modules[/]_?iview(.*)/  
  15.         },  
  16.         echarts: {  
  17.           name: 'chunk-echarts',  
  18.           priority: 20,  
  19.           test: /[/]node_modules[/]_?echarts(.*)/  
  20.         },  
  21.         commons: {  
  22.           name: 'chunk-commons',  
  23.           minChunks: 2,  
  24.           priority: 5,  
  25.           chunks: 'initial',  
  26.           reuseExistingChunk: true  
  27.         }  
  28.       }  
  29.     })  
  30.   }, 

此时我们再用 webpack-bundle-analyzer 分析一下

打包出来的 js 文件

从这里可以看出我们已经成功把 echart 和 iview 单独抽离出来了,同时 vendor.js 也相应地减小了体积。此外,我们还可以继续抽离其他更多的第三方模块。

CDN 方式

虽然第三方模块是单独抽离出来了,但是在首页或者相应路由加载时还是要加载这样一个几百 kb 的文件,还是不利于性能优化的。这时,我们可以用 CDN 的方式引入这样插件或者 UI 组件库。

    1.  在 index.html 引入相应 cdn 链接 

  1. <head>  
  2.   <link rel="stylesheet" href="https://cdn.bootcdn.net/ajax/libs/iview/3.5.4/styles/iview.css" /> 
  3. head>  
  4. <body>  
  5.   <div id="app">div>  
  6.   <script class="lazy" data-src="https://cdn.bootcss.com/vue/2.6.8/vue.min.js">script>  
  7.   <script class="lazy" data-src="https://cdn.bootcdn.net/ajax/libs/iview/3.5.4/iview.min.js">script>  
  8.   <script class="lazy" data-src="https://cdn.bootcdn.net/ajax/libs/xlsx/0.16.8/xlsx.mini.min.js">script>  
  9.   <script class="lazy" data-src="https://cdn.bootcdn.net/ajax/libs/xlsx/0.16.8/cpexcel.min.js">script>  
  10. body> 

    1.  vue.config.js 配置 externals 

  1. configureWebpack: (config) => {  
  2.   config.externals = {  
  3.     vue: 'Vue',  
  4.     xlsx: 'XLSX',  
  5.     iview: 'iView',  
  6.     iView: 'ViewUI',  
  7.   }  

    1.  删除之前的引入方式并卸载相应 npm 依赖包 

  1. npm uninstall vue iview echarts xlsx --save 

此时我们在来看一下打包后的情况

打包出来的 js 文件

well done ! 这时基本没有打包出大文件了,首页加载需要的 vendor.js 也只有几十 kb,而且我们还可以进一步优化,就是把 vue 全家桶的一些模块再通过 cdn 的方法引入,比如 vue-router,vuex,axios 等。这时页面特别是首页加载的性能就得到大大地优化了。 

 

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

webpack的异步加载原理及分包策略

下载Word文档到电脑,方便收藏和打印~

下载Word文档

猜你喜欢

webpack的异步加载原理及分包策略

webpack ensure 有人称它为异步加载,也有人称为代码切割,他其实就是将 js 模块给独立导出一个.js 文件。

使用 Spring Boot3.3 与 MyBatis-Plus 联合实现多层次树结构的异步加载策略

本文介绍了如何使用Spring Boot结合MyBatis-Plus实现多层次树结构的异步加载策略。我们通过一个简单的分类树示例展示了如何在前端逐步加载节点,避免一次性加载大量数据带来的性能问题。

编程热搜

  • Python 学习之路 - Python
    一、安装Python34Windows在Python官网(https://www.python.org/downloads/)下载安装包并安装。Python的默认安装路径是:C:\Python34配置环境变量:【右键计算机】--》【属性】-
    Python 学习之路 - Python
  • chatgpt的中文全称是什么
    chatgpt的中文全称是生成型预训练变换模型。ChatGPT是什么ChatGPT是美国人工智能研究实验室OpenAI开发的一种全新聊天机器人模型,它能够通过学习和理解人类的语言来进行对话,还能根据聊天的上下文进行互动,并协助人类完成一系列
    chatgpt的中文全称是什么
  • C/C++中extern函数使用详解
  • C/C++可变参数的使用
    可变参数的使用方法远远不止以下几种,不过在C,C++中使用可变参数时要小心,在使用printf()等函数时传入的参数个数一定不能比前面的格式化字符串中的’%’符号个数少,否则会产生访问越界,运气不好的话还会导致程序崩溃
    C/C++可变参数的使用
  • css样式文件该放在哪里
  • php中数组下标必须是连续的吗
  • Python 3 教程
    Python 3 教程 Python 的 3.0 版本,常被称为 Python 3000,或简称 Py3k。相对于 Python 的早期版本,这是一个较大的升级。为了不带入过多的累赘,Python 3.0 在设计的时候没有考虑向下兼容。 Python
    Python 3 教程
  • Python pip包管理
    一、前言    在Python中, 安装第三方模块是通过 setuptools 这个工具完成的。 Python有两个封装了 setuptools的包管理工具: easy_install  和  pip , 目前官方推荐使用 pip。    
    Python pip包管理
  • ubuntu如何重新编译内核
  • 改善Java代码之慎用java动态编译

目录