Modularity（模块化-ES6）

// 值拷贝&值引用// lib/counter.js
var counter = 1;
function increment () {counter++;
}
function decrement () {counter--;
}
module.exports = {counter: counter,increment: increment,decrement: decrement
};// src/main.js
var counter = require('../lib/counter');
counter.increment();
console.log(counter.counter); // 1// 在 main.js 当中的实例是和原本模块完全不相干的。
// 这也就解释了为什么调用了 counter.increment() 之后仍然返回1。
// 因为我们引入的 counter 变量 和 模块里的是两个不同的实例// 所以调用 counter.increment() 方法只会改变模块中的 counter 
// 想要修改引入的 counter 只有手动一下啦：
counter.counter++;
console.log(counter.counter); // 2

// lib/counter.js
export let counter = 1;
export function increment () {counter++;
}
export function decrement () {counter--;
}// src/main.js
import * as counter from '../lib/counter';
console.log(counter.counter); // 1
counter.increment();
console.log(counter.counter); // 2

// 加载 & 编译// a.js
console.log('a.js')
import { foo } from'./b';// b.js
export let foo = 1;
console.log('b.js 先执行’);// 执行结果:
// b.js 先执行
// a.js

// a.js
import { foo } from './b';
console.log('a.js');
export const bar = 1;
export const bar2 = () => {console.log('bar2');
}
export function bar3 () {console.log('bar3');
}
console.log(foo,111);// b.js
'use strict'
export let foo = 1;
import * as a from './a';
console.log(a);// 执行结果:
// { bar: undefined, bar2: undefined, bar3: [Function: bar3] }
// a.js

// 循环加载// a.js
var b = require('b');// b.js
var a = require('a');

// CommonJS 循环加载// a.js
exports.done = false;
var b = require('./b.js');
console.log('在 a.js 之中，b.done = %j', b.done);
exports.done = true;
console.log('a.js 执行完毕’);// b.js
exports.done = false;
var a = require('./a.js');
console.log('在 b.js 之中，a.done = %j', a.done);
exports.done = true;
console.log('b.js 执行完毕’);// main.js
var a = require('../lib/a');
var b = require('../lib/b’); // 不在执行
console.log('在 main.js 之中, a.done=%j, b.done=%j', a.done, b.done);// 结果
在 b.js 之中，a.done = false
b.js 执行完毕
在 a.js 之中，b.done = true
a.js 执行完毕
在 main.js 之中, a.done=true, b.done=true// 结果分析
在b.js之中，a.js没有执行完毕，只执行了第一行。
main.js执行到第二行时，不会再次执行b.js，而是输出缓存的b.js的执行结果，即它的第四行

// a.js
import { bar } from './b';
console.log('a.mjs');
console.log(bar);
export let foo = 'foo’;// b.js
'use strict'
import { foo } from './ma';
console.log('b.mjs');
console.log(foo);  // 执行a.mjs以后会报错，foo变量未定义.
export let bar = 'bar’;// 结果
b.mjs
ReferenceError: foo is not defined  // 结果分析
执行a.mjs以后，引擎发现它加载了b.mjs，因此会优先执行b.mjs，然后再执行a.mjs
执行b.mjs的时候，已知它从a.mjs输入了foo接口，这时不会去执行a.mjs，而是认为这个接口已经存在了，继续往下执行。
执行到第三行console.log(foo)的时候，才发现这个接口根本没定义，因此报错

// 让b.mjs运行的时候，foo已经有定义了。这可以通过将foo写成函数来解决// ma.js
import { bar } from './mb';
console.log('a.mjs');
console.log(bar());
function foo() { return 'foo' }
export { foo };// mb.js
import { foo } from './ma';
console.log('b.mjs');
console.log(foo());
function bar() { return'bar' }
export { bar };结果
b.mjs
foo
a.mjs
bar