含义
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,因此实现了按顺序输出。
异步遍历器
相关内容暂时略过了