一、概述
async 函數是 Generator 函數的語法糖
使用Generator 函數，依次讀取兩個文件代碼如下
var fs = require('fs'); var readFile = function (fileName) { return new Promise(function (resolve, reject) { fs.readFile(fileName, function(error, data) { if (error) return reject(error); resolve(data); }); }); }; var gen = function* () { var f1 = yield readFile('/etc/fstab'); var f2 = yield readFile('/etc/shells'); console.log(f1.toString()); console.log(f2.toString()); };
寫成async函數，就是下面這樣
var asyncReadFile = async function () { var f1 = await readFile('/etc/fstab'); var 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函數的執行，與普通函數一模一樣，只要一行
var result = asyncReadFile();
上面的代碼調用了asyncReadFile函數，然后它就會自動執行，輸出最后結果。這完全不像 Generator 函數，需要調用next方法，或者用co模塊，才能真正執行，得到最后結果
2、更好的語義
async和await，比起星號和yield，語義更清楚了。async表示函數里有異步操作，await表示緊跟在后面的表達式需要等待結果
3、更廣的適用性
co模塊約定，yield命令后面只能是 Thunk 函數或 Promise 對象，而async函數的await命令后面，可以是Promise 對象和原始類型的值（數值、字符串和布爾值，但這時等同於同步操作）
4、返回值是 Promise
async函數的返回值是 Promise 對象，這比 Generator 函數的返回值是 Iterator 對象方便多了。可以用then方法指定下一步的操作。
進一步說，async函數完全可以看作多個異步操作，包裝成的一個 Promise 對象，而await命令就是內部then命令的語法糖
二、基本用法
async函數返回一個 Promise 對象，可以使用then方法添加回調函數。當函數執行的時候，一旦遇到await就會先返回，等到異步操作完成，再接着執行函數體內后面的語句
async function getStockPriceByName(name) { var symbol = await getStockSymbol(name); var stockPrice = await getStockPrice(symbol); return stockPrice; } getStockPriceByName('goog').then(function (result) { console.log(result); });
上面代碼是一個獲取股票報價的函數，函數前面的async關鍵字，表明該函數內部有異步操作。調用該函數時，會立即返回一個Promise對象
下面是另一個例子，指定多少毫秒后輸出一個值
function timeout(ms) { return new Promise((resolve) => { setTimeout(resolve, ms); }); } async function asyncPrint(value, ms) { await timeout(ms); console.log(value); } asyncPrint('hello world', 2000);
上面代碼指定2秒以后，輸出hello world。也就是說asyncPrint執行時候遇到await就先返回出來一個promise，等await的函數timeout執行完成之后，也就是2s后，再接着執行console.log(value)，打印'hello world'。
由於async函數返回的是Promise對象，可以作為await命令的參數。所以，上面例子也可寫成下面形式
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 函數有多種使用形式
// 函數聲明
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 () => {};
三、語法
1、返回 Promise 對象
async函數返回一個 Promise 對象
async函數內部return語句返回的值，會成為then方法回調函數的參數
async function f() { return 'hello world'; } f().then(v => console.log(v)) // "hello world"
上面代碼中，函數f內部return命令返回的值，會被then方法回調函數接收到
async函數內部拋出錯誤，會導致返回的 Promise 對象變為reject狀態。拋出的錯誤對象會被catch方法回調函數接收到
async function f() { throw new Error('出錯了'); } f().then( v => console.log(v), e => console.log(e) ) // Error: 出錯了
2、Promise 對象的狀態變化
async函數返回的 Promise 對象，必須等到內部所有await命令后面的 Promise 對象執行完，才會發生狀態改變，除非遇到return語句或者拋出錯誤。也就是說，只有async函數內部的異步操作執行完，才會執行then方法指定的回調函數
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)
上面代碼中，函數getTitle內部有三個操作：抓取網頁、取出文本、匹配頁面標題。只有這三個操作全部完成，才會執行then方法里面的console.log
3、await命令
正常情況下，await命令后面是一個 Promise 對象。如果不是，會被轉成一個立即resolve的 Promise 對象
async function f() { return await 123; } f().then(v => console.log(v)) // 123
上面代碼中，await命令的參數是數值123，它被轉成 Promise 對象，並立即resolve。
await命令后面的 Promise 對象如果變為reject狀態，則reject的參數會被catch方法的回調函數接收到
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函數都會中斷執行
async function f() { await Promise.reject('出錯了'); await Promise.resolve('hello world'); // 不會執行
}
上面代碼中，第二個await語句是不會執行的，因為第一個await語句狀態變成了reject。
有時，希望即使前一個異步操作失敗，也不要中斷后面的異步操作。這時可以將第一個await放在try...catch結構里面，這樣不管這個異步操作是否成功，第二個await都會執行
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方法，處理前面可能出現的錯誤
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
4、錯誤處理
如果await后面的異步操作出錯，那么等同於async函數返回的 Promise 對象被reject
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方法的回調函數被調用，它的參數就是拋出的錯誤對象
防止出錯的方法，也是將其放在try...catch代碼塊之中
async function f() { try { await new Promise(function (resolve, reject) { throw new Error('出錯了'); }); } catch(e) { } return await('hello world'); }
//如果有多個await命令，可以統一放在try...catch結構中
async function main() { try { var val1 = await firstStep(); var val2 = await secondStep(val1); var val3 = await thirdStep(val1, val2); console.log('Final: ', val3); } catch (err) { console.error(err); } }
//下面的例子使用try...catch結構，實現多次重復嘗試
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語句捕捉，然后進入下一輪循環
5、注意事項
（1）await命令后面的Promise對象，運行結果可能是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); }); }
（2）多個await命令后面的異步操作，如果不存在繼發關系，最好讓它們同時觸發
let foo = await getFoo(); let bar = await getBar();
上面代碼中，getFoo和getBar是兩個獨立的異步操作（即互不依賴），被寫成繼發關系。這樣比較耗時，因為只有getFoo完成以后，才會執行getBar，完全可以讓它們同時觸發（注意：獨立的異步操作讓同時觸發，使用Promise.all()）縮短程序的執行時間
// 寫法一
let [foo, bar] = await Promise.all([getFoo(), getBar()]); // 寫法二
let fooPromise = getFoo(); let barPromise = getBar(); let foo = await fooPromise; let bar = await barPromise;
上面兩種寫法，getFoo和getBar都是同時觸發，這樣就會縮短程序的執行時間
（3）await命令只能用在async函數之中，如果用在普通函數，就會報錯
async function dbFuc(db) { let docs = [{}, {}, {}]; // 報錯
docs.forEach(function (doc) { await db.post(doc); }); }
上面代碼會報錯，因為await用在普通函數之中了。但是，如果將forEach方法的參數改成async函數，也有問題
function dbFuc(db) { //這里不需要 async
let docs = [{}, {}, {}]; // 可能得到錯誤結果
docs.forEach(async function (doc) { await db.post(doc); }); }
上面代碼可能不會正常工作，原因是這時三個db.post操作將是並發執行，也就是同時執行，而不是繼發執行。正確的寫法是采用for循環
async function dbFuc(db) { let docs = [{}, {}, {}]; for (let doc of docs) { await db.post(doc); } }
如果確實希望多個請求並發執行，可以使用Promise.all方法。當三個請求都會resolved時，下面兩種寫法效果相同
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 函數的實現原理，就是將 Generator 函數和自動執行器，包裝在一個函數里
async function fn(args) { // ...
} // 等同於 function fn(args) { return spawn(function* () { // ...
}); }
所有的async函數都可以寫成上面的第二種形式，其中的spawn函數就是自動執行器。
下面給出spawn函數的實現，基本就是前文自動執行器的翻版
function spawn(genF) { return new Promise(function(resolve, reject) { var gen = genF(); function step(nextF) { try { var 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 元素上面，部署了一系列的動畫，前一個動畫結束，才能開始后一個。如果當中有一個動畫出錯，就不再往下執行，返回上一個成功執行的動畫的返回值
1、Promise
首先是 Promise 的寫法
function chainAnimationsPromise(elem, animations) { // 變量ret用來保存上一個動畫的返回值
var ret = null; // 新建一個空的Promise
var p = Promise.resolve(); // 使用then方法，添加所有動畫
for(var 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等等），操作本身的語義反而不容易看出來
2、Generator
接着是 Generator 函數的寫法
function chainAnimationsGenerator(elem, animations) { return spawn(function*() { var ret = null; try { for(var anim of animations) { ret = yield anim(elem); } } catch(e) { /* 忽略錯誤，繼續執行 */ } return ret; }); }
上面代碼使用 Generator 函數遍歷了每個動畫，語義比 Promise 寫法更清晰，用戶定義的操作全部都出現在spawn函數的內部。這個寫法的問題在於，必須有一個任務運行器，自動執行 Generator 函數，上面代碼的spawn函數就是自動執行器，它返回一個 Promise 對象，而且必須保證yield語句后面的表達式，必須返回一個 Promise
3、async
最后是 async 函數的寫法
async function chainAnimationsAsync(elem, animations) { var ret = null; try { for(var anim of animations) { ret = await anim(elem); } } catch(e) { /* 忽略錯誤，繼續執行 */ } return ret; }
可以看到Async函數的實現最簡潔，最符合語義，幾乎沒有語義不相關的代碼。它將Generator寫法中的自動執行器，改在語言層面提供，不暴露給用戶，因此代碼量最少。如果使用Generator寫法，自動執行器需要用戶自己提供
六、實例
實際開發中，經常遇到一組異步操作，需要按照順序完成。比如，依次遠程讀取一組 URL，然后按照讀取的順序輸出結果。
Promise 的寫法如下
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 函數實現
async function logInOrder(urls) { for (const url of urls) { const response = await fetch(url); console.log(await response.text()); } }
上面代碼確實大大簡化，問題是所有遠程操作都是繼發。只有前一個URL返回結果，才會去讀取下一個URL，這樣做效率很差，非常浪費時間。我們需要的是並發發出遠程請求
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，因此實現了按順序輸出