含义
async函数是ES2017引入的，实质上，async函数是Generator函数的语法糖
用一个Generator函数依次读取两个文件
const fs = require('fs');
const readFile = function (fileName) {
return new Promise(function (resolve, reject) {
fs.readFile(fileName, function(error, data) {
if (error) return reject(error);
resolve(data);
});
});
};
const gen = function* () {
const f1 = yield readFile('/etc/fstab');
const f2 = yield readFile('/etc/shells');
console.log(f1.toString());
console.log(f2.toString());
};写成async函数，就是下面这样。
const asyncReadFile = async function () {
const f1 = await readFile('/etc/fstab');
const f2 = await readFile('/etc/shells');
console.log(f1.toString());
console.log(f2.toString());
};async函数就是将Generator函数的星号（*）替换成async，将yield替换成await，仅此而已。
async的改进
async函数对Generator函数的改进，体现在以下
内置执行器
Generator函数的执行必须靠执行器，所以才有了co模块，而
async函数自带执行器。也就是说，async函数的执行，与普通函数一模一样，只要一行。语义更好
- 实用性更广，
await后面可以是Promise对象和原始类型的值 - 返回值是Promise
基本用法
async函数返回一个Promise对象，可以使用then方法添加回调函数。当函数执行的时候，一旦遇到await就会先返回，等到异步操作完成，再接着执行函数体内后面的语句。
// 2s后打印字符
function timeout(text, ms){
return new Promise((resolve, reject) => {
setTimeout(resolve, ms, text)
})
}
async function print(text,ms){
return timeout(text, ms);
}
print('hello world', 2000).then(val => console.log(val))async函数有多种使用形式。
// 函数声明
async function foo() {}
// 函数表达式
const foo = async function () {};
// 对象的方法
let obj = { async foo() {} };
obj.foo().then(...)
// Class 的方法
class Storage {
constructor() {
this.cachePromise = caches.open('avatars');
}
async getAvatar(name) {
const cache = await this.cachePromise;
return cache.match(`/avatars/${name}.jpg`);
}
}
const storage = new Storage();
storage.getAvatar('jake').then(…);
// 箭头函数
const foo = async () => {};返回Promise对象
async函数返回一个Promise对象。async函数内部return语句返回的值，会成为then方法回调函数的参数。
async function f() {
return 'hello world';
}
f().then(v => console.log(v))
// "hello world"async函数内部抛出错误，会导致返回的Promise对象变为reject状态。抛出的错误对象会被catch方法回调函数接收到。
async function f() {
throw new Error('出错了');
}
f().then(
v => console.log(v),
e => console.log(e)
)
// Error: 出错了Promise对象的状态变化
async函数返回的Promise对象，必须等到内部所有await命令后面的Promise对象执行完，才会发生状态改变，除非遇到return语句或者抛出错误。
也就是说，只有async函数内部的异步操作执行完，才会执行then方法指定的回调函数。
await命令
正常情况下，await命令后面是一个Promise对象。如果不是，会被转成一个立即resolve的Promise对象。
只要一个await语句后面的Promise变为reject，那么整个async函数都会中断执行。
async function f() {
await Promise.reject('出错了');
await Promise.resolve('hello world'); // 不会执行
}有时，我们希望即使前一个异步操作失败，也不要中断后面的异步操作。这时可以将第一个await放在try...catch结构里面，这样不管这个异步操作是否成功，第二个await都会执行。
async function f() {
try {
await Promise.reject('出错了');
} catch(e) {
}
return await Promise.resolve('hello world');
}
f()
.then(v => console.log(v))
// hello world另一种方法是await后面的Promise对象再跟一个catch方法，处理前面可能出现的错误。
async function f() {
await Promise.reject('出错了')
.catch(e => console.log(e));
return await Promise.resolve('hello world');
}
f()
.then(v => console.log(v))
// 出错了
// hello world如果有多个await命令，可以统一放在try...catch结构中。
async function main() {
try {
const val1 = await firstStep();
const val2 = await secondStep(val1);
const val3 = await thirdStep(val1, val2);
console.log('Final: ', val3);
}
catch (err) {
console.error(err);
}
}使用try...catch结构，实现多次重复尝试。
const superagent = require('superagent');
const NUM_RETRIES = 3;
async function test() {
let i;
for (i = 0; i < NUM_RETRIES; ++i) {
try {
await superagent.get('http://google.com/this-throws-an-error');
break;
} catch(err) {}
}
console.log(i); // 3
}
test();注意点
（1） 把await命令放在try...catch 代码块中
（2） 多个await命令后面的异步操作，如果不存在继发关系，最好让它们同时触发
let timeout1 = function () {
return new Promise(resolve => {
setTimeout(resolve, 1000, 'timeout1')
})
};
let timeout2 = function () {
return new Promise(resolve => {
setTimeout(resolve, 3000, 'timeout1')
})
}
// 继发操作
async function fn() {
console.log('计时开始')
console.time('继发操作', 123)
let result1 = await timeout1();
let result2 = await timeout2();
}
fn().then(() => {
console.log('计时结束')
console.timeEnd('继发操作')
})
上面两await后面的异步操作，被写成了继发的关系，所以总耗时需要4s
如果二者没有继发关系，可以让它们同时触发，可以节省时间
// 并发操作1
async function fn() {
console.log('计时开始')
console.time('继发操作', 123)
let t1 = timeout1();
let t2 = timeout2();
let result1 = await t1;
let result2 = await t2;
}也可以使用Promise.all()方法，同时发出请求，等到所有Promise请求状态完成，Promise.all()的状态才会随之确定
（3） await只能放在async函数中
（4） 多个Promise请求同时发出
上面提到的两种方法都可以让多个Promise请求同时发出，要注意的是，如果使用forEach代码不会正常工作，没有执行异步的效果
async function dbFuc(db) {
let docs = [{}, {}, {}];
let promises = docs.map((doc) => db.post(doc));
let results = await Promise.all(promises);
console.log(results);
}
// 或者使用下面的写法
async function dbFuc(db) {
let docs = [{}, {}, {}];
let promises = docs.map((doc) => db.post(doc));
let results = [];
for (let promise of promises) {
results.push(await promise);
}
console.log(results);
}所以：
- 如果需要继发操作的姿势就是像写同步代码一样写之
- 如果需要并发操作的姿势可以使用for...of和Promise.all
- 关键点就是看异步发出时机与await的关系了
实例：按顺序完成异步操作
let timeout1 = function () {
return new Promise(resolve => {
setTimeout(resolve, 3000, 'timeout1')
})
};
let timeout2 = function () {
return new Promise(resolve => {
setTimeout(resolve, 3000, 'timeout2')
})
}
let timeout3 = function () {
return new Promise(resolve => {
setTimeout(resolve, 4000, 'timeout3')
})
}
let arr = [timeout1, timeout2, timeout3]
// 同时发出，按顺序输出
// async function f(urls) {
// let res = urls.map((url) => url())
// for(let i of res){
// console.log(await i)
// }
// }
// 同时发出，谁先完成输出谁
// async function f(urls) {
// let res = urls.map(async (url) => {
// console.log(await url())
// })
// }
// 依次发出，依次输出
async function f(urls) {
for (let url of urls) {
console.log(await url())
}
}
f(arr)将异步请求同时发出，然后在获取结果时进行await，这也是一般的思路
是否能够按不按顺序执行就看是否包裹一层async函数，如果额外包裹了一层async函数，就可以不按顺序，如果没有这一层async函数（比如for...of循环）就必须按照顺序执行
在看一个用fetch方法的例子
async function logInOrder(urls) {
// 并发读取远程URL
const textPromises = urls.map(async url => {
const response = await fetch(url);
return response.text();
});
// 按次序输出
for (const textPromise of textPromises) {
console.log(await textPromise);
}
}上面代码中，虽然map方法的参数是async函数，但它是并发执行的，因为只有async函数内部是继发执行，外部不受影响。后面的for..of循环内部使用了await，因此实现了按顺序输出。
异步遍历器
相关内容暂时略过了