含義

ES2017 標(biāo)準(zhǔn)引入了 async 函數(shù)，使得異步操作變得更加方便蜂筹。

async 函數(shù)是什么幅慌？一句話聘裁，它就是 Generator 函數(shù)的語(yǔ)法糖雪营。

前文有一個(gè) Generator 函數(shù)，依次讀取兩個(gè)文件衡便。

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

上面代碼的函數(shù)gen可以寫成async函數(shù)献起，就是下面這樣。

const asyncReadFile = async function () {
  const f1 = await readFile('/etc/fstab');
  const f2 = await readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

一比較就會(huì)發(fā)現(xiàn)镣陕，async函數(shù)就是將 Generator 函數(shù)的星號(hào)（*）替換成async谴餐，將yield替換成await，僅此而已茁彭。

async函數(shù)對(duì) Generator 函數(shù)的改進(jìn)总寒，體現(xiàn)在以下四點(diǎn)。

（1）內(nèi)置執(zhí)行器理肺。

Generator 函數(shù)的執(zhí)行必須靠執(zhí)行器摄闸，所以才有了co模塊善镰，而async函數(shù)自帶執(zhí)行器。也就是說(shuō)年枕，async函數(shù)的執(zhí)行炫欺，與普通函數(shù)一模一樣，只要一行熏兄。

asyncReadFile();

上面的代碼調(diào)用了asyncReadFile函數(shù)品洛，然后它就會(huì)自動(dòng)執(zhí)行，輸出最后結(jié)果摩桶。這完全不像 Generator 函數(shù)桥状，需要調(diào)用next方法，或者用co模塊硝清，才能真正執(zhí)行辅斟，得到最后結(jié)果。

（2）更好的語(yǔ)義芦拿。

async和await士飒，比起星號(hào)和yield，語(yǔ)義更清楚了蔗崎。async表示函數(shù)里有異步操作酵幕，await表示緊跟在后面的表達(dá)式需要等待結(jié)果。

（3）更廣的適用性缓苛。

co模塊約定芳撒，yield命令后面只能是 Thunk 函數(shù)或 Promise 對(duì)象，而async函數(shù)的await命令后面他嫡，可以是 Promise 對(duì)象和原始類型的值（數(shù)值番官、字符串和布爾值，但這時(shí)會(huì)自動(dòng)轉(zhuǎn)成立即 resolved 的 Promise 對(duì)象）钢属。

（4）返回值是 Promise徘熔。

async函數(shù)的返回值是 Promise 對(duì)象，這比 Generator 函數(shù)的返回值是 Iterator 對(duì)象方便多了淆党。你可以用then方法指定下一步的操作酷师。

進(jìn)一步說(shuō)，async函數(shù)完全可以看作多個(gè)異步操作染乌，包裝成的一個(gè) Promise 對(duì)象山孔，而await命令就是內(nèi)部then命令的語(yǔ)法糖。

基本用法

async函數(shù)返回一個(gè) Promise 對(duì)象荷憋，可以使用then方法添加回調(diào)函數(shù)台颠。當(dāng)函數(shù)執(zhí)行的時(shí)候，一旦遇到await就會(huì)先返回，等到異步操作完成串前，再接著執(zhí)行函數(shù)體內(nèi)后面的語(yǔ)句瘫里。

下面是一個(gè)例子。

async function getStockPriceByName(name) {
  const symbol = await getStockSymbol(name);
  const stockPrice = await getStockPrice(symbol);
  return stockPrice;
}

getStockPriceByName('goog').then(function (result) {
  console.log(result);
});

上面代碼是一個(gè)獲取股票報(bào)價(jià)的函數(shù)荡碾，函數(shù)前面的async關(guān)鍵字谨读，表明該函數(shù)內(nèi)部有異步操作。調(diào)用該函數(shù)時(shí)坛吁，會(huì)立即返回一個(gè)Promise對(duì)象劳殖。

下面是另一個(gè)例子，指定多少毫秒后輸出一個(gè)值拨脉。

function timeout(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

async function asyncPrint(value, ms) {
  await timeout(ms);
  console.log(value);
}

asyncPrint('hello world', 50);

上面代碼指定 50 毫秒以后哆姻，輸出hello world。

由于async函數(shù)返回的是 Promise 對(duì)象女坑，可以作為await命令的參數(shù)填具。所以，上面的例子也可以寫成下面的形式匆骗。

async function timeout(ms) {
  await new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

async function asyncPrint(value, ms) {
  await timeout(ms);
  console.log(value);
}

asyncPrint('hello world', 50);

async 函數(shù)有多種使用形式。

// 函數(shù)聲明
async function foo() {}

// 函數(shù)表達(dá)式
const foo = async function () {};

// 對(duì)象的方法
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(…);

// 箭頭函數(shù)
const foo = async () => {};

語(yǔ)法

async函數(shù)的語(yǔ)法規(guī)則總體上比較簡(jiǎn)單誉简，難點(diǎn)是錯(cuò)誤處理機(jī)制碉就。

返回 Promise 對(duì)象

async函數(shù)返回一個(gè) Promise 對(duì)象。

async函數(shù)內(nèi)部return語(yǔ)句返回的值闷串，會(huì)成為then方法回調(diào)函數(shù)的參數(shù)瓮钥。

async function f() {
  return 'hello world';
}

f().then(v => console.log(v))
// "hello world"

上面代碼中，函數(shù)f內(nèi)部return命令返回的值烹吵，會(huì)被then方法回調(diào)函數(shù)接收到碉熄。

async函數(shù)內(nèi)部拋出錯(cuò)誤，會(huì)導(dǎo)致返回的 Promise 對(duì)象變?yōu)?code>reject狀態(tài)肋拔。拋出的錯(cuò)誤對(duì)象會(huì)被catch方法回調(diào)函數(shù)接收到锈津。

async function f() {
  throw new Error('出錯(cuò)了');
}

f().then(
  v => console.log('resolve', v),
  e => console.log('reject', e)
)
//reject Error: 出錯(cuò)了

Promise 對(duì)象的狀態(tài)變化

async函數(shù)返回的 Promise 對(duì)象，必須等到內(nèi)部所有await命令后面的 Promise 對(duì)象執(zhí)行完凉蜂，才會(huì)發(fā)生狀態(tài)改變琼梆，除非遇到return語(yǔ)句或者拋出錯(cuò)誤。也就是說(shuō)窿吩，只有async函數(shù)內(nèi)部的異步操作執(zhí)行完茎杂，才會(huì)執(zhí)行then方法指定的回調(diào)函數(shù)。

下面是一個(gè)例子纫雁。

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"

上面代碼中潮尝，函數(shù)getTitle內(nèi)部有三個(gè)操作：抓取網(wǎng)頁(yè)、取出文本楣号、匹配頁(yè)面標(biāo)題。只有這三個(gè)操作全部完成羞海，才會(huì)執(zhí)行then方法里面的console.log。

await 命令

正常情況下曾棕，await命令后面是一個(gè) Promise 對(duì)象扣猫，返回該對(duì)象的結(jié)果。如果不是 Promise 對(duì)象翘地，就直接返回對(duì)應(yīng)的值申尤。

async function f() {
  // 等同于
  // return 123;
  return await 123;
}

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

上面代碼中，await命令的參數(shù)是數(shù)值123衙耕，這時(shí)等同于return 123昧穿。

另一種情況是，await命令后面是一個(gè)thenable對(duì)象（即定義了then方法的對(duì)象）橙喘，那么await會(huì)將其等同于 Promise 對(duì)象时鸵。

class Sleep {
  constructor(timeout) {
    this.timeout = timeout;
  }
  then(resolve, reject) {
    const startTime = Date.now();
    setTimeout(
      () => resolve(Date.now() - startTime),
      this.timeout
    );
  }
}

(async () => {
  const sleepTime = await new Sleep(1000);
  console.log(sleepTime);
})();
// 1000

上面代碼中，await命令后面是一個(gè)Sleep對(duì)象的實(shí)例厅瞎。這個(gè)實(shí)例不是 Promise 對(duì)象饰潜，但是因?yàn)槎x了then方法，await會(huì)將其視為Promise處理和簸。

這個(gè)例子還演示了如何實(shí)現(xiàn)休眠效果彭雾。JavaScript 一直沒(méi)有休眠的語(yǔ)法，但是借助await命令就可以讓程序停頓指定的時(shí)間锁保。下面給出了一個(gè)簡(jiǎn)化的sleep實(shí)現(xiàn)薯酝。

function sleep(interval) {
  return new Promise(resolve => {
    setTimeout(resolve, interval);
  })
}

// 用法
async function one2FiveInAsync() {
  for(let i = 1; i <= 5; i++) {
    console.log(i);
    await sleep(1000);
  }
}

one2FiveInAsync();

await命令后面的 Promise 對(duì)象如果變?yōu)?code>reject狀態(tài)，則reject的參數(shù)會(huì)被catch方法的回調(diào)函數(shù)接收到爽柒。

async function f() {
  await Promise.reject('出錯(cuò)了');
}

f()
.then(v => console.log(v))
.catch(e => console.log(e))
// 出錯(cuò)了

注意吴菠，上面代碼中，await語(yǔ)句前面沒(méi)有return浩村，但是reject方法的參數(shù)依然傳入了catch方法的回調(diào)函數(shù)做葵。這里如果在await前面加上return，效果是一樣的穴亏。

任何一個(gè)await語(yǔ)句后面的 Promise 對(duì)象變?yōu)?code>reject狀態(tài)蜂挪，那么整個(gè)async函數(shù)都會(huì)中斷執(zhí)行。

async function f() {
  await Promise.reject('出錯(cuò)了');
  await Promise.resolve('hello world'); // 不會(huì)執(zhí)行
}

上面代碼中嗓化，第二個(gè)await語(yǔ)句是不會(huì)執(zhí)行的棠涮，因?yàn)榈谝粋€(gè)await語(yǔ)句狀態(tài)變成了reject。

有時(shí)刺覆，我們希望即使前一個(gè)異步操作失敗严肪，也不要中斷后面的異步操作。這時(shí)可以將第一個(gè)await放在try...catch結(jié)構(gòu)里面，這樣不管這個(gè)異步操作是否成功驳糯，第二個(gè)await都會(huì)執(zhí)行篇梭。

async function f() {
  try {
    await Promise.reject('出錯(cuò)了');
  } catch(e) {
  }
  return await Promise.resolve('hello world');
}

f()
.then(v => console.log(v))
// hello world

另一種方法是await后面的 Promise 對(duì)象再跟一個(gè)catch方法，處理前面可能出現(xiàn)的錯(cuò)誤酝枢。

async function f() {
  await Promise.reject('出錯(cuò)了')
    .catch(e => console.log(e));
  return await Promise.resolve('hello world');
}

f()
.then(v => console.log(v))
// 出錯(cuò)了
// hello world

錯(cuò)誤處理

如果await后面的異步操作出錯(cuò)恬偷，那么等同于async函數(shù)返回的 Promise 對(duì)象被reject。

async function f() {
  await new Promise(function (resolve, reject) {
    throw new Error('出錯(cuò)了');
  });
}

f()
.then(v => console.log(v))
.catch(e => console.log(e))
// Error：出錯(cuò)了

上面代碼中帘睦，async函數(shù)f執(zhí)行后袍患，await后面的 Promise 對(duì)象會(huì)拋出一個(gè)錯(cuò)誤對(duì)象，導(dǎo)致catch方法的回調(diào)函數(shù)被調(diào)用竣付，它的參數(shù)就是拋出的錯(cuò)誤對(duì)象诡延。具體的執(zhí)行機(jī)制，可以參考后文的“async 函數(shù)的實(shí)現(xiàn)原理”古胆。

防止出錯(cuò)的方法肆良，也是將其放在try...catch代碼塊之中。

async function f() {
  try {
    await new Promise(function (resolve, reject) {
      throw new Error('出錯(cuò)了');
    });
  } catch(e) {
  }
  return await('hello world');
}

如果有多個(gè)await命令逸绎，可以統(tǒng)一放在try...catch結(jié)構(gòu)中惹恃。

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結(jié)構(gòu)，實(shí)現(xiàn)多次重復(fù)嘗試棺牧。

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

上面代碼中座舍，如果await操作成功，就會(huì)使用break語(yǔ)句退出循環(huán)陨帆；如果失敗，會(huì)被catch語(yǔ)句捕捉采蚀，然后進(jìn)入下一輪循環(huán)疲牵。

使用注意點(diǎn)

第一點(diǎn)，前面已經(jīng)說(shuō)過(guò)榆鼠，await命令后面的Promise對(duì)象纲爸，運(yùn)行結(jié)果可能是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);
  });
}

第二點(diǎn)识啦，多個(gè)await命令后面的異步操作，如果不存在繼發(fā)關(guān)系神妹，最好讓它們同時(shí)觸發(fā)颓哮。

let foo = await getFoo();
let bar = await getBar();

上面代碼中，getFoo和getBar是兩個(gè)獨(dú)立的異步操作（即互不依賴）鸵荠，被寫成繼發(fā)關(guān)系冕茅。這樣比較耗時(shí)，因?yàn)橹挥?code>getFoo完成以后，才會(huì)執(zhí)行getBar姨伤，完全可以讓它們同時(shí)觸發(fā)哨坪。

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

// 寫法二
let fooPromise = getFoo();
let barPromise = getBar();
let foo = await fooPromise;
let bar = await barPromise;

上面兩種寫法，getFoo和getBar都是同時(shí)觸發(fā)乍楚，這樣就會(huì)縮短程序的執(zhí)行時(shí)間当编。

第三點(diǎn)，await命令只能用在async函數(shù)之中徒溪，如果用在普通函數(shù)忿偷，就會(huì)報(bào)錯(cuò)。

async function dbFuc(db) {
  let docs = [{}, {}, {}];

  // 報(bào)錯(cuò)
  docs.forEach(function (doc) {
    await db.post(doc);
  });
}

上面代碼會(huì)報(bào)錯(cuò)词渤，因?yàn)?code>await用在普通函數(shù)之中了牵舱。但是，如果將forEach方法的參數(shù)改成async函數(shù)缺虐，也有問(wèn)題芜壁。

function dbFuc(db) { //這里不需要 async
  let docs = [{}, {}, {}];

  // 可能得到錯(cuò)誤結(jié)果
  docs.forEach(async function (doc) {
    await db.post(doc);
  });
}

上面代碼可能不會(huì)正常工作，原因是這時(shí)三個(gè)db.post()操作將是并發(fā)執(zhí)行高氮，也就是同時(shí)執(zhí)行慧妄，而不是繼發(fā)執(zhí)行。正確的寫法是采用for循環(huán)剪芍。

async function dbFuc(db) {
  let docs = [{}, {}, {}];

  for (let doc of docs) {
    await db.post(doc);
  }
}

另一種方法是使用數(shù)組的reduce()方法塞淹。

async function dbFuc(db) {
  let docs = [{}, {}, {}];

  await docs.reduce(async (_, doc) => {
    await _;
    await db.post(doc);
  }, undefined);
}

上面例子中，reduce()方法的第一個(gè)參數(shù)是async函數(shù)罪裹，導(dǎo)致該函數(shù)的第一個(gè)參數(shù)是前一步操作返回的 Promise 對(duì)象饱普，所以必須使用await等待它操作結(jié)束。另外状共，reduce()方法返回的是docs數(shù)組最后一個(gè)成員的async函數(shù)的執(zhí)行結(jié)果套耕，也是一個(gè) Promise 對(duì)象，導(dǎo)致在它前面也必須加上await峡继。

上面的reduce()的參數(shù)函數(shù)里面沒(méi)有return語(yǔ)句冯袍，原因是這個(gè)函數(shù)的主要目的是db.post()操作，不是返回值碾牌。而且async函數(shù)不管有沒(méi)有return語(yǔ)句康愤，總是返回一個(gè) Promise 對(duì)象，所以這里的return是不必要的舶吗。

如果確實(shí)希望多個(gè)請(qǐng)求并發(fā)執(zhí)行征冷，可以使用Promise.all方法。當(dāng)三個(gè)請(qǐng)求都會(huì)resolved時(shí)裤翩，下面兩種寫法效果相同资盅。

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

第四點(diǎn)调榄，async 函數(shù)可以保留運(yùn)行堆棧。

const a = () => {
  b().then(() => c());
};

上面代碼中呵扛，函數(shù)a內(nèi)部運(yùn)行了一個(gè)異步任務(wù)b()每庆。當(dāng)b()運(yùn)行的時(shí)候，函數(shù)a()不會(huì)中斷今穿，而是繼續(xù)執(zhí)行缤灵。等到b()運(yùn)行結(jié)束，可能a()早就運(yùn)行結(jié)束了蓝晒，b()所在的上下文環(huán)境已經(jīng)消失了腮出。如果b()或c()報(bào)錯(cuò)，錯(cuò)誤堆棧將不包括a()芝薇。

現(xiàn)在將這個(gè)例子改成async函數(shù)胚嘲。

const a = async () => {
  await b();
  c();
};

上面代碼中，b()運(yùn)行的時(shí)候洛二，a()是暫停執(zhí)行馋劈，上下文環(huán)境都保存著。一旦b()或c()報(bào)錯(cuò)晾嘶，錯(cuò)誤堆棧將包括a()妓雾。

async 函數(shù)的實(shí)現(xiàn)原理

async 函數(shù)的實(shí)現(xiàn)原理，就是將 Generator 函數(shù)和自動(dòng)執(zhí)行器垒迂，包裝在一個(gè)函數(shù)里械姻。

async function fn(args) {
  // ...
}

// 等同于

function fn(args) {
  return spawn(function* () {
    // ...
  });
}

所有的async函數(shù)都可以寫成上面的第二種形式，其中的spawn函數(shù)就是自動(dòng)執(zhí)行器机断。

下面給出spawn函數(shù)的實(shí)現(xiàn)楷拳，基本就是前文自動(dòng)執(zhí)行器的翻版。

function spawn(genF) {
  return new Promise(function(resolve, reject) {
    const gen = genF();
    function step(nextF) {
      let next;
      try {
        next = nextF();
      } catch(e) {
        return reject(e);
      }
      if(next.done) {
        return resolve(next.value);
      }
      Promise.resolve(next.value).then(function(v) {
        step(function() { return gen.next(v); });
      }, function(e) {
        step(function() { return gen.throw(e); });
      });
    }
    step(function() { return gen.next(undefined); });
  });
}

與其他異步處理方法的比較

我們通過(guò)一個(gè)例子吏奸，來(lái)看 async 函數(shù)與 Promise唯竹、Generator 函數(shù)的比較。

假定某個(gè) DOM 元素上面苦丁，部署了一系列的動(dòng)畫，前一個(gè)動(dòng)畫結(jié)束物臂，才能開始后一個(gè)旺拉。如果當(dāng)中有一個(gè)動(dòng)畫出錯(cuò)，就不再往下執(zhí)行棵磷，返回上一個(gè)成功執(zhí)行的動(dòng)畫的返回值蛾狗。

首先是 Promise 的寫法。

function chainAnimationsPromise(elem, animations) {

  // 變量ret用來(lái)保存上一個(gè)動(dòng)畫的返回值
  let ret = null;

  // 新建一個(gè)空的Promise
  let p = Promise.resolve();

  // 使用then方法仪媒，添加所有動(dòng)畫
  for(let anim of animations) {
    p = p.then(function(val) {
      ret = val;
      return anim(elem);
    });
  }

  // 返回一個(gè)部署了錯(cuò)誤捕捉機(jī)制的Promise
  return p.catch(function(e) {
    /* 忽略錯(cuò)誤沉桌，繼續(xù)執(zhí)行 */
  }).then(function() {
    return ret;
  });

}

雖然 Promise 的寫法比回調(diào)函數(shù)的寫法大大改進(jìn)谢鹊，但是一眼看上去，代碼完全都是 Promise 的 API（then留凭、catch等等）佃扼，操作本身的語(yǔ)義反而不容易看出來(lái)。

接著是 Generator 函數(shù)的寫法蔼夜。

function chainAnimationsGenerator(elem, animations) {

  return spawn(function*() {
    let ret = null;
    try {
      for(let anim of animations) {
        ret = yield anim(elem);
      }
    } catch(e) {
      /* 忽略錯(cuò)誤兼耀，繼續(xù)執(zhí)行 */
    }
    return ret;
  });

}

上面代碼使用 Generator 函數(shù)遍歷了每個(gè)動(dòng)畫，語(yǔ)義比 Promise 寫法更清晰求冷，用戶定義的操作全部都出現(xiàn)在spawn函數(shù)的內(nèi)部瘤运。這個(gè)寫法的問(wèn)題在于，必須有一個(gè)任務(wù)運(yùn)行器匠题，自動(dòng)執(zhí)行 Generator 函數(shù)拯坟，上面代碼的spawn函數(shù)就是自動(dòng)執(zhí)行器，它返回一個(gè) Promise 對(duì)象韭山，而且必須保證yield語(yǔ)句后面的表達(dá)式郁季，必須返回一個(gè) Promise。

最后是 async 函數(shù)的寫法掠哥。

async function chainAnimationsAsync(elem, animations) {
  let ret = null;
  try {
    for(let anim of animations) {
      ret = await anim(elem);
    }
  } catch(e) {
    /* 忽略錯(cuò)誤巩踏，繼續(xù)執(zhí)行 */
  }
  return ret;
}

可以看到 Async 函數(shù)的實(shí)現(xiàn)最簡(jiǎn)潔，最符合語(yǔ)義续搀，幾乎沒(méi)有語(yǔ)義不相關(guān)的代碼塞琼。它將 Generator 寫法中的自動(dòng)執(zhí)行器，改在語(yǔ)言層面提供禁舷，不暴露給用戶彪杉，因此代碼量最少。如果使用 Generator 寫法牵咙，自動(dòng)執(zhí)行器需要用戶自己提供派近。

實(shí)例：按順序完成異步操作

實(shí)際開發(fā)中，經(jīng)常遇到一組異步操作洁桌，需要按照順序完成渴丸。比如，依次遠(yuǎn)程讀取一組 URL另凌，然后按照讀取的順序輸出結(jié)果谱轨。

Promise 的寫法如下。

function logInOrder(urls) {
  // 遠(yuǎn)程讀取所有URL
  const textPromises = urls.map(url => {
    return fetch(url).then(response => response.text());
  });

  // 按次序輸出
  textPromises.reduce((chain, textPromise) => {
    return chain.then(() => textPromise)
      .then(text => console.log(text));
  }, Promise.resolve());
}

上面代碼使用fetch方法吠谢，同時(shí)遠(yuǎn)程讀取一組 URL土童。每個(gè)fetch操作都返回一個(gè) Promise 對(duì)象，放入textPromises數(shù)組工坊。然后献汗，reduce方法依次處理每個(gè) Promise 對(duì)象敢订，然后使用then，將所有 Promise 對(duì)象連起來(lái)罢吃，因此就可以依次輸出結(jié)果楚午。

這種寫法不太直觀，可讀性比較差刃麸。下面是 async 函數(shù)實(shí)現(xiàn)醒叁。

async function logInOrder(urls) {
  for (const url of urls) {
    const response = await fetch(url);
    console.log(await response.text());
  }
}

上面代碼確實(shí)大大簡(jiǎn)化，問(wèn)題是所有遠(yuǎn)程操作都是繼發(fā)泊业。只有前一個(gè) URL 返回結(jié)果把沼，才會(huì)去讀取下一個(gè) URL，這樣做效率很差吁伺，非常浪費(fèi)時(shí)間饮睬。我們需要的是并發(fā)發(fā)出遠(yuǎn)程請(qǐng)求。

async function logInOrder(urls) {
  // 并發(fā)讀取遠(yuǎn)程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方法的參數(shù)是async函數(shù)捆愁，但它是并發(fā)執(zhí)行的，因?yàn)橹挥?code>async函數(shù)內(nèi)部是繼發(fā)執(zhí)行窟却，外部不受影響昼丑。后面的for..of循環(huán)內(nèi)部使用了await，因此實(shí)現(xiàn)了按順序輸出夸赫。

頂層 await

根據(jù)語(yǔ)法規(guī)格菩帝，await命令只能出現(xiàn)在 async 函數(shù)內(nèi)部，否則都會(huì)報(bào)錯(cuò)茬腿。

// 報(bào)錯(cuò)
const data = await fetch('https://api.example.com');

上面代碼中呼奢，await命令獨(dú)立使用，沒(méi)有放在 async 函數(shù)里面切平，就會(huì)報(bào)錯(cuò)握础。

目前，有一個(gè)語(yǔ)法提案悴品，允許在模塊的頂層獨(dú)立使用await命令禀综，使得上面那行代碼不會(huì)報(bào)錯(cuò)了。這個(gè)提案的目的苔严，是借用await解決模塊異步加載的問(wèn)題菇存。

// awaiting.js
let output;
async function main() {
 const dynamic = await import(someMission);
 const data = await fetch(url);
 output = someProcess(dynamic.default, data);
}
main();
export { output };

上面代碼中，模塊awaiting.js的輸出值output邦蜜，取決于異步操作。我們把異步操作包裝在一個(gè) async 函數(shù)里面亥至，然后調(diào)用這個(gè)函數(shù)悼沈，只有等里面的異步操作都執(zhí)行贱迟，變量output才會(huì)有值，否則就返回undefined絮供。

上面的代碼也可以寫成立即執(zhí)行函數(shù)的形式衣吠。

// awaiting.js
let output;
(async function main() {
  const dynamic = await import(someMission);
  const data = await fetch(url);
  output = someProcess(dynamic.default, data);
})();
export { output };

下面是加載這個(gè)模塊的寫法。

// usage.js
import { output } from "./awaiting.js";

function outputPlusValue(value) { return output + value }

console.log(outputPlusValue(100));
setTimeout(() => console.log(outputPlusValue(100)), 1000);

上面代碼中壤靶，outputPlusValue()的執(zhí)行結(jié)果缚俏，完全取決于執(zhí)行的時(shí)間。如果awaiting.js里面的異步操作沒(méi)執(zhí)行完贮乳，加載進(jìn)來(lái)的output的值就是undefined忧换。

目前的解決方法，就是讓原始模塊輸出一個(gè) Promise 對(duì)象向拆，從這個(gè) Promise 對(duì)象判斷異步操作有沒(méi)有結(jié)束亚茬。

// awaiting.js
let output;
export default (async function main() {
  const dynamic = await import(someMission);
  const data = await fetch(url);
  output = someProcess(dynamic.default, data);
})();
export { output };

上面代碼中，awaiting.js除了輸出output浓恳，還默認(rèn)輸出一個(gè) Promise 對(duì)象（async 函數(shù)立即執(zhí)行后刹缝，返回一個(gè) Promise 對(duì)象），從這個(gè)對(duì)象判斷異步操作是否結(jié)束颈将。
下面是加載這個(gè)模塊的新的寫法梢夯。

// usage.js
import promise, { output } from "./awaiting.js";

function outputPlusValue(value) { return output + value }

promise.then(() => {
  console.log(outputPlusValue(100));
  setTimeout(() => console.log(outputPlusValue(100)), 1000);
});

上面代碼中，將awaiting.js對(duì)象的輸出晴圾，放在promise.then()里面颂砸，這樣就能保證異步操作完成以后，才去讀取output疑务。

這種寫法比較麻煩沾凄，等于要求模塊的使用者遵守一個(gè)額外的使用協(xié)議，按照特殊的方法使用這個(gè)模塊知允。一旦你忘了要用 Promise 加載撒蟀，只使用正常的加載方法，依賴這個(gè)模塊的代碼就可能出錯(cuò)温鸽。而且保屯，如果上面的usage.js又有對(duì)外的輸出，等于這個(gè)依賴鏈的所有模塊都要使用 Promise 加載涤垫。

頂層的await命令姑尺，就是為了解決這個(gè)問(wèn)題。它保證只有異步操作完成蝠猬，模塊才會(huì)輸出值切蟋。

// awaiting.js
const dynamic = import(someMission);
const data = fetch(url);
export const output = someProcess((await dynamic).default, await data);

上面代碼中，兩個(gè)異步操作在輸出的時(shí)候榆芦，都加上了await命令柄粹。只有等到異步操作完成喘鸟，這個(gè)模塊才會(huì)輸出值。

加載這個(gè)模塊的寫法如下驻右。

// usage.js
import { output } from "./awaiting.js";
function outputPlusValue(value) { return output + value }

console.log(outputPlusValue(100));
setTimeout(() => console.log(outputPlusValue(100)), 1000);

上面代碼的寫法什黑，與普通的模塊加載完全一樣。也就是說(shuō)堪夭，模塊的使用者完全不用關(guān)心愕把，依賴模塊的內(nèi)部有沒(méi)有異步操作，正常加載即可森爽。

這時(shí)恨豁，模塊的加載會(huì)等待依賴模塊（上例是awaiting.js）的異步操作完成，才執(zhí)行后面的代碼拗秘，有點(diǎn)像暫停在那里圣絮。所以，它總是會(huì)得到正確的output雕旨，不會(huì)因?yàn)榧虞d時(shí)機(jī)的不同扮匠，而得到不一樣的值。

注意凡涩，頂層await只能用在 ES6 模塊棒搜，不能用在 CommonJS 模塊。這是因?yàn)?CommonJS 模塊的require()是同步加載活箕，如果有頂層await力麸，就沒(méi)法處理加載了。

下面是頂層await的一些使用場(chǎng)景育韩。

// import() 方法加載
const strings = await import(`/i18n/${navigator.language}`);

// 數(shù)據(jù)庫(kù)操作
const connection = await dbConnector();

// 依賴回滾
let jQuery;
try {
  jQuery = await import('https://cdn-a.com/jQuery');
} catch {
  jQuery = await import('https://cdn-b.com/jQuery');
}

注意克蚂，如果加載多個(gè)包含頂層await命令的模塊，加載命令是同步執(zhí)行的筋讨。

// x.js
console.log("X1");
await new Promise(r => setTimeout(r, 1000));
console.log("X2");

// y.js
console.log("Y");

// z.js
import "./x.js";
import "./y.js";
console.log("Z");

上面代碼有三個(gè)模塊埃叭，最后的z.js加載x.js和y.js，打印結(jié)果是X1悉罕、Y赤屋、X2、Z壁袄。這說(shuō)明类早，z.js并沒(méi)有等待x.js加載完成，再去加載y.js嗜逻。

頂層的await命令有點(diǎn)像涩僻，交出代碼的執(zhí)行權(quán)給其他的模塊加載，等異步操作完成后，再拿回執(zhí)行權(quán)逆日，繼續(xù)向下執(zhí)行恼琼。