写点什么

webpack 配置优化, 让你的构建速度飞起

作者:Geek_02d948
  • 2022-11-01
    浙江
  • 本文字数:21587 字

    阅读完需:约 71 分钟

前言

越来越多的项目使用 webpack5 来构建项目了,今天给大家带来最前沿的 webpack5 配置,让我们代码在编译/运行时性能更好~我们会从以下角度来进行优化:


  1. 提升打包构建速度

  2. 减少代码体积

  3. 优化代码运行性能

提升打包构建速度

在进行打包速度优化之前,需要对当前项目每个部分的打包时间了解清楚。


我们借助 speed-measure-webpack-plugin 插件,它分析 webpack 的总打包耗时以及每个 plugin 和 loader 的打包耗时,从而让我们对打包时间较长的部分进行针对性优化。通过以下命令安装插件:


yarn add speed-measure-webpack-plugin -D


build 就能看到各个部分的打包耗时


缩小构建范围


构建过程是默认全局查找,这非常的耗时。通过手动配置 rules 中的文件查找范围,可以减少打包的范围,从而提升打包的速度。


在 webpack.config.js 文件中如下配置:


module.exports = {  // ...  module: {    rules: [      {        test: /.js$/,        use: ['babel-loader'],        exclude: /node_modules/,      },    ],  },};
复制代码


由于 babel-loader 对文件的转化是非常耗时的,所以缩小构建范围首先就是缩小需要 babel-loader 处理的文件范围。


可以通过 test 、 include 、 exclude 三个配置项来命中 Loader 要应用规则的文件,用 include 去命中需要被 babel-loader 处理的文件,exclude 去排除不需要被处理的文件,从而缩小了 Loader 处理文件的范围。

HotModuleReplacement

开发时我们修改了其中一个模块代码,Webpack 默认会将所有模块全部重新打包编译,速度很慢。所以我们需要做到修改某个模块代码,就只有这个模块代码需要重新打包编译,其他模块不变,这样打包速度就能很快。 HotModuleReplacement(HMR/热模块替换):在程序运行中,替换、添加或删除模块,而无需重新加载整个页面。


  1. 基本配置


module.exports = {  // 其他省略  devServer: {    host: "localhost", // 启动服务器域名    port: "3000", // 启动服务器端口号    open: true, // 是否自动打开浏览器    hot: true, // 开启HMR功能(只能用于开发环境,生产环境不需要了)  },};
复制代码


此时 css 样式经过 style-loader 处理,已经具备 HMR 功能了。 但是 js 还不行。


  1. JS 配置在 js 模块当中要加上module.hot的判断才可以


// 判断是否支持HMR功能if (module.hot) {  module.hot.accept("./js/aaa.js", function (count) {    //xxx    console.log(111);  });
module.hot.accept("./js/bbb.js", function (sum) { //xxx console.log(222); });}
复制代码


但实际上我们很少看到有这样的写法,为什么呢?这是因为上面开发我们会使用其他 loader 来解决。


比如:vue-loader, react-hot-loader。他们在处理文件的时候已经帮我们做了处理。这里我们来简单了解下 HMR 的原理,面试时面试官最喜欢问原理性问题了。

HMR 的工作原理图解

初识 HMR 的时候觉得其很神奇,一直有一些疑问萦绕在脑海。


  1. webpack 可以将不同的模块打包成 bundle 文件或者几个 chunk 文件,但是当我通过 webpack HMR 进行开发的过程中,我并没有在我的 dist 目录中找到 webpack 打包好的文件,它们去哪呢?

  2. 通过查看 webpack-dev-server 的 package.json 文件,我们知道其依赖于 webpack-dev-middleware 库,那么 webpack-dev-middleware 在 HMR 过程中扮演什么角色?

  3. 使用 HMR 的过程中,通过 Chrome 开发者工具我知道浏览器是通过 websocket 和 webpack-dev-server 进行通信的,但是 websocket 的 message 中并没有发现新模块代码。打包后的新模块又是通过什么方式发送到浏览器端的呢?为什么新的模块不通过 websocket 随消息一起发送到浏览器端呢?

  4. 浏览器拿到最新的模块代码,HMR 又是怎么将老的模块替换成新的模块,在替换的过程中怎样处理模块之间的依赖关系?

  5. 当模块的热替换过程中,如果替换模块失败,有什么回退机制吗?


带着上面的问题,于是决定深入到 webpack 源码,寻找 HMR 底层的奥秘



HMR 工作流程图解


上图是 webpack 配合 webpack-dev-server 进行应用开发的模块热更新流程图。


  • 上图底部红色框内是服务端,而上面的橙色框是浏览器端。

  • 绿色的方框是 webpack 代码控制的区域。蓝色方框是 webpack-dev-server 代码控制的区域,洋红色的方框是文件系统,文件修改后的变化就发生在这,而青色的方框是应用本身。


上图显示了我们修改代码到模块热更新完成的一个周期,通过深绿色的阿拉伯数字符号已经将 HMR 的整个过程标识了出来。


  1. 第一步,在 webpack 的 watch 模式下,文件系统中某一个文件发生修改,webpack 监听到文件变化,根据配置文件对模块重新编译打包,并将打包后的代码通过简单的 JavaScript 对象保存在内存中。

  2. 第二步是 webpack-dev-server 和 webpack 之间的接口交互,而在这一步,主要是 dev-server 的中间件 webpack-dev-middleware 和 webpack 之间的交互,webpack-dev-middleware 调用 webpack 暴露的 API 对代码变化进行监控,并且告诉 webpack,将代码打包到内存中。

  3. 第三步是 webpack-dev-server 对文件变化的一个监控,这一步不同于第一步,并不是监控代码变化重新打包。当我们在配置文件中配置了 devServer.watchContentBase 为 true 的时候,Server 会监听这些配置文件夹中静态文件的变化,变化后会通知浏览器端对应用进行 live reload。注意,这儿是浏览器刷新,和 HMR 是两个概念。

  4. 第四步也是 webpack-dev-server 代码的工作,该步骤主要是通过 sockjs((webpack-dev-server 的依赖)在浏览器端和服务端之间建立一个 websocket 长连接,将 webpack 编译打包的各个阶段的状态信息告知浏览器端,同时也包括第三步中 Server 监听静态文件变化的信息。浏览器端根据这些 socket 消息进行不同的操作。当然服务端传递的最主要信息还是新模块的 hash 值,后面的步骤根据这一 hash 值来进行模块热替换。

  5. webpack-dev-server/client 端并不能够请求更新的代码,也不会执行热更模块操作,而把这些工作又交回给了 webpack,webpack/hot/dev-server 的工作就是根据 webpack-dev-server/client 传给它的信息以及 dev-server 的配置决定是刷新浏览器呢还是进行模块热更新。当然如果仅仅是刷新浏览器,也就没有后面那些步骤了。

  6. HotModuleReplacement.runtime 是客户端 HMR 的中枢,它接收到上一步传递给他的新模块的 hash 值,它通过 JsonpMainTemplate.runtime 向 server 端发送 Ajax 请求,服务端返回一个 json,该 json 包含了所有要更新的模块的 hash 值,获取到更新列表后,该模块再次通过 jsonp 请求,获取到最新的模块代码。这就是上图中 7、8、9 步骤。

  7. 而第 10 步是决定 HMR 成功与否的关键步骤,在该步骤中,HotModulePlugin 将会对新旧模块进行对比,决定是否更新模块,在决定更新模块后,检查模块之间的依赖关系,更新模块的同时更新模块间的依赖引用。

  8. 最后一步,当 HMR 失败后,回退到 live reload 操作,也就是进行浏览器刷新来获取最新打包代码。


webpack 视频讲解:进入学习

OneOf

打包时每个文件都会经过所有 loader 处理,虽然因为 test 正则原因实际没有处理上,但是都要过一遍。比较慢。实际上就是匹配上一个 loader, 剩下的就不匹配了。


代码如下


const path = require("path");const ESLintWebpackPlugin = require("eslint-webpack-plugin");const HtmlWebpackPlugin = require("html-webpack-plugin");
module.exports = { entry: "./src/main.js", output: { path: undefined, // 开发模式没有输出,不需要指定输出目录 filename: "static/js/main.js", // 将 js 文件输出到 static/js 目录中 // clean: true, // 开发模式没有输出,不需要清空输出结果 }, module: { rules: [ { oneOf: [ { // 用来匹配 .css 结尾的文件 test: /\.css$/, // use 数组里面 Loader 执行顺序是从右到左 use: ["style-loader", "css-loader"], },
{ test: /\.(ttf|woff2?)$/, type: "asset/resource", generator: { filename: "static/media/[hash:8][ext][query]", }, }, { test: /\.js$/, exclude: /node_modules/, // 排除node_modules代码不编译 loader: "babel-loader", }, ], }, ], }, plugins: [ new ESLintWebpackPlugin({ // 指定检查文件的根目录 context: path.resolve(__dirname, "../src"), }), new HtmlWebpackPlugin({ // 以 public/index.html 为模板创建文件 // 新的html文件有两个特点:1. 内容和源文件一致 2. 自动引入打包生成的js等资源 template: path.resolve(__dirname, "../public/index.html"), }), ], // 开发服务器 devServer: { host: "localhost", // 启动服务器域名 port: "3000", // 启动服务器端口号 open: true, // 是否自动打开浏览器 hot: true, // 开启HMR功能 },};
复制代码

Cache

每次打包时 js 文件都要经过 Eslint 检查 和 Babel 编译,速度比较慢。我们可以缓存之前的 Eslint 检查 和 Babel 编译结果,这样第二次打包时速度就会更快了。对 Eslint 检查 和 Babel 编译结果进行缓存。


const path = require("path");const ESLintWebpackPlugin = require("eslint-webpack-plugin");const HtmlWebpackPlugin = require("html-webpack-plugin");
module.exports = { entry: "./src/main.js", output: { path: undefined, // 开发模式没有输出,不需要指定输出目录 filename: "static/js/main.js", // 将 js 文件输出到 static/js 目录中 // clean: true, // 开发模式没有输出,不需要清空输出结果 }, module: { rules: [ { oneOf: [ { // 用来匹配 .css 结尾的文件 test: /\.css$/, // use 数组里面 Loader 执行顺序是从右到左 use: ["style-loader", "css-loader"], }, { test: /\.less$/, use: ["style-loader", "css-loader", "less-loader"], }, { test: /\.js$/, // exclude: /node_modules/, // 排除node_modules代码不编译 include: path.resolve(__dirname, "../src"), // 也可以用包含 loader: "babel-loader", options: { cacheDirectory: true, // 开启babel编译缓存 cacheCompression: false, // 缓存文件不要压缩 }, }, ], }, ], }, plugins: [ new ESLintWebpackPlugin({ // 指定检查文件的根目录 context: path.resolve(__dirname, "../src"), exclude: "node_modules", // 默认值 cache: true, // 开启缓存 // 缓存目录 cacheLocation: path.resolve( __dirname, "../node_modules/.cache/.eslintcache" ), }), new HtmlWebpackPlugin({ // 以 public/index.html 为模板创建文件 // 新的html文件有两个特点:1. 内容和源文件一致 2. 自动引入打包生成的js等资源 template: path.resolve(__dirname, "../public/index.html"), }), ], // 开发服务器 devServer: { host: "localhost", // 启动服务器域名 port: "3000", // 启动服务器端口号 open: true, // 是否自动打开浏览器 hot: true, // 开启HMR功能 },
};
复制代码

持久化缓存

我们还可以通过通过配置 webpack 持久化缓存 cache: filesystem,来缓存生成的 webpack 模块和 chunk,改善构建速度。


简单来说,通过 cache: filesystem 可以将构建过程的 webpack 模板进行缓存,大幅提升二次构建速度、打包速度,当构建突然中断,二次进行构建时,可以直接从缓存中拉取,可提速 90% 左右。配置方式如下:


module.exports = {  cache: {    type: "filesystem", // 使用文件缓存  },};
复制代码

Network Cache

将来开发时我们对静态资源会使用缓存来优化,这样浏览器第二次请求资源就能读取缓存了,速度很快。


但是这样的话就会有一个问题, 因为前后输出的文件名是一样的,都叫 main.js,一旦将来发布新版本,因为文件名没有变化导致浏览器会直接读取缓存,不会加载新资源,项目也就没法更新了。


所以我们从文件名入手,确保更新前后文件名不一样,这样就可以做缓存了。


它们都会生成一个唯一的 hash 值。


  • fullhash(webpack4 是 hash)


每次修改任何一个文件,所有文件名的 hash 至都将改变。所以一旦修改了任何一个文件,整个项目的文件缓存都将失效。


  • chunkhash


根据不同的入口文件(Entry)进行依赖文件解析、构建对应的 chunk,生成对应的哈希值。我们 js 和 css 是同一个引入,会共享一个 hash 值。


  • contenthash


根据文件内容生成 hash 值,只有文件内容变化了,hash 值才会变化。所有文件 hash 值是独享且不同的。


// cpu核数const threads = os.cpus().length;
// 获取处理样式的Loadersconst getStyleLoaders = (preProcessor) => { return [ MiniCssExtractPlugin.loader, "css-loader", { loader: "postcss-loader", options: { postcssOptions: { plugins: [ "postcss-preset-env", // 能解决大多数样式兼容性问题 ], }, }, }, preProcessor, ].filter(Boolean);};module.exports = { entry: "./src/main.js", output: { path: path.resolve(__dirname, "../dist"), // 生产模式需要输出 // [contenthash:8]使用contenthash,取8位长度 filename: "static/js/[name].[contenthash:8].js", // 入口文件打包输出资源命名方式 chunkFilename: "static/js/[name].[contenthash:8].chunk.js", // 动态导入输出资源命名方式 assetModuleFilename: "static/media/[name].[hash][ext]", // 图片、字体等资源命名方式(注意用hash) clean: true, },
plugins: [
], // 代码分割配置 splitChunks: { chunks: "all", // 对所有模块都进行分割 // 其他内容用默认配置即可 }, }, // devServer: { // host: "localhost", // 启动服务器域名 // port: "3000", // 启动服务器端口号 // open: true, // 是否自动打开浏览器 // }, mode: "production", devtool: "source-map",};
复制代码

Thead

当项目越来越庞大时,打包速度越来越慢,甚至于需要一个下午才能打包出来代码。这个速度是比较慢的。我们想要继续提升打包速度,其实就是要提升 js 的打包速度,因为其他文件都比较少。而对 js 文件处理主要就是 eslint 、babel、Terser 三个工具,所以我们要提升它们的运行速度。我们可以开启多进程同时处理 js 文件,这样速度就比之前的单进程打包更快了。


作用:多进程打包,开启电脑的多个进程同时干一件事,速度更快。 需要注意: 请仅在特别耗时的操作中使用,因为每个进程启动就有大约为 600ms 左右开销。


我们启动进程的数量就是我们 CPU 的核数。


1.  如何获取 CPU 的核数,因为每个电脑都不一样。// nodejs核心模块,直接使用const os = require("os");// cpu核数const threads = os.cpus().length;
复制代码


const os = require("os");const path = require("path");const ESLintWebpackPlugin = require("eslint-webpack-plugin");const HtmlWebpackPlugin = require("html-webpack-plugin");const MiniCssExtractPlugin = require("mini-css-extract-plugin");const CssMinimizerPlugin = require("css-minimizer-webpack-plugin");const TerserPlugin = require("terser-webpack-plugin");
// cpu核数const threads = os.cpus().length;
// 获取处理样式的Loadersconst getStyleLoaders = (preProcessor) => { return [ MiniCssExtractPlugin.loader, "css-loader", { loader: "postcss-loader", options: { postcssOptions: { plugins: [ "postcss-preset-env", // 能解决大多数样式兼容性问题 ], }, }, }, preProcessor, ].filter(Boolean);};
module.exports = { entry: "./src/main.js", output: { path: path.resolve(__dirname, "../dist"), // 生产模式需要输出 filename: "static/js/main.js", // 将 js 文件输出到 static/js 目录中 clean: true, }, module: { rules: [ { oneOf: [ { // 用来匹配 .css 结尾的文件 test: /\.css$/, // use 数组里面 Loader 执行顺序是从右到左 use: getStyleLoaders(), }, { test: /\.less$/, use: getStyleLoaders("less-loader"), }, { test: /\.s[ac]ss$/, use: getStyleLoaders("sass-loader"), }, { test: /\.styl$/, use: getStyleLoaders("stylus-loader"), }, { test: /\.(ttf|woff2?)$/, type: "asset/resource", generator: { filename: "static/media/[hash:8][ext][query]", }, }, { test: /\.js$/, // exclude: /node_modules/, // 排除node_modules代码不编译 include: path.resolve(__dirname, "../src"), // 也可以用包含 use: [ { loader: "thread-loader", // 开启多进程 options: { workers: threads, // 数量 }, }, { loader: "babel-loader", options: { cacheDirectory: true, // 开启babel编译缓存 }, }, ], }, ], }, ], }, plugins:[ //xxx ], // devServer: { // host: "localhost", // 启动服务器域名 // port: "3000", // 启动服务器端口号 // open: true, // 是否自动打开浏览器 // }, mode: "production", devtool: "source-map",};
复制代码

Tree Shaking

开发时我们定义了一些工具函数库,或者引用第三方工具函数库或组件库。如果没有特殊处理的话我们打包时会引入整个库,但是实际上可能我们可能只用上极小部分的功能。这样将整个库都打包进来,体积就太大了。 Tree Shaking 是一个术语,通常用于描述移除 JavaScript 中的没有使用上的代码。


注意:它依赖 ES Module Webpack 已经默认开启了这个功能,无需其他配置。

Babel

Babel 为编译的每个文件都插入了辅助代码,使代码体积过大!


Babel 对一些公共方法使用了非常小的辅助代码,比如 _extend。默认情况下会被添加到每一个需要它的文件中。


你可以将这些辅助代码作为一个独立模块,来避免重复引入。


@babel/plugin-transform-runtime的作用: 禁用了 Babel 自动对每个文件的 runtime 注入,而是引入 @babel/plugin-transform-runtime 并且使所有辅助代码从这里引用。


  1. 下载包


npm i @babel/plugin-transform-runtime -D
复制代码


  1. 配置


const os = require("os");const path = require("path");const ESLintWebpackPlugin = require("eslint-webpack-plugin");const HtmlWebpackPlugin = require("html-webpack-plugin");const MiniCssExtractPlugin = require("mini-css-extract-plugin");const CssMinimizerPlugin = require("css-minimizer-webpack-plugin");const TerserPlugin = require("terser-webpack-plugin");
// cpu核数const threads = os.cpus().length;
// 获取处理样式的Loadersconst getStyleLoaders = (preProcessor) => { return [ MiniCssExtractPlugin.loader, "css-loader", { loader: "postcss-loader", options: { postcssOptions: { plugins: [ "postcss-preset-env", // 能解决大多数样式兼容性问题 ], }, }, }, preProcessor, ].filter(Boolean);};
module.exports = { entry: "./src/main.js", output: { path: path.resolve(__dirname, "../dist"), // 生产模式需要输出 filename: "static/js/main.js", // 将 js 文件输出到 static/js 目录中 clean: true, }, module: { rules: [ { oneOf: [ { // 用来匹配 .css 结尾的文件 test: /\.css$/, // use 数组里面 Loader 执行顺序是从右到左 use: getStyleLoaders(), }, { test: /\.less$/, use: getStyleLoaders("less-loader"), }, { test: /\.s[ac]ss$/, use: getStyleLoaders("sass-loader"), }, { test: /\.styl$/, use: getStyleLoaders("stylus-loader"), },
{ test: /\.js$/, // exclude: /node_modules/, // 排除node_modules代码不编译 include: path.resolve(__dirname, "../src"), // 也可以用包含 use: [ { loader: "thread-loader", // 开启多进程 options: { workers: threads, // 数量 }, }, { loader: "babel-loader", options: { cacheDirectory: true, // 开启babel编译缓存 cacheCompression: false, // 缓存文件不要压缩 plugins: ["@babel/plugin-transform-runtime"], // 减少代码体积 }, }, ], }, ], }, ], }, plugins: [ new ESLintWebpackPlugin({ // 指定检查文件的根目录 context: path.resolve(__dirname, "../src"), exclude: "node_modules", // 默认值 cache: true, // 开启缓存 // 缓存目录 cacheLocation: path.resolve( __dirname, "../node_modules/.cache/.eslintcache" ), threads, // 开启多进程 }), new HtmlWebpackPlugin({ // 以 public/index.html 为模板创建文件 // 新的html文件有两个特点:1. 内容和源文件一致 2. 自动引入打包生成的js等资源 template: path.resolve(__dirname, "../public/index.html"), }), // 提取css成单独文件 new MiniCssExtractPlugin({ // 定义输出文件名和目录 filename: "static/css/main.css", }), // css压缩 // new CssMinimizerPlugin(), ], optimization: { minimizer: [ // css压缩也可以写到optimization.minimizer里面,效果一样的 new CssMinimizerPlugin(), // 当生产模式会默认开启TerserPlugin,但是我们需要进行其他配置,就要重新写了 new TerserPlugin({ parallel: threads, // 开启多进程 }), ] ], // devServer: { // host: "localhost", // 启动服务器域名 // port: "3000", // 启动服务器端口号 // open: true, // 是否自动打开浏览器 // }, mode: "production", devtool: "source-map",};
复制代码

优化代码运行性能

多入口

  1. 文件目录


├── public├── src|   ├── app.js|   └── main.js├── package.json└── webpack.config.js
复制代码


  1. 下载包


npm i webpack webpack-cli html-webpack-plugin -D
复制代码


  1. 新建文件


内容无关紧要,主要观察打包输出的结果


  • app.js


console.log("hello app");
复制代码


  • main.js


console.log("hello main");
复制代码


  1. 配置


// webpack.config.jsconst path = require("path");const HtmlWebpackPlugin = require("html-webpack-plugin");
module.exports = { // 单入口 // entry: './src/main.js', // 多入口 entry: { main: "./src/main.js", app: "./src/app.js", }, output: { path: path.resolve(__dirname, "./dist"), // [name]是webpack命名规则,使用chunk的name作为输出的文件名。 // 什么是chunk?打包的资源就是chunk,输出出去叫bundle。 // chunk的name是啥呢? 比如: entry中xxx: "./src/xxx.js", name就是xxx。注意是前面的xxx,和文件名无关。 // 为什么需要这样命名呢?如果还是之前写法main.js,那么打包生成两个js文件都会叫做main.js会发生覆盖。(实际上会直接报错的) filename: "js/[name].js", clear: true, }, plugins: [ new HtmlWebpackPlugin({ template: "./public/index.html", }), ], mode: "production",};
复制代码


  1. 运行指令


npx webpack
复制代码


此时在 dist 目录我们能看到输出了两个 js 文件。


总结:配置了几个入口,至少输出几个 js 文件。

提取重复代码

如果多入口文件中都引用了同一份代码,我们不希望这份代码被打包到两个文件中,导致代码重复,体积更大。


我们需要提取多入口的重复代码,只打包生成一个 js 文件,其他文件引用它就好。


  1. 修改文件


  • app.js


import { sum } from "./math";
console.log("hello app");console.log(sum(1, 2, 3, 4));
复制代码


  • main.js


import { sum } from "./math";
console.log("hello main");console.log(sum(1, 2, 3, 4, 5));
复制代码


  • math.js


export const sum = (...args) => {  return args.reduce((p, c) => p + c, 0);};
复制代码


  1. 修改配置文件


// webpack.config.jsconst path = require("path");const HtmlWebpackPlugin = require("html-webpack-plugin");
module.exports = { // 单入口 // entry: './src/main.js', // 多入口 entry: { main: "./src/main.js", app: "./src/app.js", }, output: { path: path.resolve(__dirname, "./dist"), // [name]是webpack命名规则,使用chunk的name作为输出的文件名。 // 什么是chunk?打包的资源就是chunk,输出出去叫bundle。 // chunk的name是啥呢? 比如: entry中xxx: "./src/xxx.js", name就是xxx。注意是前面的xxx,和文件名无关。 // 为什么需要这样命名呢?如果还是之前写法main.js,那么打包生成两个js文件都会叫做main.js会发生覆盖。(实际上会直接报错的) filename: "js/[name].js", clean: true, }, plugins: [ new HtmlWebpackPlugin({ template: "./public/index.html", }), ], mode: "production", optimization: { // 代码分割配置 splitChunks: { chunks: "all", // 对所有模块都进行分 // 修改配置 cacheGroups: { // 组,哪些模块要打包到一个组 // defaultVendors: { // 组名 // test: /[\\/]node_modules[\\/]/, // 需要打包到一起的模块 // priority: -10, // 权重(越大越高) // reuseExistingChunk: true, // 如果当前 chunk 包含已从主 bundle 中拆分出的模块,则它将被重用,而不是生成新的模块 // }, default: { // 其他没有写的配置会使用上面的默认值 minSize: 0, // 我们定义的文件体积太小了,所以要改打包的最小文件体积 minChunks: 2, priority: -20, reuseExistingChunk: true, }, }, }, },};
复制代码


  1. 运行指令


npx webpack
复制代码


此时我们会发现生成 3 个 js 文件,其中有一个就是提取的公共模块。

按需加载,动态导入

想要实现按需加载,动态导入模块。还需要额外配置:


  1. 修改文件


  • main.js


console.log("hello main");
document.getElementById("btn").onclick = function () { // 动态导入 --> 实现按需加载 // 即使只被引用了一次,也会代码分割 import("./math.js").then(({ sum }) => { alert(sum(1, 2, 3, 4, 5)); });};
复制代码


  • app.js


console.log("hello app");
复制代码


  • public/index.html


<!DOCTYPE html><html lang="en">  <head>    <meta charset="UTF-8" />    <meta http-equiv="X-UA-Compatible" content="IE=edge" />    <meta name="viewport" content="width=device-width, initial-scale=1.0" />    <title>Code Split</title>  </head>  <body>    <h1>hello webpack</h1>    <button id="btn">计算</button>  </body></html>
复制代码


  1. 运行指令


npx webpack
复制代码


我们可以发现,一旦通过 import 动态导入语法导入模块,模块就被代码分割,同时也能按需加载了。

给动态导入文件取名称

  1. 修改文件


  • main.js


import sum from "./js/sum";// 引入资源,Webpack才会对其打包import "./css/iconfont.css";import "./css/index.css";import "./less/index.less";import "./sass/index.sass";import "./sass/index.scss";import "./styl/index.styl";
const result2 = sum(1, 2, 3, 4);console.log(result2);
// 以下代码生产模式下会删除if (module.hot) { module.hot.accept("./js/sum.js", function (sum) { const result2 = sum(1, 2, 3, 4); console.log(result2); });}
document.getElementById("btn").onClick = function () { // eslint会对动态导入语法报错,需要修改eslint配置文件 // webpackChunkName: "math":这是webpack动态导入模块命名的方式 // "math"将来就会作为[name]的值显示。 import(/* webpackChunkName: "math" */ "./js/math.js").then(({ count }) => { console.log(count(2, 1)); });};
复制代码

eslint 配置

npm i eslint-plugin-import -D
复制代码


// .eslintrc.jsmodule.exports = {  // 继承 Eslint 规则  extends: ["eslint:recommended"],  env: {    node: true, // 启用node中全局变量    browser: true, // 启用浏览器中全局变量  },  plugins: ["import"], // 解决动态导入import语法报错问题 --> 实际使用eslint-plugin-import的规则解决的  parserOptions: {    ecmaVersion: 6,    sourceType: "module",  },  rules: {    "no-var": 2, // 不能使用 var 定义变量  },};
复制代码

统一命名配置

const os = require("os");const path = require("path");const ESLintWebpackPlugin = require("eslint-webpack-plugin");const HtmlWebpackPlugin = require("html-webpack-plugin");const MiniCssExtractPlugin = require("mini-css-extract-plugin");const CssMinimizerPlugin = require("css-minimizer-webpack-plugin");const TerserPlugin = require("terser-webpack-plugin");const ImageMinimizerPlugin = require("image-minimizer-webpack-plugin");
// cpu核数const threads = os.cpus().length;
// 获取处理样式的Loadersconst getStyleLoaders = (preProcessor) => { return [ MiniCssExtractPlugin.loader, "css-loader", { loader: "postcss-loader", options: { postcssOptions: { plugins: [ "postcss-preset-env", // 能解决大多数样式兼容性问题 ], }, }, }, preProcessor, ].filter(Boolean);};
module.exports = { entry: "./src/main.js", output: { path: path.resolve(__dirname, "../dist"), // 生产模式需要输出 filename: "static/js/[name].js", // 入口文件打包输出资源命名方式 chunkFilename: "static/js/[name].chunk.js", // 动态导入输出资源命名方式 assetModuleFilename: "static/media/[name].[hash][ext]", // 图片、字体等资源命名方式(注意用hash) clean: true, }, module: { rules: [ { oneOf: [ { // 用来匹配 .css 结尾的文件 test: /.css$/, // use 数组里面 Loader 执行顺序是从右到左 use: getStyleLoaders(), }, { test: /.less$/, use: getStyleLoaders("less-loader"), }, { test: /.s[ac]ss$/, use: getStyleLoaders("sass-loader"), }, { test: /.styl$/, use: getStyleLoaders("stylus-loader"), }, { test: /.(png|jpe?g|gif|svg)$/, type: "asset", parser: { dataUrlCondition: { maxSize: 10 * 1024, // 小于10kb的图片会被base64处理 }, }, // generator: { // // 将图片文件输出到 static/imgs 目录中 // // 将图片文件命名 [hash:8][ext][query] // // [hash:8]: hash值取8位 // // [ext]: 使用之前的文件扩展名 // // [query]: 添加之前的query参数 // filename: "static/imgs/[hash:8][ext][query]", // }, }, { test: /.(ttf|woff2?)$/, type: "asset/resource", // generator: { // filename: "static/media/[hash:8][ext][query]", // }, }, { test: /.js$/, // exclude: /node_modules/, // 排除node_modules代码不编译 include: path.resolve(__dirname, "../src"), // 也可以用包含 use: [ { loader: "thread-loader", // 开启多进程 options: { workers: threads, // 数量 }, }, { loader: "babel-loader", options: { cacheDirectory: true, // 开启babel编译缓存 cacheCompression: false, // 缓存文件不要压缩 plugins: ["@babel/plugin-transform-runtime"], // 减少代码体积 }, }, ], }, ], }, ], }, plugins: [ new ESLintWebpackPlugin({ // 指定检查文件的根目录 context: path.resolve(__dirname, "../src"), exclude: "node_modules", // 默认值 cache: true, // 开启缓存 // 缓存目录 cacheLocation: path.resolve( __dirname, "../node_modules/.cache/.eslintcache" ), threads, // 开启多进程 }), new HtmlWebpackPlugin({ // 以 public/index.html 为模板创建文件 // 新的html文件有两个特点:1. 内容和源文件一致 2. 自动引入打包生成的js等资源 template: path.resolve(__dirname, "../public/index.html"), }), // 提取css成单独文件 new MiniCssExtractPlugin({ // 定义输出文件名和目录 filename: "static/css/[name].css", chunkFilename: "static/css/[name].chunk.css", }), // css压缩 // new CssMinimizerPlugin(), ], optimization: { minimizer: [ // css压缩也可以写到optimization.minimizer里面,效果一样的 new CssMinimizerPlugin(), // 当生产模式会默认开启TerserPlugin,但是我们需要进行其他配置,就要重新写了 new TerserPlugin({ parallel: threads, // 开启多进程 }), // 压缩图片 new ImageMinimizerPlugin({ minimizer: { implementation: ImageMinimizerPlugin.imageminGenerate, options: { plugins: [ ["gifsicle", { interlaced: true }], ["jpegtran", { progressive: true }], ["optipng", { optimizationLevel: 5 }], [ "svgo", { plugins: [ "preset-default", "prefixIds", { name: "sortAttrs", params: { xmlnsOrder: "alphabetical", }, }, ], }, ], ], }, }, }), ], // 代码分割配置 splitChunks: { chunks: "all", // 对所有模块都进行分割 // 其他内容用默认配置即可 }, }, // devServer: { // host: "localhost", // 启动服务器域名 // port: "3000", // 启动服务器端口号 // open: true, // 是否自动打开浏览器 // }, mode: "production", devtool: "source-map",};
复制代码


运行指令


npx webpack
复制代码


观察打包输出 js 文件名称。

Preload / Prefetch

我们前面已经做了代码分割,同时会使用 import 动态导入语法来进行代码按需加载(我们也叫懒加载,比如路由懒加载就是这样实现的)。


但是加载速度还不够好,比如:是用户点击按钮时才加载这个资源的,如果资源体积很大,那么用户会感觉到明显卡顿效果。


我们想在浏览器空闲时间,加载后续需要使用的资源。我们就需要用上 Preload 或 Prefetch 技术。


  • Preload:告诉浏览器立即加载资源。

  • Prefetch:告诉浏览器在空闲时才开始加载资源。它们共同点:

  • 都只会加载资源,并不执行。

  • 都有缓存。它们区别:

  • Preload加载优先级高,Prefetch加载优先级低。

  • Preload只能加载当前页面需要使用的资源,Prefetch可以加载当前页面资源,也可以加载下一个页面需要使用的资源。


总结:


  • 当前页面优先级高的资源用 Preload 加载。

  • 下一个页面需要使用的资源用 Prefetch 加载。


它们的问题:兼容性较差。


  • 我们可以去 Can I Use 网站查询 API 的兼容性问题。

  • Preload 相对于 Prefetch 兼容性好一点


npm i @vue/preload-webpack-plugin -D
复制代码


配置如下


const os = require("os");const path = require("path");const ESLintWebpackPlugin = require("eslint-webpack-plugin");const HtmlWebpackPlugin = require("html-webpack-plugin");const MiniCssExtractPlugin = require("mini-css-extract-plugin");const CssMinimizerPlugin = require("css-minimizer-webpack-plugin");const TerserPlugin = require("terser-webpack-plugin");const ImageMinimizerPlugin = require("image-minimizer-webpack-plugin");const PreloadWebpackPlugin = require("@vue/preload-webpack-plugin");
// cpu核数const threads = os.cpus().length;
// 获取处理样式的Loadersconst getStyleLoaders = (preProcessor) => { return [ MiniCssExtractPlugin.loader, "css-loader", { loader: "postcss-loader", options: { postcssOptions: { plugins: [ "postcss-preset-env", // 能解决大多数样式兼容性问题 ], }, }, }, preProcessor, ].filter(Boolean);};
module.exports = { entry: "./src/main.js", output: { path: path.resolve(__dirname, "../dist"), // 生产模式需要输出 filename: "static/js/[name].js", // 入口文件打包输出资源命名方式 chunkFilename: "static/js/[name].chunk.js", // 动态导入输出资源命名方式 assetModuleFilename: "static/media/[name].[hash][ext]", // 图片、字体等资源命名方式(注意用hash) clean: true, }, module: { rules: [ { oneOf: [ { // 用来匹配 .css 结尾的文件 test: /.css$/, // use 数组里面 Loader 执行顺序是从右到左 use: getStyleLoaders(), }, { test: /.less$/, use: getStyleLoaders("less-loader"), }, { test: /.s[ac]ss$/, use: getStyleLoaders("sass-loader"), }, { test: /.styl$/, use: getStyleLoaders("stylus-loader"), }, { test: /.(png|jpe?g|gif|svg)$/, type: "asset", parser: { dataUrlCondition: { maxSize: 10 * 1024, // 小于10kb的图片会被base64处理 }, }, // generator: { // // 将图片文件输出到 static/imgs 目录中 // // 将图片文件命名 [hash:8][ext][query] // // [hash:8]: hash值取8位 // // [ext]: 使用之前的文件扩展名 // // [query]: 添加之前的query参数 // filename: "static/imgs/[hash:8][ext][query]", // }, }, { test: /.(ttf|woff2?)$/, type: "asset/resource", // generator: { // filename: "static/media/[hash:8][ext][query]", // }, }, { test: /.js$/, // exclude: /node_modules/, // 排除node_modules代码不编译 include: path.resolve(__dirname, "../src"), // 也可以用包含 use: [ { loader: "thread-loader", // 开启多进程 options: { workers: threads, // 数量 }, }, { loader: "babel-loader", options: { cacheDirectory: true, // 开启babel编译缓存 cacheCompression: false, // 缓存文件不要压缩 plugins: ["@babel/plugin-transform-runtime"], // 减少代码体积 }, }, ], }, ], }, ], }, plugins: [ new ESLintWebpackPlugin({ // 指定检查文件的根目录 context: path.resolve(__dirname, "../src"), exclude: "node_modules", // 默认值 cache: true, // 开启缓存 // 缓存目录 cacheLocation: path.resolve( __dirname, "../node_modules/.cache/.eslintcache" ), threads, // 开启多进程 }), new HtmlWebpackPlugin({ // 以 public/index.html 为模板创建文件 // 新的html文件有两个特点:1. 内容和源文件一致 2. 自动引入打包生成的js等资源 template: path.resolve(__dirname, "../public/index.html"), }), // 提取css成单独文件 new MiniCssExtractPlugin({ // 定义输出文件名和目录 filename: "static/css/[name].css", chunkFilename: "static/css/[name].chunk.css", }), // css压缩 // new CssMinimizerPlugin(), new PreloadWebpackPlugin({ rel: "preload", // preload兼容性更好 as: "script", // rel: 'prefetch' // prefetch兼容性更差 }), ], optimization: { minimizer: [ // css压缩也可以写到optimization.minimizer里面,效果一样的 new CssMinimizerPlugin(), // 当生产模式会默认开启TerserPlugin,但是我们需要进行其他配置,就要重新写了 new TerserPlugin({ parallel: threads, // 开启多进程 }), // 压缩图片 new ImageMinimizerPlugin({ minimizer: { implementation: ImageMinimizerPlugin.imageminGenerate, options: { plugins: [ ["gifsicle", { interlaced: true }], ["jpegtran", { progressive: true }], ["optipng", { optimizationLevel: 5 }], [ "svgo", { plugins: [ "preset-default", "prefixIds", { name: "sortAttrs", params: { xmlnsOrder: "alphabetical", }, }, ], }, ], ], }, }, }), ], // 代码分割配置 splitChunks: { chunks: "all", // 对所有模块都进行分割 // 其他内容用默认配置即可 }, }, // devServer: { // host: "localhost", // 启动服务器域名 // port: "3000", // 启动服务器端口号 // open: true, // 是否自动打开浏览器 // }, mode: "production", devtool: "source-map",};
复制代码

Core-js

过去我们使用 babel 对 js 代码进行了兼容性处理,其中使用 @babel/preset-env 智能预设来处理兼容性问题。


它能将 ES6 的一些语法进行编译转换,比如箭头函数、点点点运算符等。但是如果是 async 函数、promise 对象、数组的一些方法(includes)等,它没办法处理。


所以此时我们 js 代码仍然存在兼容性问题,一旦遇到低版本浏览器会直接报错。所以我们想要将 js 兼容性问题彻底解决,core-js 是专门用来做 ES6 以及以上 API 的 polyfill


polyfill翻译过来叫做垫片/补丁。就是用社区上提供的一段代码,让我们在不兼容某些新特性的浏览器上,使用该新特性。


npm i core-js
复制代码


手动全部引用:


import "core-js";import count from "./js/count";import sum from "./js/sum";// 引入资源,Webpack才会对其打包const result1 = count(2, 1);console.log(result1);const result2 = sum(1, 2, 3, 4);console.log(result2);// 添加promise代码const promise = Promise.resolve();promise.then(() => {  console.log("hello promise");});
复制代码


上面时手动全部引用的情况,这样引入会将所有兼容性代码全部引入,体积太大了。我们只想引入 promise 的 polyfill


手动按需引入


import "core-js/es/promise";import count from "./js/count";import sum from "./js/sum";// 引入资源,Webpack才会对其打包const result1 = count(2, 1);console.log(result1);const result2 = sum(1, 2, 3, 4);console.log(result2);// 添加promise代码const promise = Promise.resolve();promise.then(() => { console.log("hello promise");});
复制代码


只引入打包 promise 的 polyfill,打包体积更小。但是将来如果还想使用其他语法,我需要手动引入库很麻烦。


自动按需引入


import count from "./js/count";import sum from "./js/sum";// 引入资源,Webpack才会对其打包const result1 = count(2, 1);console.log(result1);const result2 = sum(1, 2, 3, 4);console.log(result2);// 添加promise代码const promise = Promise.resolve();promise.then(() => {  console.log("hello promise");});
复制代码


//babel.config.jsmodule.exports = {  // 智能预设:能够编译ES6语法  presets: [    [      "@babel/preset-env",      // 按需加载core-js的polyfill      { useBuiltIns: "usage", corejs: { version: "3", proposals: true } },    ],  ],};
复制代码

externals

externals 可以告诉 webpack 不打包资源,从而减少入口文件的大小,如果不打包某个包,又要用到他,这个时候需要从 html 的 script 标签进行引入,一般引入的是包的 cdn 资源,配置 externals 的方法有多种: 具体查看 webpack 官网 externals。


例如,从 CDN 引入 jQuery,而不是把它打包:


index.html


<script src="https://code.jquery.com/jquery-3.1.0.js" integrity="sha256-slogkvB1K3VOkzAI8QITxV3VzpOnkeNVsKvtkYLMjfk=" crossorigin="anonymous"></script>
复制代码


这样就剥离了那些不需要改动的依赖模块,换句话,下面展示的代码还可以正常运行:


import $ from 'jquery';
$('.my-element').animate(/* ... */);
复制代码


webpack.config.js


module.exports = {  //...  externals: {    jquery: 'jQuery',  },};
复制代码


其实 webpack 自带了插入 cdn 的方法,而且有很多种,具体自己查看官网,这里将一种最常用的。


添加 externalsType: 'script' , 修改 externals 配置,将 jquery 的值改为数组


Shimming 预置依赖,ProvidePlugin

webpack compiler 能够识别遵循 ES2015 模块语法、CommonJS 或 AMD 规范编写的模块。然而,一些 third party(第三方库) 可能会引用一些全局依赖(例如 jQuery 中的 $)。因此这些 library 也可能会创建一些需要导出的全局变量。这些 “broken modules(不符合规范的模块)” 就是 shimming(预置依赖) 发挥作用的地方。 index.js:


import $ from 'jquery'import _ from 'lodash'import { ui } from './ui'
ui()
const dom = $('<div>')dom.html(_.join(['Niall','August'],'-'))$('body').append(dom)
复制代码


ui.js:


export function ui(){ $('body').css('background',_.join(['green'],'')) }
复制代码


ui.js 的作用就是将body的背景颜色设置为green,但是在 ui.js 中需要用到 jquery 的$和 lodash 的_,这种情况下,虽然 webpack 可以打包 index.js,但是这个 ui.js 却并不能发挥它的作用,控制台会报以下错误:



解决方法: 为 webpack 提供预置依赖


const path = require('path');const webpack = require('webpack');
module.exports = { entry: './src/index.js', output: { filename: 'main.js', path: path.resolve(__dirname, 'dist'), }, plugins: [ new webpack.HotModuleReplacementPlugin(), // new BundleAnalyzerPlugin(), new webpack.ProvidePlugin({ _: 'lodash', $: 'jquery' }) ],
复制代码


这里_: 'lodash'ProvidePlugin 在打包一个文件时,如果发现了该文件中使用到了_,那么就会向其中注入var _ = require('lodash')'


其实还有一种写法:


如果我们想在项目中随处使用_.join(),那么我们可以这样写:


new webpack.ProvidePlugin({ _join: ['lodash','join'], $: 'jquery' })
复制代码


这里的join: ['lodash','join']会让 ProvidePlugin 向使用了join的文件中注入:


var _join = require('lodash').join
复制代码


ui.js:


export function ui(){ $('body').css('background',_join(['green'],'')) }
复制代码


这样就能达到我们想要的效果了。


好了,到这我们的高级配置就到这里了,除了上面这些还有其他优化手段,到这就不一一列举了,感兴趣的可以自己到官网上查阅,下面我们来总结一下我们从 4 个角度对 webpack 和代码进行了优化:


  1. 提升 webpack 提升打包构建速度


  • 使用peed-measure-webpack-plugin分析打包耗时,进行针对性优化。

  • 使用 HotModuleReplacement 让开发时只重新编译打包更新变化了的代码,不变的代码使用缓存,从而使更新速度更快。

  • 使用 OneOf 让资源文件一旦被某个 loader 处理了,就不会继续遍历了,打包速度更快。

  • 使用 Cache 对 eslint 和 babel 处理的结果进行缓存,让第二次打包速度更快。

  • 使用 Thead 多进程处理 eslint 和 babel 任务,速度更快。(需要注意的是,进程启动通信都有开销的,要在比较多代码处理时使用才有效果)


  1. 减少代码体积


  • 使用 Tree Shaking 剔除了没有使用的多余代码,让代码体积更小。

  • 使用 @babel/plugin-transform-runtime 插件对 babel 进行处理,让辅助代码从中引入,而不是每个文件都生成辅助代码,从而体积更小。

  • 使用externals对需要分割的代码进行 cdn 资源引用,减少代码的体积,但同时会增加带宽。


  1. 优化代码运行性能


  • 使用 Code Split 对代码进行分割成多个 js 文件,从而使单个文件体积更小,并行加载 js 速度更快。并通过 import 动态导入语法进行按需加载,从而达到需要使用时才加载该资源,不用时不加载资源。

  • 使用 Preload / Prefetch 对代码进行提前加载,等未来需要使用时就能直接使用,从而用户体验更好。

  • 使用 Core-js 对 js 进行兼容性处理,让我们代码能运行在低版本浏览器。

  • 使用ProvidePlugin对需引用代码 # # Shimming 预置依赖


用户头像

Geek_02d948

关注

还未添加个人签名 2022-09-08 加入

还未添加个人简介

评论

发布
暂无评论
webpack配置优化,让你的构建速度飞起_webpack_Geek_02d948_InfoQ写作社区