JavaScript：体验异步的优雅解决方案

1、异步解决方案的进化史

JavaScript的异步操做一直是个麻烦事，因此不断有人提出它的各类解决方案。能够追溯到最先的回调函数(ajax老朋友)，到Promise(不算新的朋友)，再到ES6的Generator(强劲的朋友)。
几年前咱们可能用过一个比较著名的Async.js，可是它没有摆脱回调函数，而且错误处理也是按照“回调函数的第一个参数用来传递错误”这样一个约定。而众所周知的回调地狱仍然是一个比较突出的问题，直到Generator改变了这种异步风格。
可是ES7的async await的出现(碉堡的新朋友)，咱们能够轻松写出同步风格的代码同时又拥有异步机制，能够说是目前最简单，最优雅，最佳的解决方案了。

2、async await语法

async await语法比较简单，能够认为是Generator的语法糖，比起星号和yield更具备语义化。下面一个简单的例子表示1秒以后输出hello world：

function timeout(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

async function asyncPrint(value, ms) {
  await timeout(ms);
  console.log(value)
}

asyncPrint('hello world', 1000);

1. await只能用在async函数中，若是用在普通函数就会报错
2. await后面跟的是一个Promise对象(固然其它值也能够，可是会包装成一个当即resolve的Promise，也就没有意义了)
3. await会等待Promise的结果返回再继续执行

await等待的虽然是Promise对象，可是没必要写.then()，直接能够获得返回值，将上面的代码微调，发现返回值result也是能够输出hello world：

function timeout(ms) {
  return new Promise((resolve) => {
    setTimeout(_ => {resolve('hello world')}, ms);
  });
}

async function asyncPrint(ms) {
  let result = await timeout(ms);
  console.log(result)
}

asyncPrint(1000);

3、async await错误处理

前面说了await等待的虽然是Promise对象，可是没必要写.then()，因此其实也不用写.catch()了，直接用try catch就能捕捉错误，这样能够避免错误处理代码很是冗余和笨重，仍是将上面的例子微调：

function timeout(ms) {
  return new Promise((resolve, reject) => {
    setTimeout(_ => {reject('error')}, ms);//reject模拟出错，返回error
  });
}

async function asyncPrint(ms) {
  try {
     console.log('start');
     await timeout(ms);//这里返回了错误
     console.log('end');//因此这句代码不会被执行了
  } catch(err) {
     console.log(err); //这里捕捉到错误error
  }
}

asyncPrint(1000);

若是有多个await，能够一块儿放在try catch中：

async function main() {
  try {
    const async1 = await firstAsync();
    const async2 = await secondAsync();
    const async3 = await thirdAsync();
  }
  catch (err) {
    console.error(err);
  }
}

4、async await注意点

1). 前面已经说过，await命令后面的Promise对象，运行结果极可能是reject或逻辑报错，因此最好把await放在try catch代码块中。
2). 多个await命令的异步操做，若是不存在依赖关系，让它们同时触发。

const async1 = await firstAsync();
const async2 = await secondAsync();

上面代码中，async1和async2若是是两个独立的异步操做，这样写会比较耗时，由于只有firstAsync完成之后，才会执行secondAsync，彻底能够用Promise.all优雅地处理：

let [async1, async2] = await Promise.all([firstAsync(), secondAsync()]);

3). await只能用在async函数之中，若是用在普通函数就会报错：

async function main() {
  let docs = [{}, {}, {}];

  //报错 await is only valid in async function
  docs.forEach(function (doc) {
    await post(doc);
    console.log('main');
  });
}
function post(){
  return new Promise((resolve) => {
    setTimeout(resolve, 1000);
  });
}

在forEach内部方法加上async就能够了：

async function main() {
  let docs = [{}, {}, {}];

  docs.forEach(async function (doc) {
    await post(doc);
    console.log('main');
  });
}
function post(){
  return new Promise((resolve) => {
    setTimeout(resolve, 1000);
  });
}

可是你会发现3个main是同时输出的，这就说明post是并发执行的，而不是继发执行，改为for就能够解决问题，3个main是分别相隔1秒输出：

async function main() {
  let docs = [{}, {}, {}];

  for (let doc of docs) {
    await post(doc);
    console.log('main');
  }
}
function post(){
  return new Promise((resolve) => {
    setTimeout(resolve, 1000);
  });
}

总之，用了async await以后整我的神清气爽，能够用很是简洁和优雅的代码实现各类花式异步操做，而且在业务逻辑复杂的状况下能够不用陷入回调地狱中。不敢说这必定是终极的解决方案，但确实是目前最优雅的解决方案！