概述
在ES6之前,JavaScript一直没有模块(module)体系,无法将一个大程序拆分成互相依赖的小文件,再用简单的方法拼装起来。社区制定了一些模块加载方案,最主要的有CommonJS和AMD两种。前者用于服务器,后者用于浏览器。
ES6在语言标准的层面上,实现了模块功能,而且实现很简单,可以完全取代CommmJS和AMD规范,成为浏览器和服务器通用的模块解决方案。
由于 ES6 模块是编译时加载,使得静态分析成为可能。有了它,就能进一步拓宽 JavaScript 的语法,比如引入宏(macro)和类型检验(type system)这些只能靠静态分析实现的功能。
严格模式
ES6 的模块自动采用严格模式,不管你有没有在模块头部加上"use strict";
。
严格模式主要有以下限制。
- 变量必须声明后再使用
- 函数的参数不能有同名属性,否则报错
- 不能使用
with
语句 - 不能对只读属性赋值,否则报错
- 不能使用前缀0表示八进制数,否则报错
- 不能删除不可删除的属性,否则报错
- 不能删除变量
delete prop
,会报错,只能删除属性delete global[prop]
-
eval
不会在它的外层作用域引入变量 -
eval
和arguments
不能被重新赋值 -
arguments
不会自动反映函数参数的变化 - 不能使用
arguments.callee
- 不能使用
arguments.caller
- 禁止
this
指向全局对象 - 不能使用
fn.caller
和fn.arguments
获取函数调用的堆栈 - 增加了保留字(比如
protected
、static
和interface
)
export命令
模块功能主要由两个命令构成:export
和import
。export
命令用于规定模块的对外接口,import
命令用于输入其他模块提供的功能。
一个模块就是一个独立的文件。该文件内部的所有变量,外部无法获取。
// 对外输出变量
export var firstName = 'Angus'
export var lastName = 'jay'
export var year = 1998
// 另一种写法
var firstName = 'Angus'
var lastName = 'jay'
var year = 1998
export {firstName,lastName,year} // 优先考虑这种写法。可以在脚本尾部清除看出输出变量
// 除了输出变量,还可以输出函数或类(class)
export function multiply(x,y){
retrun x * y
}
// 通常export输出变量就是本来的名字,但可以用as关键字重命名
export {
multiply as stream1,
multiply as stream2
}
// multiply可以用两个不同的名字输出两次
// 对外输出变量
export var firstName = 'Angus'
export var lastName = 'jay'
export var year = 1998
// 另一种写法
var firstName = 'Angus'
var lastName = 'jay'
var year = 1998
export {firstName,lastName,year} // 优先考虑这种写法。可以在脚本尾部清除看出输出变量
// 除了输出变量,还可以输出函数或类(class)
export function multiply(x,y){
retrun x * y
}
// 通常export输出变量就是本来的名字,但可以用as关键字重命名
export {
multiply as stream1,
multiply as stream2
}
// multiply可以用两个不同的名字输出两次
需要特别注意的是,export
命令规定的是对外的接口,必须与模块内部的变量建立一一对应关系。
// 报错
export 1
// 报错
var m = 1
export m
// 以上两种写法,没有提供对外的接口,都是直接输出1。只是一个值,不是接口
// 写法一
export var m = 1
// 写法二
var m = 1
export {m}
// 写法三
var n = 1
export {n as m}
// 同样对function和class的输出也必须遵守接口名与模块变量一一对应的关系
// 报错
function f(){}
export f
// 正确
export function f(){}
// 正确
function f(){}
export {f}
// 报错
export 1
// 报错
var m = 1
export m
// 以上两种写法,没有提供对外的接口,都是直接输出1。只是一个值,不是接口
// 写法一
export var m = 1
// 写法二
var m = 1
export {m}
// 写法三
var n = 1
export {n as m}
// 同样对function和class的输出也必须遵守接口名与模块变量一一对应的关系
// 报错
function f(){}
export f
// 正确
export function f(){}
// 正确
function f(){}
export {f}
另外,export
语句输出的接口,与其对应的值是动态绑定关系,即通过该接口,可以取到模块内部实时的值。
export var foo = 'bar'
setTimeout(() => foo='baz',500)
export var foo = 'bar'
setTimeout(() => foo='baz',500)
import命令
使用export
命令定义了模块的对外接口后,其他JS文件就可以通过import
命令加载这个模块。
import {firstName,lastName,year} from './profile'
function setName(element){
element.textContent = firstName + '' + lastName
}
// 使用as关键字将输入的变量重命名
import {lastName as surname} from './profile'
// import后面的from指定模块文件的位置,可以使相对路径也可以是绝对路径,.js后缀可以省略
// import命名具有提升效果,会提升到整个模块的头部,首先执行
foo()
import {foo} from 'my_module'
// 由于import是静态执行,所以不能使用表达式和变量,这些只有在运行时才能得到结果的语法结构
// 报错
import { 'f' + 'oo' } from 'my_module'
// 报错
if(x === 1){
import { foo } from 'module1'
}else{
import { foo } from 'module2'
}
import {firstName,lastName,year} from './profile'
function setName(element){
element.textContent = firstName + '' + lastName
}
// 使用as关键字将输入的变量重命名
import {lastName as surname} from './profile'
// import后面的from指定模块文件的位置,可以使相对路径也可以是绝对路径,.js后缀可以省略
// import命名具有提升效果,会提升到整个模块的头部,首先执行
foo()
import {foo} from 'my_module'
// 由于import是静态执行,所以不能使用表达式和变量,这些只有在运行时才能得到结果的语法结构
// 报错
import { 'f' + 'oo' } from 'my_module'
// 报错
if(x === 1){
import { foo } from 'module1'
}else{
import { foo } from 'module2'
}
import
语句会执行所加载的模块,因此可以有以下写法
import 'lodash'
// 多次重复执行同一句import语句,那么只会执行一次
import 'lodash'
import 'lodash'
// import语句是Singleton模式
import {foo} from 'my_module'
import {bar} from 'my_module'
// 等同于
import {foo,bar} from 'my_module'
import 'lodash'
// 多次重复执行同一句import语句,那么只会执行一次
import 'lodash'
import 'lodash'
// import语句是Singleton模式
import {foo} from 'my_module'
import {bar} from 'my_module'
// 等同于
import {foo,bar} from 'my_module'
目前阶段,通过 Babel 转码,CommonJS 模块的require
命令和 ES6 模块的import
命令,可以写在同一个模块里面,但是最好不要这样做。因为import
在静态解析阶段执行,所以它是一个模块之中最早执行的。
模块的整体加载
除了指定加载某个输出值,还可以使用整体加载,即用星号*
指定一个对象,所有输出值都加载在这个对象上。
import * as circle from './circle'
// 注意:模块整体加载所在的对象,应该是可以静态分析的,所以不允许运行时改变
circle.foo = 'hello'
circle.area = function(){}
import * as circle from './circle'
// 注意:模块整体加载所在的对象,应该是可以静态分析的,所以不允许运行时改变
circle.foo = 'hello'
circle.area = function(){}
export default命令
为了使用方便,在不需要用户知道所要加载的变量名或者函数名时就能加载模块,需要使用到export default
命名,为模块指定默认输出。
export default function (){
console.log('foo')
}
// 加载时,import命令可以为该匿名函数指定任意名字
import customName from './export-default'
customName() // 'foo'
// export default命令用在非匿名函数前也可以
export default function foo(){}
// 另一种写法
function foo(){}
export default foo
export default function (){
console.log('foo')
}
// 加载时,import命令可以为该匿名函数指定任意名字
import customName from './export-default'
customName() // 'foo'
// export default命令用在非匿名函数前也可以
export default function foo(){}
// 另一种写法
function foo(){}
export default foo
export default
命令用于指定模块的默认输出。显然,一个模块只能有一个默认输出,因此export default
命令只能使用一次。所以,import
命令后面才不用加大括号,因为只可能对应一个方法。
本质上,export default
就是输出一个叫做default
的变量或方法,然后系统允许你为它取任意名字。
function add(){}
export {add as default}
// 等同于
export default add
import {default as foo} from 'modules'
// 等同于
import foo from 'modules'
function add(){}
export {add as default}
// 等同于
export default add
import {default as foo} from 'modules'
// 等同于
import foo from 'modules'
同样地,因为export default
本质是将该命令后面的值,赋给default
变量以后再默认,所以直接将一个值写在export default
之后。
// 正确
export default 10
// 报错
export 10
// 正确
export default 10
// 报错
export 10
可以在一条import
语句中,同时输入默认方法和其他接口
import _,{each,each as forEach} from 'lodash'
// 对应的export语句
export default function(){}
export function each(){}
import _,{each,each as forEach} from 'lodash'
// 对应的export语句
export default function(){}
export function each(){}
export default
也可以用来输出类。
export default class{}
import MyClass from 'myClass'
let o = new MyClass()
export default class{}
import MyClass from 'myClass'
let o = new MyClass()
export与import的复合写法
// 在一个模块中,同时输入输出同一个模块
export {foo,bar} from 'my_module'
// 等同于
import {foo,bar} from 'my_module'
export {foo,bar}
// 接口改名与整体输出也可以采用这种写法
export {foo as myFoo} from 'my_module'
export * from 'my_module'
// 在一个模块中,同时输入输出同一个模块
export {foo,bar} from 'my_module'
// 等同于
import {foo,bar} from 'my_module'
export {foo,bar}
// 接口改名与整体输出也可以采用这种写法
export {foo as myFoo} from 'my_module'
export * from 'my_module'
import()
import
命令会被 JavaScript 引擎静态分析,先于模块内的其他模块执行(叫做”连接“更合适)。import
和export
命令只能在模块的顶层,不能在代码块之中。这样的设计导致无法在运行时加载模块。在语法上,条件加载就不可能实现。
如果import
命令要取代 Node 的require
方法,这就形成了一个障碍。因为require
是运行时加载模块,import
命令无法取代require
的动态加载功能。
// 报错
if (x === 2) {
import MyModual from './myModual';
}
// require加载的模块只有运行时才知道,import语句做不到这一点
const path = './' + fileName
const myModual = require(path)
// 报错
if (x === 2) {
import MyModual from './myModual';
}
// require加载的模块只有运行时才知道,import语句做不到这一点
const path = './' + fileName
const myModual = require(path)
在这种情况下,产生一个提案,建议引入import()
函数,完成动态加载。import()
返回一个Promise对象完成异步加载。这样就类似于Node的require
方法,不同于require
方法的同步加载。