代码规范

本章探讨如何将 ES6 的新语法，运用到编码实践之中，与传统的 JavaScript 语法结合在一起，写出合理的、易于阅读和维护的代码。

多家公司和组织已经公开了它们的风格规范，下面的内容主要参考了 Airbnb 公司的 JavaScript 风格规范。

块级作用域

（1）let 取代 var

ES6 提出了两个新的声明变量的命令：let和const。其中，let完全可以取代var，因为两者语义相同，而且let没有副作用。

  1. 'use strict';
  3. if (true) {
  4.   let x = 'hello';
  5. }
  7. for (let i = 0; i < 10; i++) {
  8.   console.log(i);
  9. }

上面代码如果用var替代let，实际上就声明了两个全局变量，这显然不是本意。变量应该只在其声明的代码块内有效，var命令做不到这一点。

var命令存在变量提升效用，let命令没有这个问题。

  1. 'use strict';
  3. if (true) {
  4.   console.log(x); // ReferenceError
  5.   let x = 'hello';
  6. }

上面代码如果使用var替代let，console.log那一行就不会报错，而是会输出undefined，因为变量声明提升到代码块的头部。这违反了变量先声明后使用的原则。

所以，建议不再使用var命令，而是使用let命令取代。

（2）全局常量和线程安全

在let和const之间，建议优先使用const，尤其是在全局环境，不应该设置变量，只应设置常量。

const优于let有几个原因。一个是const可以提醒阅读程序的人，这个变量不应该改变；另一个是const比较符合函数式编程思想，运算不改变值，只是新建值，而且这样也有利于将来的分布式运算；最后一个原因是 JavaScript 编译器会对const进行优化，所以多使用const，有利于提高程序的运行效率，也就是说let和const的本质区别，其实是编译器内部的处理不同。

  1. // bad
  2. var a = 1, b = 2, c = 3;
  4. // good
  5. const a = 1;
  6. const b = 2;
  7. const c = 3;
  9. // best
  10. const [a, b, c] = [1, 2, 3];

const声明常量还有两个好处，一是阅读代码的人立刻会意识到不应该修改这个值，二是防止了无意间修改变量值所导致的错误。

所有的函数都应该设置为常量。

长远来看，JavaScript 可能会有多线程的实现（比如 Intel 公司的 River Trail 那一类的项目），这时let表示的变量，只应出现在单线程运行的代码中，不能是多线程共享的，这样有利于保证线程安全。

字符串

静态字符串一律使用单引号或反引号，不使用双引号。动态字符串使用反引号。

  1. // bad
  2. const a = "foobar";
  3. const b = 'foo' + a + 'bar';
  5. // acceptable
  6. const c = `foobar`;
  8. // good
  9. const a = 'foobar';
  10. const b = `foo${a}bar`;

解构赋值

使用数组成员对变量赋值时，优先使用解构赋值。

  1. const arr = [1, 2, 3, 4];
  3. // bad
  4. const first = arr[0];
  5. const second = arr[1];
  7. // good
  8. const [first, second] = arr;

函数的参数如果是对象的成员，优先使用解构赋值。

  1. // bad
  2. function getFullName(user) {
  3.   const firstName = user.firstName;
  4.   const lastName = user.lastName;
  5. }
  7. // good
  8. function getFullName(obj) {
  9.   const { firstName, lastName } = obj;
  10. }
  12. // best
  13. function getFullName({ firstName, lastName }) {
  14. }

如果函数返回多个值，优先使用对象的解构赋值，而不是数组的解构赋值。这样便于以后添加返回值，以及更改返回值的顺序。

  1. // bad
  2. function processInput(input) {
  3.   return [left, right, top, bottom];
  4. }
  6. // good
  7. function processInput(input) {
  8.   return { left, right, top, bottom };
  9. }
  11. const { left, right } = processInput(input);

对象

单行定义的对象，最后一个成员不以逗号结尾。多行定义的对象，最后一个成员以逗号结尾。

  1. // bad
  2. const a = { k1: v1, k2: v2, };
  3. const b = {
  4.   k1: v1,
  5.   k2: v2
  6. };
  8. // good
  9. const a = { k1: v1, k2: v2 };
  10. const b = {
  11.   k1: v1,
  12.   k2: v2,
  13. };

对象尽量静态化，一旦定义，就不得随意添加新的属性。如果添加属性不可避免，要使用Object.assign方法。

  1. // bad
  2. const a = {};
  3. a.x = 3;
  5. // if reshape unavoidable
  6. const a = {};
  7. Object.assign(a, { x: 3 });
  9. // good
  10. const a = { x: null };
  11. a.x = 3;

如果对象的属性名是动态的，可以在创造对象的时候，使用属性表达式定义。

  1. // bad
  2. const obj = {
  3.   id: 5,
  4.   name: 'San Francisco',
  5. };
  6. obj[getKey('enabled')] = true;
  8. // good
  9. const obj = {
  10.   id: 5,
  11.   name: 'San Francisco',
  12.   [getKey('enabled')]: true,
  13. };

上面代码中，对象obj的最后一个属性名，需要计算得到。这时最好采用属性表达式，在新建obj的时候，将该属性与其他属性定义在一起。这样一来，所有属性就在一个地方定义了。

另外，对象的属性和方法，尽量采用简洁表达法，这样易于描述和书写。

  1. var ref = 'some value';
  3. // bad
  4. const atom = {
  5.   ref: ref,
  7.   value: 1,
  9.   addValue: function (value) {
  10.     return atom.value + value;
  11.   },
  12. };
  14. // good
  15. const atom = {
  16.   ref,
  18.   value: 1,
  20.   addValue(value) {
  21.     return atom.value + value;
  22.   },
  23. };

原因：这样更简短且描述更清楚

  1. const job = 'FrontEnd'
  3. // bad
  4. const item = {
  5.   job: job
  6. }
  8. // good
  9. const item = {
  10.   job
  11. }
  • 只对非法标识符的属性使用引号，eslint: quote-props

原因：因为通常来说我们认为这样主观上会更容易阅读，这样会带来代码高亮上的提升，同时也更容易被主流 JS 引擎优化

  1. // bad
  2. const bad = {
  3.   'foo': 3,
  4.   'bar': 4,
  5.   'data-blah': 5
  6. }
  8. // good
  9. const good = {
  10.   foo: 3,
  11.   bar: 4,
  12.   'data-blah': 5
  13. }
  • 优先使用对象展开运算符 ... 来做对象浅拷贝而不是使用 Object.assign，使用对象剩余操作符来获得一个包含确定的剩余属性的新对象
  1. // very bad
  2. const original = { a: 1, b: 2 }
  3. const copy = Object.assign(original, { c: 3 }) // this mutates `original` ಠ_ಠ
  4. delete copy.a // so does this
  6. // bad
  7. const original = { a: 1, b: 2 }
  8. const copy = Object.assign({}, original, { c: 3 }) // copy => { a: 1, b: 2, c: 3 }
  10. // good
  11. const original = { a: 1, b: 2 }
  12. const copy = { ...original, c: 3 } // copy => { a: 1, b: 2, c: 3 }
  14. const { a, ...noA } = copy // noA => { b: 2, c: 3 }

数组

使用扩展运算符（…）拷贝数组。

  1. // bad
  2. const len = items.length;
  3. const itemsCopy = [];
  4. let i;
  6. for (i = 0; i < len; i++) {
  7.   itemsCopy[i] = items[i];
  8. }
  10. // good
  11. const itemsCopy = [...items];

函数

那些使用匿名函数当作参数的场合，尽量用箭头函数代替。因为这样更简洁，而且绑定了 this。

  1. // bad
  2. [1, 2, 3].map(function (x) {
  3.   return x * x;
  4. });
  6. // good
  7. [1, 2, 3].map((x) => {
  8.   return x * x;
  9. });
  11. // best
  12. [1, 2, 3].map(x => x * x);

箭头函数取代Function.prototype.bind，不应再用 self/_this/that 绑定 this。

  1. // bad
  2. const self = this;
  3. const boundMethod = function(...params) {
  4.   return method.apply(self, params);
  5. }
  7. // acceptable
  8. const boundMethod = method.bind(this);
  10. // best
  11. const boundMethod = (...params) => method.apply(this, params);

简单的、单行的、不会复用的函数，建议采用箭头函数。如果函数体较为复杂，行数较多，还是应该采用传统的函数写法。

所有配置项都应该集中在一个对象，放在最后一个参数，布尔值不可以直接作为参数。

  1. // bad
  2. function divide(a, b, option = false ) {
  3. }
  5. // good
  6. function divide(a, b, { option = false } = {}) {
  7. }

不要在函数体内使用 arguments 变量，使用 rest 运算符（…）代替。因为 rest 运算符显式表明你想要获取参数，而且 arguments 是一个类似数组的对象，而 rest 运算符可以提供一个真正的数组。

  1. // bad
  2. function concatenateAll() {
  3.   const args = Array.prototype.slice.call(arguments);
  4.   return args.join('');
  5. }
  7. // good
  8. function concatenateAll(...args) {
  9.   return args.join('');
  10. }

使用默认值语法设置函数参数的默认值。

  1. // bad
  2. function handleThings(opts) {
  3.   opts = opts || {};
  4. }
  6. // good
  7. function handleThings(opts = {}) {
  8.   // ...
  9. }
  • 使用具名函数表达式而非函数声明，eslint: func-style

原因：这样做会导致函数声明被提升，这意味着很容易在文件中定义此函数之前引用它，不利于可读性和可维护性。如果你发现函数定义既庞大又复杂以至于不能理解文件的其他部分，或许你应该将它拆分成模块！别忘记要显式命名表达式，而不用管名字是否是从包含的变量（通常出现在现代浏览器中或者使用 Babel 编译器的时候）中推断的。这样会消除错误调用堆栈中的任何假设。 (讨论)

  1. // bad
  2. function foo () {
  3.   // ...
  4. }
  6. // bad
  7. const foo = function () {
  8.   // ...
  9. }
  11. // good
  12. // lexical name distinguished from the variable-referenced invocation(s)
  13. const short = function longUniqueMoreDescriptiveLexicalFoo () {
  14.   // ...
  15. }
  • 不要在非函数代码块（if , while 等）中声明函数，eslint：no-loop-func ```javascript // bad if (isUse) { function test () { // do something } }

// good let test if (isUse) { test = () => { // do something } }

  3.    - 将参数默认值放在最后
  5. ```javascript
  6. // bad
  7. function handleThings (opts = {}, name) {
  8.   // ...
  9. }
  11. // good
  12. function handleThings (name, opts = {}) {
  13.   // ...
  14. }

原因：操作作为参数传入的对象可能在原始调用中造成意想不到的变量副作用

  1. // bad
  2. function f1 (obj) {
  3.   obj.key = 1
  4. }
  6. // good
  7. function f2 (obj) {
  8.   const key = Object.prototype.hasOwnProperty.call(obj, 'key') ? obj.key : 1
  9. }

原因：参数重新赋值可能会导致无法预期的行为，尤其是当操作 arguments 对象时，也可能导致优化问题，尤其是在 V8 引擎中

  1. // bad
  2. function f1 (a) {
  3.   a = 1
  4. }
  6. function f2 (a) {
  7.   if (!a) { a = 1 }
  8. }
  10. // good
  11. function f3 (a) {
  12.   const b = a || 1
  13. }
  15. function f4 (a = 1) {
  16. }
  • 如果函数体只包含一条没有副作用的返回表达式的语句，可以省略花括号并使用隐式的 return， 否则保留花括号并使用 return 语句，eslint: arrow-parens, arrow-body-style
  1. // bad
  2. [1, 2, 3].map(number => {
  3.   const nextNumber = number + 1
  4.   `A string containing the ${nextNumber}.`
  5. })
  7. // good
  8. [1, 2, 3].map(number => `A string containing the ${number}.`)
  10. // good
  11. [1, 2, 3].map((number) => {
  12.   const nextNumber = number + 1
  13.   return `A string containing the ${nextNumber}.`
  14. })
  16. // good
  17. [1, 2, 3].map((number, index) => ({
  18.   index: number
  19. }))
  21. // No implicit return with side effects
  22. function foo(callback) {
  23.   const val = callback()
  24.   if (val === true) {
  25.     // Do something if callback returns true
  26.   }
  27. }
  29. let bool = false
  31. // bad
  32. foo(() => bool = true)
  34. // good
  35. foo(() => {
  36.   bool = true
  37. })
  39. - 函数如果只接收一个参数并且没使用用花括号，则省略圆括号，否则为了清晰明确则使用圆括号包裹参数，注意：总是使用圆括号也是可以接受的，eslint 中的 ["always" 选项](https://eslint.org/docs/rules/arrow-parens#always)，eslint: [arrow-parens](http://eslint.org/docs/rules/arrow-parens.html)
  41. ```js
  42. // bad
  43. [1, 2, 3].map((x) => x * x)
  45. // good
  46. [1, 2, 3].map(x => x * x)
  48. // good
  49. [1, 2, 3].map(number => (
  50.   `A long string with the ${number}. It’s so long that we’ve broken it ` +
  51.   'over multiple lines!'
  52. ))
  54. // bad
  55. [1, 2, 3].map(x => {
  56.   const y = x + 1
  57.   return x * y
  58. })
  60. // good
  61. [1, 2, 3].map((x) => {
  62.   const y = x + 1
  63.   return x * y
  64. })

Map 结构

注意区分 Object 和 Map，只有模拟现实世界的实体对象时，才使用 Object。如果只是需要key: value的数据结构，使用 Map 结构。因为 Map 有内建的遍历机制。

  1. let map = new Map(arr);
  3. for (let key of map.keys()) {
  4.   console.log(key);
  5. }
  7. for (let value of map.values()) {
  8.   console.log(value);
  9. }
  11. for (let item of map.entries()) {
  12.   console.log(item[0], item[1]);
  13. }

Class

总是用 Class，取代需要 prototype 的操作。因为 Class 的写法更简洁，更易于理解。

  1. // bad
  2. function Queue(contents = []) {
  3.   this._queue = [...contents];
  4. }
  5. Queue.prototype.pop = function() {
  6.   const value = this._queue[0];
  7.   this._queue.splice(0, 1);
  8.   return value;
  9. }
  11. // good
  12. class Queue {
  13.   constructor(contents = []) {
  14.     this._queue = [...contents];
  15.   }
  16.   pop() {
  17.     const value = this._queue[0];
  18.     this._queue.splice(0, 1);
  19.     return value;
  20.   }
  21. }

使用extends实现继承，因为这样更简单，不会有破坏instanceof运算的危险。

  1. // bad
  2. const inherits = require('inherits');
  3. function PeekableQueue(contents) {
  4.   Queue.apply(this, contents);
  5. }
  6. inherits(PeekableQueue, Queue);
  7. PeekableQueue.prototype.peek = function() {
  8.   return this._queue[0];
  9. }
  11. // good
  12. class PeekableQueue extends Queue {
  13.   peek() {
  14.     return this._queue[0];
  15.   }
  16. }

模块

首先，Module 语法是 JavaScript 模块的标准写法，坚持使用这种写法。使用import取代require。

  1. // bad
  2. const moduleA = require('moduleA');
  3. const func1 = moduleA.func1;
  4. const func2 = moduleA.func2;
  6. // good
  7. import { func1, func2 } from 'moduleA';

使用export取代module.exports。

  1. // commonJS的写法
  2. var React = require('react');
  4. var Breadcrumbs = React.createClass({
  5.   render() {
  6.     return <nav />;
  7.   }
  8. });
  10. module.exports = Breadcrumbs;
  12. // ES6的写法
  13. import React from 'react';
  15. class Breadcrumbs extends React.Component {
  16.   render() {
  17.     return <nav />;
  18.   }
  19. };
  21. export default Breadcrumbs;

如果模块只有一个输出值，就使用export default，如果模块有多个输出值，就不使用export default，export default与普通的export不要同时使用。

不要在模块输入中使用通配符。因为这样可以确保你的模块之中，有一个默认输出（export default）。

  1. // bad
  2. import * as myObject from './importModule';
  4. // good
  5. import myObject from './importModule';