掌握 Async/Await

85193658

2019-05-07

关注关注

摘要： 还不用Async/Await就OUT了。。

原文：掌握 Async/Await
作者：Jartto

前端工程师肯定都经历过 JS 回调链狱的痛苦过程，我们在使用 Promise 的时候总是不尽人意。这时候 Async/Await 应运而生，它到底有什么魔力，我们来说道说道。

一、回顾 Promise

所谓 Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。

1. 语法

new Promise(executor);
new Promise(function(resolve, reject) { ... });

2. 参数

带有 resolve 、reject 两个参数的一个函数。这个函数在创建 Promise 对象的时候会立即得到执行（在 Promise 构造函数返回 Promise 对象之前就会被执行），并把成功回调函数（resolve）和失败回调函数（reject）作为参数传递进来。调用成功回调函数（resolve）和失败回调函数（reject）会分别触发 Promise 的成功或失败。

这个函数通常被用来执行一些异步操作，操作完成以后可以选择调用成功回调函数（resolve）来触发 Promise 的成功状态，或者，在出现错误的时候调用失败回调函数（reject）来触发 Promise 的失败。

3. Promise.all

用 Promise.all 来执行，all 接收一个数组参数，里面的值最终都算返回 Promise 对象。这样，三个异步操作的并行执行的，等到它们都执行完后才会进到 then 里面。

Promise.all([async1(), async2(), async3()])
.then(function(results){
  console.log(results);
});

all 会把所有异步操作的结果放进一个数组中传给 then，就是上面的 results。

4. Promise.race

all 方法的效果实际上是「谁跑的慢，以谁为准执行回调」，那么相对的就有另一个方法「谁跑的快，以谁为准执行回调」，这就是 race方法：

Promise.race([requestImg(), timeout()])
.then(function(results){
    console.log(results);
})
.catch(function(reason){
    console.log(reason);
});

上述代码演示了 race 的基本用法，实现的功能是：请求图片，如果请求成功就返回图片，否则就调用超时函数。

更多资源，请查看：

二、Promise 为何不完美？

乍一看，Promise 还不错，帮我们解决了回调链狱的问题。当然这只是简单使用，碰到复杂的业务也有很鸡肋的场景，比如：

1. 错误处理

在下面的 Promise 示例中，Try/Catch 不能处理 JSON.parse 的错误，因为它在 Promise中。我们需要使用 catch，这样错误处理代码非常冗余。并且，在我们的实际生产代码会更加复杂。

const makeRequest = () => {
  try {
    getJSON().then(result => {
      // JSON.parse可能会出错
      const data = JSON.parse(result)
      console.log(data)
    })
    // 取消注释，处理异步代码的错误
    // .catch((err) => {
    //   console.log(err)
    // })
  } catch (err) {
    console.log(err)
  }
}

Async/Await 让 Try/Catch 可以同时处理同步和异步错误。使用 Async/Await 的话，catch能处理 JSON.parse 错误:

const makeRequest = async () => {
  try {
    // this parse may fail
    const data = JSON.parse(await getJSON())
    console.log(data)
  } catch (err) {
    console.log(err)
  }
}

Async/Await 最让人舒服的一点是代码看起来是同步的。

2. 条件语句

下面示例中，需要获取数据，然后根据返回数据决定是直接返回，还是继续获取更多的数据。

const makeRequest = () => {
  return getJSON()
    .then(data => {
      if (data.needsAnotherRequest) {
        return makeAnotherRequest(data)
          .then(moreData => {
            console.log(moreData)
            return moreData
          })
      } else {
        console.log(data)
        return data
      }
    })
}

这些代码看着就头痛。嵌套（6层），括号，return 语句很容易让人感到迷茫，而它们只是需要将最终结果传递到最外层的Promise。如果换成 Async/Await 呢：

const makeRequest = async () => {
  const data = await getJSON();
  if (data.needsAnotherRequest) {
    const moreData = await makeAnotherRequest(data);
    console.log(moreData);
    return moreData;
  } else {
    console.log(data);
    return data;  
  }
}

所以，这才是真正摆脱回调链狱的正确做法。

3. 中间值

你很可能遇到过这样的场景，调用 promise1，使用 promise1 返回的结果去调用 promise2，然后使用两者的结果去调用promise3。你的代码很可能是这样的：

const makeRequest = () => {
  return promise1()
    .then(value1 => {
      return promise2(value1);
        .then(value2 => {        
          return promise3(value1, value2);
        })
    })
}
// 或者：
const makeRequest = () => {
  return promise1()
    .then(value1 => {
      return Promise.all([value1, promise2(value1)])
    })
    .then(([value1, value2]) => {      
      return promise3(value1, value2)
    })
}

怎么写都会觉得很复杂，那如果 Async/Await 用来实现呢，表现可能如下：

const makeRequest = async () => {
  const value1 = await promise1();
  const value2 = await promise2(value1);
  return promise3(value1, value2);
}

是不是很 6 ，将复杂的场景简化，这样的代码就很有灵性了。

4. 错误栈

调用了多个 Promise，假设 Promise 链中某个地方抛出了一个错误，Promise 链中返回的错误栈没有给出错误发生位置的线索。更糟糕的是，它会误导我们；错误栈中唯一的函数名为 callAPromise，然而它和错误没有关系。(文件名和行号还是有用的)。

const makeRequest = () => {
  return callAPromise()
    .then(() => callAPromise())
    .then(() => callAPromise())
    .then(() => callAPromise())
    .then(() => callAPromise())
    .then(() => {
      throw new Error("oops");
    })
}

makeRequest().catch(err => {
  console.log(err);
  // output
  // Error: oops at callAPromise.then.then.then.then.then (index.js:8:13)
})

然而，Async/Await 中的错误栈会指向错误所在的函数：

const makeRequest = async () => {
  await callAPromise();
  await callAPromise();
  await callAPromise();
  throw new Error("oops");
}

makeRequest().catch(err => {
  console.log(err);
  // output
  // Error: oops at makeRequest (index.js:7:9)
})

5. 调试

调试 Promise 有两个问题：

不能在返回表达式的箭头函数中设置断点；
如果你在 then 代码块中设置断点，调试器不会跳到下一个 then，因为它只会跳过异步代码;

而使用 Await/Async 时，你不再需要那么多箭头函数，这样你就可以像调试同步代码一样跳过 Await 语句。

这里只简单的列出问题，详细请查看原文：Async/Await 替代 Promise 的 6 个理由

三、新时代的曙光 Async/Await

简单介绍：

Await/Async 是写异步代码的新方式，以前的方法有回调函数和 Promise。
Await/Async 是基于 Promise 实现的，它不能用于普通的回调函数。
Await/Async 与 Promise 一样，是非阻塞的。
Await/Async 使得异步代码看起来像同步代码，这正是它的魔力所在。

使用 Promise 是这样的:

const jarttoDemo = () =>
getJSON().then(data => {
  return data;
})

jarttoDemo();

使用 Async/Await 是这样的:

const jarttoDemo = async () => {
  let data = await getJSON();
  return data;
}

jarttoDemo();

基本规则：

Async 表示这是一个 Async 函数，Await 只能用在这个函数里面。
Await 表示在这里等待 Promise返回结果了，再继续执行。
Await 后面跟着的应该是一个 Promise 对象，当然，其他返回值也没关系，只是会立即执行，不过那样就没有意义了。

四、更多用法示例

1. 简单示例

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();

2. 获得返回值

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’
};

3. 错误捕获

const makeRequest = async () => {
  try {
    // this parse may fail
    const data = JSON.parse(await getJSON())
    console.log(data)
  } catch (err) {
    console.log(err)
  }
}

既然 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`
  }
};

4. 条件语句

Promise 写法：

const makeRequest = () => {
  return getJSON()
    .then(data => {
      if (data.needsAnotherRequest) {
        return makeAnotherRequest(data)
          .then(moreData => {
            return moreData;
          })
      } else {
        return data;
      }
    })
}

Async/Await 写法：

const makeRequest = async () => {
  const data = await getJSON();
  if (data.needsAnotherRequest) {
    const moreData = await makeAnotherRequest(data);
    return moreData;
  } else {
    return data;  
  }
}

5. 循环多个 `Await`

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

需要注意的是，Await 必须在 Async 函数的上下文中的。

6. 在 `forEach` 中使用

async function printFiles() {
    const files = await getFilePaths();

    for (let file of files) {
        const contents = await fs.readFile(file, "utf8");
        console.log(contents);
    }
}

async function printFiles() {
    const files = await getFilePaths();

    await Promise.all(
        files.map(file => {
            return async () => {
                const contents = await fs.readFile(file, "utf8");
                console.log(contents);
            };
        })
    );
}

示例参考如下文章：

五、总结

我们一直在强调代码的可读性和可维护性，对我来说，Async/Await 更加易懂和易用。所以，不管是 Promise 还是 Async/Await ，能解决实际问题的技术就是好技术。

当然，Async/Await 也是基于 Promise 概念的，技术上我们也可以求同存异，不必太过较真。一句话，选择权在你！

原作者： Fundebug
https://blog.fundebug.com/2019/05/08/master-async-await/

async promise 回调函数