JS async function

🌙
手机阅读
本文目录结构

功能

async function 用来定义一个返回 AsyncFunction 对象的异步函数。异步函数是指通过事件循环异步执行的函数,它会通过一个隐式的 Promise 返回其结果。如果你在代码中使用了异步函数,就会发现它的语法和结构会更像是标准的同步函数。

你还可以使用 异步函数表达式 来定义异步函数。

演示

function resolveAfter2Seconds() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve('resolved');
    }, 2000);
  });
}

async function asyncCall() {
  console.log('calling');
  var result = await resolveAfter2Seconds();
  console.log(result);
  // expected output: 'resolved'
}

asyncCall();

语法

async function name([param[, param[, ... param]]]) { statements }

参数

name

函数名称。

param

要传递给函数的参数。

statements

函数体语句。

返回值

返回的 Promise 对象会运行执行 (resolve) 异步函数的返回结果,或者运行拒绝 (reject)——如果异步函数抛出异常的话。

描述

异步函数可以包含 await 指令,该指令会暂停异步函数的执行,并等待 Promise 执行,然后继续执行异步函数,并返回结果。

记住,await 关键字只在异步函数内有效。如果你在异步函数外使用它,会抛出语法错误。

注意,当异步函数暂停时,它调用的函数会继续执行(收到异步函数返回的隐式 Promise)

async/await 的目的是简化使用多个 promise 时的同步行为,并对一组 Promises 执行某些操作。正如 Promises 类似于结构化回调,async/await 更像结合了 generators 和 promises。

示例

简单例子

var resolveAfter2Seconds = function() {
  console.log("starting slow promise");
  return new Promise(resolve => {
    setTimeout(function() {
      resolve("slow");
      console.log("slow promise is done");
    }, 2000);
  });
};

var resolveAfter1Second = function() {
  console.log("starting fast promise");
  return new Promise(resolve => {
    setTimeout(function() {
      resolve("fast");
      console.log("fast promise is done");
    }, 1000);
  });
};

var sequentialStart = async function() {
  console.log('==SEQUENTIAL START==');

  // 1. Execution gets here almost instantly
  const slow = await resolveAfter2Seconds();
  console.log(slow); // 2. this runs 2 seconds after 1.

  const fast = await resolveAfter1Second();
  console.log(fast); // 3. this runs 3 seconds after 1.
}

var concurrentStart = async function() {
  console.log('==CONCURRENT START with await==');
  const slow = resolveAfter2Seconds(); // starts timer immediately
  const fast = resolveAfter1Second(); // starts timer immediately

  // 1. Execution gets here almost instantly
  console.log(await slow); // 2. this runs 2 seconds after 1.
  console.log(await fast); // 3. this runs 2 seconds after 1., immediately after 2., since fast is already resolved
}

var concurrentPromise = function() {
  console.log('==CONCURRENT START with Promise.all==');
  return Promise.all([resolveAfter2Seconds(), resolveAfter1Second()]).then((messages) => {
    console.log(messages[0]); // slow
    console.log(messages[1]); // fast
  });
}

var parallel = async function() {
  console.log('==PARALLEL with await Promise.all==');

  // Start 2 "jobs" in parallel and wait for both of them to complete
  await Promise.all([
      (async()=>console.log(await resolveAfter2Seconds()))(),
      (async()=>console.log(await resolveAfter1Second()))()
  ]);
}

// This function does not handle errors. See warning below!
var parallelPromise = function() {
  console.log('==PARALLEL with Promise.then==');
  resolveAfter2Seconds().then((message)=>console.log(message));
  resolveAfter1Second().then((message)=>console.log(message));
}

sequentialStart(); // after 2 seconds, logs "slow", then after 1 more second, "fast"

// wait above to finish
setTimeout(concurrentStart, 4000); // after 2 seconds, logs "slow" and then "fast"

// wait again
setTimeout(concurrentPromise, 7000); // same as concurrentStart

// wait again
setTimeout(parallel, 10000); // truly parallel: after 1 second, logs "fast", then after 1 more second, "slow"

// wait again
setTimeout(parallelPromise, 13000); // same as parallel

await and parallelism(并行) 在 sequentialStart 中,程序在第一个 await 停留了 2 秒,然后又在第二个 await 停留了 1 秒。直到第一个计时器结束后,第二个计时器才被创建。程序需要 3 秒执行完毕。

在 concurrentStart 中,两个计时器被同时创建,然后执行 await。这两个计时器同时运行,这意味着程序完成运行只需要 2 秒,而不是 3 秒,即最慢的计时器的时间。

但是 await 仍旧是顺序执行的,第二个 await 还是得等待第一个执行完。在这个例子中,这使得先运行结束的输出出现在最慢的输出之后。

如果你希望并行执行两个或更多的任务,你必须像在 parallel 中一样使用 await Promise.all([job1(), job2()])。

请注意下面情况

async/await 和 Promise#then 对比以及错误处理

大多数异步函数也可以使用 Promises 编写。但是,在错误处理方面,async 函数更容易捕获异常错误

上面例子中的 concurrentStart 函数和 concurrentPromise 函数在功能上都是等效的。在 concurrentStart 函数中,如果任一 awaited 调用失败,它将自动捕获异常,异步函数执行中断,并通过隐式返回 Promise 将错误传递给调用者。

在 Promise 例子中这种情况同样会发生,该函数必须负责返回一个捕获函数完成的 Promise。在 concurrentPromise 函数中,这意味着它从 Promise.all([]).then() 返回一个 Promise。事实上,在此示例的先前版本忘记了这样做!

但是,async 函数仍有可能然可能错误地忽略错误。

以 parallel 异步函数为例。 如果它没有等待 await(或返回)Promise.all([]) 调用的结果,则不会传播任何错误。

虽然 parallelPromise 函数示例看起来很简单,但它根本不会处理错误! 这样做需要一个类似于 return Promise.all([]) 处理方式。

使用 async 函数重写 promise 链

返回 Promise 的 API 将会产生一个 promise 链,它将函数肢解成许多部分。例如下面的代码:

function getProcessedData(url) {
  return downloadData(url) // 返回一个 promise 对象
    .catch(e => {
      return downloadFallbackData(url)  // 返回一个 promise 对象
    })
    .then(v => {
      return processDataInWorker(v); // 返回一个 promise 对象
    });
}

可以重写为单个 async 函数:

async function getProcessedData(url) {
  let v;
  try {
    v = await downloadData(url);
  } catch (e) {
    v = await downloadFallbackData(url);
  }
  return processDataInWorker(v);
}

注意,在上述示例中,return 语句中没有 await 操作符,因为 async function 的返回值将被隐式地传递给 Promise.resolve。

return await promiseValue; 与 return promiseValue; 的比较

返回值隐式的传递给 Promise.resolve,并不意味着 return await promiseValue; 和 return promiseValue; 在功能上相同。

看下下面重写的上面代码,在 processDataInWorker 抛出异常时返回了 null:

async function getProcessedData(url) {
  let v;
  try {
    v = await downloadData(url);
  } catch(e) {
    v = await downloadFallbackData(url);
  }
  try {
    return await processDataInWorker(v); // 注意 `return await` 和单独 `return` 的比较
  } catch (e) {
    return null;
  }
}

简单地写上 return processDataInworker(v); 将导致在 processDataInWorker(v) 出错时 function 返回值为 Promise 而不是返回 null。return foo; 和 return await foo;,有一些细微的差异:return foo; 不管 foo 是 promise 还是 rejects 都将会直接返回 foo。相反地,如果 foo 是一个 Promise,return await foo; 将等待 foo 执行 (resolve) 或拒绝 (reject),如果是拒绝,将会在返回前抛出异常。

规范

Specification Status Comment
ECMAScript Latest Draft (ECMA-262)
async function
Draft 初始定义于 ES2017.
ECMAScript 2017 (ECMA-262)
async function
Standard

AXIHE / 精选资源

浏览全部教程

面试题

学习网站

前端培训
自己甄别

前端书籍

关于朱安邦

我叫 朱安邦,阿西河的站长,在杭州。

以前是一名平面设计师,后来开始接接触前端开发,主要研究前端技术中的JS方向。

业余时间我喜欢分享和交流自己的技术,欢迎大家关注我的 Bilibili

关注我: Github / 知乎

目前重心已经放在研究区块链上面了

我叫朱安邦,阿西河的站长

目前在杭州从事区块链周边的开发工作,机械专业,以前从事平面设计工作。

2014年底脱产在老家自学6个月的前端技术,自学期间几乎从未出过家门,最终找到了满意的前端工作。更多>