浅谈webpack组织模块的原理

现在前端用webpack打包js和其它文件已经是主流了，加上node的流行，使得前端的工程方式和后端越来越像。所有的东西都模块化，最后统一编译。webpack因为版本的不断更新以及各种各样纷繁复杂的配置选项，在使用中出现一些迷之错误常常让人无所适从。所以了解一下webpack究竟是怎么组织编译模块的，生成的代码到底是怎么执行的，还是很有好处的，否则它就永远是个黑箱。当然了我是前端小白，最近也是刚开始研究webpack的原理，在这里做一点记录。

编译模块

编译两个字听起来就很黑科技，加上生成的代码往往是一大坨不知所云的东西，所以常常会让人却步，但其实里面的核心原理并没有什么难。所谓的webpack的编译，其实只是webpack在分析了你的源代码后，对其作出一定的修改，然后把所有源代码统一组织在一个文件里而已。最后生成一个大的bundle js文件，被浏览器或者其它javascript引擎执行并返回结果。

在这里用一个简单的案例来说明webpack打包模块的原理。例如我们有一个模块ma.js

var aa = 1;

function getdate() {
 return new date();
}

module.exports = {
 aa: aa,
 getdate: getdate
}

我随便定义了一个变量aa和一个函数getdate，然后export出来，这里是用commonjs的写法。

然后再定义一个app.js，作为main文件，仍然是commonjs风格：

var ma = require('./ma.js');

console.log('ma.aa =' + ma.aa);
ma.getdate();

现在我们有了两个模块，使用webpack来打包，入口文件是app.js，依赖于模块ma.js，webpack要做几件事情：

1. 从入口模块app.js开始，分析所有模块的依赖关系，把所有用到的模块都读取进来。
2. 每一个模块的源代码都会被组织在一个立即执行的函数里。
3. 改写模块代码中和require和export相关的语法，以及它们对应的引用变量。
4. 在最后生成的bundle文件里建立一套模块管理系统，能够在runtime动态加载用到的模块。

我们可以看一下上面这个例子，webpack打包出来的结果。最后的bundle文件总的来说是一个大的立即执行的函数，组织层次比较复杂，大量的命名也比较晦涩，所以我在这里做了一定改写和修饰，把它整理得尽量简单易懂。

首先是把所有用到的模块都罗列出来，以它们的文件名（一般是完整路径）为id，建立一张表：

var modules = {
 './ma.js': generated_ma,
 './app.js': generated_app
}

关键是上面的generated_xxx是什么？它是一个函数，它把每个模块的源代码包裹在里面，使之成为一个局部的作用域，从而不会暴露内部的变量，实际上就把每个模块都变成一个执行函数。它的定义一般是这样：

function generated_module(module, exports, webpack_require) {
  // 模块的具体代码。
  // ...
}

在这里模块的具体代码是指生成代码，webpack称之为generated code。例如ma，经过改写得到这样的结果：

function generated_ma(module, exports, webpack_require) {
 var aa = 1;
 
 function getdate() {
  return new date();
 }

 module.exports = {
  aa: aa,
  getdate: getdate
 }
}

乍一看似乎和源代码一模一样。的确，ma没有require或者import其它模块，export用的也是传统的commonjs风格，所以生成代码没有任何改动。不过值得注意的是最后的module.exports = ...，这里的module就是外面传进来的参数module，这实际上是在告诉我们，运行这个函数，模块ma的源代码就会被执行，并且最后需要export的内容就会被保存到外部，到这里就标志着ma加载完成，而那个外部的东西实际上就后面要说的模块管理系统。

接下来看app.js的生成代码：

function generated_app(module, exports, webpack_require) {
 var ma_imported_module = webpack_require('./ma.js');
 
 console.log('ma.aa =' + ma_imported_module['aa']);
 ma_imported_module['getdate']();
}

可以看到，app.js的源代码中关于引入的模块ma的部分做了修改，因为无论是require/exports，或是es6风格的import/export，都无法被javascript解释器直接执行，它需要依赖模块管理系统，把这些抽象的关键词具体化。也就是说，webpack_require就是require的具体实现，它能够动态地载入模块ma，并且将结果返回给app。

到这里你脑海里可能已经初步逐渐构建出了一个模块管理系统的想法，我们来看一下webpack_require的实现：

// 加载完毕的所有模块。
var installedmodules = {};

function webpack_require(moduleid) {
 // 如果模块已经加载过了，直接从cache中读取。
 if (installedmodules[moduleid]) {
  return installedmodules[moduleid].exports;
 }

 // 创建新模块并添加到installedmodules。
 var module = installedmodules[moduleid] = {
  id: moduleid,
  exports: {}
 };
 
 // 加载模块，即运行模块的生成代码，
 modules[moduleid].call(
  module.exports, module, module.exports, webpack_require);
 
 return module.exports;
}

注意倒数第二句里的modules就是我们之前定义过的所有模块的generated code：

var modules = {
 './ma.js': generated_ma,
 './app.js': generated_app
}

webpack_require的逻辑写得很清楚，首先检查模块是否已经加载，如果是则直接从cache中返回模块的exports结果。如果是全新的模块，那么就建立相应的数据结构module，并且运行这个模块的generated code，这个函数传入的正是我们建立的module对象，以及它的exports域，这实际上就是commonjs里exports和module的由来。当运行完这个函数，模块就被加载完成了，需要export的结果保存到了module对象中。

所以我们看到所谓的模块管理系统，原理其实非常简单，只要耐心将它们抽丝剥茧理清楚了，根本没有什么深奥的东西，就是由这三个部分组成：

// 所有模块的生成代码
var modules；
// 所有已经加载的模块，作为缓存表
var installedmodules；
// 加载模块的函数
function webpack_require(moduleid);

当然以上一切代码，在整个编译后的bundle文件中，都被包在一个大的立即执行的匿名函数中，最后返回的就是这么一句话：

return webpack_require(‘./app.js');

即加载入口模块app.js，后面所有的依赖都会动态地、递归地在runtime加载。当然webpack真正生成的代码略有不同，它在结构上大致是这样：

(function(modules) {
 var installedmodules = {};
 
 function webpack_require(moduleid) {
   // ...
 }

 return webpack_require('./app.js');
}) ({
 './ma.js': generated_ma,
 './app.js': generated_app
});

可以看到它是直接把modules作为立即执行函数的参数传进去的而不是另外定义的，当然这和上面的写法没什么本质不同，我做这样的改写是为了解释起来更清楚。

es6的import和export

以上的例子里都是用传统的commonjs的写法，现在更通用的es6风格是用import和export关键词，在使用上也略有一些不同。不过对于webpack或者其它模块管理系统而言，这些新特性应该只被视为语法糖，它们本质上还是和require/exports一样的，例如export：

export aa
// 等价于:
module.exports['aa'] = aa

export default bb
// 等价于:
module.exports['default'] = bb

而对于import：

import {aa} from './ma.js'
// 等价于
var aa = require('./ma.js')['aa']

比较特殊的是这样的：

import m from './m.js'

情况会稍微复杂一点，它需要载入模块m的default export，而模块m可能并非是由es6的export来写的，也可能根本没有export default，所以webpack在为模块生成generated code的时候，会判断它是不是es6风格的export，例如我们定义模块mb.js:

let x = 3;

let printx = () => {
 console.log('x = ' + x);
}

export {printx}
export default x

它使用了es6的export，那么webpack在mb的generated code就会加上一句话：

function generated_mb(module, exports, webpack_require) {
 object.defineproperty(module.exports, '__esmodule', {value: true});
 // mb的具体代码
 // ....
}

也就是说，它给mb的export标注了一个__esmodule，说明它是es6风格的export。这样在其它模块中，当一个依赖模块以类似import m from './m.js'这样的方式加载时，会首先判断得到的是不是一个es6 export出来的模块。如果是，则返回它的default，如果不是，则返回整个export对象。例如上面的ma是传统commonjs的，mb是es6风格的：

// ma is commonjs module
import ma from './ma.js'
console.log(ma);

// mb is es6 module
import mb from './mb.js'
console.log(mb);

我们定义get_export_default函数：

function get_export_default(module) {
 return module && module.__esmodule? module['default'] : module;
}

这样generated code运行后在ma和mb上会得到不同的结果：

var ma_imported_module = webpack_require('./ma.js');
// 打印完整的 ma_imported_module
console.log(get_export_default(ma_imported_module));

var mb_imported_module = webpack_require('./mb.js');
// 打印 mb_imported_module['default']
console.log(get_export_default(mb_imported_module));

这就是在es6的import上，webpack需要做一些特殊处理的地方。不过总体而言，es6的import/export在本质上和commonjs没有区别，而且webpack最后生成的generated code也还是基于commonjs的module/exports这一套机制来实现模块的加载的。

模块管理系统

以上就是webpack如何打包组织模块，实现runtime模块加载的解读，其实它的原理并不难，核心的思想就是建立模块的管理系统，而这样的做法也是具有普遍性的，如果你读过node.js的module部分的源代码，就会发现其实用的是类似的方法。这里有一篇可以参考。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。