历史上,JavaScript 一直没有模块(module)体系,无法将一个大程序拆分成互相依赖的小文件,再用简单的方法拼装起来。
其他语言都有这项功能,比如 Ruby 的require
、Python 的import
,甚至就连 CSS 都有@import
,
但是 JavaScript 任何这方面的支持都没有,这对开发大型的、复杂的项目形成了巨大障碍。
在 ES6 之前,社区制定了一些模块加载方案,最主要的有 CommonJS 和 AMD 两种。
前者用于服务器,后者用于浏览器。
ES6 在语言标准的层面上,实现了模块功能,
而且实现得相当简单,完全可以取代 CommonJS 和 AMD 规范,成为浏览器和服务器通用的模块解决方案。
ES6 模块的设计思想是尽量的静态化,使得编译时就能确定模块的依赖关系,以及输入和输出的变量。
CommonJS 和 AMD 模块,都只能在运行时确定这些东西。
比如,CommonJS 模块就是对象,输入时必须查找对象属性。
// CommonJS模块
let {
stat, exists, readFile } = require('fs');
// 等同于
let _fs = require('fs');
let stat = _fs.stat;
let exists = _fs.exists;
let readfile = _fs.readfile;
上面代码的实质是整体加载fs
模块(即加载fs
的所有方法),生成一个对象(_fs
),然后再从这个对象上面读取 3 个方法。
这种加载称为“运行时加载”,因为只有运行时才能得到这个对象,导致完全没办法在编译时做“静态优化”。
ES6 模块不是对象,而是通过export
命令显式指定输出的代码,再通过import
命令输入。
// ES6模块
import {
stat, exists, readFile } from 'fs';
上面代码的实质是从fs
模块加载 3 个方法,其他方法不加载。
这种加载称为“编译时加载” 或者 静态加载,
即 ES6 可以在编译时就完成模块加载,效率要比 CommonJS 模块的加载方式高。
当然,这也导致了没法引用 ES6 模块本身,因为它不是对象。
由于 ES6 模块是编译时加载,使得静态分析成为可能。
有了它,就能进一步拓宽 JavaScript 的语法,
比如引入宏(macro)和类型检验(type system)这些只能靠静态分析实现的功能。
除了静态加载带来的各种好处,ES6 模块还有以下好处。
UMD
模块格式了,将来服务器和浏览器都会支持 ES6 模块格式。目前,通过各种工具库,其实已经做到了这一点。navigator
对象的属性。Math
对象),未来这些功能可以通过模块提供。本章介绍 ES6 模块的语法,下一章介绍如何在浏览器和 Node 之中,加载 ES6 模块。
ES6 的模块自动采用严格模式,不管你有没有在模块头部加上"use strict";
。
严格模式主要有以下限制。
with
语句delete prop
,会报错,只能删除属性delete global[prop]
eval
不会在它的外层作用域引入变量eval
和arguments
不能被重新赋值arguments
不会自动反映函数参数的变化arguments.callee
arguments.caller
this
指向全局对象fn.caller
和fn.arguments
获取函数调用的堆栈protected
、static
和interface
)上面这些限制,模块都必须遵守。
由于严格模式是 ES5 引入的,不属于 ES6,所以请参阅相关 ES5 书籍,本书不再详细介绍了。
其中,尤其需要注意this
的限制。
ES6 模块之中,顶层的this
指向undefined
,即不应该在顶层代码使用this
。
模块功能主要由两个命令构成:export
和import
。
export
命令用于规定模块的对外接口,import
命令用于输入其他模块提供的功能。
一个模块就是一个独立的文件。该文件内部的所有变量,外部无法获取。
如果你希望外部能够读取模块内部的某个变量,就必须使用export
关键字输出该变量。
下面是一个 JS 文件,里面使用export
命令输出变量。
// profile.js
export var firstName = 'Michael';
export var lastName = 'Jackson';
export var year = 1958;
上面代码是profile.js
文件,保存了用户信息。
ES6 将其视为一个模块,里面用export
命令对外部输出了三个变量。
export
的写法,除了像上面这样,还有另外一种。
// profile.js
var firstName = 'Michael';
var lastName = 'Jackson';
var year = 1958;
export {
firstName, lastName, year};
上面代码在export
命令后面,使用大括号指定所要输出的一组变量。
它与前一种写法(直接放置在var
语句前)是等价的,但是应该优先考虑使用这种写法。
因为这样就可以在脚本尾部,一眼看清楚输出了哪些变量。
export
命令除了输出变量,还可以输出函数或类(class)。
export function multiply(x, y) {
return x * y;
};
上面代码对外输出一个函数multiply
。
通常情况下,export
输出的变量就是本来的名字,但是可以使用as
关键字重命名。
function v1() {
... }
function v2() {
... }
export {
v1 as streamV1,
v2 as streamV2,
v2 as streamLatestVersion
};
上面代码使用as
关键字,重命名了函数v1
和v2
的对外接口。
重命名后,v2
可以用不同的名字输出两次。
需要特别注意的是,export
命令规定的是对外的接口,必须与模块内部的变量建立一一对应关系。
// 报错
export 1;
// 报错
var m = 1;
export m;
上面两种写法都会报错,因为没有提供对外的接口。
第一种写法直接输出 1,第二种写法通过变量m
,还是直接输出 1。
1
只是一个值,不是接口。
正确的写法是下面这样。
// 写法一
export var m = 1;
// 写法二
var m = 1;
export {
m};
// 写法三
var n = 1;
export {
n as m};
上面三种写法都是正确的,规定了对外的接口m
。
其他脚本可以通过这个接口,取到值1
。
它们的实质是,在接口名与模块内部变量之间,建立了一一对应的关系。
同样的,function
和class
的输出,也必须遵守这样的写法。
// 报错
function f() {
}
export f;
// 正确
export function f() {
};
// 正确
function f() {
}
export {
f};
另外,export
语句输出的接口,与其对应的值是动态绑定关系,
即通过该接口,可以实时取到模块内部最新的值。
export var foo = 'bar';
setTimeout(() => foo = 'baz', 500);
上面代码输出变量foo
,值为bar
,500 毫秒之后变成baz
。
这一点与 CommonJS 规范完全不同。
CommonJS 模块输出的是值的缓存,不存在动态更新,详见下文《Module 的加载实现》一节。
最后,export
命令可以出现在模块的任何位置,只要处于模块顶层就可以。
注意: 如果处于块级作用域内,就会报错,下一节的import
命令也是如此。
这是因为处于条件代码块之中,就没法做静态优化了,违背了 ES6 模块的设计初衷。
function foo() {
export default 'bar' // SyntaxError
}
foo()
上面代码中,export
语句放在函数之中,结果报错。
使用export
命令定义了模块的对外接口以后,其他 JS 文件就可以通过import
命令加载这个模块。
// main.js
import {
firstName, lastName, year} from './profile.js';
function setName(element) {
element.textContent = firstName + ' ' + lastName;
}
上面代码的import
命令,用于加载profile.js
文件,并从中输入变量。
import
命令接受一对大括号,里面指定要从其他模块导入的变量名。
注意: 大括号里面的变量名,必须与被导入模块(profile.js
)对外接口的名称相同。
如果想为输入的变量重新取一个名字,import
命令要使用as
关键字,将输入的变量重命名。
import {
lastName as surname } from './profile.js';
import
命令输入的变量都是只读的,因为它的本质是输入接口。
也就是说,不允许在加载模块的脚本里面,改写接口。
import {
a} from './xxx.js'
a = {
}; // Syntax Error : 'a' is read-only;
上面代码中,脚本加载了变量a
,对其重新赋值就会报错,因为a
是一个只读的接口。
但是,如果a
是一个对象,改写a
的属性是允许的。
import {
a} from './xxx.js'
a.foo = 'hello'; // 合法操作
上面代码中,a
的属性可以成功改写,并且其他模块也可以读到改写后的值。
不过,这种写法很难查错,建议: 凡是输入的变量,都当作完全只读,轻易不要改变它的属性。
import
后面的from
指定模块文件的位置,可以是相对路径,也可以是绝对路径,.js
后缀可以省略。
如果只是模块名,不带有路径,那么必须有配置文件,告诉 JavaScript 引擎该模块的位置。
import {
myMethod} from 'util';
上面代码中,util
是模块文件名,由于不带有路径,必须通过配置,告诉引擎怎么取到这个模块。
注意,import
命令具有提升效果,会提升到整个模块的头部,首先执行。
foo();
import {
foo } from 'my_module';
上面的代码不会报错,因为import
的执行早于foo
的调用。
这种行为的本质是,import
命令是编译阶段执行的,在代码运行之前。
由于import
是静态执行,所以不能使用表达式和变量,这些只有在运行时才能得到结果的语法结构。
// 报错
import {
'f' + 'oo' } from 'my_module';
// 报错
let module = 'my_module';
import {
foo } from module;
// 报错
if (x === 1) {
import {
foo } from 'module1';
} else {
import {
foo } from 'module2';
}
上面三种写法都会报错,因为它们用到了表达式、变量和if
结构。
在静态分析阶段,这些语法都是没法得到值的。
最后,import
语句会执行所加载的模块,因此可以有下面的写法。
import 'lodash';
上面代码仅仅执行lodash
模块,但是不输入任何值。
如果多次重复执行同一句import
语句,那么只会执行一次,而不会执行多次。
import 'lodash';
import 'lodash';
上面代码加载了两次lodash
,但是只会执行一次。
import {
foo } from 'my_module';
import {
bar } from 'my_module';
// 等同于
import {
foo, bar } from 'my_module';
上面代码中,虽然foo
和bar
在两个语句中加载,但是它们对应的是同一个my_module
实例。
也就是说,import
语句是 Singleton 模式。
目前阶段,通过 Babel 转码,CommonJS 模块的require
命令和 ES6 模块的import
命令,可以写在同一个模块里面,
但是最好不要这样做。
因为import
在静态解析阶段执行,所以它是一个模块之中最早执行的。
下面的代码可能不会得到预期结果。
require('core-js/modules/es6.symbol');
require('core-js/modules/es6.promise');
import React from 'React';
除了指定加载某个输出值,还可以使用整体加载,
即用星号(*
)指定一个对象,所有输出值都加载在这个对象上面。
下面是一个circle.js
文件,它输出两个方法area
和circumference
。
// circle.js
export function area(radius) {
return Math.PI * radius * radius;
}
export function circumference(radius) {
return 2 * Math.PI * radius;
}
现在,加载这个模块。
// main.js
import {
area, circumference } from './circle';
console.log('圆面积:' + area(4));
console.log('圆周长:' + circumference(14));
上面写法是逐一指定要加载的方法,
整体加载的写法如下。
import * as circle from './circle';
console.log('圆面积:' + circle.area(4));
console.log('圆周长:' + circle.circumference(14));
注意,模块整体加载所在的那个对象(上例是circle
),应该是可以静态分析的,所以不允许运行时改变。
下面的写法都是不允许的。
import * as circle from './circle';
// 下面两行都是不允许的
circle.foo = 'hello';
circle.area = function () {
};
从前面的例子可以看出,使用import
命令的时候,用户需要知道所要加载的变量名或函数名,否则无法加载。
但是,用户肯定希望快速上手,未必愿意阅读文档,去了解模块有哪些属性和方法。
为了给用户提供方便,让他们不用阅读文档就能加载模块,就要用到export default
命令,为模块指定默认输出。
// export-default.js
export default function () {
console.log('foo');
}
上面代码是一个模块文件export-default.js
,它的默认输出是一个函数。
其他模块加载该模块时,import
命令可以为该匿名函数指定任意名字。
// import-default.js
import customName from './export-default';
customName(); // 'foo'
上面代码的import
命令,可以用任意名称指向export-default.js
输出的方法,这时就不需要知道原模块输出的函数名。
需要注意的是,这时import
命令后面,不使用大括号。
export default
命令用在非匿名函数前,也是可以的。
// export-default.js
export default function foo() {
console.log('foo');
}
// 或者写成
function foo() {
console.log('foo');
}
export default foo;
上面代码中,foo
函数的函数名foo
,在模块外部是无效的。加载的时候,视同匿名函数加载。
下面比较一下默认输出和正常输出。
// 第一组
export default function crc32() {
// 输出
// ...
}
import crc32 from 'crc32'; // 输入
// 第二组
export function crc32() {
// 输出
// ...
};
import {
crc32} from 'crc32'; // 输入
上面代码的两组写法,
第一组是使用export default
时,对应的import
语句不需要使用大括号;
第二组是不使用export default
时,对应的import
语句需要使用大括号。
export default
命令用于指定模块的默认输出。
显然,一个模块只能有一个默认输出,因此export default
命令只能使用一次。
所以,import命令后面才不用加大括号,因为只可能唯一对应export default
命令。
本质上,export default
就是输出一个叫做default
的变量或方法,然后系统允许你为它取任意名字。
所以,下面的写法是有效的。
// modules.js
function add(x, y) {
return x * y;
}
export {
add as default};
// 等同于
// export default add;
// app.js
import {
default as foo } from 'modules';
// 等同于
// import foo from 'modules';
正是因为export default
命令其实只是输出一个叫做default
的变量,
所以它后面不能跟变量声明语句。
// 正确
export var a = 1;
// 正确
var a = 1;
export default a;
// 错误
export default var a = 1;
上面代码中,export default a
的含义是将变量a
的值赋给变量default
。
所以,最后一种写法会报错。
同样地,因为export default
命令的本质是将后面的值,赋给default
变量,
所以可以直接将一个值写在export default
之后。
// 正确
export default 42;
// 报错
export 42;
上面代码中,后一句报错是因为没有指定对外的接口,而前一句指定外对接口为default
。
有了export default
命令,输入模块时就非常直观了,以输入 lodash 模块为例。
import _ from 'lodash';
如果想在一条import
语句中,同时输入默认方法和其他接口,可以写成下面这样。
import _, {
each, each as forEach } from 'lodash';
对应上面代码的export
语句如下。
export default function (obj) {
// ···
}
export function each(obj, iterator, context) {
// ···
}
export {
each as forEach };
上面代码的最后一行的意思是,暴露出forEach
接口,默认指向each
接口,即forEach
和each
指向同一个方法。
export default
也可以用来输出类。
// MyClass.js
export default class {
... }
// main.js
import MyClass from 'MyClass';
let o = new MyClass();
如果在一个模块之中,先输入后输出同一个模块,import
语句可以与export
语句写在一起。
export {
foo, bar } from 'my_module';
// 可以简单理解为
import {
foo, bar } from 'my_module';
export {
foo, bar };
上面代码中,export
和import
语句可以结合在一起,写成一行。
但需要注意的是,写成一行以后,foo
和bar
实际上并没有被导入当前模块,
只是相当于对外转发了这两个接口,导致当前模块不能直接使用foo
和bar
。
模块的接口改名和整体输出,也可以采用这种写法。
// 接口改名
export {
foo as myFoo } from 'my_module';
// 整体输出
export * from 'my_module';
默认接口的写法如下。
export {
default } from 'foo';
具名接口改为默认接口的写法如下。
export {
es6 as default } from './someModule';
// 等同于
import {
es6 } from './someModule';
export default es6;
同样地,默认接口也可以改名为具名接口。
export {
default as es6 } from './someModule';
下面三种import
语句,没有对应的复合写法。
import * as someIdentifier from "someModule";
import someIdentifier from "someModule";
import someIdentifier, {
namedIdentifier } from "someModule";
为了做到形式的对称,现在有提案,提出补上这三种复合写法。
export * as someIdentifier from "someModule";
export someIdentifier from "someModule";
export someIdentifier, {
namedIdentifier } from "someModule";
模块之间也可以继承。
假设有一个circleplus
模块,继承了circle
模块。
// circleplus.js
export * from 'circle';
export var e = 2.71828182846;
export default function(x) {
return Math.exp(x);
}
上面代码中的export *
,表示再输出circle
模块的所有属性和方法。
注意,export *
命令会忽略circle
模块的default
方法。
然后,上面代码又输出了自定义的e
变量和默认方法。
这时,也可以将circle
的属性或方法,改名后再输出。
// circleplus.js
export {
area as circleArea } from 'circle';
上面代码表示,只输出circle
模块的area
方法,且将其改名为circleArea
。
加载上面模块的写法如下。
// main.js
import * as math from 'circleplus';
import exp from 'circleplus';
console.log(exp(math.e));
上面代码中的import exp
表示,将circleplus
模块的默认方法加载为exp
方法。
本书介绍const
命令的时候说过,const
声明的常量只在当前代码块有效。
如果想设置跨模块的常量(即跨多个文件),或者说一个值要被多个模块共享,
可以采用下面的写法。
// constants.js 模块
export const A = 1;
export const B = 3;
export const C = 4;
// test1.js 模块
import * as constants from './constants';
console.log(constants.A); // 1
console.log(constants.B); // 3
// test2.js 模块
import {
A, B} from './constants';
console.log(A); // 1
console.log(B); // 3
如果要使用的常量非常多,可以建一个专门的constants
目录,将各种常量写在不同的文件里面,保存在该目录下。
// constants/db.js
export const db = {
url: 'http://my.couchdbserver.local:5984',
admin_username: 'admin',
admin_password: 'admin password'
};
// constants/user.js
export const users = ['root', 'admin', 'staff', 'ceo', 'chief', 'moderator'];
然后,将这些文件输出的常量,合并在index.js
里面。
// constants/index.js
export {
db} from './db';
export {
users} from './users';
使用的时候,直接加载index.js
就可以了。
// script.js
import {
db, users} from './index';
前面介绍过,import
命令会被 JavaScript 引擎静态分析,
先于模块内的其他语句执行(import
命令叫做”连接“ binding 其实更合适)。
所以,下面的代码会报错。
// 报错
if (x === 2) {
import MyModual from './myModual';
}
上面代码中,引擎处理import
语句是在编译时,这时不会去分析或执行if
语句,所以import
语句放在if
代码块之中毫无意义,
因此会报句法错误,而不是执行时错误。
也就是说,import
和export
命令只能在模块的顶层,不能在代码块之中(比如,在if
代码块之中,或在函数之中)。
这样的设计,固然有利于编译器提高效率,但也导致无法在运行时加载模块。
在语法上,条件加载就不可能实现。
如果import
命令要取代 Node 的require
方法,这就形成了一个障碍。
因为require
是运行时加载模块,import
命令无法取代require
的动态加载功能。
const path = './' + fileName;
const myModual = require(path);
上面的语句就是动态加载,require
到底加载哪一个模块,只有运行时才知道。import
命令做不到这一点。
因此,有一个提案,建议引入import()
函数,完成动态加载。
import(specifier)
上面代码中,import
函数的参数specifier
,指定所要加载的模块的位置。
import
命令能够接受什么参数,import()
函数就能接受什么参数,
两者区别主要是后者为动态加载。
import()
返回一个 Promise 对象。下面是一个例子。
const main = document.querySelector('main');
import(`./section-modules/${
someVariable}.js`)
.then(module => {
module.loadPageInto(main);
})
.catch(err => {
main.textContent = err.message;
});
import()
函数可以用在任何地方,不仅仅是模块,非模块的脚本也可以使用。
它是运行时执行,也就是说,什么时候运行到这一句,就会加载指定的模块。
另外,import()
函数与所加载的模块没有静态连接关系,这点也是与import
语句不相同。
import()
类似于 Node 的require
方法,区别主要是前者是异步加载,后者是同步加载。
下面是import()
的一些适用场合。
(1)按需加载。
import()
可以在需要的时候,再加载某个模块。
button.addEventListener('click', event => {
import('./dialogBox.js')
.then(dialogBox => {
dialogBox.open();
})
.catch(error => {
/* Error handling */
})
});
上面代码中,import()
方法放在click
事件的监听函数之中,只有用户点击了按钮,才会加载这个模块。
(2)条件加载
import()
可以放在if
代码块,根据不同的情况,加载不同的模块。
if (condition) {
import('moduleA').then(...);
} else {
import('moduleB').then(...);
}
上面代码中,如果满足条件,就加载模块 A,否则加载模块 B。
(3)动态的模块路径
import()
允许模块路径动态生成。
import(f())
.then(...);
上面代码中,根据函数f
的返回结果,加载不同的模块。
import()
加载模块成功以后,这个模块会作为一个对象,当作then
方法的参数。
因此,可以使用对象解构赋值的语法,获取输出接口。
import('./myModule.js')
.then(({
export1, export2}) => {
// ...·
});
上面代码中,export1
和export2
都是myModule.js
的输出接口,可以解构获得。
如果模块有default
输出接口,可以用参数直接获得。
import('./myModule.js')
.then(myModule => {
console.log(myModule.default);
});
上面的代码也可以使用具名输入的形式。
import('./myModule.js')
.then(({
default: theDefault}) => {
console.log(theDefault);
});
如果想同时加载多个模块,可以采用下面的写法。
Promise.all([
import('./module1.js'),
import('./module2.js'),
import('./module3.js'),
])
.then(([module1, module2, module3]) => {
···
});
import()
也可以用在 async 函数之中。
async function main() {
const myModule = await import('./myModule.js');
const {
export1, export2} = await import('./myModule.js');
const [module1, module2, module3] =
await Promise.all([
import('./module1.js'),
import('./module2.js'),
import('./module3.js'),
]);
}
main();
上一章介绍了模块的语法,本章介绍如何在浏览器和 Node 之中加载 ES6 模块,
以及实际开发中经常遇到的一些问题(比如循环加载)。
HTML 网页中,浏览器通过标签加载 JavaScript 脚本。
上面代码中,由于浏览器脚本的默认语言是 JavaScript,因此
type="application/javascript"
可以省略。默认情况下,浏览器是同步加载 JavaScript 脚本,
即渲染引擎遇到
标签就会停下来,等到执行完脚本,再继续向下渲染。
如果是外部脚本,还必须加入脚本下载的时间。
如果脚本体积很大,下载和执行的时间就会很长,因此造成浏览器堵塞,用户会感觉到浏览器“卡死”了,没有任何响应。
这显然是很不好的体验,所以浏览器允许脚本异步加载,
下面就是两种异步加载的语法。
上面代码中,
标签打开
defer
或async
属性,脚本就会异步加载。渲染引擎遇到这一行命令,就会开始下载外部脚本,
但不会等它下载和执行,而是直接执行后面的命令。
defer
与async
的区别是:
defer
要等到整个页面在内存中正常渲染结束(DOM 结构完全生成,以及其他脚本执行完成),才会执行;
async
一旦下载完,渲染引擎就会中断渲染,执行这个脚本以后,再继续渲染。一句话,
defer
是“渲染完再执行”,async
是“下载完就执行”。另外,如果有多个
defer
脚本,会按照它们在页面出现的顺序加载,而多个
async
脚本是不能保证加载顺序的。加载规则
浏览器加载 ES6 模块,也使用
标签,但是要加入
type="module"
属性。
上面代码在网页中插入一个模块
foo.js
,由于type
属性设为module
,所以浏览器知道这是一个 ES6 模块。浏览器对于带有
type="module"
的,都是异步加载,不会造成堵塞浏览器,
即等到整个页面渲染完,再执行模块脚本,等同于打开了
标签的
defer
属性。
如果网页有多个
,它们会按照在页面出现的顺序依次执行。
标签的
async
属性也可以打开,这时只要加载完成,渲染引擎就会中断渲染立即执行。执行完成后,再恢复渲染。
一旦使用了
async
属性,就不会按照在页面出现的顺序执行,而是只要该模块加载完成,就执行该模块。
ES6 模块也允许内嵌在网页中,语法行为与加载外部脚本完全一致。
对于外部的模块脚本(上例是
foo.js
),有几点需要注意。
use strict
。import
命令加载其他模块(.js
后缀不可省略,需要提供绝对 URL 或相对 URL),也可以使用export
命令输出对外接口。this
关键字返回undefined
,而不是指向window
。也就是说,在模块顶层使用this
关键字,是无意义的。下面是一个示例模块。
import utils from 'https://example.com/js/utils.js';
const x = 1;
console.log(x === window.x); //false
console.log(this === undefined); // true
利用顶层的this
等于undefined
这个语法点,可以侦测当前代码是否在 ES6 模块之中。
const isNotModuleScript = this !== undefined;
讨论 Node 加载 ES6 模块之前,必须了解 ES6 模块与 CommonJS 模块完全不同。
它们有两个重大差异。
第二个差异是因为 CommonJS 加载的是一个对象(即module.exports
属性),该对象只有在脚本运行完才会生成。
而 ES6 模块不是对象,它的对外接口只是一种静态定义,在代码静态解析阶段就会生成。
下面重点解释第一个差异。
CommonJS 模块输出的是值的拷贝,也就是说,一旦输出一个值,模块内部的变化就影响不到这个值。
请看下面这个模块文件lib.js
的例子。
// lib.js
var counter = 3;
function incCounter() {
counter++;
}
module.exports = {
counter: counter,
incCounter: incCounter,
};
上面代码输出内部变量counter
和改写这个变量的内部方法incCounter
。
然后,在main.js
里面加载这个模块。
// main.js
var mod = require('./lib');
console.log(mod.counter); // 3
mod.incCounter();
console.log(mod.counter); // 3
上面代码说明,lib.js
模块加载以后,它的内部变化就影响不到输出的mod.counter
了。
这是因为mod.counter
是一个原始类型的值,会被缓存。
除非写成一个函数,才能得到内部变动后的值。
// lib.js
var counter = 3;
function incCounter() {
counter++;
}
module.exports = {
get counter() {
return counter
},
incCounter: incCounter,
};
上面代码中,输出的counter
属性实际上是一个取值器函数。
现在再执行main.js
,就可以正确读取内部变量counter
的变动了。
$ node main.js
3
4
ES6 模块的运行机制与 CommonJS 不一样。
JS 引擎对脚本静态分析的时候,遇到模块加载命令import
,就会生成一个只读引用。
等到脚本真正执行时,再根据这个只读引用,到被加载的那个模块里面去取值。
换句话说,ES6 的import
有点像 Unix 系统的“符号连接”,原始值变了,import
加载的值也会跟着变。
因此,ES6 模块是动态引用,并且不会缓存值,模块里面的变量绑定其所在的模块。
还是举上面的例子。
// lib.js
export let counter = 3;
export function incCounter() {
counter++;
}
// main.js
import {
counter, incCounter } from './lib';
console.log(counter); // 3
incCounter();
console.log(counter); // 4
上面代码说明,ES6 模块输入的变量counter
是活的,完全反应其所在模块lib.js
内部的变化。
再举一个出现在export
一节中的例子。
// m1.js
export var foo = 'bar';
setTimeout(() => foo = 'baz', 500);
// m2.js
import {
foo} from './m1.js';
console.log(foo);
setTimeout(() => console.log(foo), 500);
上面代码中,m1.js
的变量foo
,在刚加载时等于bar
,过了 500 毫秒,又变为等于baz
。
让我们看看,m2.js
能否正确读取这个变化。
$ babel-node m2.js
bar
baz
上面代码表明,ES6 模块不会缓存运行结果,而是动态地去被加载的模块取值,并且变量总是绑定其所在的模块。
由于 ES6 输入的模块变量,只是一个“符号连接”,所以这个变量是只读的,对它进行重新赋值会报错。
// lib.js
export let obj = {
};
// main.js
import {
obj } from './lib';
obj.prop = 123; // OK
obj = {
}; // TypeError
上面代码中,main.js
从lib.js
输入变量obj
,可以对obj
添加属性,但是重新赋值就会报错。
因为变量obj
指向的地址是只读的,不能重新赋值,这就好比main.js
创造了一个名为obj
的const
变量。
最后,export
通过接口,输出的是同一个值。不同的脚本加载这个接口,得到的都是同样的实例。
// mod.js
function C() {
this.sum = 0;
this.add = function () {
this.sum += 1;
};
this.show = function () {
console.log(this.sum);
};
}
export let c = new C();
上面的脚本mod.js
,输出的是一个C
的实例。不同的脚本加载这个模块,得到的都是同一个实例。
// x.js
import {
c} from './mod';
c.add();
// y.js
import {
c} from './mod';
c.show();
// main.js
import './x';
import './y';
现在执行main.js
,输出的是1
。
$ babel-node main.js
1
这就证明了x.js
和y.js
加载的都是C
的同一个实例。
Node 对 ES6 模块的处理比较麻烦,因为它有自己的 CommonJS 模块格式,与 ES6 模块格式是不兼容的。
目前的解决方案是,将两者分开,ES6 模块和 CommonJS 采用各自的加载方案。
Node 要求 ES6 模块采用.mjs
后缀文件名。
也就是说,只要脚本文件里面使用import
或者export
命令,那么就必须采用.mjs
后缀名。
require
命令不能加载.mjs
文件,会报错,只有import
命令才可以加载.mjs
文件。
反过来,.mjs
文件里面也不能使用require
命令,必须使用import
。
目前,这项功能还在试验阶段。安装 Node v8.5.0 或以上版本,要用--experimental-modules
参数才能打开该功能。
$ node --experimental-modules my-app.mjs
为了与浏览器的import
加载规则相同,Node 的.mjs
文件支持 URL 路径。
import './foo?query=1'; // 加载 ./foo 传入参数 ?query=1
上面代码中,脚本路径带有参数?query=1
,Node 会按 URL 规则解读。
同一个脚本只要参数不同,就会被加载多次,并且保存成不同的缓存。
由于这个原因,只要文件名中含有:
、%
、#
、?
等特殊字符,最好对这些字符进行转义。
目前,Node 的import
命令只支持加载本地模块(file:
协议),不支持加载远程模块。
如果模块名不含路径,那么import
命令会去node_modules
目录寻找这个模块。
import 'baz';
import 'abc/123';
如果模块名包含路径,那么import
命令会按照路径去寻找这个名字的脚本文件。
import 'file:///etc/config/app.json';
import './foo';
import './foo?search';
import '../bar';
import '/baz';
如果脚本文件省略了后缀名,比如import './foo'
,
Node 会依次尝试四个后缀名:./foo.mjs
、./foo.js
、./foo.json
、./foo.node
。
如果这些脚本文件都不存在,Node 就会去加载./foo/package.json
的main
字段指定的脚本。
如果./foo/package.json
不存在或者没有main
字段,
那么就会依次加载./foo/index.mjs
、./foo/index.js
、./foo/index.json
、./foo/index.node
。
如果以上四个文件还是都不存在,就会抛出错误。
最后,Node 的import
命令是异步加载,这一点与浏览器的处理方法相同。
ES6 模块应该是通用的,同一个模块不用修改,就可以用在浏览器环境和服务器环境。
为了达到这个目标,Node 规定 ES6 模块之中不能使用 CommonJS 模块的特有的一些内部变量。
首先,就是this
关键字。
ES6 模块之中,顶层的this
指向undefined
;
CommonJS 模块的顶层this
指向当前模块,这是两者的一个重大差异。
其次,以下这些顶层变量在 ES6 模块之中都是不存在的。
arguments
require
module
exports
__filename
__dirname
如果你一定要使用这些变量,有一个变通方法,就是写一个 CommonJS 模块输出这些变量,
然后再用 ES6 模块加载这个 CommonJS 模块。
但是这样一来,该 ES6 模块就不能直接用于浏览器环境了,所以不推荐这样做。
// expose.js
module.exports = {
__dirname};
// use.mjs
import expose from './expose.js';
const {
__dirname} = expose;
上面代码中,expose.js
是一个 CommonJS 模块,输出变量__dirname
,该变量在 ES6 模块之中不存在。
ES6 模块加载expose.js
,就可以得到__dirname
。
CommonJS 模块的输出都定义在module.exports
这个属性上面。
Node 的import
命令加载 CommonJS 模块,Node 会自动将module.exports
属性,当作模块的默认输出,即等同于export default xxx
。
下面是一个 CommonJS 模块。
// a.js
module.exports = {
foo: 'hello',
bar: 'world'
};
// 等同于
export default {
foo: 'hello',
bar: 'world'
};
import
命令加载上面的模块,module.exports
会被视为默认输出,
即import
命令实际上输入的是这样一个对象{ default: module.exports }
。
所以,一共有三种写法,可以拿到 CommonJS 模块的module.exports
。
// 写法一
import baz from './a';
// baz = {foo: 'hello', bar: 'world'};
// 写法二
import {
default as baz} from './a';
// baz = {foo: 'hello', bar: 'world'};
// 写法三
import * as baz from './a';
// baz = {
// get default() {return module.exports;},
// get foo() {return this.default.foo}.bind(baz),
// get bar() {return this.default.bar}.bind(baz)
// }
上面代码的第三种写法,
可以通过baz.default
拿到module.exports
。foo
属性和bar
属性就是可以通过这种方法拿到了module.exports
。
下面是一些例子。
// b.js
module.exports = null;
// es.js
import foo from './b';
// foo = null;
import * as bar from './b';
// bar = { default:null };
上面代码中,es.js
采用第二种写法时,要通过bar.default
这样的写法,才能拿到module.exports
。
// c.js
module.exports = function two() {
return 2;
};
// es.js
import foo from './c';
foo(); // 2
import * as bar from './c';
bar.default(); // 2
bar(); // throws, bar is not a function
上面代码中,bar
本身是一个对象,不能当作函数调用,只能通过bar.default
调用。
CommonJS 模块的输出缓存机制,在 ES6 加载方式下依然有效。
// foo.js
module.exports = 123;
setTimeout(_ => module.exports = null);
上面代码中,对于加载foo.js
的脚本,module.exports
将一直是123
,而不会变成null
。
由于 ES6 模块是编译时确定输出接口,CommonJS 模块是运行时确定输出接口,
所以采用import
命令加载 CommonJS 模块时,不允许采用下面的写法。
// 不正确
import {
readFile } from 'fs';
上面的写法不正确,因为fs
是 CommonJS 格式,只有在运行时才能确定readFile
接口,
而import
命令要求编译时就确定这个接口。解决方法就是改为整体输入。
// 正确的写法一
import * as express from 'express';
const app = express.default();
// 正确的写法二
import express from 'express';
const app = express();
CommonJS 模块加载 ES6 模块,不能使用require
命令,而要使用import()
函数。
ES6 模块的所有输出接口,会成为输入对象的属性。
// es.mjs
let foo = {
bar: 'my-default' };
export default foo;
// cjs.js
const es_namespace = await import('./es.mjs');
// es_namespace = {
// get default() {
// ...
// }
// }
console.log(es_namespace.default);
// { bar:'my-default' }
上面代码中,default
接口变成了es_namespace.default
属性。
下面是另一个例子。
// es.js
export let foo = {
bar:'my-default' };
export {
foo as bar };
export function f() {
};
export class c {
};
// cjs.js
const es_namespace = await import('./es');
// es_namespace = {
// get foo() {return foo;}
// get bar() {return foo;}
// get f() {return f;}
// get c() {return c;}
// }
“循环加载”(circular dependency)指的是,a
脚本的执行依赖b
脚本,而b
脚本的执行又依赖a
脚本。
// a.js
var b = require('b');
// b.js
var a = require('a');
通常,“循环加载”表示存在强耦合,如果处理不好,还可能导致递归加载,使得程序无法执行,因此应该避免出现。
但是实际上,这是很难避免的,尤其是依赖关系复杂的大项目,很容易出现a
依赖b
,b
依赖c
,c
又依赖a
这样的情况。
这意味着,模块加载机制必须考虑“循环加载”的情况。
对于 JavaScript 语言来说,目前最常见的两种模块格式 CommonJS 和 ES6,
处理“循环加载”的方法是不一样的,返回的结果也不一样。
介绍 ES6 如何处理“循环加载”之前,先介绍目前最流行的 CommonJS 模块格式的加载原理。
CommonJS 的一个模块,就是一个脚本文件。
require
命令第一次加载该脚本,就会执行整个脚本,然后在内存生成一个对象。
{
id: '...',
exports: {
... },
loaded: true,
...
}
上面代码就是 Node 内部加载模块后生成的一个对象。
该对象的id
属性是模块名,exports
属性是模块输出的各个接口,loaded
属性是一个布尔值,表示该模块的脚本是否执行完毕。
其他还有很多属性,这里都省略了。
以后需要用到这个模块的时候,就会到exports
属性上面取值。
即使再次执行require
命令,也不会再次执行该模块,而是到缓存之中取值。
也就是说,CommonJS 模块无论加载多少次,都只会在第一次加载时运行一次,
以后再加载,就返回第一次运行的结果,除非手动清除系统缓存。
CommonJS 模块的重要特性是加载时执行,即脚本代码在require
的时候,就会全部执行。
一旦出现某个模块被"循环加载",就只输出已经执行的部分,还未执行的部分不会输出。
让我们来看,Node 官方文档里面的例子。脚本文件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 执行完毕');
上面代码之中,a.js
脚本先输出一个done
变量,然后加载另一个脚本文件b.js
。
注意,此时a.js
代码就停在这里,等待b.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 执行完毕');
上面代码之中,b.js
执行到第二行,就会去加载a.js
,这时,就发生了“循环加载”。
系统会去a.js
模块对应对象的exports
属性取值,
可是因为a.js
还没有执行完,从exports
属性只能取回已经执行的部分,而不是最后的值。
a.js
已经执行的部分,只有一行。
exports.done = false;
因此,对于b.js
来说,它从a.js
只输入一个变量done
,值为false
。
然后,b.js
接着往下执行,等到全部执行完毕,再把执行权交还给a.js
。
于是,a.js
接着往下执行,直到执行完毕。
我们写一个脚本main.js
,验证这个过程。
var a = require('./a.js');
var b = require('./b.js');
console.log('在 main.js 之中, a.done=%j, b.done=%j', a.done, b.done);
执行main.js
,运行结果如下。
$ node main.js
在 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
的执行结果,即它的第四行。
exports.done = true;
总之,CommonJS 输入的是被输出值的拷贝,不是引用。
另外,由于 CommonJS 模块遇到循环加载时,返回的是当前已经执行的部分的值,而不是代码全部执行后的值,两者可能会有差异。
所以,输入变量的时候,必须非常小心。
var a = require('a'); // 安全的写法
var foo = require('a').foo; // 危险的写法
exports.good = function (arg) {
return a.foo('good', arg); // 使用的是 a.foo 的最新值
};
exports.bad = function (arg) {
return foo('bad', arg); // 使用的是一个部分加载时的值
};
上面代码中,如果发生循环加载,require('a').foo
的值很可能后面会被改写,改用require('a')
会更保险一点。
ES6 处理“循环加载”与 CommonJS 有本质的不同。
ES6 模块是动态引用,如果使用import
从一个模块加载变量(即import foo from 'foo'
),那些变量不会被缓存,
而是成为一个指向被加载模块的引用,需要开发者自己保证,真正取值的时候能够取到值。
请看下面这个例子。
// a.mjs
import {
bar} from './b';
console.log('a.mjs');
console.log(bar);
export let foo = 'foo';
// b.mjs
import {
foo} from './a';
console.log('b.mjs');
console.log(foo);
export let bar = 'bar';
上面代码中,a.mjs
加载b.mjs
,b.mjs
又加载a.mjs
,构成循环加载。执行a.mjs
,结果如下。
$ node --experimental-modules a.mjs
b.mjs
ReferenceError: foo is not defined
上面代码中,执行a.mjs
以后会报错,foo
变量未定义,这是为什么?
让我们一行行来看,ES6 循环加载是怎么处理的。
首先,执行a.mjs
以后,引擎发现它加载了b.mjs
,因此会优先执行b.mjs
,然后再执行a.mjs
。
接着,执行b.mjs
的时候,已知它从a.mjs
输入了foo
接口,这时不会去执行a.mjs
,而是认为这个接口已经存在了,继续往下执行。
执行到第三行console.log(foo)
的时候,才发现这个接口根本没定义,因此报错。
解决这个问题的方法,就是让b.mjs
运行的时候,foo
已经有定义了。这可以通过将foo
写成函数来解决。
// a.mjs
import {
bar} from './b';
console.log('a.mjs');
console.log(bar());
function foo() {
return 'foo' }
export {
foo};
// b.mjs
import {
foo} from './a';
console.log('b.mjs');
console.log(foo());
function bar() {
return 'bar' }
export {
bar};
这时再执行a.mjs
就可以得到预期结果。
$ node --experimental-modules a.mjs
b.mjs
foo
a.mjs
bar
这是因为函数具有提升作用,在执行import {bar} from './b'
时,函数foo
就已经有定义了,
所以b.mjs
加载的时候不会报错。这也意味着,如果把函数foo
改写成函数表达式,也会报错。
// a.mjs
import {
bar} from './b';
console.log('a.mjs');
console.log(bar());
const foo = () => 'foo';
export {
foo};
上面代码的第四行,改成了函数表达式,就不具有提升作用,执行就会报错。
我们再来看 ES6 模块加载器SystemJS给出的一个例子。
// even.js
import {
odd } from './odd'
export var counter = 0;
export function even(n) {
counter++;
return n === 0 || odd(n - 1);
}
// odd.js
import {
even } from './even';
export function odd(n) {
return n !== 0 && even(n - 1);
}
上面代码中,even.js
里面的函数even
有一个参数n
,只要不等于 0,就会减去 1,传入加载的odd()
。odd.js
也会做类似操作。
运行上面这段代码,结果如下。
$ babel-node
> import * as m from './even.js';
> m.even(10);
true
> m.counter
6
> m.even(20)
true
> m.counter
17
上面代码中,参数n
从 10 变为 0 的过程中,even()
一共会执行 6 次,所以变量counter
等于 6。
第二次调用even()
时,参数n
从 20 变为 0,even()
一共会执行 11 次,加上前面的 6 次,所以变量counter
等于 17。
这个例子要是改写成 CommonJS,就根本无法执行,会报错。
// even.js
var odd = require('./odd');
var counter = 0;
exports.counter = counter;
exports.even = function (n) {
counter++;
return n == 0 || odd(n - 1);
}
// odd.js
var even = require('./even').even;
module.exports = function (n) {
return n != 0 && even(n - 1);
}
上面代码中,even.js
加载odd.js
,而odd.js
又去加载even.js
,形成“循环加载”。
这时,执行引擎就会输出even.js
已经执行的部分(不存在任何结果),
所以在odd.js
之中,变量even
等于null
,等到后面调用even(n - 1)
就会报错。
$ node
> var m = require('./even');
> m.even(10)
TypeError: even is not a function
浏览器目前还不支持 ES6 模块,为了现在就能使用,可以将转为 ES5 的写法。
除了 Babel 可以用来转码之外,还有以下两个方法,也可以用来转码。
ES6 module transpiler是 square 公司开源的一个转码器,可以将 ES6 模块转为 CommonJS 模块或 AMD 模块的写法,从而在浏览器中使用。
首先,安装这个转码器。
$ npm install -g es6-module-transpiler
然后,使用compile-modules convert
命令,将 ES6 模块文件转码。
$ compile-modules convert file1.js file2.js
-o
参数可以指定转码后的文件名。
$ compile-modules convert -o out.js file1.js
另一种解决方法是使用 SystemJS。
它是一个垫片库(polyfill),可以在浏览器内加载 ES6 模块、AMD 模块和 CommonJS 模块,将其转为 ES5 格式。
它在后台调用的是 Google 的 Traceur 转码器。
使用时,先在网页内载入system.js
文件。
然后,使用System.import
方法加载模块文件。
上面代码中的./app
,指的是当前目录下的 app.js 文件。它可以是 ES6 模块文件,System.import
会自动将其转码。
需要注意的是,System.import
使用异步加载,返回一个 Promise 对象,可以针对这个对象编程。
下面是一个模块文件。
// app/es6-file.js:
export class q {
constructor() {
this.es6 = 'hello';
}
}
然后,在网页内加载这个模块文件。
上面代码中,System.import
方法返回的是一个 Promise 对象,所以可以用then
方法指定回调函数。
本章探讨如何将 ES6 的新语法,运用到编码实践之中,与传统的 JavaScript 语法结合在一起,写出合理的、易于阅读和维护的代码。
多家公司和组织已经公开了它们的风格规范,下面的内容主要参考了 Airbnb 公司的 JavaScript 风格规范。
(1)let 取代 var
ES6 提出了两个新的声明变量的命令:let
和const
。其中,let
完全可以取代var
,
因为两者语义相同,而且let
没有副作用。
'use strict';
if (true) {
let x = 'hello';
}
for (let i = 0; i < 10; i++) {
console.log(i);
}
上面代码如果用var
替代let
,实际上就声明了两个全局变量,这显然不是本意。
变量应该只在其声明的代码块内有效,var
命令做不到这一点。
var
命令存在变量提升效用,let
命令没有这个问题。
'use strict';
if (true) {
console.log(x); // ReferenceError
let x = 'hello';
}
上面代码如果使用var
替代let
,console.log
那一行就不会报错,而是会输出undefined
,
因为变量声明提升到代码块的头部。这违反了变量先声明后使用的原则。
所以,建议不再使用var
命令,而是使用let
命令取代。
(2)全局常量和线程安全
在let
和const
之间,建议优先使用const
,尤其是在全局环境,不应该设置变量,只应设置常量。
const
优于let
有几个原因。
一个是const
可以提醒阅读程序的人,这个变量不应该改变;
另一个是const
比较符合函数式编程思想,运算不改变值,只是新建值,而且这样也有利于将来的分布式运算;
最后一个原因是 JavaScript 编译器会对const
进行优化,
所以多使用const
,有利于提高程序的运行效率,也就是说let
和const
的本质区别,其实是编译器内部的处理不同。
// bad
var a = 1, b = 2, c = 3;
// good
const a = 1;
const b = 2;
const c = 3;
// best
const [a, b, c] = [1, 2, 3];
const
声明常量还有两个好处,
一是阅读代码的人立刻会意识到不应该修改这个值,
二是防止了无意间修改变量值所导致的错误。
所有的函数都应该设置为常量。
长远来看,JavaScript 可能会有多线程的实现(比如 Intel 公司的 River Trail 那一类的项目),
这时let
表示的变量,只应出现在单线程运行的代码中,不能是多线程共享的,这样有利于保证线程安全。
静态字符串一律使用单引号或反引号,不使用双引号。动态字符串使用反引号。
// bad
const a = "foobar";
const b = 'foo' + a + 'bar';
// acceptable
const c = `foobar`;
// good
const a = 'foobar';
const b = `foo${
a}bar`;
const c = 'foobar';
使用数组成员对变量赋值时,优先使用解构赋值。
const arr = [1, 2, 3, 4];
// bad
const first = arr[0];
const second = arr[1];
// good
const [first, second] = arr;
函数的参数如果是对象的成员,优先使用解构赋值。
// bad
function getFullName(user) {
const firstName = user.firstName;
const lastName = user.lastName;
}
// good
function getFullName(obj) {
const {
firstName, lastName } = obj;
}
// best
function getFullName({
firstName, lastName }) {
}
如果函数返回多个值,优先使用对象的解构赋值,而不是数组的解构赋值。
这样便于以后添加返回值,以及更改返回值的顺序。
// bad
function processInput(input) {
return [left, right, top, bottom];
}
// good
function processInput(input) {
return {
left, right, top, bottom };
}
const {
left, right } = processInput(input);
单行定义的对象,最后一个成员不以逗号结尾。多行定义的对象,最后一个成员以逗号结尾。
// bad
const a = {
k1: v1, k2: v2, };
const b = {
k1: v1,
k2: v2
};
// good
const a = {
k1: v1, k2: v2 };
const b = {
k1: v1,
k2: v2,
};
对象尽量静态化,一旦定义,就不得随意添加新的属性。
如果添加属性不可避免,要使用Object.assign
方法。
// bad
const a = {
};
a.x = 3;
// if reshape unavoidable
const a = {
};
Object.assign(a, {
x: 3 });
// good
const a = {
x: null };
a.x = 3;
如果对象的属性名是动态的,可以在创造对象的时候,使用属性表达式定义。
// bad
const obj = {
id: 5,
name: 'San Francisco',
};
obj[getKey('enabled')] = true;
// good
const obj = {
id: 5,
name: 'San Francisco',
[getKey('enabled')]: true,
};
上面代码中,对象obj
的最后一个属性名,需要计算得到。
这时最好采用属性表达式,在新建obj
的时候,将该属性与其他属性定义在一起。
这样一来,所有属性就在一个地方定义了。
另外,对象的属性和方法,尽量采用简洁表达法,这样易于描述和书写。
var ref = 'some value';
// bad
const atom = {
ref: ref,
value: 1,
addValue: function (value) {
return atom.value + value;
},
};
// good
const atom = {
ref,
value: 1,
addValue(value) {
return atom.value + value;
},
};
使用扩展运算符(...)拷贝数组。
// bad
const len = items.length;
const itemsCopy = [];
let i;
for (i = 0; i < len; i++) {
itemsCopy[i] = items[i];
}
// good
const itemsCopy = [...items];
使用 Array.from 方法,将类似数组的对象转为数组。
const foo = document.querySelectorAll('.foo');
const nodes = Array.from(foo);
立即执行函数可以写成箭头函数的形式。
(() => {
console.log('Welcome to the Internet.');
})();
那些需要使用函数表达式的场合,尽量用箭头函数代替。
因为这样更简洁,而且绑定了 this。
// bad
[1, 2, 3].map(function (x) {
return x * x;
});
// good
[1, 2, 3].map((x) => {
return x * x;
});
// best
[1, 2, 3].map(x => x * x);
箭头函数取代Function.prototype.bind
,不应再用 self/_this/that 绑定 this。
// bad
const self = this;
const boundMethod = function(...params) {
return method.apply(self, params);
}
// acceptable
const boundMethod = method.bind(this);
// best
const boundMethod = (...params) => method.apply(this, params);
简单的、单行的、不会复用的函数,建议采用箭头函数。
如果函数体较为复杂,行数较多,还是应该采用传统的函数写法。
所有配置项都应该集中在一个对象,放在最后一个参数,布尔值不可以直接作为参数。
// bad
function divide(a, b, option = false ) {
}
// good
function divide(a, b, {
option = false } = {
}) {
}
不要在函数体内使用 arguments 变量,使用 rest 运算符(...)代替。
因为 rest 运算符显式表明你想要获取参数,而且 arguments 是一个类似数组的对象,而 rest 运算符可以提供一个真正的数组。
// bad
function concatenateAll() {
const args = Array.prototype.slice.call(arguments);
return args.join('');
}
// good
function concatenateAll(...args) {
return args.join('');
}
使用默认值语法设置函数参数的默认值。
// bad
function handleThings(opts) {
opts = opts || {
};
}
// good
function handleThings(opts = {
}) {
// ...
}
注意区分 Object 和 Map,只有模拟现实世界的实体对象时,才使用 Object。
如果只是需要key: value
的数据结构,使用 Map 结构。因为 Map 有内建的遍历机制。
let map = new Map(arr);
for (let key of map.keys()) {
console.log(key);
}
for (let value of map.values()) {
console.log(value);
}
for (let item of map.entries()) {
console.log(item[0], item[1]);
}
总是用 Class,取代需要 prototype 的操作。因为 Class 的写法更简洁,更易于理解。
// bad
function Queue(contents = []) {
this._queue = [...contents];
}
Queue.prototype.pop = function() {
const value = this._queue[0];
this._queue.splice(0, 1);
return value;
}
// good
class Queue {
constructor(contents = []) {
this._queue = [...contents];
}
pop() {
const value = this._queue[0];
this._queue.splice(0, 1);
return value;
}
}
使用extends
实现继承,因为这样更简单,不会有破坏instanceof
运算的危险。
// bad
const inherits = require('inherits');
function PeekableQueue(contents) {
Queue.apply(this, contents);
}
inherits(PeekableQueue, Queue);
PeekableQueue.prototype.peek = function() {
return this._queue[0];
}
// good
class PeekableQueue extends Queue {
peek() {
return this._queue[0];
}
}
首先,Module 语法是 JavaScript 模块的标准写法,坚持使用这种写法。使用import
取代require
。
// bad
const moduleA = require('moduleA');
const func1 = moduleA.func1;
const func2 = moduleA.func2;
// good
import {
func1, func2 } from 'moduleA';
使用export
取代module.exports
。
// commonJS的写法
var React = require('react');
var Breadcrumbs = React.createClass({
render() {
return <nav />;
}
});
module.exports = Breadcrumbs;
// ES6的写法
import React from 'react';
class Breadcrumbs extends React.Component {
render() {
return <nav />;
}
};
export default Breadcrumbs;
如果模块只有一个输出值,就使用export default
,
如果模块有多个输出值,就不使用export default
,export default
与普通的export
不要同时使用。
不要在模块输入中使用通配符。因为这样可以确保你的模块之中,有一个默认输出(export default)。
// bad
import * as myObject from './importModule';
// good
import myObject from './importModule';
如果模块默认输出一个函数,函数名的首字母应该小写。
function makeStyleGuide() {
}
export default makeStyleGuide;
如果模块默认输出一个对象,对象名的首字母应该大写。
const StyleGuide = {
es6: {
}
};
export default StyleGuide;
ESLint 是一个语法规则和代码风格的检查工具,可以用来保证写出语法正确、风格统一的代码。
首先,安装 ESLint。
$ npm i -g eslint
然后,安装 Airbnb 语法规则,以及 import、a11y、react 插件。
$ npm i -g eslint-config-airbnb
$ npm i -g eslint-plugin-import eslint-plugin-jsx-a11y eslint-plugin-react
最后,在项目的根目录下新建一个.eslintrc
文件,配置 ESLint。
{
"extends": "eslint-config-airbnb"
}
现在就可以检查,当前项目的代码是否符合预设的规则。
index.js
文件的代码如下。
var unusued = 'I have no purpose!';
function greet() {
var message = 'Hello, World!';
alert(message);
}
greet();
使用 ESLint 检查这个文件,就会报出错误。
$ eslint index.js
index.js
1:1 error Unexpected var, use let or const instead no-var
1:5 error unusued is defined but never used no-unused-vars
4:5 error Expected indentation of 2 characters but found 4 indent
4:5 error Unexpected var, use let or const instead no-var
5:5 error Expected indentation of 2 characters but found 4 indent
✖ 5 problems (5 errors, 0 warnings)
上面代码说明,原文件有五个错误,
其中两个是不应该使用var
命令,而要使用let
或const
;一个是定义了变量,却没有使用;
另外两个是行首缩进为 4 个空格,而不是规定的 2 个空格。
未完待续,下一章节,つづく