ES6系列之小知识点

数组

扩展运算符（...）

扩展运算符（spread）是三个点（...）。它比如 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列。
将一个数组转为用逗号分隔的参数序列。

function add(x, y) {
  return x + y;
}

const numbers = [4, 38];
add(...numbers) // 42

let arr1 = [0, 1, 2];
let arr2 = [3, 4, 5];
arr1.push(...arr2);

复制数组

const a1 = [1, 2];
// 写法一
const a2 = [...a1];
// 写法二
const [...a2] = a1;

上面的两种写法，a2都是a1的克隆。

合并数组

// ES5
[1, 2].concat(more)
// ES6
[1, 2, ...more]

var arr1 = ['a', 'b'];
var arr2 = ['c'];
var arr3 = ['d', 'e'];

// ES5的合并数组
arr1.concat(arr2, arr3);        // [ 'a', 'b', 'c', 'd', 'e' ]

// ES6的合并数组
[...arr1, ...arr2, ...arr3]     // [ 'a', 'b', 'c', 'd', 'e' ]

与解构赋值结合

const [first, ...rest] = [1, 2, 3, 4, 5];
first // 1
rest  // [2, 3, 4, 5]

const [first, ...rest] = [];
first // undefined
rest  // []

const [first, ...rest] = ["foo"];
first  // "foo"
rest   // []

若是将扩展运算符用于数组赋值，只能放在参数的最后一位，不然会报错。

字符串

let str = 'x\uD83D\uDE80y';

[...str].reverse().join('')            // "y🚀x"

var b = {...str}       //  {0: "x", 1: "�", 2: "�", 3: "y"}

数组的空位

1.ES5 对空位的处理:

• forEach(), filter(), reduce(), every() 和some()都会跳过空位。
• map()会跳过空位，但会保留这个值
• join()和toString()会将空位视为undefined，而undefined和null会被处理成空字符串。

2.ES6 则是明确将空位转为undefined。

对象

单行定义的对象，最后一个成员不以逗号结尾。多行定义的对象，最后一个成员以逗号结尾。
对象尽可能静态化，一旦定义，就不得随意添加新的属性。若是添加属性不可避免，要使用Object.assign方法。

属性的简洁表示法

ES6 容许直接写入变量和函数，做为对象的属性和方法。

属性简洁表示
const foo = 'bar';
const baz = {foo};
baz // {foo: "bar"}

// 等同于
const baz = {foo: foo};

方法简洁表示
const o = {
  method() {
    return "Hello!";
  }
};

// 等同于

const o = {
  method: function() {
    return "Hello!";
  }
};

属性名表达式

ES6 容许字面量定义对象时，用表达式做为对象的属性名，即把表达式放在方括号内。

let propKey = 'foo';
let hello = 'haha';

let obj = {
  [propKey]: true,
  ['a' + 'bc']: 123,
  [hello]() {
    return 'hi';
  }  
};

属性名表达式若是是一个对象，默认状况下会自动将对象转为字符串[object Object]，这一点要特别当心。

扩展运算符（...）

对象的扩展运算符（...）用于取出参数对象的全部可遍历属性，拷贝到当前对象之中。

扩展运算符能够用于合并两个对象。

let ab = { ...a, ...b };
// 等同于
let ab = Object.assign({}, a, b);

若是用户自定义的属性，放在扩展运算符后面，则扩展运算符内部的同名属性会被覆盖掉。

let aWithOverrides = { ...a, x: 1, y: 2 };
// 等同于
let aWithOverrides = { ...a, ...{ x: 1, y: 2 } };

与数组的扩展运算符同样，对象的扩展运算符后面能够跟表达式。

const obj = {
  ...(x > 1 ? {a: 1} : {}),
  b: 2,
};

函数

参数的默认值

function Point(x = 0, y = 0) {
  this.x = x;
  this.y = y;
}

const p = new Point();
p // { x: 0, y: 0 }

参数默认值能够与解构赋值的默认值，结合起来使用。

function foo({x, y = 5}) {
  console.log(x, y);
}

foo({}) // undefined 5
foo({x: 1}) // 1 5
foo({x: 1, y: 2}) // 1 2
foo() // TypeError: Cannot read property 'x' of undefined

参数默认值不是传值的，而是每次都从新计算默认值表达式的值。也就是说，参数默认值是惰性求值的。
参数设置默认值，这个参数是无法省略的。
指定了默认值之后，函数的length属性，将返回没有指定默认值的参数个数。

rest 参数（...变量名）

rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中。

function add(...values) {
  let sum = 0;

  for (var val of values) {
    sum += val;
  }

  return sum;
}

add(2, 5, 3) // 10

name 属性

函数的name属性，返回该函数的函数名。

function foo() {}
foo.name // "foo"

函数参数的尾逗号

参数写成多行（即每一个参数占据一行），尾部直接有一个逗号。

function clownsEverywhere(
  param1,
  param2,
) { /* ... */ }