ES6- 代码编程风格(let、字符串、解构赋值)

1.let 取代 var

2.全局常量和线程安全

在let 和 const 之间，建议优先使用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]

3.字符串

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

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

4. 解构赋值

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

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: vl, 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,
}