/**
* @author 阮一峰
* Copyright http://es6.ruanyifeng.com/#docs/style
*/

1.块级作用域

（1）let 取代 var

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

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

原因:

const可以提醒阅读程序的人，这个变量不应该改变；

const比较符合函数式编程思想，运算不改变值，只是新建值,而且这样也有利于将来的分布式运算；

JavaScript 编译器会对const进行优化，所以多使用const，有利于提供程序的运行效率，

2.字符串

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

3.解构赋值

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

var arr = [1,2,3,4];

const [first,second] = arr;

等价于

const first = arr[0];

const second = arr[1];

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

4.对象

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

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;

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

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;
},
};

5.数组

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

// 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);

6.函数

立即执行函数可以写成箭头函数的形式

(()=>{
console.log('hello world')
})

那些需要使用函数表达式的场合，尽量用箭头函数代替。因为这样更简洁，而且绑定了this。

//bed
[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);

简单的、单行的、不会复用的函数，建议采用箭头函数。如果函数体较为复杂，

行数较多，还是应该采用传统的函数写法

7.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]);
}

8.Class

总是用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 = [...contens];
}
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];
}
}

9.模块

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

//bed
const moduleA = require('ModuleA');
const func1 = moduleA.func1;
const func2 = moduleA.func2;

//good
import {func1,func2} form 'ModuleA';

使用export取代module.exports。

//CommonJs的写法
var React = require('react');
var Breadcrumbs = React.createClass({
render({
return <nav />
})
})
moudle.exports = Breadcrumbs;

//ES6的写法

import React form 'react';

class Breadcrumbs extends React.Component{
render({
return <nav />
})
}

exports default Breadcrumbs;

如果模块只有一个输出值，就使用export default，如果模块有多个输出值，

就不使用export default，export default与普通的export不要同时使用。

如果模块默认输出一个函数，函数名的首字母应该小写。

function makeStyleGuide() {
}

export default makeStyleGuide;

如果模块默认输出一个对象，对象名的首字母应该大写。

const StyleGuide = {
es6: {
}
};

export default StyleGuide;