WebPack

1.webpack基本概念

本质上，webpack 是一个用于现代 JavaScript 应用程序的 静态模块打包工具。当 webpack 处理应用程序时，它会在内部从一个或多个入口点构建一个 依赖图(dependency graph)，然后将你项目中所需的每一个模块组合成一个或多个 bundles，它们均为静态资源，用于展示你的内容。

2.webpack使用步骤

2.1基础使用

默认入口: ./src/index.js

默认出口: ./dist/main.js

初始化包环境

1
yarn init

安装依赖包

1
yarn add webpack webpack-cli -D

配置scripts

1
2
3
"scripts":{
"build":"webpack"
}

新建目录src
新建src/add/add.js - 定义求和函数导出

1
2
3
4
//导出该函数
export const addFun = (a,b)=>{
    return a + b
}

新建src/index.js导入使用

1
2
3
//导入求和模块
import { addFun } from "./add/add";
console.log(addFun(9,8));

运行打包命令

1
2
yarn build
#或者 npm run build

总结: src并列处, 生成默认dist目录和打包后默认main.js文件
image-20240715200308132

2.2webpack 更新打包

目标: 以后代码变更, 如何重新打包呢

新建src/tool/tool.js - 定义导出数组求和方法

1
2
3
4
//定义导出数组的求和方法
export const getArrSum = arr=>{arr.reduce((sum,val)=>{
    sum += val,0
})}

src/index.js - 导入使用

1
2
3
4
5
6
//导入求和模块
import { addFun} from "./add/add.js";
import { getArrSum } from "./tool/tool.js";

console.log(addFun(9,8));
console.log(getArrSum[0,1,2]);

重新打包

1
yarn build

总结1: src下开发环境, dist是打包后, 分别独立

总结2: 打包后格式压缩, 变量压缩等

3.webpack的配置

目标: 告诉webpack从哪开始打包, 打包后输出到哪里

  1. 默认入口: ./src/index.js

  2. 默认出口: ./dist/main.js

webpack配置 - webpack.config.js(默认)

  1. 在scr同级目录下新建webpack.config.js文件
  2. 填入配置项
  3. 用法：entry: string | [string]

1.单个入口（简写）语法

1
2
3
module.exports = {
  entry: './path/to/my/entry/file.js',
};

entry 属性的单个入口语法，是以下形式的简写：

1
2
3
4
5
module.exports = {
  entry: {
    main: './path/to/my/entry/file.js',
  },
};

我们也可以将一个文件路径数组传递给entry属性。

1
2
3
4
5
6
7
8
9
module.exports = {
    //传入路径数组
  entry: ['./src/file_1.js', './src/file_2.js'],
    //出口
  output: {
      //出口文件名称
    filename: 'bundle.js',
  },
};

2.对象语法

用法：entry: { <entryChunkName> string | [string] } | {}

1
2
3
4
5
6
module.exports = {
  entry: {
    app: './src/app.js',
    adminApp: './src/adminApp.js',
  },
};

2.1.描述入口的对象

用于描述入口的对象。你可以使用如下属性：

  • dependOn: 当前入口所依赖的入口。它们必须在该入口被加载前被加载。
  • filename: 指定要输出的文件名称。
  • import: 启动时需加载的模块。
  • library: 指定 library 选项，为当前 entry 构建一个 library。
  • runtime: 运行时 chunk 的名字。如果设置了，就会创建一个新的运行时 chunk。在 webpack 5.43.0 之后可将其设为 false 以避免一个新的运行时 chunk。
  • publicPath: 当该入口的输出文件在浏览器中被引用时，为它们指定一个公共 URL 地址。请查看 output.publicPath。

3.示例

webpack.config.js

1
2
3
4
5
6
7
8
9
10
11
const path = require('path')

//向外共享模块
module.exports = {
    //入口
    entry: './src/index.js',
    output: {
        path: path.join(__dirname, 'dist'), //出口路径
        filename: 'bundle.js' //出口文件名称
    }
}

image-20240715203906789

4.打包流程

image-20240716141145523

重点: 所有要被打包的资源都要跟入口产生直接/间接的引用关系

5.案例—webpack隔行变色

目标: 工程化模块化开发前端项目, webpack会对ES6模块化处理

新建目录结构如下

image-20240716142958812
scr下新建main.js写入下面的内容

1
2
3
4
5
6
7
import $ from "jquery";

$(function(){
    $('#app li:nth-child(odd)').css('color','red')
    $('#app li:nth-child(even').css('color','blue')

})
  • :nth-child(an+b) 是更通用的形式，其中a和b是整数，n是一个循环变量，从0开始。
  • 当a=1且b=0时，简写为:nth-child(odd)，意味着每两个元素取一个，即选择了所有奇数位置的子元素（1, 3, 5, …）。
  • 相对应的，:nth-child(even) 也就是 :nth-child(2n)，会选择偶数位置的子元素（2, 4, 6, …）。

public下新建index.html，写入下面的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Test</title>
</head>
<script src="./dist.js"></script>
<body>
    <div id="app">
        <ul>
            <li>1</li>
            <li>2</li>
            <li>3</li>
            <li>4</li>
            <li>5</li>
            <li>6</li>
            <li>7</li>
            <li>8</li>
        </ul>
        <ul><li>2</li></ul>
    </div>
</body>
</html>

在package.json中加入下面的内容
image-20240716143107256

注：记得安装webpack命令如下

1
yarn add webpack webpack-cli -D

执行yarn build进行打包dist目录下会出现下面的内容
image-20240716143223307

特别注意：

  • index.html是从public复制过来的，打包后没有自动生成这个文件

  • 在index.html中引入打包后生成的js文件

    • <script src="./dist.js"></script>

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17

      效果图：
      ![image-20240716143411574](../images/WebPack/image-20240716143411574.png)

      ## 6.自动生成html文件(使用插件)

      插件的用法：
      由于**插件**可以携带参数/选项，你必须在 webpack 配置中，向 `plugins` 属性传入一个 `new` 实例。

      取决于你的 webpack 用法，对应有多种使用插件的方式。

      为了解决上面的案例并没有直接为我们生成html文件，这时通过 **html-webpack-plugin**插件, 让webpack打包后生成html文件并自动引入打包后的js

      ### 6.1.安装

      ```bash
      yarn add html-webpack-plugin -D

6.2.配置webpack.config.js文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const path = require('path')
//引入HtmlWebpackPlugin插件
const HtmlWebpackPlugin = require('html-webpack-plugin')
module.exports = {
    //入口
    entry:{
        main:'./src/main.js'
    },
    output:{
        path:path.join(__dirname,'dist'),
        filename:'dist.js'
    },
    plugins:[
        //实例化HtmlWebPackPlugin对象
        new HtmlWebpackPlugin({
            // 以此为模板生成打包后html文件
            template:'./public/index.html'
        })
    ]

6.3.重新打包

运行yarn build进行重新打包，查看是否自动生成了html文件
image-20240716144836219
可以看到，确实自动生成了index文件查看运行是没有问题的。

总结: webpack就像一个人, webpack.config.js是人物属性, 给它穿什么装备它就干什么活

4.加载器(loader)

Webpack 支持使用 loader 对文件进行预处理。你可以构建包括 JavaScript 在内的任何静态资源。并且可以使用 Node.js 轻松编写自己的 loader。

在 require() 语句中使用 loadername! 作为前缀的方式来使用 loader，或者在 webpack 配置中配置 regex 来自动应用它们

4.1.使用 loader

在你的应用程序中，有两种使用 loader 的方式：

  • 配置方式（推荐）：在 webpack.config.js 文件中指定 loader。
  • 内联方式：在每个 import 语句中显式指定 loader。

注意在 webpack v4 版本可以通过 CLI 使用 loader，但是在 webpack v5 中被弃用。

配置

module.rules 允许你在 webpack 配置中指定多个 loader。 这种方式是展示 loader 的一种简明方式，并且有助于使代码变得简洁和易于维护。同时让你对各个 loader 有个全局概览：

loader 从右到左（或从下到上）地取值(evaluate)/执行(execute)。在下面的示例中，从 sass-loader 开始执行，然后继续执行 css-loader，最后以 style-loader 为结束。
image-20240716150801029

4.2.loader-处理CSS文件

loaders加载器, 可让webpack处理其他类型的文件, 打包到js中
原因: webpack默认只认识 js 文件和 json文件

使用 loader 告诉 webpack 加载 CSS 文件，为此，首先要安装loader

1
npm install --save-dev css-loader ts-loader

随后在webpack.config.js中配置对每个.css文件使用css-loader
推荐将 style-loader 与 css-loader 一起使用

1
2
3
4
5
6
7
8
9
10
11
12
13
module.exports = {
  module: {
      // loader的规则
    rules: [
      {
        // 匹配所有的css文件
        test: /\.css$/i,
          // 先用 css-loader 让webpack能够识别 css 文件的内容并打包再用 style-loader 将样式, 把css插入到dom中，详见loader执行顺序
        use: ['style-loader', 'css-loader'],
      },
    ],
  },
};

接下来新建scr/css/li.css文件，写一段去掉li样式的css代码

1
2
3
ul li {
    list-style: none;
}

最重要的一步，引入css文件到入口。

1
import './css/li.css'

image-20240716152103182

运行打包后dist/index.html观察效果和css引入情况
可以看到默认的有序列表的小圆点已经被去除了
image-20240716153413662

4.3.loader-处理less文件

目标: less-loader让webpack处理less文件, less模块翻译less代码

less-loader文档
1.下载依赖包

1
yarn add less less-loader -D

2.配置webpack.config.js文件

1
2
3
4
5
6
7
8
9
10
module:{
    rules:[
        {
            //匹配以.less结尾的文件
            test:/\.less$/,
            // 使用less-loader, 让webpack处理less文件, 内置还会			用less翻译less代码成css内容
            use:['style-loader','css-loader','less-loader']
        }
    ]
}

3.新建scr/less/index.less -设置li字体大小为24px

1
2
3
4
5
@size:24px;

ul li {
    font-size:@size
}

4.(重点)引入index.less文件到入口文件

1
import './less/index.less'

image-20240716154226286

5.打包运行查看效果。
image-20240716154919118
字体确实变了。

4.4.loder-处理图片文件

目标: 用asset module方式(webpack5版本新增)

asset module文档

如果webpack的版本是webpack5，直接在webpack.config.js配置即可

1
2
3
4
{
    test: /\.(png|jpg|gif|jpeg)$/i,
    type: 'asset'
}

如果你用的是webpack4及以前的，请按照下面的步骤进行配置
url-loader文档

file-loader文档

1.下载依赖包

1
yarn add url-loader file-loader -D

2.webpack.config.js配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module:{
    rules:[
        {
        	{
  				test: /\.(png|jpg|gif|jpeg)$/i,
            use: [
    				{
            // 匹配文件, 尝试转base64字符串打包到js中
                loader: 'url-loader', 
      // 配置limit, 超过8k, 不转, file-loader复制, 随机名, 输出文	件
      options: {
        limit: 8 * 1024,
      },
    },
  ],
}
        }
    ]
}

图片转成 base64 字符串

  • 好处就是浏览器不用发请求了，直接可以读取
  • 坏处就是如果图片太大，再转base64就会让图片的体积增大 30% 左右

3.在src/assets目录下准备两个图片
4.在css/less/index.less中把小图片用做背景

1
2
3
body {
    background: url(../assets/image.png) no-repeat center
}

5.在src/main.js - 把大图插入到创建的img标签上, 添加body上显示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import $ from "jquery";
import './css/li.css'
import './less/index.less'
//导入图片并命名
import imageUrl from './assets/李泽伟 (3).jpg'
//通过dom创建元素
let theImg = document.createElement('img')
//给theImg标签的src属性进行赋值
theImg.src = imageUrl
//展示到页面上
document.body.appendChild(theImg)
$(function(){
    $('#app li:nth-child(odd)').css('color','red')
    $('#app li:nth-child(even').css('color','blue')
})

6.打包运行dist/index.html观察2个图片区别

4.5.loader-处理字体文件

用asset module技术, asset/resource直接输出到dist目录下

  • if webpack version > = 5

    • { // webpack5默认内部不认识这些文件, 所以当做静态资源直接输出即可
    test: /\.(eot|svg|ttf|woff|woff2)$/,
    type: 'asset/resource',
    generator: {
        filename: 'font/[name].[hash:6][ext]'
    }
}

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19

      * if f webpack version <= 4

        * ```js
           { // 处理字体图标的解析
               test: /\.(eot|svg|ttf|woff|woff2)$/,
                   use: [
                       {
                           loader: 'url-loader',
                           options: {
                               limit: 2 * 1024,
                               // 配置输出的文件名
                               name: '[name].[ext]',
                               // 配置输出的文件目录
                               outputPath: "fonts/"
                           }
                       }
                   ]
           }

2.scr/assets/目录下放入字体库fonts文件
3.在main.js中(入口文件)引入iconfonts.css

1
2
//引入字体库文件
import './assets/fonts/iconfonts.css'

4.在public/index.html使用字体图标样式

1
<i class="iconfont icon-weixin"></i>

5.执行打包命令-观察打包后网页效果
image-20240716181853292

总结: url-loader和file-loader 可以打包静态资源文件

4.6.loader-处理高版本的js语法

高版本的js代码，比如箭头函数，在打包后原封不动的打包在了js文件中，当遇到一些低版本的浏览器就会报错。
报错的原因是：webpack默认仅设内置了模块化的 兼容性处理，也就是在使用import export时。

解决方案：让webpack配合babel-loader对js语法做处理

babel官网
babel-loader

1.安装

1
npm install -D babel-loader @babel/core @babel/preset-env webpack

或者

1
yarn add -D babel-loader @babel/core @babel/preset-env

2.配置webpack.config.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
module: {
  rules: [
    {
      test: /\.js$/,
      exclude: /(node_modules|bower_components)/,
      use: {
        loader: 'babel-loader',
        options: {
            // 预设:转码规则(用bable开发环境本来预设的)
          presets: ['@babel/preset-env'],
        },
      },
    },
  ];
}

3.在main.js中使用箭头函数

1
2
3
4
let fn =()=>{
    console.log('你好babel');
}
console.log(fn);

注意：这里必须打印，不能调用/不使用, 不然webpack会精简成一句打印不要函数了/不会编译未使用的代码
没有babel集成时, 原样直接打包进lib/bundle.js
有babel集成时, 会翻译成普通函数打包进lib/bundle.js

4.打包后观察lib/bundle.js - 被转成成普通函数使用了 - 这就是babel降级翻译的功能

image-20240716183852063

5.webpack开发服务器

文档地址：https://webpack.docschina.org/configuration/dev-server/

为什么要使用webpack开发服务器？

答： 开启一个开发服务器, 在电脑内存中打包, 缓存一些已经打包过的内容, 只重新打包修改的文件, 最终运行加载在内存中给浏览器使用

5.1.webpack-dev-server自动刷新

启动本地服务, 可实时更新修改的代码, 打包变化代码到内存中, 然后直接提供端口和网页访问

1.下载包

1
yarn add webpack-dev-server -D

2.配置自定义命令

1
2
3
4
scripts: {
	"build": "webpack",
	"serve": "webpack serve"
}

3.运行命令-启动webpack开发服务器

1
yarn serve #或者 npm run server

5.2.webpack-dev-server配置

1.在webpack.config.js中添加服务器配置

更多配置项请参考文档：https://webpack.docschina.org/configuration/dev-server/#devserverafter

1
2
3
4
5
6
module.exports = {
    // ...其他配置
    devServer: {
      port: 3000 // 端口号
    }
}

6.webpack的两种模式

1.Development 模式

特点:

  • 快速编译: 开发模式追求的是快速的编译速度，以便于开发者能够快速看到代码更改的效果。它不会进行大量的压缩和优化，从而加速重新打包的过程。
  • 源码映射 (Source Maps): 默认情况下，此模式会生成详细的源码映射，这有助于开发者在浏览器的开发者工具中轻松地追踪源代码中的错误和警告，即使代码经过了加载器和插件的转换。
  • 保持模块热替换 (Hot Module Replacement, HMR) 功能: 这使得在不刷新页面的情况下更新变更的模块成为可能，极大地提升了开发效率。

使用场景: 在日常开发过程中，当你需要频繁修改代码并查看效果时，应使用开发模式。它可以帮助你快速迭代，即时查看代码更改的结果，同时保持调试的便利性。

2.Production 模式

特点:

  • 优化输出: 生产模式会对最终的输出进行各种优化，包括代码压缩、模块和资源的最小化，以及去除死代码（Tree Shaking），以减小文件体积，提高加载速度。
  • 性能提升: 通过减少文件大小和优化资源加载顺序等手段，显著提升应用在生产环境中的性能。
  • 更少的源码映射信息: 默认情况下，生产模式生成的源码映射信息被优化以减小其体积，并且通常不会包含原始源代码的每一行详细信息，而是为了错误报告而设计的。
  • 静态资源处理: 包括对静态资源如图片和字体进行更高效的处理，如压缩和更合理的文件名哈希，以利用缓存机制。

使用场景: 当你的项目准备部署到线上或者生产环境时，应该使用生产模式。这个模式确保了应用以最优的状态运行，不仅提高了用户体验，还考虑到了性能和资源管理的最佳实践。

设置方式

在 webpack.config.js 配置文件中，你可以通过设置 mode 属性来指定构建模式：

1
2
3
4
1module.exports = {
2  mode: 'development', // 或 'production'
3  // 其他配置...
4};

或者在命令行中通过 --mode 参数指定：

1
2
3
4
5
1// 开发模式
2npx webpack --mode development
3
4// 生产模式
5npx webpack --mode production

确保在适当的环境下选择正确的模式，这对于保持开发效率和保障线上应用的性能至关重要。

面试题

1、什么是webpack（必会）

​ webpack是一个打包模块化javascript的工具，在webpack里一切文件皆模块，通过loader转换文件，通过plugin注入钩子，最后输出由多个模块组合成的文件，webpack专注构建模块化项目

2、Webpack的优点是什么？（必会）

  1. 专注于处理模块化的项目，能做到开箱即用，一步到位
  2. 通过plugin扩展，完整好用又不失灵活
  3. 通过loaders扩展, 可以让webpack把所有类型的文件都解析打包
  4. 区庞大活跃，经常引入紧跟时代发展的新特性，能为大多数场景找到已有的开源扩展

3、webpack的构建流程是什么?从读取配置到输出文件这个过程尽量说全（必会）

​ Webpack 的运行流程是一个串行的过程，从启动到结束会依次执行以下流程：

​ 1. 初始化参数：从配置文件读取与合并参数，得出最终的参数

  1. 开始编译：用上一步得到的参数初始化 Compiler 对象，加载所有配置的插件，开始执行编译
  2. 确定入口：根据配置中的 entry 找出所有的入口文件
  3. 编译模块：从入口文件出发，调用所有配置的 Loader 对模块进行翻译，再找出该模块依赖的模块，再递归本步骤直到所有入口依赖的文件都经过了本步骤的处理
  4. 完成模块编译：在经过第4步使用 Loader 翻译完所有模块后，得到了每个模块被翻译后的最终内容以及它们之间的依赖关系
  5. 输出资源：根据入口和模块之间的依赖关系，组装成一个个包含多个模块的 Chunk，再把每个 Chunk 转换成一个单独的文件加入到输出列表，这步是可以修改输出内容的最后机会
  6. 输出完成：在确定好输出内容后，根据配置确定输出的路径和文件名，把文件内容写入到文件系统。

在以上过程中，Webpack 会在特定的时间点广播出特定的事件，插件在监听到感兴趣的事件后会执行特定的逻辑，并且插件可以调用 Webpack 提供的 API 改变 Webpack 的运行结果

4、说一下 Webpack 的热更新原理(必会)

​ webpack 的热更新又称热替换（Hot Module Replacement），缩写为 HMR。这个机制可以做到不用刷新浏览器而将新变更的模块替换掉旧的模块。

​ HMR的核心就是客户端从服务端拉去更新后的文件，准确的说是 chunk diff (chunk 需要更新的部分)，实际上 WDS 与浏览器之间维护了一个 Websocket，当本地资源发生变化时，WDS 会向浏览器推送更新，并带上构建时的 hash，让客户端与上一次资源进行对比。客户端对比出差异后会向 WDS 发起 Ajax 请求来获取更改内容(文件列表、hash)，这样客户端就可以再借助这些信息继续向 WDS 发起 jsonp 请求获取该chunk的增量更新。

​ 后续的部分(拿到增量更新之后如何处理？哪些状态该保留？哪些又需要更新？)由 HotModulePlugin 来完成，提供了相关 API 以供开发者针对自身场景进行处理，像react-hot-loader 和 vue-loader 都是借助这些 API 实现 HMR。

5、webpack与grunt、gulp的不同？（必会）

​ 1) 三者之间的区别

​ 三者都是前端构建工具，grunt和gulp在早期比较流行，现在webpack相对来说比较主流，不过一些轻量化的任务还是会用gulp来处理，比如单独打包CSS文件等。

​ grunt和gulp是基于任务和流（Task、Stream）的。类似jQuery，找到一个（或一类）文件，对其做一系列链式操作，更新流上的数据， 整条链式操作构成了一个任务，多个任务就构成了整个web的构建流程。

​ webpack是基于入口的。webpack会自动地递归解析入口所需要加载的所有资源文件，然后用不同的Loader来处理不同的文件，用Plugin来扩展webpack功能。

​ 2) 从构建思路来说

​ gulp和grunt需要开发者将整个前端构建过程拆分成多个Task，并合理控制所有Task的调用关系 webpack需要开发者找到入口，并需要清楚对于不同的资源应该使用什么Loader做何种解析和加工

​ 3) 对于知识背景来说

​ gulp更像后端开发者的思路，需要对于整个流程了如指掌 webpack更倾向于前端开发者的思路

6、有哪些常见的Loader？他们是解决什么问题的？（必会）

1、 file-loader：把文件输出到一个文件夹中，在代码中通过相对 URL 去引用输出的文件

2、 url-loader：和 file-loader 类似，但是能在文件很小的情况下以 base64 的方式把文件内容注入到代码中去

3、 source-map-loader：加载额外的 Source Map 文件，以方便断点调试

4、 image-loader：加载并且压缩图片文件

5、 babel-loader：把 ES6 转换成 ES5

6、 css-loader：加载 CSS，支持模块化、压缩、文件导入等特性

7、 style-loader：把 CSS 代码注入到 JavaScript 中，通过 DOM 操作去加载 CSS。

8、 eslint-loader：通过 ESLint 检查 JavaScript 代码

7、Loader和Plugin的不同？（必会）

​ 1) 不同的作用

​ Loader直译为”加载器”。Webpack将一切文件视为模块，但是webpack原生是只能解析js文件，如果想将其他文件也打包的话，就会用到loader。 所以Loader的作用是让webpack拥有了加载和解析非JavaScript文件的能力。

​ Plugin直译为”插件”。Plugin可以扩展webpack的功能，让webpack具有更多的灵活性。 在 Webpack 运行的生命周期中会广播出许多事件，Plugin 可以监听这些事件，在合适的时机通过 Webpack 提供的 API 改变输出结果。

2) 不同的用法

​ Loader在module.rules中配置，也就是说他作为模块的解析规则而存在。 类型为数组，每一项都是一个Object，里面描述了对于什么类型的文件（test），使用什么加载(loader)和使用的参数（options）

​ Plugin在plugins中单独配置。 类型为数组，每一项是一个plugin的实例，参数都通过构造函数传入。