块级作用域
（1）用let代替var，var有变量提升，而let没有
var声明相当于全局变量，let有块级作用域
（2）在let和const之间，优先使用const，尤其是在全局环境，不应该设置变量，只应该设置常量。
let和const的本质区别在于编译器内部的处理不同
所有的函数都应该设置为常量
解构赋值
使用数组成员对变量赋值，优先使用解构赋值。
函数的参数如果是对象的成员，优先使用解构赋值。
如果函数返回多个值，优先使用对象的解构赋值，而不是数组的解构赋值。这样便于以后添加返回值，以及更改返回顺序。
字符串
静态字符串一律使用单引号或反引号，不使用双引号。动态字符串使用反引号
对象
单行定义的对象，最后一个成员不以逗号结尾。
多行定义的对象，最后一个成员以逗号结尾。
对象尽量静态化，一旦定义，就不得随意添加新的属性。如果添加属性不可避免，要使用Object.assign方法
const a = {};
Object.assign(a,{x:3});
如果对象的属性名是动态的，可以在创造对象的时候，使用属性表达式定义
const obj = {
id:5,
name:''XXX,
[getKey('enabled')]:true,
};
上面对象obj的最后一个属性名，需要计算得到。这时最好采用属性表达式，在新建obj的时候，将该属性与其他属性定义在一起。
varref='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;
},
};
对象的属性和方法，尽量采用简洁表达法，这样易于描述和书写。
数组
使用扩展运算符（...）拷贝数组。
使用 Array.from 方法，将类似数组的对象转为数组
函数
立即执行函数可以写成箭头函数的形式。
(() => {
console.log('welcom~');
})();
需要使用函数表达式的场合，尽量用箭头函数代替，因为这样更简洁，而且绑定了this
//good
[1,2,3].map((x) => {
return x*x;
})
//best
[1,2,3].map(x=>x*x);
箭头函数取代Function.prototype.bind,不应在用self/_this/that bangding this
const boundMethod = (...params) => method.apply(this,params);
简单的、单行的、不回复用的函数建议采用箭头函数。如果函数体较为复杂，行数比较多，还是采用传统的函数写法。
所有配置项都应该集中在一个对象，放在最后一个参数，布尔值不可以直接作为参数。
function divide(a,b,{option = false} = {}){}
不要在函数体内使用arguments变量，使用rest运算符（...）代替。因为 rest 运算符显式表明你想要获取参数，而且 arguments 是一个类似数组的对象，而 rest 运算符可以提供一个真正的数组。
// good
function concatenateAll(...args) {
return args.join('');
}
使用默认值语法设置函数参数的默认值。
// good
function handleThings(opts = {}) {
// ...
}
Map结构
注意区分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
总是用 Class，取代需要 prototype 的操作。
// good
class Queue {
constructor(contents = []) {
this._queue = [...contents];
}
pop() {
const value = this._queue[0];
this._queue.splice(0, 1);
return value;
}
}
使用extends实现继承，因为这样更简单，不会有破坏instanceof运算的危险。
// good
class PeekableQueue extends Queue {
peek() {
return this._queue[0];
}
}
模块
// 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 ;
}
});
module.exports = Breadcrumbs;
// ES6的写法
import React from 'react';
class Breadcrumbs extends React.Component {
render() {
return ;
}
};
export default Breadcrumbs;
如果模块只有一个输出值，就使用export default，如果模块有多个输出值，就不使用export default，export default与普通的export不要同时使用。
如果模块默认输出一个函数，函数名的首字母应该小写。
function makeStyleGuide() {
}
export default makeStyleGuide;
如果模块默认输出一个对象，对象名的首字母应该大写。
const StyleGuide = {
es6: {
}
};
export default StyleGuide;
ESLint的使用
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 个空格。