36. 异步函数

async function fetchJsonAsync(url) {
  try {
    const request = await fetch(url); // async
    const text = await request.text(); // async
    return JSON.parse(text); // sync
  }
  catch (error) {
    assert.fail(error);
  }
}

function fetchJsonViaPromises(url) {
  return fetch(url) // async
  .then(request => request.text()) // async
  .then(text => JSON.parse(text)) // sync
  .catch(error => {
    assert.fail(error);
  });
}

• 异步函数标有关键字async。
• 在异步函数体内，您可以编写基于 Promise 的代码，就好像它是同步的一样。只要其值为 Promise，您只需要添加await运算符。该运算符暂停异步函数并在 Promise 结算后恢复：
  • 如果那个 Promise 被履行，await将返回其履行值。
  • 如果那个 Promise 被拒绝，await会抛出其拒绝值。
• 异步函数的结果始终是一个 Promise：
  • 返回的任何值（显式或隐式）用于实现 Promise。
  • 抛出的任何异常都用于拒绝 Promise。

fetchJsonAsync('http://example.com/person.json')
.then(obj => {
  assert.deepEqual(obj, {
    first: 'Jane',
    last: 'Doe',
  });
});

// Async function declaration
async function func1() {}
// Async function expression
const func2 = async function () {};
// Async arrow function
const func3 = async () => {};
// Async method definition (in classes, too)
const obj = { async m() {} };

async function asyncFunc() {
  return 123; // (A)
}
asyncFunc()
.then(result => {
  assert.equal(result, 123);
});

async function asyncFunc() {
}
asyncFunc()
.then(result => {
  assert.equal(result, undefined);
});

let thrownError;
async function asyncFunc() {
  thrownError = new Error('Problem!');
  throw thrownError; // (A)
}
asyncFunc()
.catch(err => {
  assert.equal(err, thrownError);
});

async function asyncFunc() {
  return Promise.resolve('abc');
}
asyncFunc()
.then(result => assert.equal(result, 'abc'));

• new Promise((resolve, reject) => { ··· })内的resolve(q)
• .then(result => { ··· })内的return q
• .catch(err => { ··· })内的return q

• 当前的异步功能被暂停（类似于使用yield时同步生成器是如何暂停一样）。
• 继续处理任务队列。
• 一旦 Promise 得到解决，异步函数就会恢复：
  • 如果 Promise 被履行，await将返回履行值。
  • 如果 Promise 被拒绝，await会抛出拒绝值。

• 如果其操作对象最终成为被履行的 Promise，await将返回其履行值：

  assert.equal(await Promise.resolve('yes!'), 'yes!');
  

• 也允许非 Promise 值，并简单地传递（同步，没有异步函数的暂停）：

  assert.equal(await 'yes!', 'yes!');
  

• 如果其操作对象是被拒绝的 Promise，则await会抛出拒绝值：

  try {
    await Promise.reject(new Error());
    assert.fail(); // we never get here
  } catch (e) {
    assert.equal(e instanceof Error, true);
  }
  

• Error的实例（包括其子类的实例）将被特别处理并抛出：

  try {
    await new Error();
    assert.fail(); // we never get here
  } catch (e) {
    assert.equal(e instanceof Error, true);
  }
  

练习：Fetch API 通过异步函数

exercises/async-functions/fetch_json2_test.js

• 异步函数，异步方法：使用关键字async定义。异步函数也称为 _async/await ，基于作为其语法基础的两个关键字。
• 直接使用 Promise ：意味着代码在没有await的情况下处理 Promise。
• 基于 Promise 的：通过 Promises 提供结果和错误的函数或方法。也就是说，异步函数和返回 Promises 的函数都是合格的。
• 异步：异步地传递结果和错误的函数或方法。这里，任何使用异步模式（回调，事件，Promise 等）的操作都是合格的。唉，事情有点令人困惑，因为“异步函数(async function)”中的“异步(async)”是“异步(asynchronous)”的缩写。

async function downloadContent(urls) {
  return urls.map((url) => {
    return await httpGet(url); // SyntaxError!
  });
}

async function downloadContent(urls) {
  return urls.map(async (url) => {
    return await httpGet(url);
  });
}

async function downloadContent(urls) {
  const promiseArray = urls.map(async (url) => {
    return await httpGet(url); // (A)
  });
  return await Promise.all(promiseArray);
}

async function downloadContent(urls) {
  const promiseArray = urls.map(
    url => httpGet(url));
  return await Promise.all(promiseArray); // (B)
}

练习：异步映射和过滤

exercises/async-functions/map_async_test.js

(async () => { // start
  const promise = Promise.resolve('abc');
  const value = await promise;
  assert.equal(value, 'abc');
})(); // end

const promise = (async () => 123)();
promise.then(x => assert.equal(x, 123));

const otherAsyncFunc1 = () => Promise.resolve('one');
const otherAsyncFunc2 = () => Promise.resolve('two');
async function asyncFunc() {
  const result1 = await otherAsyncFunc1();
  assert.equal(result1, 'one');
  const result2 = await otherAsyncFunc2();
  assert.equal(result2, 'two');
}

async function asyncFunc() {
  const [result1, result2] = await Promise.all([
    otherAsyncFunc1(),
    otherAsyncFunc2(),
  ]);
  assert.equal(result1, 'one');
  assert.equal(result2, 'two');
}

async function asyncFunc() {
  const promise1 = otherAsyncFunc1();
  const promise2 = otherAsyncFunc2();
  const result1 = await promise1;
  const result2 = await promise2;
  assert.equal(result1, 'one');
  assert.equal(result2, 'two');
}

• 当异步函数启动时会创建其结果的 Promise p。
• 然后函数体被执行。执行可以通过两种方式返回：
  • 执行可以永久返回，同时结算p：
    • return一个已满足的p。
    • throw一个被拒绝的p。
  • 执行也可以暂时离开，当通过await等待另一个 Promise q的结算时。异步函数被暂停，执行离开它。一旦q被结算，它就会恢复。
• Promise p在执行首次（永久或暂时）离开函数体后返回。

async function asyncFunc() {
  console.log('asyncFunc() starts'); // (A)
  return 'abc';
}
asyncFunc().
then(x => { // (B)
  console.log(`Resolved: ${x}`);
});
console.log('Task ends'); // (C)
// Output:
// 'asyncFunc() starts'
// 'Task ends'
// 'Resolved: abc'

async function asyncFunc() {
  const writer = openFile('someFile.txt');
  writer.write('hello'); // don't wait
  writer.write('world'); // don't wait
  await writer.close(); // wait for file to close
}

await longRunningAsyncOperation();
console.log('Done!');