《JavaScript 設計模式》一書對某種技巧有相當詳細的描述:想實現方法的鏈式呼叫,只要在原型上定義的方法都回傳該實例的參照即可。書中給了這樣一段程式:
(function () {
function _$(els) {
this.elements = [];
for (var i = 0, len = els.length; i < len; ++i) {
var element = els[i];
if (typeof element == 'string') {
element = document.getElementById(element);
}
this.elements.push(element);
}
}
_$.prototype = {
each: function (fn) {
for (var i = 0, len = this.elements.length; i < len; ++i) {
fn.call(this, this.elements[i]);
}
return this;
},
setStyle: function (prop, val) {
this.each(function (el) { el.style[prop] = val; });
return this;
},
show: function () {
var that = this;
this.each(function () { that.setStyle('display', 'block'); });
return this;
},
addEvent: function (type, fn) {
var add = function (el) {
if (window.addEventListener) {
el.addEventListener(type, fn, false);
} else if (window.attachEvent) {
el.attachEvent('on' + type, fn);
}
};
this.each(function (el) { add(el); });
return this;
}
};
window.$ = function () { return new _$(arguments); };
})();
每個方法都以 return this 收尾,於是呼叫結果又被傳給鏈上的下一個方法。問題來了:如果我們要操作的資料是透過非同步請求取得的,鏈還能維持嗎?
答案是不能——至少在直覺上不能。因為 $.ajax() 立刻返回,而資料要等回呼才到,那時 return this 早就執行完了。Dustin Diaz 提供了一個漂亮的解法。
function Queue() {
this._methods = []; // 等待中的回呼
this._response = null; // 非同步取得的結果
this._flushed = false; // 是否已經「沖洗」過
}
Queue.prototype = {
// 加入回呼
add: function (fn) {
if (this._flushed) {
fn(this._response); // 資料已就緒,立刻執行
} else {
this._methods.push(fn); // 否則排入隊列
}
},
// 資料到達時,一次清空隊列
flush: function (resp) {
if (this._flushed) return; // 只 flush 一次
this._response = resp;
this._flushed = true;
while (this._methods[0]) {
this._methods.shift()(resp);
}
}
};
這個設計的關鍵在 _flushed 旗標。在資料到達之前呼叫 add,回呼會被存起來;資料到達後呼叫 flush,隊列中的回呼依序以資料為參數執行。而在 flush 之後才呼叫 add 的話,回呼會立刻執行——這讓「先後順序」在兩種情況下都能正確運作,是整個技巧成立的核心。
(function ($) {
$.fn.fetch = function (url) {
var queue = new Queue;
this.each(function () {
var el = this;
queue.add(function (resp) {
$(el).html(resp);
});
});
$.ajax({
url: url,
dataType: 'html',
success: function (html) { queue.flush(html); }
});
return this;
};
})(jQuery);
於是鏈式呼叫就能跨過非同步的界線繼續下去:
$("<div/>")
.fetch('/server/navigation.html')
.addClass('column')
.appendTo('#side');
若一個隊列裡有很多步驟都要等伺服器回應,可以把它包進建構子裡:
function fetchTweet(url) {
this.queue = new Queue;
this.tweet = "";
var self = this;
ajax(url, function (resp) {
self.tweet = resp;
self.queue.flush(this);
});
}
fetchTweet.prototype = {
linkify: function () {
this.queue.add(function (self) {
self.tweet = self.tweet.replace(/\b@(\w{1,20})\b/g, '$1');
});
return this;
},
filterBadWords: function () {
this.queue.add(function (self) {
self.tweet = self.tweet.replace(/\b(fuck|shit|piss)\b/g, "");
});
return this;
},
appendTo: function (selector) {
this.queue.add(function (self) {
$(self.tweet).appendTo(selector);
});
return this;
}
};
呼叫方式與同步版本別無二致:
fetchTweet(url).linkify().filterBadWords().appendTo('#status');
原文下方的評論區提出了幾個很值得思考的質疑,這裡整理如下。
第一,$.fn.fetch 只是把回傳內容附加到元素上,真的需要 Queue 嗎?jQuery 的 $.fn.load 本來就能做到。若隊列裡只有一個回呼,直接寫就好:
(function ($) {
$.fn.fetch = function (url) {
var queue = new Queue;
this.each(function () {
var el = this;
$.ajax({
url: url,
type: 'get',
dataType: 'json',
success: function (resp) { $(el).html(resp['text1']); }
});
});
return this;
};
})(jQuery);
第二,這個 Queue 實作有個明顯的副作用:flush 之後才 add 的回呼會立即執行,這在語意上讓「鏈式呼叫」變成了「依照註冊時機決定何時執行」,充滿了隱性狀態。用的人若不理解 _flushed,很容易寫出順序錯亂的程式碼。
第三,也是最根本的一點:這個技巧之所以看起來優雅,是因為它把「非同步」偽裝成「同步」。但兩者的本質終究不同——非同步可能失敗,鏈式呼叫卻沒有表達失敗的位置。
今日的答案很清楚:用 Promise。它把「 eventual 的值」變成一等公民,鏈式呼叫自然成立,而且 .catch() 提供了同步鏈永遠缺的那個錯誤分支:
fetch('/server/navigation.html')
.then(function (res) { return res.text(); })
.then(function (html) {
return $("<div/>").addClass('column').appendTo('#side').html(html);
})
.catch(function (e) { console.error('載入失敗', e); });
用 async/await 甚至能寫成完全線性的樣子。Queue 這個實作的價值,在於它示範了「如何把非同步的資料注入到一個同步風格的鏈條裡」這個問題本身——理解了那個問題,才會明白 Promise 為什麼是更好的答案。