ES6基础

let和const

let 和 var相比，有块作用域，存在暂时性死区，没有变量提升，不能提前使用，不允许重复声明。

const 声明一个只读的常量，声明后不允许被改变，基础类型是不能被改变，但是如果声明了一个引用类型，其值是可以被改变的，因为只声明了它的指针，指针是基础类型，指针所指的实际地址改变是不影响的。

解构赋值

解构赋值可以用来解构数组、对象、函数等。

let [a, b, c] = [1, 2, 3];
let { foo, bar } = { foo: 'aaa', bar: 'bbb' };

默认值，只有右边的值为underfind时才取默认值。

let [a = 0, b = 2, c = 3] = [1, null, underfind]
a // 1
b // null
c // 3

解构对象：

// 重命名
let { foo: baz } = { foo: 'aaa', bar: 'bbb' };
baz // "aaa"

// 默认值
var {x = 3} = {x: undefined};
x // 3

var {x = 3} = {x: null};
x // null

解构函数参数：

function add([x, y]){
  return x + y;
}
add([1, 2]); // 3

// 默认值
function move({x = 0, y = 0} = {}) {
  return [x, y];
}
move({x: 3, y: 8}); // [3, 8]
move({x: 3}); // [3, 0]

模板字符串

let name = 'world';
let str = `hello, ${name}`;

// 标签模板

let a = 5;
let b = 10;

tag`Hello ${ a + b } world ${ a * b }`;
// 等同于
tag(['Hello ', ' world ', ''], 15, 50);

函数扩展

默认值

function log(x, y = 'World') {
  console.log(x, y);
}

获取参数

arguments对象
function log(x, y) {
  console.log(arguments); // 类数组参数列表
}

rest 参数 
// 获取多余参数，不必再为定义参数而定义多个参数，使用时直接传入参数，统一接收多余参数
function log(...arg) {
  console.log(arg);
}
log(1, 2, 3) // [1, 2, 3] 参数数组

function log(arr, ...arg) {
  console.log(arr);
  console.log(arg);
}
log([1, 2], 1, 2, 3) // [1, 2] [1, 2, 3]

name属性获取函数名

function log() {}
log.name // log

var f = function () {};
// ES5
f.name // ""
// ES6
f.name // "f"

箭头函数

箭头函数代码块多条语句必须加大括号，不加大括号是直接return返回，返回对象可以使用大括号加return或者直接使用括号包括。

// 箭头函数没有自己的this对象
// 不可以使用arguments对象，该对象在函数体内不存在。可以用 rest 参数代替。
// 对象的函数不要使用箭头函数

const fun = function(a, b) {
    return a + b
}
const fun = (a, b) => a + b
// 相当于
const fun = (a, b) => { return a + b}

// 返回对象
const fun = (a, b) => ({a: a, b: b})
// 相当于
const fun = (a, b) => {
    return {a: a, b: b}
}

[1, 2, 3, 4].map(item => ({a: item * 2, b: item + 1}))
[1, 2, 3, 4].map(item => {
    return {a: item * 2, b: item + 1}
})

尾调用

尾递归

函数柯里化