# 異步操作和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寫法,自動執行器需要用戶自己提供。