ES8新特性（2017）

异步函数（async await）

async用于定义一个异步函数，该函数返回一个Promise。如果async函数返回的是一个同步的值，这个值将被包装成一个理解resolve的Promise，等同于return Promise.resolve(value)。

异步函数存在以下四种使用形式：
函数声明： async function foo() {}
函数表达式： const foo = async function() {}
对象的方式： let obj = { async foo() {} }
箭头函数： const foo = async () => {}

// 返回Promise
let timer = async () => {
    return new Promise((reslove, reject) => {
        setTimeout(() => {
            reslove("test");
        }, 1000);
    })
}
timer().then(res => {
    console.log(res);
}).catch(err => {
    console.log(err.message);
});

// 返回同步的值
let sayHello = async () => "hello world"; // 等同于return Promise.resolve("hello world");
sayHello().then(res => {
    console.log(res);
}).catch(err => {
    console.log(err.message);
});

await用于一个异步操作之前，表示要“等待”这个异步操作的返回值。await也可以用于一个同步的值。

const promise1 = new Promise((resolve, reject) => {
    setTimeout(resolve, 300, 'promise1');
});
const promise2 = new Promise((resolve, reject) => {
    setTimeout(resolve, 400, 'promise2');
});
const promise3 = new Promise((resolve, reject) => {
    setTimeout(resolve, 100, 'promise3');
});

let getList = async () => {
    let result = await Promise.all([promise1, promise2, promise3]);
    return result;
}

getList().then(res => {
    console.log(res); // ["promise1", "promise2", "promise3"]
}).catch(err => {
    console.log(err);
});

async函数对异常的处理和Promise链一样，可以直接用.catch()捕捉到，如果有一个Promise被reject()那么后面的将不会再执行。

Object.entries()

Object.entries()函数将一个给定对象中可枚举属性的键名和键值按照二维数组的方式返回。如果对象是数组，则会将数组的下标作为键值返回。

Object.entries({ "a": 1, "b": 2 , "c": 3}); // [["a", 1], ["b", 2], ["c", 3]]
Object.entries([1, 2, 3]); // [["0", 1], ["1", 2], ["2", 3]]

entries()返回的数组顺序和for循环一样，如果对象的key值是数字，则返回值会对key值进行排序。

Object.values()

不同于es6中 Object.keys()返回的是键名，Object.values()只返回自己的键值对中属性的值。它返回的数组顺序，也跟Object.entries()保持一致。

Object.values({ "a": 1, "b": 2 , "c": 3}); // [1, 2, 3]
Object.values([1, 2, 3]); // [1, 2, 3]

字符串填充（padStart()和padEnd()）

let str = "text";
console.log(str.padStart(10, "*")); // 从左侧填充
console.log(str.padEnd(10, "*")); // 从右侧填充
console.log(str.padStart(1, "*")); // 如果字符串需要填充到的目标长度小于当前长度，则返回当前字符串本身
console.log(str.padStart(10)); // 填充字符串参数的缺省值为 " "
console.log(str.padStart(10, "abcdefghijklmn")); // 如果填充字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断

Object.getOwnPropertyDescriptors()

该方法会返回目标对象中所有自身属性（非继承属性）。

const obj = {
  "foo": 123,
  get bar() { 
      return "abc";
  }
};
 
console.log(Object.getOwnPropertyDescriptors(obj));
/*{
    foo: {
        value: 123,
        writable: true,
        enumerable: true,
        configurable: true
    },
    bar: {
        get: [Function: bar],
        set: undefined,
        enumerable: true,
        configurable: true
    }
}*/

函数参数支持尾部逗号

在ES5中，在函数参数后面有逗号会报非法语法，而ES8允许在定义或者调用函数时添加尾部逗号而不报错，

let f = (a, b, c, d,) => {
  console.log(d);
}