鏈式調用我們天天在用,比如 jQuery 的 $(ele).show().find(child).hide(),又比如 AngularJS 的 $http.get(url).success(fn_s).error(fn_e)。但這些都是已經包裝好的成品,我們享受了鏈式調用帶來的順手,卻很少去想背後是怎麼串起來的。
隨著鏈式調用普及,實作方案也越來越多。最常見的三種是:jQuery 直接回傳 this、underscore 的可選式(_.chain()),以及 lodash 的惰性求值。下面逐一拆解,並各寫一個 demo。
這是最常見、也是所有方案的基礎。我們做一個簡單的鏈式運算類,首先得有個欄位保存結果:
function A(num) {
this.value = num || 0; // 這裡就不做傳參校驗了
}
接著加上運算方法,關鍵是每個方法都要把 this 回傳出去:
A.prototype.add = function(a) { this.value += a; return this; };
A.prototype.reduce = function(a) { this.value -= a; return this; };
最後補上兩個轉換方法,方便觀察結果:
A.prototype.valueOf = function() { return this.value; };
A.prototype.toString = function() { return this.value + ''; };
驗證一下:
var a = new A(2); alert(a.add(1).reduce(2)); // 1
這個 demo 簡單到不需要任何說明,我們直接進入第二種。
underscore 規定了兩種呼叫風格:_.forEach(arr, fn) 這種直接呼叫,以及 _.chain(arr).forEach(fn).map(fn) 這種鏈式。
先實作前者。這裡不談 underscore 的細節,只簡化實作 forEach 與 map,且僅處理陣列:
var _ = {};
_.forEach = function(array, fn) {
array.forEach(function(v, i, array) { fn.apply(v, [v, i, array]); });
};
_.map = function(array, fn) {
return array.map(function(v, i, array) { return fn.apply(v, [v, i, array]); });
};
接下來問題來了:要支援鏈式,第一步該做什麼?觀察第二種呼叫方式可以發現,無論 forEach 還是 map 都是在 _.chain(arr) 的回傳值上呼叫的。所以 _.chain(arr) 必須回傳一個物件,而這個物件上要有與 _ 相同的方法,只是原來的第一個參數被固定成了 chain 傳入的那份資料。
確定了要回傳物件,那它的建構函式怎麼寫?我們借用 _ 這個變數本身來充當——函式也是物件,把 _ 從物件改成函式,不會破壞既有的邏輯:
var _ = function(array) {
this._value = Array.prototype.slice.apply(array);
};
_.forEach = function(array, fn) {
array.forEach(function(v, i, array) { fn.apply(v, [v, i, array]); });
};
_.map = function(array, fn) {
return array.map(function(v, i, array) { return fn.apply(v, [v, i, array]); });
};
_.chain = function(array) { return new _(array); };
新建構函式有了,但它生成的物件除了 _value 之外一片空白。怎麼把 _ 上的方法稍作修改後搬過去?用迴圈加閉包:
for (var i in _) {
if (i !== 'chain') { // chain 不需要搬
_.prototype[i] = (function(i) {
// i 是迴圈變數,必須靠閉包轉成局部變數,否則全部會指向最後一個值
return function() {
var args = Array.prototype.slice.apply(arguments);
args.unshift(this._value); // 把 _value 塞進參數第一位
if (i === 'map') {
// map 有回傳值,需要更新 _value
this._value = _[i].apply(this, args);
} else {
// forEach 沒有回傳值,_value 保持不變
_[i].apply(this, args);
}
return this; // 回傳 this 才能繼續串下去
};
})(i);
}
}
最後模仿 underscore,補一個 value() 取出結果:
_.prototype.value = function() { return this._value; };
驗證:
var a = [1, 2, 3];
_.forEach(a, function(v){ console.log(v); });
alert(_.map(a, function(v){ return ++v; }));
alert(_.chain(a).map(function(v){ return ++v; })
.forEach(function(v){ console.log(v); })
.value());
最複雜的來了。先解釋什麼是惰性調用。
看 _.chain(arr).forEach(fn).map(fn).value() 這個鏈:執行到 chain(arr) 時回傳一個物件;執行到 forEach 時開始輪詢,跑完再回傳該物件;執行到 map 時又輪詢一次,跑完再回傳;最後 value 取出 _value。每一步都是獨立、依序完成的。
惰性調用則是:執行到 forEach 時不跑,只是把這個操作塞進佇列;執行到 map 時再把 map 也塞進佇列。那什麼時候才真正執行?當某個特定操作(例如 value)被塞進佇列時,才一口氣把前面排隊的全部跑完。
惰性調用有什麼好處?傳統鏈式操作的格式是 obj.job1().job2().job3(),整條鏈上就只有 job,沒有 controller。如果需求變成「連續執行 100 次 job1-3」,傳統寫法得重複 100 次,或者用 for 迴圈把整條鏈打斷。而加上 controller 之後,用惰性調用可以寫成 obj.loop(100).job1().job2().job3().end().done()——loop 宣告開啟 100 次迴圈,end 結束本次迴圈,done 是開始執行的標誌。程式碼量差得非常明顯。
動手實作。既然任何 controller 或 job 的呼叫都是「把操作塞進佇列」,那建構函式自然要有個佇列屬性;有了佇列,就得有索引標明目前執行到哪;要做 loop,還需要總次數與目前次數,以及一個記錄迴圈起點的屬性:
function Task() {
this.queen = []; // 任務佇列
this.queenIndex = 0; // 目前執行的索引
this.loopCount = 0; // loop 總次數
this.loopIndex = 0; // 目前是第幾次 loop
this.loopStart = 0; // 本次 loop 從佇列哪一項開始
}
接著實作 controller 與 job,以 job()、loop()、end()、done() 為例。它們其實各有兩副面孔:一副是本身的業務邏輯(job 就是 do something;loop 負責記錄 loopCount 與 loopStart;end 負責 loopIndex + 1 並判斷是否要跳回 loopStart),另一副則是不管業務是什麼,一律把對應操作塞進任務佇列——這副面孔可以視為前一種的「包裝器」。
既然最終呼叫格式是 new Task().loop(100).job().end().done(),那鏈上的方法就是包裝器,該放在 Task.prototype 上;而第一種形態(真正的業務邏輯)就放到 Task.prototype.__proto__ 上:
var _task_proto = {
loop: function(num) {
this.loopStart = this.queenIndex;
this.loopCount = num;
},
job: function(str) {
console.log(str);
},
end: function() {
this.loopIndex++;
if (this.loopIndex < this.loopCount) {
this.queenIndex = this.loopStart; // 回到迴圈起點
} else {
this.loopIndex = 0;
}
},
done: function() {
console.log('done');
}
};
Task.prototype.__proto__ = _task_proto;
然後遍歷 _task_proto,在 Task.prototype 上生成對應的包裝器,並讓每個包裝器回傳 this 以維持鏈式:
for (var i in _task_proto) {
(function(i) {
var raw = Task.prototype[i];
Task.prototype[i] = function() {
// 把實作方法、名稱與參數存進任務佇列
this.queen.push({ name: i, fn: raw, args: arguments });
return this;
};
})(i);
}
現在問題來了:什麼時候開始執行?又怎麼讓任務有條不紊地執行與跳轉?我們在 Task.prototype 上定義一個專門負責調度的方法。由於佇列是依序執行、以索引定位的,與迭代器頗為神似,就把它取名為 next:
Task.prototype.next = function() {
var task = this.queen[this.queenIndex]; // 取出下一個任務
task.fn.apply(this, task.args); // 執行真正的實作並帶入參數
if (task.name !== 'done') {
this.queenIndex++;
this.next(); // 還沒結束,索引 +1 後繼續
} else {
this.queen = []; // 全部跑完,清空佇列
this.queenIndex = 0; // 重置索引
}
};
有了 next,還得在 done 的包裝器上補一句,讓佇列真正啟動:
for (var i in _task_proto) {
(function(i) {
var raw = Task.prototype[i];
Task.prototype[i] = function() {
this.queen.push({ name: i, fn: raw, args: arguments });
if (i === 'done') { this.next(); } // done 是啟動開關
return this;
};
})(i);
}
最後驗證:
var t = new Task();
console.log('1');
t.job('fuck').loop(3).job('world').end()
.loop(3).job('world').end()
.job('!').done();
console.log('2');
t.job('fuck').loop(3).job('world').job('!').end().done();
console.log('3');
t.job('fuck').loop(3).job('world').job('!').end().job('!');
鏈式調用玩到這裡大致完整了。這幾個 demo——尤其是惰性調用那一版——稍加改造就能擴充出相當可觀的能力,像是加入條件跳轉、非同步任務、錯誤處理等,這裡就不再展開。