结论 https://zhuanlan.zhihu.com/p/161015809https://zhuanlan.zhihu.com/p/161015809

commonJS ES Module
值 1.基本类型：值复制，不共享
2.引用类型：浅拷贝，共享
3.工作空间可以修改引入的值		 1.只读导入，动态读取
2.不可再外部修改引用，但是可以调用引用包含的方法
执行顺序 1.检查是否有该模块的缓存
2.如果有，则使用缓存
3.如果没有，则执行该模块代码，并缓存		 1.检查该模块是否引入过？
2.是，暂时认该模块为{}
3.否，进入该模块并执行其代码（不做缓存）
import 会被提升到最先执行

commonJS

  1. // mod.js
  2. let conout =1;
  3. let friends =['晓明'];
  5. function plusCount(){
  6.   count++;
  7. };
  9. funciton plusYuanhua(){
  10.   friendes.push('袁华')
  11. };
  13. setInterval(()=>{
  14.   console.log('mod.js 每秒打印 - count',count)
  15.   console.log('mod.js 每秒打印 - friends',friends)
  16. },1000)
  18. module.exports ={
  19.   coount,
  20.   friends,
  21.   plusCount,
  22.   plusYuanhua
  23. }
  24. ==============================================================================================
  25. //index.js
  26. const mod =require('./mod.js');
  28. console.log('index.js 初次引入 -mod.count',mod.count);
  29. console.log('index.js 初始导入 - mod.friends',mod.friends);
  31. mod.plusCount();
  32. mod.plusYuanhua();
  35. console.log('index.js 执行mod.plusCount 后-mod.count',mod.count);
  36. console.log('index.js 执行mod.plusYuanhua后- mod.friends',mod.friends);
  38. setTimeout(()=>{
  39.   //count是基础数据类型,值传递，不共享 ，所以在indx.js改变了 count 并不会改变mod.js 的count
  40.  mod.count=3;
  41.   console.log('index.js 延迟2s- mod.count',mod.count);
  42.   console.log('index.js 延迟2s- mod.friends',mod.friends);
  43. },2000)
  46. /*
  47. index.js 初次导入 - mod.count 1
  48. index.js 初次导入 - mod.friends [ '夏洛' ]
  50. index.js 执行 mod.plusCount/plusYuanhua 后 - mod.count 1
  51. index.js 执行 mod.plusCount/plusYuanhua 后 - mod.friends [ '夏洛', '袁华' ]
  53. mod.js 每秒打印 - count 2
  54. mod.js 每秒打印 - friends [ '夏洛', '袁华' ]
  56. mod.js 每秒打印 - count 2
  57. mod.js 每秒打印 - friends [ '夏洛', '袁华' ]
  59. index.js 延时2s - mod.count 3
  60. index.js 延时2s - mod.friends [ '夏洛', '袁华' ]
  62. mod.js 每秒打印 - count 2
  63. mod.js 每秒打印 - friends [ '夏洛', '袁华' ]
  64. */

ES Module

Node 13.2 增加了对ES Module 的支持，为了使node识别ES Module ,你需要做如下之一
1.更改.js 为.mjs,并使用 node index.mjs
2.package.json 添加字段 ‘type’:’module’,如此所有.js 均被识别为ES Module

  1. // indes.mjs
  2. import { counter} from './mod.mjs';
  3. //1.只读导入，动态读取
  4. //2.不可再外部修改引用，但是可以调用引用包含的方法
  5. counter ={} ;// TypeError: Assignment to constant variable.
  6. console.log('a.js-1',counter)
  8. //mod.mjs
  9. export let counter ={
  10.   count:1
  11. }
  12. setInterval(()=>{
  13.   console.log('modb.js-1',counter.count)
  14. }，1000)

可见 import 为只读引入，如此，mod.mjs 中 count 变化会及时的反应在 index.mjs 中

commoJS

  1. //index.js
  2. let a = require('./modA.js');
  3. let b =require('./modB.js');
  4. console.log('index.js-1','执行完毕',a.done,b.done);
  6. // modA.js
  7. exports.done =false;
  8. let b = require('./mobB.js');
  9. consle.log('modA.js-1',b.done);
  10. exports.done =true;
  11. console.log('modB.js-2','执行完毕');
  13. //modB.js
  14. exports.done =false;
  15. let a =require('./modA.js');
  16. console.log('modB.js-1',a.done);
  17. exports.done=true;
  18. console.log('mobB.js-2','执行完毕')
  20. /*
  21. modB.js-1 false
  22. modB.js-2 执行完毕
  23. modA.js-1 true
  24. modB.js-2 执行完毕
  25. index.js-1 执行完毕 true true
  26. */

执行顺序是这样的：

  1. node 执行 index.js 文件，发现require(‘./modA.js’)，暂停 index.js 代码执行，进入 modA 模块
  2. 在 modA 中发现require(‘./modB.js’)，暂停 modA 代码执行，将已执行的部分 modA 代码缓存，随后进入 modB 模块
  3. 在 modB 中发现require(‘./modA.js’)，提取已缓存的部分 modA，执行所有的 modB 代码，完毕后，缓存 modB 执行结果，执行栈返回至 modA
  4. 执行 modA 剩余代码，完毕后，缓存 modA，执行栈返回 index.js
  5. 在 index.js 发现require(‘./modBjs’)，提取已有的 modB 缓存，执行剩余代码

    ES Module

    ```javascript // index.mjs console.log(“before import mod”) import { b } from “./mod.mjs” console.log(“b is “ + b) export let a = b + 1;

// mod.mjs console.log(“before import index”) import { b } from “./index.mjs” console.log(“b is “ + b) export let a = b + 1;

/ before import a a is undefined before import b b is NAN / ```

  1. 进入 index.mjs ，提升 import(‘./modB.mjs’) 语句至顶部，最先执行，进入 modB
  2. 提升提升 import(‘./index.mjs’) 语句至顶部，发现已经执行过 index.mjs，此处将从 index 导入的内容当作 { }，执行剩余代码。完毕后，执行栈返回 index.mjs
  3. 执行剩余代码