ES7/8流行特性

摘要：的两个特性数组是否包含某元素它的作用类似于都可以用来查询数组或字符串是否包含指定元素。基本规则表示这是一个函数，只能用在这个函数里面。表示在这里等待返回结果了，再继续执行。

Array.prototype.includes(数组是否包含某元素)
它的作用类似于indexOf(),都可以用来查询数组或字符串是否包含指定元素。indexOf()会返回相应元素的位置，下标从0开始；includes()会返回布尔值。

let arr = ["react", "angular", "vue"]
let str = "hello world"
console.log(str.indexOf("l"));      //2
console.log(str.lastIndexOf("l"));  //9
console.log(arr.indexOf("vue"));    //2
console.log(arr.lastIndexOf("vue"));//2
console.log(arr.indexOf("v"));      //-1
console.log(arr.includes("v"));     //false
console.log(arr.includes("vue"));   //true

includes第二可选参数fromIndex，允许从特定位置开始寻找匹配.

console.log(str.includes("l", 3)); //true

Exponentiation Operator(求冥运算)
ES5的求幂运算使用方法Math.pow()，ES7的求幂运算直接用**：

console.log(7 ** 2); //49
console.log(Math.pow(7, 2)); //49

它还可以操纵结果。

  let a = 5
  a **= 3  // a = a ** 3
  console.log(a === Math.pow(5, 3)) // true
  console.log(a ) // 125
  console.log(Math.pow(5, 3)) // 125

这里我们要实现一个暂停功能，输入N毫秒，则停顿N毫秒后才继续往下执行。

var sleep = function (time) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            resolve();
        }, time);
    })
};

var start = async function () {
    // 在这里使用起来就像同步代码那样直观
    console.log("start");
    await sleep(3000);
    console.log("end");
};

start();

控制台先输出start，稍等3秒后，输出了end。

async 表示这是一个async函数，await只能用在这个函数里面。

await 表示在这里等待promise返回结果了，再继续执行。

await 后面跟着的应该是一个promise对象（当然，其他返回值也没关系，只是会立即执行，不过那样就没有意义了…）

await等待的虽然是promise对象，但不必写.then(..)，直接可以得到返回值。

var sleep = function (time) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            // 返回 ‘ok’
            resolve("ok");
        }, time);
    })
};

var start = async function () {
    let result = await sleep(3000);
    console.log(result); // 收到 ‘ok’
};

既然.then(..)不用写了，那么.catch(..)也不用写，可以直接用标准的try catch语法捕捉错误。

var sleep = function (time) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            // 模拟出错了，返回 ‘error’
            reject("error");
        }, time);
    })
};

var start = async function () {
    try {
        console.log("start");
        await sleep(3000); // 这里得到了一个返回错误
        
        // 所以以下代码不会被执行了
        console.log("end");
    } catch (err) {
        console.log(err); // 这里捕捉到错误 `error`
    }
};

await看起来就像是同步代码，所以可以理所当然的写在for循环里，不必担心以往需要闭包才能解决的问题。

..省略以上代码

var start = async function () {
    for (var i = 1; i <= 10; i++) {
        console.log(`当前是第${i}次等待..`);
        await sleep(1000);
    }
};

值得注意的是，await必须在async函数的上下文中的。

..省略以上代码

let 一到十 = [1,2,3,4,5,6,7,8,9,10];

// 错误示范
一到十.forEach(function (v) {
    console.log(`当前是第${v}次等待..`);
    await sleep(1000); // 错误!! await只能在async函数中运行
});

// 正确示范
for(var v of 一到十) {
    console.log(`当前是第${v}次等待..`);
    await sleep(1000); // 正确, for循环的上下文还在async函数中
}

这个例子是一个小应用，根据电影文件名，自动下载对应的海报

import fs from "fs";
import path from "path";
import request from "request";

var movieDir = __dirname + "/movies",
    exts     = [".mkv", ".avi", ".mp4", ".rm", ".rmvb", ".wmv"];

// 读取文件列表
var readFiles = function () {
    return new Promise(function (resolve, reject) {
        fs.readdir(movieDir, function (err, files) {
            resolve(files.filter((v) => exts.includes(path.parse(v).ext)));
        });
    });
};

// 获取海报
var getPoster = function (movieName) {
    let url = `https://api.douban.com/v2/movie/search?q=${encodeURI(movieName)}`;

    return new Promise(function (resolve, reject) {
        request({url: url, json: true}, function (error, response, body) {
            if (error) return reject(error);

            resolve(body.subjects[0].images.large);
        })
    });
};

// 保存海报
var savePoster = function (movieName, url) {
    request.get(url).pipe(fs.createWriteStream(path.join(movieDir, movieName + ".jpg")));
};


(async () => {
    let files = await readFiles();

    // await只能使用在原生语法
    for (var file of files) {
        let name = path.parse(file).name;

        console.log(`正在获取【${name}】的海报`);
        savePoster(name, await getPoster(name));
    }

    console.log("=== 获取海报完成 ===");
})();

String.prototype.padStart 和 String.prototype.padEnd在javascript字符操作是一个不错的体验，帮助避免依赖而外的库。
padStart()在开始部位填充，返回一个给出长度的字符串，填充物给定字符串，把字符串填充到期望的长度。从字符串的左边开始（至少大部分西方语言），一个经典例子是使用空格创建列：

console.log("react".padStart(10).length)         // "       react" is 10
console.log("backbone".padStart(10).length)         // "  backbone" is 10

它对于财务方面非常有用：

console.log("0.00".padStart(20))             
console.log("10,000.00".padStart(20))    
console.log("250,000.00".padStart(20))

这结果作为一个会计总账格式非常漂亮：

            0.00
       10,000.00
      250,000.00

第二个参数，让我们放一些其他的填充字符替代空字符串，一个字符串填充：

console.log("react".padStart(10, "_"))         // "_____react"
console.log("backbone".padStart(10, "*"))         // "**backbone"

padEnd顾名思义就是从字符串的尾端右边开始填充。第二个参数，你能实际上用一个任何长度的字符串。例如：

console.log("react".padEnd(10, ":-)"))         // "react:-):-" is 10
console.log("backbone".padEnd(10, "*"))         // "backbone**" is 10