es6-module（模块化）和严格模式

es6模块自动开启严格模式 ES6模块的思想是尽量的静态化, 编译时就确认依赖关系

1. es6的模块化是编译时加载（所以可以做静态优化，引入宏和类型检查）原来用CommonJS(server) AMD(browser) 运行时
   宏? 类型检查
2. commonJS是运行时加载，所以不能做静态优化
3. 模块化解决命名冲突 type=“module”

let obj = {
	name: 123
}
export default obj

import { name } from 'obj' // 并不支持这种写法, 以为很合理, 导入的不是对象么, 然后把里面的name 解构出来.
import xx from 'obj'
let { name } = xxx;

必须放在最外层

!!!!!  本质上，export default就是输出一个叫做default的变量或方法，然后系统允许你为它取任意名字。

export default aa === export { add as default }; // 默认暴露

全部引入?  import * as b from 'a'; 
import { a, b } form './main.js' import 是只读的  也可以用as; 
import foo from 'modules'  === import { default as foo }  from 'modules'

多次import某一个变量,只会执行一次 

// a.js
export default function a() { // 默认暴露
	...
}

// b.js
import a from './a' // 这种写法最常见
import { a, b, c } from 'fs' // 编译时加载/静态加载
import * as sum from './a' // sum.default()

export

export 可以多个, 也可以混搭 export default , export default 只能一个

// 写法一
export var m = 1;

// 写法二
var m = 1;
export { m };  注意, 这里不是对象, 也可以写成 export { m as xx }

// 写法三
var n = 1;
export {n as m};

// 默认暴露
export default{} // 严格模式只能有一个默认暴露

// 正确
export function f() {};

// 正确
function f() {}
export { f };

import 引入

1. import 不能配合解构赋值

import a from 'a' // 这种不带括号的引入的是默认暴露的
import a, { m } from 'a' // 混搭

commonJS模块

// CommonJS模块
let { stat, exists, readfile } = require('fs');

// 等同于
let _fs = require('fs');
let stat = _fs.stat;
let exists = _fs.exists;
let readfile = _fs.readfile;

const XX = rquire('xx')
module.exports = xxxx

const Contoller = require('egg').Controller

class Fruit extends Contoller {
	async index() {
		this.ctx.body = '123'
	}
}

module.exports = Fruit

严格模式

1. 变量声明后再使用
2. with

解构赋值

1. 解构不成功, 值为undefined
2. let { a: b = 123 } = { a: 1 }; // b真正被赋值的是后者 允许设置默认值
3. 可重复解构, let { a: b, a: c } = { a: 1} 可连续解构{ a: { b } }
4. let { age, …rest } = { age: 19, name: ‘123’ } // res { name: ‘123’ }

let { a: b = 123 } // 这样会报错, 也是, 如果不解构的话, 这样写图啥?

参考文档

阮一峰 ES6-module