# 異步操作和Async函數
1. [基本概念](http://es6.ruanyifeng.com/#docs/async#基本概念)
2. [Generator函數](http://es6.ruanyifeng.com/#docs/async#Generator函數)
3. [Thunk函數](http://es6.ruanyifeng.com/#docs/async#Thunk函數)
4. [co模塊](http://es6.ruanyifeng.com/#docs/async#co模塊)
5. [async函數](http://es6.ruanyifeng.com/#docs/async#async函數)
異步編程對JavaScript語言太重要。Javascript語言的執行環境是“單線程”的，如果沒有異步編程，根本沒法用，非卡死不可。
ES6誕生以前，異步編程的方法，大概有下面四種。
* 回調函數
* 事件監聽
* 發布/訂閱
* Promise 對象
ES6將JavaScript異步編程帶入了一個全新的階段，ES7的`Async`函數更是提出了異步編程的終極解決方案。
## 基本概念
### 異步
所謂"異步"，簡單說就是一個任務分成兩段，先執行第一段，然后轉而執行其他任務，等做好了準備，再回過頭執行第二段。
比如，有一個任務是讀取文件進行處理，任務的第一段是向操作系統發出請求，要求讀取文件。然后，程序執行其他任務，等到操作系統返回文件，再接著執行任務的第二段（處理文件）。這種不連續的執行，就叫做異步。
相應地，連續的執行就叫做同步。由于是連續執行，不能插入其他任務，所以操作系統從硬盤讀取文件的這段時間，程序只能干等著。
### 回調函數
JavaScript語言對異步編程的實現，就是回調函數。所謂回調函數，就是把任務的第二段單獨寫在一個函數里面，等到重新執行這個任務的時候，就直接調用這個函數。它的英語名字callback，直譯過來就是"重新調用"。
讀取文件進行處理，是這樣寫的。
~~~
fs.readFile('/etc/passwd', function (err, data) {
if (err) throw err;
console.log(data);
});
~~~
上面代碼中，readFile函數的第二個參數，就是回調函數，也就是任務的第二段。等到操作系統返回了`/etc/passwd`這個文件以后，回調函數才會執行。
一個有趣的問題是，為什么Node.js約定，回調函數的第一個參數，必須是錯誤對象err（如果沒有錯誤，該參數就是null）？原因是執行分成兩段，在這兩段之間拋出的錯誤，程序無法捕捉，只能當作參數，傳入第二段。
### Promise
回調函數本身并沒有問題，它的問題出現在多個回調函數嵌套。假定讀取A文件之后，再讀取B文件，代碼如下。
~~~
fs.readFile(fileA, function (err, data) {
fs.readFile(fileB, function (err, data) {
// ...
});
});
~~~
不難想象，如果依次讀取多個文件，就會出現多重嵌套。代碼不是縱向發展，而是橫向發展，很快就會亂成一團，無法管理。這種情況就稱為"回調函數噩夢"（callback hell）。
Promise就是為了解決這個問題而提出的。它不是新的語法功能，而是一種新的寫法，允許將回調函數的嵌套，改成鏈式調用。采用Promise，連續讀取多個文件，寫法如下。
~~~
var readFile = require('fs-readfile-promise');
readFile(fileA)
.then(function(data){
console.log(data.toString());
})
.then(function(){
return readFile(fileB);
})
.then(function(data){
console.log(data.toString());
})
.catch(function(err) {
console.log(err);
});
~~~
上面代碼中，我使用了fs-readfile-promise模塊，它的作用就是返回一個Promise版本的readFile函數。Promise提供then方法加載回調函數，catch方法捕捉執行過程中拋出的錯誤。
可以看到，Promise 的寫法只是回調函數的改進，使用then方法以后，異步任務的兩段執行看得更清楚了，除此以外，并無新意。
Promise 的最大問題是代碼冗余，原來的任務被Promise 包裝了一下，不管什么操作，一眼看去都是一堆 then，原來的語義變得很不清楚。
那么，有沒有更好的寫法呢？
## Generator函數
### 協程
傳統的編程語言，早有異步編程的解決方案（其實是多任務的解決方案）。其中有一種叫做"協程"（coroutine），意思是多個線程互相協作，完成異步任務。
協程有點像函數，又有點像線程。它的運行流程大致如下。
* 第一步，協程A開始執行。
* 第二步，協程A執行到一半，進入暫停，執行權轉移到協程B。
* 第三步，（一段時間后）協程B交還執行權。
* 第四步，協程A恢復執行。
上面流程的協程A，就是異步任務，因為它分成兩段（或多段）執行。
舉例來說，讀取文件的協程寫法如下。
~~~
function *asyncJob() {
// ...其他代碼
var f = yield readFile(fileA);
// ...其他代碼
}
~~~
上面代碼的函數`asyncJob`是一個協程，它的奧妙就在其中的`yield`命令。它表示執行到此處，執行權將交給其他協程。也就是說，`yield`命令是異步兩個階段的分界線。
協程遇到`yield`命令就暫停，等到執行權返回，再從暫停的地方繼續往后執行。它的最大優點，就是代碼的寫法非常像同步操作，如果去除yield命令，簡直一模一樣。
### Generator函數的概念
Generator函數是協程在ES6的實現，最大特點就是可以交出函數的執行權（即暫停執行）。
整個Generator函數就是一個封裝的異步任務，或者說是異步任務的容器。異步操作需要暫停的地方，都用`yield`語句注明。Generator函數的執行方法如下。
~~~
function* gen(x){
var y = yield x + 2;
return y;
}
var g = gen(1);
g.next() // { value: 3, done: false }
g.next() // { value: undefined, done: true }
~~~
上面代碼中，調用Generator函數，會返回一個內部指針（即遍歷器）g 。這是Generator函數不同于普通函數的另一個地方，即執行它不會返回結果，返回的是指針對象。調用指針g的next方法，會移動內部指針（即執行異步任務的第一段），指向第一個遇到的yield語句，上例是執行到`x + 2`為止。
換言之，next方法的作用是分階段執行Generator函數。每次調用next方法，會返回一個對象，表示當前階段的信息（value屬性和done屬性）。value屬性是yield語句后面表達式的值，表示當前階段的值；done屬性是一個布爾值，表示Generator函數是否執行完畢，即是否還有下一個階段。
### Generator函數的數據交換和錯誤處理
Generator函數可以暫停執行和恢復執行，這是它能封裝異步任務的根本原因。除此之外，它還有兩個特性，使它可以作為異步編程的完整解決方案：函數體內外的數據交換和錯誤處理機制。
next方法返回值的value屬性，是Generator函數向外輸出數據；next方法還可以接受參數，這是向Generator函數體內輸入數據。
~~~
function* gen(x){
var y = yield x + 2;
return y;
}
var g = gen(1);
g.next() // { value: 3, done: false }
g.next(2) // { value: 2, done: true }
~~~
上面代碼中，第一個next方法的value屬性，返回表達式`x + 2`的值（3）。第二個next方法帶有參數2，這個參數可以傳入 Generator 函數，作為上個階段異步任務的返回結果，被函數體內的變量y接收。因此，這一步的 value 屬性，返回的就是2（變量y的值）。
Generator 函數內部還可以部署錯誤處理代碼，捕獲函數體外拋出的錯誤。
~~~
function* gen(x){
try {
var y = yield x + 2;
} catch (e){
console.log(e);
}
return y;
}
var g = gen(1);
g.next();
g.throw('出錯了');
// 出錯了
~~~
上面代碼的最后一行，Generator函數體外，使用指針對象的throw方法拋出的錯誤，可以被函數體內的try ...catch代碼塊捕獲。這意味著，出錯的代碼與處理錯誤的代碼，實現了時間和空間上的分離，這對于異步編程無疑是很重要的。
### 異步任務的封裝
下面看看如何使用 Generator 函數，執行一個真實的異步任務。
~~~
var fetch = require('node-fetch');
function* gen(){
var url = 'https://api.github.com/users/github';
var result = yield fetch(url);
console.log(result.bio);
}
~~~
上面代碼中，Generator函數封裝了一個異步操作，該操作先讀取一個遠程接口，然后從JSON格式的數據解析信息。就像前面說過的，這段代碼非常像同步操作，除了加上了yield命令。
執行這段代碼的方法如下。
~~~
var g = gen();
var result = g.next();
result.value.then(function(data){
return data.json();
}).then(function(data){
g.next(data);
});
~~~
上面代碼中，首先執行Generator函數，獲取遍歷器對象，然后使用next 方法（第二行），執行異步任務的第一階段。由于Fetch模塊返回的是一個Promise對象，因此要用then方法調用下一個next 方法。
可以看到，雖然 Generator 函數將異步操作表示得很簡潔，但是流程管理卻不方便（即何時執行第一階段、何時執行第二階段）。
## Thunk函數
### 參數的求值策略
Thunk函數早在上個世紀60年代就誕生了。
那時，編程語言剛剛起步，計算機學家還在研究，編譯器怎么寫比較好。一個爭論的焦點是"求值策略"，即函數的參數到底應該何時求值。
~~~
var x = 1;
function f(m){
return m * 2;
}
f(x + 5)
~~~
上面代碼先定義函數f，然后向它傳入表達式`x + 5`。請問，這個表達式應該何時求值？
一種意見是"傳值調用"（call by value），即在進入函數體之前，就計算`x + 5`的值（等于6），再將這個值傳入函數f 。C語言就采用這種策略。
~~~
f(x + 5)
// 傳值調用時，等同于
f(6)
~~~
另一種意見是"傳名調用"（call by name），即直接將表達式`x + 5`傳入函數體，只在用到它的時候求值。Haskell語言采用這種策略。
~~~
f(x + 5)
// 傳名調用時，等同于
(x + 5) * 2
~~~
傳值調用和傳名調用，哪一種比較好？回答是各有利弊。傳值調用比較簡單，但是對參數求值的時候，實際上還沒用到這個參數，有可能造成性能損失。
~~~
function f(a, b){
return b;
}
f(3 * x * x - 2 * x - 1, x);
~~~
上面代碼中，函數f的第一個參數是一個復雜的表達式，但是函數體內根本沒用到。對這個參數求值，實際上是不必要的。因此，有一些計算機學家傾向于"傳名調用"，即只在執行時求值。
### Thunk函數的含義
編譯器的"傳名調用"實現，往往是將參數放到一個臨時函數之中，再將這個臨時函數傳入函數體。這個臨時函數就叫做Thunk函數。
~~~
function f(m){
return m * 2;
}
f(x + 5);
// 等同于
var thunk = function () {
return x + 5;
};
function f(thunk){
return thunk() * 2;
}
~~~
上面代碼中，函數f的參數`x + 5`被一個函數替換了。凡是用到原參數的地方，對`Thunk`函數求值即可。
這就是Thunk函數的定義，它是"傳名調用"的一種實現策略，用來替換某個表達式。
### JavaScript語言的Thunk函數
JavaScript語言是傳值調用，它的Thunk函數含義有所不同。在JavaScript語言中，Thunk函數替換的不是表達式，而是多參數函數，將其替換成單參數的版本，且只接受回調函數作為參數。
~~~
// 正常版本的readFile（多參數版本）
fs.readFile(fileName, callback);
// Thunk版本的readFile（單參數版本）
var readFileThunk = Thunk(fileName);
readFileThunk(callback);
var Thunk = function (fileName){
return function (callback){
return fs.readFile(fileName, callback);
};
};
~~~
上面代碼中，fs模塊的readFile方法是一個多參數函數，兩個參數分別為文件名和回調函數。經過轉換器處理，它變成了一個單參數函數，只接受回調函數作為參數。這個單參數版本，就叫做Thunk函數。
任何函數，只要參數有回調函數，就能寫成Thunk函數的形式。下面是一個簡單的Thunk函數轉換器。
~~~
// ES5版本
var Thunk = function(fn){
return function (){
var args = Array.prototype.slice.call(arguments);
return function (callback){
args.push(callback);
return fn.apply(this, args);
}
};
};
// ES6版本
var Thunk = function(fn) {
return function (...args) {
return function (callback) {
return fn.call(this, ...args, callback);
}
};
};
~~~
使用上面的轉換器，生成`fs.readFile`的Thunk函數。
~~~
var readFileThunk = Thunk(fs.readFile);
readFileThunk(fileA)(callback);
~~~
下面是另一個完整的例子。
~~~
function f(a, cb) {
cb(a);
}
let ft = Thunk(f);
let log = console.log.bind(console);
ft(1)(log) // 1
~~~
### Thunkify模塊
生產環境的轉換器，建議使用Thunkify模塊。
首先是安裝。
~~~
$ npm install thunkify
~~~
使用方式如下。
~~~
var thunkify = require('thunkify');
var fs = require('fs');
var read = thunkify(fs.readFile);
read('package.json')(function(err, str){
// ...
});
~~~
Thunkify的源碼與上一節那個簡單的轉換器非常像。
~~~
function thunkify(fn){
return function(){
var args = new Array(arguments.length);
var ctx = this;
for(var i = 0; i < args.length; ++i) {
args[i] = arguments[i];
}
return function(done){
var called;
args.push(function(){
if (called) return;
called = true;
done.apply(null, arguments);
});
try {
fn.apply(ctx, args);
} catch (err) {
done(err);
}
}
}
};
~~~
它的源碼主要多了一個檢查機制，變量`called`確保回調函數只運行一次。這樣的設計與下文的Generator函數相關。請看下面的例子。
~~~
function f(a, b, callback){
var sum = a + b;
callback(sum);
callback(sum);
}
var ft = thunkify(f);
var print = console.log.bind(console);
ft(1, 2)(print);
// 3
~~~
上面代碼中，由于`thunkify`只允許回調函數執行一次，所以只輸出一行結果。
### Generator 函數的流程管理
你可能會問， Thunk函數有什么用？回答是以前確實沒什么用，但是ES6有了Generator函數，Thunk函數現在可以用于Generator函數的自動流程管理。
Generator函數可以自動執行。
~~~
function* gen() {
// ...
}
var g = gen();
var res = g.next();
while(!res.done){
console.log(res.value);
res = g.next();
}
~~~
上面代碼中，Generator函數`gen`會自動執行完所有步驟。
但是，這不適合異步操作。如果必須保證前一步執行完，才能執行后一步，上面的自動執行就不可行。這時，Thunk函數就能派上用處。以讀取文件為例。下面的Generator函數封裝了兩個異步操作。
~~~
var fs = require('fs');
var thunkify = require('thunkify');
var readFile = thunkify(fs.readFile);
var gen = function* (){
var r1 = yield readFile('/etc/fstab');
console.log(r1.toString());
var r2 = yield readFile('/etc/shells');
console.log(r2.toString());
};
~~~
上面代碼中，yield命令用于將程序的執行權移出Generator函數，那么就需要一種方法，將執行權再交還給Generator函數。
這種方法就是Thunk函數，因為它可以在回調函數里，將執行權交還給Generator函數。為了便于理解，我們先看如何手動執行上面這個Generator函數。
~~~
var g = gen();
var r1 = g.next();
r1.value(function(err, data){
if (err) throw err;
var r2 = g.next(data);
r2.value(function(err, data){
if (err) throw err;
g.next(data);
});
});
~~~
上面代碼中，變量g是Generator函數的內部指針，表示目前執行到哪一步。next方法負責將指針移動到下一步，并返回該步的信息（value屬性和done屬性）。
仔細查看上面的代碼，可以發現Generator函數的執行過程，其實是將同一個回調函數，反復傳入next方法的value屬性。這使得我們可以用遞歸來自動完成這個過程。
### Thunk函數的自動流程管理
Thunk函數真正的威力，在于可以自動執行Generator函數。下面就是一個基于Thunk函數的Generator執行器。
~~~
function run(fn) {
var gen = fn();
function next(err, data) {
var result = gen.next(data);
if (result.done) return;
result.value(next);
}
next();
}
function* g() {
// ...
}
run(g);
~~~
上面代碼的`run`函數，就是一個Generator函數的自動執行器。內部的`next`函數就是Thunk的回調函數。`next`函數先將指針移到Generator函數的下一步（`gen.next`方法），然后判斷Generator函數是否結束（`result.done`屬性），如果沒結束，就將`next`函數再傳入Thunk函數（`result.value`屬性），否則就直接退出。
有了這個執行器，執行Generator函數方便多了。不管內部有多少個異步操作，直接把Generator函數傳入`run`函數即可。當然，前提是每一個異步操作，都要是Thunk函數，也就是說，跟在`yield`命令后面的必須是Thunk函數。
~~~
var g = function* (){
var f1 = yield readFile('fileA');
var f2 = yield readFile('fileB');
// ...
var fn = yield readFile('fileN');
};
run(g);
~~~
上面代碼中，函數`g`封裝了`n`個異步的讀取文件操作，只要執行`run`函數，這些操作就會自動完成。這樣一來，異步操作不僅可以寫得像同步操作，而且一行代碼就可以執行。
Thunk函數并不是Generator函數自動執行的唯一方案。因為自動執行的關鍵是，必須有一種機制，自動控制Generator函數的流程，接收和交還程序的執行權。回調函數可以做到這一點，Promise 對象也可以做到這一點。
## co模塊
### 基本用法
[co模塊](https://github.com/tj/co)是著名程序員TJ Holowaychuk于2013年6月發布的一個小工具，用于Generator函數的自動執行。
比如，有一個Generator函數，用于依次讀取兩個文件。
~~~
var gen = function* (){
var f1 = yield readFile('/etc/fstab');
var f2 = yield readFile('/etc/shells');
console.log(f1.toString());
console.log(f2.toString());
};
~~~
co模塊可以讓你不用編寫Generator函數的執行器。
~~~
var co = require('co');
co(gen);
~~~
上面代碼中，Generator函數只要傳入co函數，就會自動執行。
co函數返回一個Promise對象，因此可以用then方法添加回調函數。
~~~
co(gen).then(function (){
console.log('Generator 函數執行完成');
});
~~~
上面代碼中，等到Generator函數執行結束，就會輸出一行提示。
### co模塊的原理
為什么co可以自動執行Generator函數？
前面說過，Generator就是一個異步操作的容器。它的自動執行需要一種機制，當異步操作有了結果，能夠自動交回執行權。
兩種方法可以做到這一點。
（1）回調函數。將異步操作包裝成Thunk函數，在回調函數里面交回執行權。
（2）Promise 對象。將異步操作包裝成Promise對象，用then方法交回執行權。
co模塊其實就是將兩種自動執行器（Thunk函數和Promise對象），包裝成一個模塊。使用co的前提條件是，Generator函數的yield命令后面，只能是Thunk函數或Promise對象。
上一節已經介紹了基于Thunk函數的自動執行器。下面來看，基于Promise對象的自動執行器。這是理解co模塊必須的。
### 基于Promise對象的自動執行
還是沿用上面的例子。首先，把fs模塊的readFile方法包裝成一個Promise對象。
~~~
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());
};
~~~
然后，手動執行上面的Generator函數。
~~~
var g = gen();
g.next().value.then(function(data){
g.next(data).value.then(function(data){
g.next(data);
});
});
~~~
手動執行其實就是用then方法，層層添加回調函數。理解了這一點，就可以寫出一個自動執行器。
~~~
function run(gen){
var g = gen();
function next(data){
var result = g.next(data);
if (result.done) return result.value;
result.value.then(function(data){
next(data);
});
}
next();
}
run(gen);
~~~
上面代碼中，只要Generator函數還沒執行到最后一步，next函數就調用自身，以此實現自動執行。
### co模塊的源碼
co就是上面那個自動執行器的擴展，它的源碼只有幾十行，非常簡單。
首先，co函數接受Generator函數作為參數，返回一個 Promise 對象。
~~~
function co(gen) {
var ctx = this;
return new Promise(function(resolve, reject) {
});
}
~~~
在返回的Promise對象里面，co先檢查參數gen是否為Generator函數。如果是，就執行該函數，得到一個內部指針對象；如果不是就返回，并將Promise對象的狀態改為resolved。
~~~
function co(gen) {
var ctx = this;
return new Promise(function(resolve, reject) {
if (typeof gen === 'function') gen = gen.call(ctx);
if (!gen || typeof gen.next !== 'function') return resolve(gen);
});
}
~~~
接著，co將Generator函數的內部指針對象的next方法，包裝成onFulfilled函數。這主要是為了能夠捕捉拋出的錯誤。
~~~
function co(gen) {
var ctx = this;
return new Promise(function(resolve, reject) {
if (typeof gen === 'function') gen = gen.call(ctx);
if (!gen || typeof gen.next !== 'function') return resolve(gen);
onFulfilled();
function onFulfilled(res) {
var ret;
try {
ret = gen.next(res);
} catch (e) {
return reject(e);
}
next(ret);
}
});
}
~~~
最后，就是關鍵的next函數，它會反復調用自身。
~~~
function next(ret) {
if (ret.done) return resolve(ret.value);
var value = toPromise.call(ctx, ret.value);
if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, '
+ 'but the following object was passed: "' + String(ret.value) + '"'));
}
~~~
上面代碼中，next 函數的內部代碼，一共只有四行命令。
第一行，檢查當前是否為 Generator 函數的最后一步，如果是就返回。
第二行，確保每一步的返回值，是 Promise 對象。
第三行，使用 then 方法，為返回值加上回調函數，然后通過 onFulfilled 函數再次調用 next 函數。
第四行，在參數不符合要求的情況下（參數非 Thunk 函數和 Promise 對象），將 Promise 對象的狀態改為 rejected，從而終止執行。
### 處理并發的異步操作
co支持并發的異步操作，即允許某些操作同時進行，等到它們全部完成，才進行下一步。
這時，要把并發的操作都放在數組或對象里面，跟在yield語句后面。
~~~
// 數組的寫法
co(function* () {
var res = yield [
Promise.resolve(1),
Promise.resolve(2)
];
console.log(res);
}).catch(onerror);
// 對象的寫法
co(function* () {
var res = yield {
1: Promise.resolve(1),
2: Promise.resolve(2),
};
console.log(res);
}).catch(onerror);
~~~
下面是另一個例子。
~~~
co(function* () {
var values = [n1, n2, n3];
yield values.map(somethingAsync);
});
function* somethingAsync(x) {
// do something async
return y
}
~~~
上面的代碼允許并發三個`somethingAsync`異步操作，等到它們全部完成，才會進行下一步。
## async函數
### 含義
ES7提供了`async`函數，使得異步操作變得更加方便。`async`函數是什么？一句話，`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) 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`函數的語法規則總體上比較簡單，難點是錯誤處理機制。
（1）`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）`async`函數返回的Promise對象，必須等到內部所有`await`命令的Promise對象執行完，才會發生狀態改變。也就是說，只有`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)
// "ECMAScript 2017 Language Specification"
~~~
（3）正常情況下，`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
~~~
如果有多個`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);
}
}
~~~
（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`方法的回調函數被調用，它的參數就是拋出的錯誤對象。具體的執行機制，可以參考后文的“async函數的實現”。
防止出錯的方法，也是將其放在`try...catch`代碼塊之中。
~~~
async function f() {
try {
await new Promise(function (resolve, reject) {
throw new Error('出錯了');
});
} catch(e) {
}
return await('hello world');
}
~~~
### async函數的實現
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`函數是非常新的語法功能，新到都不屬于 ES6，而是屬于 ES7。目前，它仍處于提案階段，但是轉碼器`Babel`和`regenerator`都已經支持，轉碼后就能使用。
### async 函數的用法
`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', 50);
~~~
上面代碼指定50毫秒以后，輸出"hello world"。
Async函數有多種使用形式。
~~~
// 函數聲明
async function foo() {}
// 函數表達式
const foo = async function () {};
// 對象的方法
let obj = { async foo() {} };
// 箭頭函數
const foo = async () => {};
~~~
### 注意點
第一點，`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);
};
}
~~~
第二點，多個`await`命令后面的異步操作，如果不存在繼發關系，最好讓它們同時觸發。
~~~
let foo = await getFoo();
let bar = await getBar();
~~~
上面代碼中，`getFoo`和`getBar`是兩個獨立的異步操作（即互不依賴），被寫成繼發關系。這樣比較耗時，因為只有`getFoo`完成以后，才會執行`getBar`，完全可以讓它們同時觸發。
~~~
// 寫法一
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`函數之中，如果用在普通函數，就會報錯。
~~~
async function dbFuc(db) {
let docs = [{}, {}, {}];
// 報錯
docs.forEach(function (doc) {
await db.post(doc);
});
}
~~~
上面代碼會報錯，因為await用在普通函數之中了。但是，如果將`forEach`方法的參數改成`async`函數，也有問題。
~~~
async function dbFuc(db) {
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`方法。
~~~
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);
}
~~~
ES6將`await`增加為保留字。使用這個詞作為標識符，在ES5是合法的，在ES6將拋出SyntaxError。
### 與Promise、Generator的比較
我們通過一個例子，來看Async函數與Promise、Generator函數的區別。
假定某個DOM元素上面，部署了一系列的動畫，前一個動畫結束，才能開始后一個。如果當中有一個動畫出錯，就不再往下執行，返回上一個成功執行的動畫的返回值。
首先是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等等），操作本身的語義反而不容易看出來。
接著是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。
最后是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寫法，自動執行器需要用戶自己提供。
