对CommonJS模块和6模块之间的差异的细节

到目前为止，它已在实践中3个月。在最近的采访中，采访中的问题，涉及到模块加载的知识有一个主题，借此机会让CommonJS模块和模块之间的一些重要差异，6总结。什么是语法的区别是不特定的，和它主要是参考的差异。

CommonJS

对于基本数据类型，它属于复制，它将由模块缓存。同时，该变量可以被重新分配到其他模块该模块的输出。

对于复杂的数据类型，它是一个浅拷贝，因为两个模块引用的对象指向相同的内存空间，模块值的变化会影响另一个模块。

当一个模块加载了需要的命令时，整个模块的代码就会运行。

当相同的模块加载的模块不需要命令，再执行一次，但在高速缓存中的值，也就是说，无论多少次CommonJS模块被加载时，它将只运行一次的第一次。再次加载后，它将返回第一次运行的结果，除非手动清除系统缓存。

加载时，它在加载时执行，也就是说，脚本代码是在需要时执行的。

ES6模块

在6模块属于动态只读参考值。

为只读的，不允许修改变量的值了，和进口的变量是只读的，无论是基本数据类型或复杂的数据类型。当该模块能够导入命令，产生一个只读的参考。当脚本会被执行，该值为加载模块基于该只读参考。

对于动态的，原始值会改变，并且导入负载的值会发生变化，不管它是基本数据类型还是复杂数据类型。

循环荷载作用下，

有一些重要的区别，现在举一些例子来说明每一点。

CommonJS

对于基本数据类型，它属于复制，它将由模块缓存。同时，该变量可以被重新分配到其他模块该模块的输出。
/ / b.js
设计数＝1
让（pluscount）= = > {
计数+ +
}
（setTimeout（）= > {
console.log（'b.js-1，计数）
}，1000）
module.exports = { {
计数，
pluscount
}

/ / a.js
让国防部=需要（'。 / b.js）
console.log（'a.js-1，MOD，计数）
mod.pluscount（）
console.log（'a.js-2，MOD，计数）
（setTimeout（）= > {
mod.count = 3
console.log（'a.js-3，MOD，计数）
}，2000）

结a.js
a.js-1 1
a.js-2 1
b.js-1 2 / 1秒
a.js-3 3 / 2秒
上面的代码显示，B单元输出的计数变量是一种复制行为，pluscount方法调用后，在一个模块的计数不受影响。同时，你可以在一个模块的值在B模块的变化。如果你希望能够同步代码，你可以去用口吸气。
相同的代码/其他
module.exports = { {
获取计数（）{
返回计数
}，
pluscount
}

结a.js
a.js-1 1
a.js-2 1
b.js-1 2 / 1秒
a.js-3 2 / 2秒，因为那里是二传没有定义，所以是不可能设定值。所以回到2
对于复杂的数据类型，它是一个浅拷贝，因为两个模块引用的对象指向相同的内存空间，模块值的变化会影响另一个模块。
/ / b.js
让obj = { {
数：1
}
让（pluscount）= = > {
Obj。数+ +
}
（setTimeout（）= > {
console.log（'b.js-1，对象计数）
}，1000）
（setTimeout（）= > {
console.log（'b.js-2，对象计数）
}，3000）
module.exports = { {
Obj，
pluscount
}

/ / a.js
VaR =需要（'。 / b.js）
console.log（'a.js-1，MOD OBJ。计数）
mod.pluscount（）
console.log（'a.js-2，MOD OBJ。计数）
（setTimeout（）= > {
mod.obj.count = 3
console.log（'a.js-3，MOD OBJ。计数）
}，2000）

结a.js
a.js-1 1
a.js-2 2
b.js-1 2
a.js-3 3
b.js-2 3
你可以看到，对象是对象的浅表副本。当一个模块执行的打印obj.count的值是1，然后通过pluscount方法，又当打印2，然后计数的值被修改的3个模块，并在这一次的B模块的值是3。

三.当一个模块加载了需要的命令时，整个模块的代码就会运行。

4。当相同的模块加载的要求命令，模块将不会被执行了，但在高速缓存中的值，也就是说，无论多少次CommonJS模块被加载时，它将只运行一次的第一次。再次加载后，它将返回第一次运行的结果，除非手动清除系统缓存。

当5。循环被加载，它在加载时执行，也就是说，脚本代码都是在需要时执行的。
3, 4和5可以在同一个例子中加以说明。

/ / b.js
exports.done = false
让=需要（'。 / a.js）
console.log（'b.js-1 '，a.done）
exports.done =真
console.log（'b.js-2 '，'执行完成）

/ / a.js
exports.done = false
让B =需要（'。 / b.js）
console.log（'a.js-1 '，b.done）
exports.done =真
console.log（'a.js-2 '，'执行完成）

/ / c.js
让=需要（'。 / a.js）
让B =需要（'。 / b.js）

console.log（'c.js-1 '，'执行完成，a.done，b.done）

结c.js
b.js-1假
对b.js-2执行完毕
a.js-1真实
对a.js-2执行完毕
c.js-1执行真实
仔细看看整个过程。

C模块是在Node.js.At这一点执行，你碰到的需要关键词和执行在A.js的所有代码。

在模块中导出之后，通过执行B模块的代码来引入B模块。

在B模块中导出之后，模块按需要引入，此时模块的代码被执行。

一个模块只执行exports.done =虚假陈述。

回到B模块、打印b.js-1，出口，b.js-2.the B模块完成。

回到一个模块，然后打印a.js-1，出口，b.js-2.the模块完成

回到C模块，然后需要，你需要引入B模块，因为它已经在一个模块中引入，这个值可以直接输出。

最终u3002

从上面的结果和分析过程中可以看到，当遇到需要命令时，执行相应的模块代码。当使用循环引用时，只输出模块的一部分代码。当引用相同的模块时，它不会再次加载，而是获取缓存。

ES6模块

在6模块的价值属于动态只读参考。只是解释复杂数据类型。

为只读的，不允许修改变量的值了，和进口的变量是只读的，无论是基本数据类型或复杂的数据类型。当该模块能够导入命令，产生一个只读的参考。当脚本会被执行，该值为加载模块基于该只读参考。

对于动态的，原始值会改变，并且导入负载的值会发生变化，不管它是基本数据类型还是复杂数据类型。
/ / b.js
导出让计数器= {
数：1
}
（setTimeout（）= > {
console.log（'b.js-1，计数器计数）
}，1000）

/ / a.js
进口{反}从'。 / b.js
计数器{ }
console.log（'a.js-1，计数器）

语法错误：计数器是只读的。
虽然反不能指派一个新的对象，你可以向对象添加属性和方法。在这个时候是没有错误的。这种行为和关键字const的用法。
/ / a.js
进口{反}从'。 / b.js
计数器+计数+
console.log（计数器）

2
当循环加载，ES6模块是一个动态的参考。只要有两个模块之间的引用，可以执行的代码。
/ / b.js
进口{ &&foo} '。 / a.js；
导出函数条（）{
console.log（'bar）；
如果（Math.random（）> 0.5）{
（食品）；
}
}

/ / a.js
进口{酒吧}从'。 / b.js；
导出函数富（）{
console.log（'foo）；
（酒吧）；
console.log（'execution完成）；
}
（食品）；

结a.js
Foo
酒吧
执行完毕

也可以执行 /
Foo
酒吧
Foo
酒吧
执行完毕
执行完毕
在两个模块之间有一个引用，因此可以正常执行。

CommonJS模块和6模块之间的区别是由萧边的全部内容。我们希望能给你一个参考，希望你能支持它。