# Webpack4打包机制原理解析|原理篇

> 本文系统解析了Webpack4的打包机制，包括依赖分析、模块打包流程、Loader与Plugin的作用、AST解析与代码转换等核心原理，帮助开发者深入理解Webpack4如何实现高效的前端资源打包与优化。

- 原文：https://feinterview.poetries.top/docs/principle-docs/webpack/01-Webpack4%E6%89%93%E5%8C%85%E6%9C%BA%E5%88%B6%E5%8E%9F%E7%90%86%E8%A7%A3%E6%9E%90
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.09

---

<!-- principle-learning-suite:start -->
<div class="article-learning-label">文章学习导航</div>

<div class="article-learning-label">面试总览</div>

- 入口出发 → 找依赖 → 转换模块 → 组织产物
- `loader` 管源码转换，`plugin` 介入构建流程
- 模块关系是图，共享依赖和循环引用都可能存在
- `chunk` 是分组单位，输出资源还包含运行时代码
- `Babel` 是可选转换工具，不能等同于整个 `webpack`

**打包就是把源码之间的依赖关系整理好，生成浏览器能加载的一组资源。** `webpack` 从入口找出引用的模块，交给匹配的 `loader` 转换，再分析转换后的依赖，递归完成模块图。接着按入口、动态导入和拆包配置组织代码块，输出文件与加载它们的运行时。理解这条链路，才能分清语法转换报错、模块找不到和浏览器加载资源失败分别发生在哪一步。

**版本校准：** 旧文中的 `webpack 4`、`JSONP` 更新清单或 `react-hot-loader` 代码用于解释历史链路，不应直接复制到新项目。当前 `webpack-dev-server 4+` 默认启用 `HMR`，严格 `ESM` 可使用 `import.meta.webpackHot`；生产环境不得携带 `HMR runtime`。以 [webpack HMR 官方指南](https://webpack.js.org/guides/hot-module-replacement/) 和项目锁定版本为准。
<!-- principle-learning-suite:end -->

> `webpack`是一个打包模块化 `JavaScript` 的工具，在 `webpack`里一切文件皆模块，通过 `Loader` 转换文件，通过 `Plugin` 注入钩子，最后输出由多个模块组合成的文件。`webpack`专注于构建模块化项目。

### 简单版打包模型步骤

> 我们先从简单的入手看，当 webpack 的配置只有一个出口时，不考虑分包的情况，其实我们只得到了一个bundle.js的文件，这个文件里包含了我们所有用到的js模块，可以直接被加载执行。那么，我可以分析一下它的打包思路，大概有以下4步：

- 利用`babel`完成代码转换及解析,并生成单个文件的依赖模块`Map`
- 从入口开始递归分析，并生成整个项目的依赖图谱
- 将各个引用模块打包为一个立即执行函数
- 将最终的`bundle`文件写入`bundle.js`中

### 单个文件的依赖模块Map

- 我们会可以使用这几个包：
  - `@babel/parser`：负责将代码解析为抽象语法树
  - `@babel/traverse`：遍历抽象语法树的工具，我们可以在语法树中解析特定的节点，然后做一些操作，如`ImportDeclaratio`n获取通过`import`引入的模块,`FunctionDeclaration`获取函数
  - `@babel/core`：代码转换，如ES6的代码转为ES5的模式

> 由这几个模块的作用，其实已经可以推断出应该怎样获取单个文件的依赖模块了，转为`Ast`->遍历`Ast`->调用`ImportDeclaration`。代码如下

```js
// exportDependencies.js
const fs = require('fs')
const path = require('path')
const parser = require('@babel/parser')
const traverse = require('@babel/traverse').default
const babel = require('@babel/core')

 const exportDependencies = (filename)=>{
    const content = fs.readFileSync(filename,'utf-8')
    // 转为Ast
    const ast = parser.parse(content, {
        sourceType : 'module'//babel官方规定必须加这个参数，不然无法识别ES Module
    })

    const dependencies = {}
    //遍历AST抽象语法树
    traverse(ast, {
        //调用ImportDeclaration获取通过import引入的模块
        ImportDeclaration({node}){
            const dirname = path.dirname(filename)
            const newFile = './' + path.join(dirname, node.source.value)
            //保存所依赖的模块
            dependencies[node.source.value] = newFile
        }
    })
    //通过@babel/core和@babel/preset-env进行代码的转换
    const {code} = babel.transformFromAst(ast, null, {
        presets: ["@babel/preset-env"]
    })
    return{
        filename,//该文件名
        dependencies,//该文件所依赖的模块集合(键值对存储)
        code//转换后的代码
    }
}
module.exports = exportDependencies
```

可以跑一个例子:

```js
//info.js
const a = 1
export a
// index.js
import info from'./info.js'
console.log(info)

//testExport.js
const exportDependencies = require('./exportDependencies')
console.log(exportDependencies('./src/index.js'))
```

**单个文件的依赖模块Map**

> 有了获取单个文件依赖的基础，我们就可以在这基础上，进一步得出整个项目的模块依赖图谱了。首先，从入口开始计算，得到`entryMap`，然后遍历`entryMap.dependencies`,取出其`value`(即依赖的模块的路径)，然后再获取这个依赖模块的依赖图谱，以此类推递归下去即可，代码如下：

```js
const exportDependencies = require('./exportDependencies')

//entry为入口文件路径
const exportGraph = (entry)=>{
    const entryModule = exportDependencies(entry)
    const graphArray = [entryModule]
    for(let i = 0; i < graphArray.length; i++){
        const item = graphArray[i];
        //拿到文件所依赖的模块集合,dependencies的值参考exportDependencies
        const { dependencies } = item;
        for(let j in dependencies){
            graphArray.push(
                exportDependencies(dependencies[j])
            )//关键代码，目的是将入口模块及其所有相关的模块放入数组
        }
    }
    //接下来生成图谱
    const graph = {}
    graphArray.forEach(item => {
        graph[item.filename] = {
            dependencies: item.dependencies,
            code: item.code
        }
    })
    //可以看出，graph其实是 文件路径名：文件内容 的集合
    return graph
}
module.exports = exportGraph
```

### 输出立即执行函数

> 首先，我们的代码被加载到页面中的时候，是需要立即执行的。所以输出的`bundle.js`实质上要是一个立即执行函数。我们主要注意以下几点：

- 我们写模块的时候，用的是 `import/export`.经转换后,变成了`require/exports`
- 我们要让`require/exports`能正常运行，那么我们得定义这两个东西，并加到`bundle.js`里
- 在依赖图谱里，代码都成了字符串。要执行，可以使用`eval`

> 因此，我们要做这些工作：

- 定义一个`require`函数，`require`函数的本质是执行一个模块的代码，然后将相应变量挂载到`exports`对象上
- 获取整个项目的依赖图谱，从入口开始，调用`require`方法。完整代码如下：

```js
const exportGraph = require('./exportGraph')
// 写入文件，可以用fs.writeFileSync等方法，写入到output.path中
const exportBundle = require('./exportBundle')

const exportCode = (entry)=>{
    //要先把对象转换为字符串，不然在下面的模板字符串中会默认调取对象的toString方法，参数变成[Object object]
    const graph = JSON.stringify(exportGraph(entry))
    exportBundle(`
        (function(graph) {
            //require函数的本质是执行一个模块的代码，然后将相应变量挂载到exports对象上
            function require(module) {
                //localRequire的本质是拿到依赖包的exports变量
                function localRequire(relativePath) {
                    return require(graph[module].dependencies[relativePath]);
                }
                var exports = {};
                (function(require, exports, code) {
                    eval(code);
                })(localRequire, exports, graph[module].code);
                return exports;
                //函数返回指向局部变量，形成闭包，exports变量在函数执行后不会被摧毁
            }
            require('${entry}')
        })(${graph})`)
}
module.exports = exportCode
```

> 至此，简单打包完成。贴一下我跑的demo的结果。`bundle.js`的文件内容为：

```js
 (function(graph) {
  //require函数的本质是执行一个模块的代码，然后将相应变量挂载到exports对象上
  function require(module) {
      //localRequire的本质是拿到依赖包的exports变量
      function localRequire(relativePath) {
          returnrequire(graph[module].dependencies[relativePath]);
      }
      var exports = {};
      (function(require, exports, code) {
          eval(code);
      })(localRequire, exports, graph[module].code);
      return exports;//函数返回指向局部变量，形成闭包，exports变量在函数执行后不会被摧毁
  }
  require('./src/index.js')
})({"./src/index.js":{"dependencies":{"./info.js":"./src/info.js"},"code":"\"use strict\";\n\nvar _info = _interopRequireDefault(require(\"./info.js\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nconsole.log(_info[\"default\"]);"},"./src/info.js":{"dependencies":{"./name.js":"./src/name.js"},"code":"\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = void 0;\n\nvar _name = require(\"./name.js\");\n\nvar info = \"\".concat(_name.name, \" is beautiful\");\nvar _default = info;\nexports[\"default\"] = _default;"},"./src/name.js":{"dependencies":{},"code":"\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.name = void 0;\nvar name = 'winty';\nexports.name = name;"}})
```

### webpack打包流程概括

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

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

> 在以上过程中， `Webpack` 会在特定的时间点广播特定的事件，插件在监听到感兴趣的事件后会执行特定的逻辑，井且插件可以调用 `Webpack` 提供的 `API` 改变 `Webpack` 的运行结果。其实以上7个步骤，可以简单归纳为初始化、编译、输出，三个过程，而这个过程其实就是前面说的基本模型的扩展。

<!-- principle-followup:start -->
- **项目只写普通脚本，也一定会经过 `Babel` 吗？**

  不一定，只有配置了对应转换流程才会经过。`webpack` 能分析模块依赖，不代表它自动把所有新语法转换成旧浏览器支持的写法。
- **两个入口都引用一个工具，会生成两份代码吗？**

  要看拆包配置。模块图里可以是同一个模块，但输出到哪些代码块由分组规则决定，可以用 `splitChunks` 抽取共享部分。
- **互相引用的两个文件，会让依赖分析一直递归吗？**

  构建器会记录已处理模块，不会每次都从头遍历。运行时还要维护模块缓存，否则循环引用会造成重复执行甚至无限调用。
- **图片文件为什么也能写进 `import`？**

  构建工具把它当成资源依赖处理，输出地址或内联内容。具体转换方式取决于版本与配置，不能把图片直接当脚本执行。

<!-- principle-followup:end -->
