Async/Await简介
- async/await是写异步代码的新方式，以前的方法有回调函数和Promise。
- async/await是基于Promise实现的，它不能用于普通的回调函数。
- async/await与Promise一样，是非阻塞的。
- async/await使得异步代码看起来像同步代码，这正是它的魔力所在。
Async/Await语法
Promise写法:
const makeRequest = () =>
getJSON()
.then(data => {
console.log(data)
return "done"
})
makeRequest()
Async/Await写法:
const makeRequest = async () => {
console.log(await getJSON())
return "done"
}
makeRequest()
示例中，getJSON函数返回一个promise，这个promise成功resolve时会返回一个promise对象。我们只是调用这个函数，打印返回的JSON对象，然后返回“done”。
它们有一些细微不同:
- 函数前面多了一个async关键字。await关键字只能用在async定义的函数内。async函数会隐式的返回一个promise，该promise的resolve值就是函数return的值。(示例中resolve值就是字符串"done")
- 第1点暗示我们不能在最外层代码中使用await，因为不在async函数内。
//不能在最外层代码中使用await
await makeRequest()
//这是会出事的
makeRequest().then((result) => {
//代码
})
await getJSON()表示console.log会等到getJSON的promise成功reosolve之后再执行。
为什么Async/Await更好？
1. 简洁
由示例可知，使用Async/Await明显节约了不少代码。我们不需要写.then，不需要写匿名函数处理Promise的resolve值，也不需要定义多余的data变量，还避免了嵌套代码。这些小的优点会迅速累计起来，这在之后的代码示例中会更加明显。
2. 错误处理
Async/Await让try/catch可以同时处理同步和异步错误。在下面的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)
}
}
使用aync/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)
}
}
3. 条件语句
下面示例中，需要获取数据，然后根据返回数据决定是直接返回，还是继续获取更多的数据。
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语句很容易让人看不懂。
使用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
}
}
4. 中间值
你可能遇到过这样的场景，调用promise1，使用promise1返回的结果调用promise2，然后使用两者的结果调用promise3。使用promise的代码是：
const makeRequest = () => {
return promise1()
.then(value1 => {
return promise2(value1)
.then(value2 => {
return promise3(value1, value2)
})
})
}
如何promise3不使用value1，可以很简单的将promise铺平。如果忍受不了嵌套，可以将value1 & value2放进Promise.all来避免深层嵌套：
const makeRequest = () => {
return promise1()
.then(value1 => {
return Promise.all([value1, promise2(value1)])
})
.then(([value1, value2]) => {
return promise3(value1, value2)
})
}
这种方法为了可读性牺牲了语义，除了避免嵌套，并没有其他理由将value1和value2放在一个数组中。
使用async/await的话，代码会变得异常简单和直观:
const makeRequest = async () => {
const value1 = await promise1()
const value2 = await promise2(value1)
return promise3(value1, value2)
}
5. 错误栈
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)
})
上述示例中调用了多个promise，假设promise链中某个地方抛出了一个异常，返回的错误栈没有给出错误发生的位置信息。
async/await中的错误栈会指向错误所在的函数：
const makeRequest = async () => {
await callAPromise()
await callAPromise()
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)
})
在开发过程中，可能这一点优势并不是很大。但是，如果是分析生产环境的错误日志时，它将非常有用。
6. 调试
async/await能够使代码更方便调试。
promise调试非常痛苦：
- 不能在返回表达式的箭头函数中设置断点
const makeRequest = () => {
return callAPromise()
.then(() => callAPromise())
.then(() => callAPromise())
.then(() => callAPromise())
.then(() => callAPromise())
}
- 如果在.then代码块中设置断点，使用Step Over快捷键，调试器不会调到下一个.then，因为它只会跳过异步代码。
使用async/await时，不再需要那么多箭头函数，这样就可以像调试同步代码一样跳过await语句。
const makeRequest = async () => {
await callAPromise()
await callAPromise()
await callAPromise()
await callAPromise()
}
