Commonjs和Es6语法规范的理解

ES6 module和CommonJS到底有什么区别？

“ES6 module是编译时加载，输出的是接口，CommonJS运行时加载，加载的是一个对象”

这里的“编译时”是什么意思？和运行时有什么区别？“接口”又是什么意思？

“ES6 模块输出的是值的引用，CommonJS 模块输出的是一个值的拷贝”

那么“值的引用”和“值的拷贝”对于开发者又有什么区别呢？

下面通过一些示例详细说明ES6 module和CommonJS的5点区别。

1. 编译时导出接口 VS 运行时导出对象

CommonJS 模块是运行时加载，因为 CommonJS 加载的是一个对象（即module.exports属性），该对象只有在脚本运行完才会生成。

ES6 模块是它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。

这里的“编译时”，指的是js代码在运行之前的编译过程，我们熟悉的变量提升就发生在编译阶段，但是由于编译过程是引擎的行为，开发者没法在编译阶段做任何操作，所以不容易直观地理解“编译时导出接口和运行时导出对象”这个区别。

不过我们在循环引用这个场景就可以轻松地理解两者的差异。

来看下面CommonJS的代码

// index.js
const {log} = require('./lib.js');
module.exports = {
    name: 'index'
};
log();

// lib.js
const {name} = require('./index.js');
module.exports = {
    log: function () {
        console.log(name);
    }
};

执行index.js：node index.js结果会打印"undefined"。

这里index模块和lib相互依赖。

我们分析一下代码执行过程，首先const {log} = require('./lib.js');导入lib.js模块，这时候开始加载lib模块，lib会先导入index，const {name} = require('./index.js');但这个时候index还没有定义name，所以lib中这里的name是undefined，然后lib导出log方法。

接下来index导出name，然后执行log，由于lib中的name是undefined，因此最终结果是打印undefined。

整个过程模块都是运行时加载，代码依次执行，所以很容易分析出执行结果。

而ES6 module有所不同，接下来看一个es6 module的例子。代码内容和上面一样，只是把模块规范从CommonJS换成es6 module。

// index.mjs
import {log} from './lib.mjs';
export const name = 'index';
log();

// lib.mjs
import {name} from './index.mjs';
export const log = () => {
    console.log(name);
};

首先import {log} from './lib.mjs';导入lib模块，注意这个时候虽然没有执行export const name = 'index';，index模块还没有导出name的值，但是index模块已经编译完成，lib已经可以获取到name的引用，只是还没有值。这非常像代码编译阶段的变量提升。

然后加载lib模块，import {name} from './index.mjs';这句导入了index模块的name，（这时候获取到的是name这个引用，但因为还没有值，因此如果马上打印name console.log(name)会报错。）接下来lib导出log方法。

然后index模块执行export const name = 'index';导出name，其值为"index"。

最后执行log方法log();因为name已经赋值，所以lib中name的引用可以正常访问到值"index"，所以最终结果是打印"index"。

综上所述，es6 module虽然模块未初始化好时候就被lib导入，但因为获取的是导出的接口（接口编译阶段就已经输出了），等初始化好之后就能使用了。

2. 引用 VS 值拷贝

ES6 module导入的模块不会缓存值，它是一个引用，这个在上面的例子中已经讨论过。 CommonJS会缓存值，这个很好理解，因为js中普通变量是值的拷贝，其实就是把模块中的值赋给一个新的变量。

看下CommonJS的一个例子

// index.js
const {name} = require('./lib.js'); // 等价于const lib = require('./lib'); const {name} = lib;
setTimeout(() => {
    console.log(name); // 'Sam'
}, 1000);

// lib.js
const lib = {
    name: 'Sam'
};
module.exports = lib;
setTimeout(() => {
    lib.name = 'Bob';
}, 500);

index模块中导入lib的nameconst {name} = require('./lib.js');其实就是把lib中的name赋给index里面一个name变量。后面lib中name的变化不会影响到index中的name变量。

而ES6中类似的引用语法，导入的则是引用

// index.mjs
import {name} from './lib.mjs';
setTimeout(() => {
    console.log(name); // 'Bob'
}, 1000);

// lib.mjs
export let name = 'Sam';
setTimeout(() => {
    name = 'Bob';
}, 500);

这里index模块中的name是lib导出的name的引用，因此lib中name变化会同步到index中。

当然这并不意味着ES6 module可以做到比CommonJS更多的事情，因为如果希望在CommonJS中获取到变化，也可以直接访问lib.name。

// index.js
const lib = require('./lib.js');
setTimeout(() => {
    console.log(lib.name); // 'Bob'
}, 1000);

所以这个特性的区别只是需要我们在实现模块时候注意一下，避免预期之外的情况。

其实在上面循环引用的例子中，也能看到CommonJS拷贝值和ES6 module引用的区别，CommonJS因为是拷贝值，所以导入模块时候如果还没初始化好，就是undefined，而ES6 module是引用，所以初始化好之后就可以用了。

3. 静态 VS 动态

ES6 module静态语法和CommonJS的动态语法是很重要的区别，

CommonJS的动态性体现在两个方面

可以根据条件判断是否加载模块

if (condition) {
    require('./lib');
}

require的模块参数可以是一个变量

require(`./${template}/index.js`);

这种动态性导致依赖关系不好分析，打包工具在静态代码分析阶段不容易知道模块是否需要被加载、模块的哪些部分需要被加载，哪些不会被用到。

相应地，ES6 module的静态性体现在

import必须在顶层
import的模块参数只能是字符串，不能是变量所以打包工具能够静态分析出依赖关系，并确定知道哪些模块需要被加载、模块的哪些部分被用到。

所以ES6 module静态语法支持打包tree-shaking，而CommonJS不行。

4. 只读 VS 可变

CommonJS导入的模块和普通变量没有区别，ES6 module导入的模块则不同，import导入的模块是只读的。

// demo-commonjs.js
let path = require('path');
path = 1;

// demo-esm.js
import path from 'path';
path = 1; // Error: Cannot assign to 'path' because it is an import