異步編程對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模塊是著名程序員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() {} };
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 () => {};
注意點
第一點,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寫法,自動執行器需要用戶自己提供。
實例:按順序完成異步操作
實際開發中,經常遇到一組異步操作,需要按照順序完成。比如,依次遠程讀取一組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
,因此實現了按順序輸出。
異步遍歷器
《遍歷器》一章說過,Iterator接口是一種數據遍歷的協議,只要調用遍歷器對象的next
方法,就會得到一個表示當前成員信息的對象{value, done}
。其中,value
表示當前的數據的值,done
是一個布爾值,表示遍歷是否結束。
這隱含着規定,next
方法是同步的,只要調用就必須立刻返回值。也就是說,一旦執行next
方法,就必須同步地得到value
和done
這兩方面的信息。這對於同步操作,當然沒有問題,但對於異步操作,就不太合適了。目前的解決方法是,Generator函數裏面的異步操作,返回一個Thunk函數或者Promise對象,即value
屬性是一個Thunk函數或者Promise對象,等待以後返回真正的值,而done
屬性則還是同步產生的。
目前,有一個提案,爲異步操作提供原生的遍歷器接口,即value
和done
這兩個屬性都是異步產生,這稱爲”異步遍歷器“(Async Iterator)。
異步遍歷的接口
異步遍歷器的最大的語法特點,就是調用遍歷器的next
方法,返回的是一個Promise對象。
asyncIterator
.next()
.then(
({ value, done }) => /* ... */
);
上面代碼中,asyncIterator
是一個異步遍歷器,調用next
方法以後,返回一個Promise對象。因此,可以使用then
方法指定,這個Promise對象的狀態變爲resolve
以後的回調函數。回調函數的參數,則是一個具有value
和done
兩個屬性的對象,這個跟同步遍歷器是一樣的。
我們知道,一個對象的同步遍歷器的接口,部署在Symbol.iterator
屬性上面。同樣地,對象的異步遍歷器接口,部署在Symbol.asyncIterator
屬性上面。不管是什麼樣的對象,只要它的Symbol.asyncIterator
屬性有值,就表示應該對它進行異步遍歷。
下面是一個異步遍歷器的例子。
const asyncIterable = createAsyncIterable(['a', 'b']);
const asyncIterator = someCollection[Symbol.asyncIterator]();
asyncIterator.next()
.then(iterResult1 => {
console.log(iterResult1); // { value: 'a', done: false }
return asyncIterator.next();
}).then(iterResult2 => {
console.log(iterResult2); // { value: 'b', done: false }
return asyncIterator.next();
}).then(iterResult3 => {
console.log(iterResult3); // { value: undefined, done: true }
});
上面代碼中,異步遍歷器其實返回了兩次值。第一次調用的時候,返回一個Promise對象;等到Promise對象resolve
了,再返回一個表示當前數據成員信息的對象。這就是說,異步遍歷器與同步遍歷器最終行爲是一致的,只是會先返回Promise對象,作爲中介。
由於異步遍歷器的next
方法,返回的是一個Promise對象。因此,可以把它放在await
命令後面。
async function f() {
const asyncIterable = createAsyncIterable(['a', 'b']);
const asyncIterator = asyncIterable[Symbol.asyncIterator]();
console.log(await asyncIterator.next());
// { value: 'a', done: false }
console.log(await asyncIterator.next());
// { value: 'b', done: false }
console.log(await asyncIterator.next());
// { value: undefined, done: true }
}
上面代碼中,next
方法用await
處理以後,就不必使用then
方法了。整個流程已經很接近同步處理了。
注意,異步遍歷器的next
方法是可以連續調用的,不必等到上一步產生的Promise對象resolve
以後再調用。這種情況下,next
方法會累積起來,自動按照每一步的順序運行下去。下面是一個例子,把所有的next
方法放在Promise.all
方法裏面。
const asyncGenObj = createAsyncIterable(['a', 'b']);
const [{value: v1}, {value: v2}] = await Promise.all([
asyncGenObj.next(), asyncGenObj.next()
]);
console.log(v1, v2); // a b
另一種用法是一次性調用所有的next
方法,然後await
最後一步操作。
const writer = openFile('someFile.txt');
writer.next('hello');
writer.next('world');
await writer.return();
for await…of
前面介紹過,for...of
循環用於遍歷同步的Iterator接口。新引入的for await...of
循環,則是用於遍歷異步的Iterator接口。
async function f() {
for await (const x of createAsyncIterable(['a', 'b'])) {
console.log(x);
}
}
// a
// b
上面代碼中,createAsyncIterable()
返回一個異步遍歷器,for...of
循環自動調用這個遍歷器的next
方法,會得到一個Promise對象。await
用來處理這個Promise對象,一旦resolve
,就把得到的值(x
)傳入for...of
的循環體。
如果next
方法返回的Promise對象被reject
,那麼就要用try...catch
捕捉。
async function () {
try {
for await (const x of createRejectingIterable()) {
console.log(x);
}
} catch (e) {
console.error(e);
}
}
注意,for await...of
循環也可以用於同步遍歷器。
(async function () {
for await (const x of ['a', 'b']) {
console.log(x);
}
})();
// a
// b
異步Generator函數
就像Generator函數返回一個同步遍歷器對象一樣,異步Generator函數的作用,是返回一個異步遍歷器對象。
在語法上,異步Generator函數就是async
函數與Generator函數的結合。
async function* readLines(path) {
let file = await fileOpen(path);
try {
while (!file.EOF) {
yield await file.readLine();
}
} finally {
await file.close();
}
}
上面代碼中,異步操作前面使用await
關鍵字標明,即await
後面的操作,應該返回Promise對象。凡是使用yield
關鍵字的地方,就是next
方法的停下來的地方,它後面的表達式的值(即await file.readLine()
的值),會作爲next()
返回對象的value
屬性,這一點是於同步Generator函數一致的。
可以像下面這樣,使用上面代碼定義的異步Generator函數。
for await (const line of readLines(filePath)) {
console.log(line);
}
異步Generator函數可以與for await...of
循環結合起來使用。
async function* prefixLines(asyncIterable) {
for await (const line of asyncIterable) {
yield '> ' + line;
}
}
yield
命令依然是立刻返回的,但是返回的是一個Promise對象。
async function* asyncGenerator() {
console.log('Start');
const result = await doSomethingAsync(); // (A)
yield 'Result: '+ result; // (B)
console.log('Done');
}
上面代碼中,調用next
方法以後,會在B
處暫停執行,yield
命令立刻返回一個Promise對象。這個Promise對象不同於A
處await
命令後面的那個Promise對象。主要有兩點不同,一是A
處的Promise對象resolve
以後產生的值,會放入result
變量;二是B
處的Promise對象resolve
以後產生的值,是表達式'Result: ' + result
的值;二是A
處的Promise對象一定先於B
處的Promise對象resolve
。
如果異步Generator函數拋出錯誤,會被Promise對象reject
,然後拋出的錯誤被catch
方法捕獲。
async function* asyncGenerator() {
throw new Error('Problem!');
}
asyncGenerator()
.next()
.catch(err => console.log(err)); // Error: Problem!
注意,普通的async
函數返回的是一個Promise對象,而異步Generator函數返回的是一個異步Iterator對象。基本上,可以這樣理解,async
函數和異步Generator函數,是封裝異步操作的兩種方法,都用來達到同一種目的。區別在於,前者自帶執行器,後者通過for await...of
執行,或者自己編寫執行器。下面就是一個異步Generator函數的執行器。
async function takeAsync(asyncIterable, count=Infinity) {
const result = [];
const iterator = asyncIterable[Symbol.asyncIterator]();
while (result.length < count) {
const {value,done} = await iterator.next();
if (done) break;
result.push(value);
}
return result;
}
上面代碼中,異步Generator函數產生的異步遍歷器,會通過while
循環自動執行,每當await iterator.next()
完成,就會進入下一輪循環。
下面是這個自動執行器的一個使用實例。
async function f() {
async function* gen() {
yield 'a';
yield 'b';
yield 'c';
}
return await takeAsync(gen());
}
f().then(function (result) {
console.log(result); // ['a', 'b', 'c']
})
異步Generator函數出現以後,JavaScript就有了四種函數形式:普通函數、async
函數、Generator函數和異步Generator函數。請注意區分每種函數的不同之處。
最後,同步的數據結構,也可以使用異步Generator函數。
async function* createAsyncIterable(syncIterable) {
for (const elem of syncIterable) {
yield elem;
}
}
上面代碼中,由於沒有異步操作,所以也就沒有使用await
關鍵字。
yield* 語句
yield*
語句也可以跟一個異步遍歷器。
async function* gen1() {
yield 'a';
yield 'b';
return 2;
}
async function* gen2() {
const result = yield* gen1();
}
上面代碼中,gen2
函數裏面的result
變量,最後的值是2
。
與同步Generator函數一樣,for await...of
循環會展開yield*
。
(async function () {
for await (const x of gen2()) {
console.log(x);
}
})();
// a
// b