Commonjs和Es6语法规范的理解

悠悠 2023-10-15 08:49 138阅读 0赞

![99c97e32a9ea43db8ec3e3aa5f70b90d.png][]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的动态性体现在两个方面

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

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

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

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

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

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

1.  import必须在顶层
2.  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

### 5. 异步 VS 同步 ###

ES6 module支持异步加载，浏览器中会用到该特性，而Commonjs是不支持异步的，因为服务器端不需要异步加载。所以CommonJS不可替代ES6 module，ES6 module可以替代CommonJS。

### 总结 ###

ES6 module和CommonJS的区别主要有5点

1.  ES6 module是编译时导出接口，CommonJS是运行时导出对象。
2.  ES6 module输出的值的引用，CommonJS输出的是一个值的拷贝。
3.  ES6 module语法是静态的，CommonJS语法是动态的。
4.  ES6 module导入模块的是只读的引用，CommonJS导入的是可变的，是一个普通的变量。
5.  ES6 module支持异步，CommonJS不支持异步。

ES6 module作为新的规范，可以替代之前的AMD、CMD、CommonJS作为浏览器和服务端的通用模块方案。NodeJS在13.2.0版本后已经开始完全支持ES6 module，ES6 module在未来也会实际的模块化标准。

[99c97e32a9ea43db8ec3e3aa5f70b90d.png]: https://img-blog.csdnimg.cn/99c97e32a9ea43db8ec3e3aa5f70b90d.png