欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

es6 async函数语法实例讲解

程序员文章站 2022-06-15 10:24:03
async函数的语法 async函数的语法规则总体上比较简单,难点是错误处理机制。 返回 Promise 对象 async函数返回一个 Promise 对象。 async函...

async函数的语法

async函数的语法规则总体上比较简单,难点是错误处理机制。

返回 Promise 对象

async函数返回一个 Promise 对象。

async函数内部return语句返回的值,会成为then方法回调函数的参数。

async function f() {

return 'hello world';

}

f().then(v => console.log(v))

// "hello world"

上面代码中,函数f内部return命令返回的值,会被then方法回调函数接收到。

async函数内部抛出错误,会导致返回的 Promise 对象变为reject状态。抛出的错误对象会被catch方法回调函数接收到。

async function f() {

throw new Error('出错了');

}

f().then(

v => console.log(v),

e => console.log(e)

)

// Error: 出错了

Promise 对象的状态变化

ES6 async函数返回的 Promise 对象,必须等到内部所有await命令后面的 Promise

 对象执行完,才会发生状态改变,除非遇到return语句或者抛出错误。也就是说,只有async函数内部的异步操作执行完,才会执行then方法指定的回调函数。

下面是一个例子。

async function getTitle(url) {

let response = await fetch(url);

let html = await response.text();

return html.match(/<title>([\s\S]+)<\/title>/i)[1];

}

getTitle('https://tc39.github.io/ecma262/').then(console.log)

// "ECMAScript 2017 Language Specification"

上面代码中,函数getTitle内部有三个操作:抓取网页、取出文本、匹配页面标题。只有这三个操作全部完成,才会执行then方法里面的console.log。

await 命令

正常情况下,await命令后面是一个 Promise 对象。如果不是,会被转成一个立即resolve的

 Promise 对象。

async function f() {

return await 123;

}

f().then(v => console.log(v))

// 123

上面代码中,await命令的参数是数值123,它被转成

 Promise 对象,并立即resolve。

await命令后面的 Promise 对象如果变为reject状态,则reject的参数会被catch方法的回调函数接收到。

async function f() {

await Promise.reject('出错了');

}

f()

.then(v => console.log(v))

.catch(e => console.log(e))

// 出错了

注意,上面代码中,await语句前面没有return,但是reject方法的参数依然传入了catch方法的回调函数。这里如果在await前面加上return,效果是一样的。

只要一个await语句后面的 Promise 变为reject,那么整个async函数都会中断执行。

async function f() {

await Promise.reject('出错了');

await Promise.resolve('hello world'); // 不会执行

}

上面代码中,第二个await语句是不会执行的,因为第一个await语句状态变成了reject。

有时,我们希望即使前一个异步操作失败,也不要中断后面的异步操作。这时可以将第一个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后面的异步操作出错,那么等同于async函数返回的

 Promise 对象被reject。

async function f() {

await new Promise(function (resolve, reject) {

throw new Error('出错了');

});

}

f()

.then(v => console.log(v))

.catch(e => console.log(e))

// Error:出错了

上面代码中,async函数f执行后,await后面的

 Promise 对象会抛出一个错误对象,导致catch方法的回调函数被调用,它的参数就是抛出的错误对象。具体的执行机制,可以参考后文的“async函数的实现原理”。

防止出错的方法,也是将其放在try...catch代码块之中。

async function f() {

try {

await new Promise(function (resolve, reject) {

throw new Error('出错了');

});

} catch(e) {

}

return await('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('https://google.com/this-throws-an-error');

break;

} catch(err) {}

}

console.log(i); // 3

}

test();

上面代码中,如果await操作成功,就会使用break语句退出循环;如果失败,会被catch语句捕捉,然后进入下一轮循环。

使用注意点

第一点,前面已经说过,await命令后面的Promise对象,运行结果可能是rejected,所以最好把await命令放在try...catch代码块中。

async function myFunction() {

try {

await somethingThatReturnsAPromise();

} catch (err) {

console.log(err);

}

}

// 另一种写法

async function myFunction() {

await somethingThatReturnsAPromise()

.catch(function (err) {

console.log(err);

});

}

第二点,多个await命令后面的异步操作,如果不存在继发关系,最好让它们同时触发。

let foo = await getFoo();

let bar = await getBar();

上面代码中,getFoo和getBar是两个独立的异步操作(即互不依赖),被写成继发关系。这样比较耗时,因为只有getFoo完成以后,才会执行getBar,完全可以让它们同时触发。

// 写法一

let [foo, bar] = await Promise.all([getFoo(), getBar()]);

// 写法二

let fooPromise = getFoo();

let barPromise = getBar();

let foo = await fooPromise;

let bar = await barPromise;

上面两种写法,getFoo和getBar都是同时触发,这样就会缩短程序的执行时间。

第三点,await命令只能用在async函数之中,如果用在普通函数,就会报错。

async function dbFuc(db) {

let docs = [{}, {}, {}];

// 报错

docs.forEach(function (doc) {

await db.post(doc);

});

}

上面代码会报错,因为await用在普通函数之中了。但是,如果将forEach方法的参数改成async函数,也有问题。

function dbFuc(db) { //这里不需要 async

let docs = [{}, {}, {}];

// 可能得到错误结果

docs.forEach(async function (doc) {

await db.post(doc);

});

}

上面代码可能不会正常工作,原因是这时三个db.post操作将是并发执行,也就是同时执行,而不是继发执行。正确的写法是采用for循环。

async function dbFuc(db) {

let docs = [{}, {}, {}];

for (let doc of docs) {

await db.post(doc);

}

}

如果确实希望多个请求并发执行,可以使用Promise.all方法。当三个请求都会resolved时,下面两种写法效果相同。

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

}

目前,@std/esm模块加载器支持顶层await,即await命令可以不放在

 async函数里面,直接使用。

// async函数的写法

const start = async () => {

const res = await fetch('google.com');

return res.text();

};

start().then(console.log);

// 顶层 await 的写法

const res = await fetch('google.com');

console.log(await res.text());

上面代码中,第二种写法的脚本必须使用@std/esm加载器,才会生效。