async await 代码风格指南

async 函数的特性

1
> const asyncFunction = async () => {};
2
> typeof asyncFunction
3
< 'function'
4
5
> asyncFunction.constructor.name
6
< "AsyncFunction"

no-return-promise

如果可以直接返回一个值,不需要把它包裹在 Promise.resolve 里,因为 async 函数会通过一个隐式的 Promise 返回其结果。

1
// bad
2
const foo = async () => Promise.resolve(0);
3
4
// good
5
const foo = async () => 0;

no-return-await

不应该在 async function,中 return await。因为 async function 的返回值总是封装在 Promise.resolvereturn await 实际上并没有做任何事情,只是在 Promise resolvereject 之前增加了额外的时间。ESLint

1
// bad
2
const foo = async () => {
3
  return await bar();
4
}
5
6
// still bad
7
const foo = async () => {
8
  const result = await bar();
9
  return result;
10
}
11
12
// good
13
const foo = async () => {
14
  return bar();
15
}

唯一有效是,如果 try/catch 语句中使用 return await 可以来捕获另一个基于 Promise 的函数的错误。

1
// good
2
const foo = async () => {
3
  try {
4
    return await bar();
5
  } catch (error) {}
6
}

由于 async 函数返回值封装在 Promise.resolve,下面两个写法的实际表现相同的:

1
const foo = async () => {
2
  const result = await bar();
3
  return result;
4
}
5
6
const foo = async () => {
7
  const result = bar();
8
  return Promise.resolve(result);
9
}

await-promise

并不一定要 await asyncFunction() 可以直接 await promise,这样你可以控制发起 promise 的时间,注意以下代码的不同:

1
function delay(delay) {
2
  return new Promise(resolve => {
3
    setTimeout(() => {
4
      resolve('resolved');
5
    }, delay);
6
  });
7
}
8
async function asyncCall() {
9
  // 1. wait for 3000 ms
10
  console.log(await delay(1000));
11
  console.log(await delay(2000));
12
13
  // 2. wait for 2000 ms
14
  const foo = delay(1000);
15
  const bar = delay(2000);
16
  console.log(await foo); // after 1000 ms
17
  console.log(await bar); // after 2000 ms
18
19
  // 3. wait for 2000 ms
20
  const foo = delay(1000);
21
  const bar = delay(2000);
22
  console.log(await bar); // after 2000 ms
23
  console.log(await foo); // after 2000 ms
24
}
25
asyncCall();
26
27
// 4. wait for 2000 ms
28
Promise.all([delay(1000), delay(2000)]).then(([a, b]) => {
29
  console.log(a);
30
  console.log(b);
31
});

对于上述 23,由于现实中难以确定 Promise 的顺序,很少会这样写。