異步函數 · ES6語法學習

# async 函數 1. [含義](https://es6.ruanyifeng.com/?search=...&x=7&y=7#docs/async#%E5%90%AB%E4%B9%89) 2. [基本用法](https://es6.ruanyifeng.com/?search=...&x=7&y=7#docs/async#%E5%9F%BA%E6%9C%AC%E7%94%A8%E6%B3%95) 3. [語法](https://es6.ruanyifeng.com/?search=...&x=7&y=7#docs/async#%E8%AF%AD%E6%B3%95) 4. [async 函數的實現原理](https://es6.ruanyifeng.com/?search=...&x=7&y=7#docs/async#async%20%E5%87%BD%E6%95%B0%E7%9A%84%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86) 5. [與其他異步處理方法的比較](https://es6.ruanyifeng.com/?search=...&x=7&y=7#docs/async#%E4%B8%8E%E5%85%B6%E4%BB%96%E5%BC%82%E6%AD%A5%E5%A4%84%E7%90%86%E6%96%B9%E6%B3%95%E7%9A%84%E6%AF%94%E8%BE%83) 6. [實例：按順序完成異步操作](https://es6.ruanyifeng.com/?search=...&x=7&y=7#docs/async#%E5%AE%9E%E4%BE%8B%EF%BC%9A%E6%8C%89%E9%A1%BA%E5%BA%8F%E5%AE%8C%E6%88%90%E5%BC%82%E6%AD%A5%E6%93%8D%E4%BD%9C) 7. [頂層 await](https://es6.ruanyifeng.com/?search=...&x=7&y=7#docs/async#%E9%A1%B6%E5%B1%82%20await) ## 含義 ES2017 標準引入了 async 函數，使得異步操作變得更加方便。 async 函數是什么？一句話，它就是 Generator 函數的語法糖。前文有一個 Generator 函數，依次讀取兩個文件。 ~~~javascript 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()); }; ~~~ 上面代碼的函數`gen`可以寫成`async`函數，就是下面這樣。 ~~~javascript const asyncReadFile = async function () { const f1 = await readFile('/etc/fstab'); const f2 = await readFile('/etc/shells'); console.log(f1.toString()); console.log(f2.toString()); }; ~~~ 一比較就會發現，`async`函數就是將 Generator 函數的星號（`*`）替換成`async`，將`yield`替換成`await`，僅此而已。 `async`函數對 Generator 函數的改進，體現在以下四點。（1）內置執行器。 Generator 函數的執行必須靠執行器，所以才有了`co`模塊，而`async`函數自帶執行器。也就是說，`async`函數的執行，與普通函數一模一樣，只要一行。 ~~~javascript asyncReadFile(); ~~~ 上面的代碼調用了`asyncReadFile`函數，然后它就會自動執行，輸出最后結果。這完全不像 Generator 函數，需要調用`next`方法，或者用`co`模塊，才能真正執行，得到最后結果。（2）更好的語義。 `async`和`await`，比起星號和`yield`，語義更清楚了。`async`表示函數里有異步操作，`await`表示緊跟在后面的表達式需要等待結果。（3）更廣的適用性。 `co`模塊約定，`yield`命令后面只能是 Thunk 函數或 Promise 對象，而`async`函數的`await`命令后面，可以是 Promise 對象和原始類型的值（數值、字符串和布爾值，但這時會自動轉成立即 resolved 的 Promise 對象）。（4）返回值是 Promise。 `async`函數的返回值是 Promise 對象，這比 Generator 函數的返回值是 Iterator 對象方便多了。你可以用`then`方法指定下一步的操作。進一步說，`async`函數完全可以看作多個異步操作，包裝成的一個 Promise 對象，而`await`命令就是內部`then`命令的語法糖。 ## 基本用法 `async`函數返回一個 Promise 對象，可以使用`then`方法添加回調函數。當函數執行的時候，一旦遇到`await`就會先返回，等到異步操作完成，再接著執行函數體內后面的語句。下面是一個例子。 ~~~javascript async function getStockPriceByName(name) { const symbol = await getStockSymbol(name); const stockPrice = await getStockPrice(symbol); return stockPrice; } getStockPriceByName('goog').then(function (result) { console.log(result); }); ~~~ 上面代碼是一個獲取股票報價的函數，函數前面的`async`關鍵字，表明該函數內部有異步操作。調用該函數時，會立即返回一個`Promise`對象。下面是另一個例子，指定多少毫秒后輸出一個值。 ~~~javascript 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`函數返回的是 Promise 對象，可以作為`await`命令的參數。所以，上面的例子也可以寫成下面的形式。 ~~~javascript 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 函數有多種使用形式。 ~~~javascript // 函數聲明 async function foo() {} // 函數表達式 const foo = async function () {}; // 對象的方法 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(…); // 箭頭函數 const foo = async () => {}; ~~~ ## 語法 `async`函數的語法規則總體上比較簡單，難點是錯誤處理機制。 ### 返回 Promise 對象 `async`函數返回一個 Promise 對象。 `async`函數內部`return`語句返回的值，會成為`then`方法回調函數的參數。 ~~~javascript async function f() { return 'hello world'; } f().then(v => console.log(v)) // "hello world" ~~~ 上面代碼中，函數`f`內部`return`命令返回的值，會被`then`方法回調函數接收到。 `async`函數內部拋出錯誤，會導致返回的 Promise 對象變為`reject`狀態。拋出的錯誤對象會被`catch`方法回調函數接收到。 ~~~javascript async function f() { throw new Error('出錯了'); } f().then( v => console.log('resolve', v), e => console.log('reject', e) ) //reject Error: 出錯了 ~~~ ### Promise 對象的狀態變化 `async`函數返回的 Promise 對象，必須等到內部所有`await`命令后面的 Promise 對象執行完，才會發生狀態改變，除非遇到`return`語句或者拋出錯誤。也就是說，只有`async`函數內部的異步操作執行完，才會執行`then`方法指定的回調函數。下面是一個例子。 ~~~javascript 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 對象，返回該對象的結果。如果不是 Promise 對象，就直接返回對應的值。 ~~~javascript async function f() { // 等同于 // return 123; return await 123; } f().then(v => console.log(v)) // 123 ~~~ 上面代碼中，`await`命令的參數是數值`123`，這時等同于`return 123`。另一種情況是，`await`命令后面是一個`thenable`對象（即定義了`then`方法的對象），那么`await`會將其等同于 Promise 對象。 ~~~javascript 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`命令后面是一個`Sleep`對象的實例。這個實例不是 Promise 對象，但是因為定義了`then`方法，`await`會將其視為`Promise`處理。這個例子還演示了如何實現休眠效果。JavaScript 一直沒有休眠的語法，但是借助`await`命令就可以讓程序停頓指定的時間。下面給出了一個簡化的`sleep`實現。 ~~~javascript 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 對象如果變為`reject`狀態，則`reject`的參數會被`catch`方法的回調函數接收到。 ~~~javascript 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`函數都會中斷執行。 ~~~javascript async function f() { await Promise.reject('出錯了'); await Promise.resolve('hello world'); // 不會執行 } ~~~ 上面代碼中，第二個`await`語句是不會執行的，因為第一個`await`語句狀態變成了`reject`。有時，我們希望即使前一個異步操作失敗，也不要中斷后面的異步操作。這時可以將第一個`await`放在`try...catch`結構里面，這樣不管這個異步操作是否成功，第二個`await`都會執行。 ~~~javascript 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`方法，處理前面可能出現的錯誤。 ~~~javascript 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`。 ~~~javascript 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`代碼塊之中。 ~~~javascript async function f() { try { await new Promise(function (resolve, reject) { throw new Error('出錯了'); }); } catch(e) { } return await('hello world'); } ~~~ 如果有多個`await`命令，可以統一放在`try...catch`結構中。 ~~~javascript 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`結構，實現多次重復嘗試。 ~~~javascript 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`操作成功，就會使用`break`語句退出循環；如果失敗，會被`catch`語句捕捉，然后進入下一輪循環。 ### 使用注意點第一點，前面已經說過，`await`命令后面的`Promise`對象，運行結果可能是`rejected`，所以最好把`await`命令放在`try...catch`代碼塊中。 ~~~javascript async function myFunction() { try { await somethingThatReturnsAPromise(); } catch (err) { console.log(err); } } // 另一種寫法 async function myFunction() { await somethingThatReturnsAPromise() .catch(function (err) { console.log(err); }); } ~~~ 第二點，多個`await`命令后面的異步操作，如果不存在繼發關系，最好讓它們同時觸發。 ~~~javascript let foo = await getFoo(); let bar = await getBar(); ~~~ 上面代碼中，`getFoo`和`getBar`是兩個獨立的異步操作（即互不依賴），被寫成繼發關系。這樣比較耗時，因為只有`getFoo`完成以后，才會執行`getBar`，完全可以讓它們同時觸發。 ~~~javascript // 寫法一 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`函數之中，如果用在普通函數，就會報錯。 ~~~javascript async function dbFuc(db) { let docs = [{}, {}, {}]; // 報錯 docs.forEach(function (doc) { await db.post(doc); }); } ~~~ 上面代碼會報錯，因為`await`用在普通函數之中了。但是，如果將`forEach`方法的參數改成`async`函數，也有問題。 ~~~javascript function dbFuc(db) { //這里不需要 async let docs = [{}, {}, {}]; // 可能得到錯誤結果 docs.forEach(async function (doc) { await db.post(doc); }); } ~~~ 上面代碼可能不會正常工作，原因是這時三個`db.post()`操作將是并發執行，也就是同時執行，而不是繼發執行。正確的寫法是采用`for`循環。 ~~~javascript async function dbFuc(db) { let docs = [{}, {}, {}]; for (let doc of docs) { await db.post(doc); } } ~~~ 另一種方法是使用數組的`reduce()`方法。 ~~~javascript async function dbFuc(db) { let docs = [{}, {}, {}]; await docs.reduce(async (_, doc) => { await _; await db.post(doc); }, undefined); } ~~~ 上面例子中，`reduce()`方法的第一個參數是`async`函數，導致該函數的第一個參數是前一步操作返回的 Promise 對象，所以必須使用`await`等待它操作結束。另外，`reduce()`方法返回的是`docs`數組最后一個成員的`async`函數的執行結果，也是一個 Promise 對象，導致在它前面也必須加上`await`。上面的`reduce()`的參數函數里面沒有`return`語句，原因是這個函數的主要目的是`db.post()`操作，不是返回值。而且`async`函數不管有沒有`return`語句，總是返回一個 Promise 對象，所以這里的`return`是不必要的。如果確實希望多個請求并發執行，可以使用`Promise.all`方法。當三個請求都會`resolved`時，下面兩種寫法效果相同。 ~~~javascript 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); } ~~~ 第四點，async 函數可以保留運行堆棧。 ~~~javascript const a = () => { b().then(() => c()); }; ~~~ 上面代碼中，函數`a`內部運行了一個異步任務`b()`。當`b()`運行的時候，函數`a()`不會中斷，而是繼續執行。等到`b()`運行結束，可能`a()`早就運行結束了，`b()`所在的上下文環境已經消失了。如果`b()`或`c()`報錯，錯誤堆棧將不包括`a()`。現在將這個例子改成`async`函數。 ~~~javascript const a = async () => { await b(); c(); }; ~~~ 上面代碼中，`b()`運行的時候，`a()`是暫停執行，上下文環境都保存著。一旦`b()`或`c()`報錯，錯誤堆棧將包括`a()`。 ## async 函數的實現原理 async 函數的實現原理，就是將 Generator 函數和自動執行器，包裝在一個函數里。 ~~~javascript async function fn(args) { // ... } // 等同于 function fn(args) { return spawn(function* () { // ... }); } ~~~ 所有的`async`函數都可以寫成上面的第二種形式，其中的`spawn`函數就是自動執行器。下面給出`spawn`函數的實現，基本就是前文自動執行器的翻版。 ~~~javascript 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); }); }); } ~~~ ## 與其他異步處理方法的比較我們通過一個例子，來看 async 函數與 Promise、Generator 函數的比較。假定某個 DOM 元素上面，部署了一系列的動畫，前一個動畫結束，才能開始后一個。如果當中有一個動畫出錯，就不再往下執行，返回上一個成功執行的動畫的返回值。首先是 Promise 的寫法。 ~~~javascript function chainAnimationsPromise(elem, animations) { // 變量ret用來保存上一個動畫的返回值 let ret = null; // 新建一個空的Promise let p = Promise.resolve(); // 使用then方法，添加所有動畫 for(let anim of animations) { p = p.then(function(val) { ret = val; return anim(elem); }); } // 返回一個部署了錯誤捕捉機制的Promise return p.catch(function(e) { /* 忽略錯誤，繼續執行 */ }).then(function() { return ret; }); } ~~~ 雖然 Promise 的寫法比回調函數的寫法大大改進，但是一眼看上去，代碼完全都是 Promise 的 API（`then`、`catch`等等），操作本身的語義反而不容易看出來。接著是 Generator 函數的寫法。 ~~~javascript function chainAnimationsGenerator(elem, animations) { return spawn(function*() { let ret = null; try { for(let anim of animations) { ret = yield anim(elem); } } catch(e) { /* 忽略錯誤，繼續執行 */ } return ret; }); } ~~~ 上面代碼使用 Generator 函數遍歷了每個動畫，語義比 Promise 寫法更清晰，用戶定義的操作全部都出現在`spawn`函數的內部。這個寫法的問題在于，必須有一個任務運行器，自動執行 Generator 函數，上面代碼的`spawn`函數就是自動執行器，它返回一個 Promise 對象，而且必須保證`yield`語句后面的表達式，必須返回一個 Promise。最后是 async 函數的寫法。 ~~~javascript async function chainAnimationsAsync(elem, animations) { let ret = null; try { for(let anim of animations) { ret = await anim(elem); } } catch(e) { /* 忽略錯誤，繼續執行 */ } return ret; } ~~~ 可以看到 Async 函數的實現最簡潔，最符合語義，幾乎沒有語義不相關的代碼。它將 Generator 寫法中的自動執行器，改在語言層面提供，不暴露給用戶，因此代碼量最少。如果使用 Generator 寫法，自動執行器需要用戶自己提供。 ## 實例：按順序完成異步操作實際開發中，經常遇到一組異步操作，需要按照順序完成。比如，依次遠程讀取一組 URL，然后按照讀取的順序輸出結果。 Promise 的寫法如下。 ~~~javascript function logInOrder(urls) { // 遠程讀取所有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`方法，同時遠程讀取一組 URL。每個`fetch`操作都返回一個 Promise 對象，放入`textPromises`數組。然后，`reduce`方法依次處理每個 Promise 對象，然后使用`then`，將所有 Promise 對象連起來，因此就可以依次輸出結果。這種寫法不太直觀，可讀性比較差。下面是 async 函數實現。 ~~~javascript async function logInOrder(urls) { for (const url of urls) { const response = await fetch(url); console.log(await response.text()); } } ~~~ 上面代碼確實大大簡化，問題是所有遠程操作都是繼發。只有前一個 URL 返回結果，才會去讀取下一個 URL，這樣做效率很差，非常浪費時間。我們需要的是并發發出遠程請求。 ~~~javascript async function logInOrder(urls) { // 并發讀取遠程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`方法的參數是`async`函數，但它是并發執行的，因為只有`async`函數內部是繼發執行，外部不受影響。后面的`for..of`循環內部使用了`await`，因此實現了按順序輸出。 ## 頂層 await 根據語法規格，`await`命令只能出現在 async 函數內部，否則都會報錯。 ~~~javascript // 報錯 const data = await fetch('https://api.example.com'); ~~~ 上面代碼中，`await`命令獨立使用，沒有放在 async 函數里面，就會報錯。目前，有一個[語法提案](https://github.com/tc39/proposal-top-level-await)，允許在模塊的頂層獨立使用`await`命令，使得上面那行代碼不會報錯了。這個提案的目的，是借用`await`解決模塊異步加載的問題。 ~~~javascript // 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`，取決于異步操作。我們把異步操作包裝在一個 async 函數里面，然后調用這個函數，只有等里面的異步操作都執行，變量`output`才會有值，否則就返回`undefined`。上面的代碼也可以寫成立即執行函數的形式。 ~~~javascript // awaiting.js let output; (async function main() { const dynamic = await import(someMission); const data = await fetch(url); output = someProcess(dynamic.default, data); })(); export { output }; ~~~ 下面是加載這個模塊的寫法。 ~~~javascript // usage.js import { output } from "./awaiting.js"; function outputPlusValue(value) { return output + value } console.log(outputPlusValue(100)); setTimeout(() => console.log(outputPlusValue(100), 1000); ~~~ 上面代碼中，`outputPlusValue()`的執行結果，完全取決于執行的時間。如果`awaiting.js`里面的異步操作沒執行完，加載進來的`output`的值就是`undefined`。目前的解決方法，就是讓原始模塊輸出一個 Promise 對象，從這個 Promise 對象判斷異步操作有沒有結束。 ~~~javascript // 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`，還默認輸出一個 Promise 對象（async 函數立即執行后，返回一個 Promise 對象），從這個對象判斷異步操作是否結束。下面是加載這個模塊的新的寫法。 ~~~javascript // 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`對象的輸出，放在`promise.then()`里面，這樣就能保證異步操作完成以后，才去讀取`output`。這種寫法比較麻煩，等于要求模塊的使用者遵守一個額外的使用協議，按照特殊的方法使用這個模塊。一旦你忘了要用 Promise 加載，只使用正常的加載方法，依賴這個模塊的代碼就可能出錯。而且，如果上面的`usage.js`又有對外的輸出，等于這個依賴鏈的所有模塊都要使用 Promise 加載。頂層的`await`命令，就是為了解決這個問題。它保證只有異步操作完成，模塊才會輸出值。 ~~~javascript // awaiting.js const dynamic = import(someMission); const data = fetch(url); export const output = someProcess((await dynamic).default, await data); ~~~ 上面代碼中，兩個異步操作在輸出的時候，都加上了`await`命令。只有等到異步操作完成，這個模塊才會輸出值。加載這個模塊的寫法如下。 ~~~javascript // usage.js import { output } from "./awaiting.js"; function outputPlusValue(value) { return output + value } console.log(outputPlusValue(100)); setTimeout(() => console.log(outputPlusValue(100), 1000); ~~~ 上面代碼的寫法，與普通的模塊加載完全一樣。也就是說，模塊的使用者完全不用關心，依賴模塊的內部有沒有異步操作，正常加載即可。這時，模塊的加載會等待依賴模塊（上例是`awaiting.js`）的異步操作完成，才執行后面的代碼，有點像暫停在那里。所以，它總是會得到正確的`output`，不會因為加載時機的不同，而得到不一樣的值。注意，頂層`await`只能用在 ES6 模塊，不能用在 CommonJS 模塊。這是因為 CommonJS 模塊的`require()`是同步加載，如果有頂層`await`，就沒法處理加載了。下面是頂層`await`的一些使用場景。 ~~~javascript // import() 方法加載 const strings = await import(`/i18n/${navigator.language}`); // 數據庫操作 const connection = await dbConnector(); // 依賴回滾 let jQuery; try { jQuery = await import('https://cdn-a.com/jQuery'); } catch { jQuery = await import('https://cdn-b.com/jQuery'); } ~~~ 注意，如果加載多個包含頂層`await`命令的模塊，加載命令是同步執行的。 ~~~javascript // 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"); ~~~ 上面代碼有三個模塊，最后的`z.js`加載`x.js`和`y.js`，打印結果是`X1`、`Y`、`X2`、`Z`。這說明，`z.js`并沒有等待`x.js`加載完成，再去加載`y.js`。頂層的`await`命令有點像，交出代碼的執行權給其他的模塊加載，等異步操作完成后，再拿回執行權，繼續向下執行。