異步編程是 JavaScript 的核心難題,而 jQuery 在這方面的探索史,本身就是一部小型的框架進化史。本文梳理 jQuery 1.8 之前 Deferred(異步列隊)相關模塊的誕生、分裂與重構過程。
jQuery 在 1.5 引入了 Deferred 對象,當時它還沒有獨立成模塊,而是塞在核心裡;直到 1.5.2 才被拆分出來。它最初擁有兩個構造器:_Deferred、Deferred,以及一個 when 方法。
出於變量跨作用域共用的考慮,jQuery 實現異步列隊時並沒有採用面向對象方式,而是把 _Deferred 當作一個工廠方法,返回一個不透明的函數列隊。之所以說「不透明」,是因為它的狀態與元素都用閉包保護起來了,只能通過列隊對象暴露的方法操作:
done —— 添加函數resolveWith —— 在指定作用域下執行所有函數resolve —— 執行所有函數isResolved —— 判定是否已調用過 resolvecancel —— 中斷執行_Deferred 自始至終都是內部方法,從未在文檔中公開。
有意思的是血統問題:Deferred 本是 Python 世界大名鼎鼎的 Twisted 框架的產物,由早期七大 JS 類庫之一的 MochiKit 取經回來,最後被 Dojo 繼承衣缽。jQuery 為了避免抄襲惡名,把方法名改得面目全非,結果成了 jQuery 命名最難懂的 API。
Dojo jQuery 說明
addBoth then 同時添加正常回調與錯誤回調
addCallback done 添加正常回調
addErrback fail 添加錯誤回調
callback done 執行所有正常回調
errback reject 執行所有錯誤回調
doneWith resolveWith 在指定作用域下執行所有正常回調
rejectWith 在指定作用域下執行所有錯誤回調
promise promise 返回外界無法改變其狀態的 Deferred 對象
when 用於實現「回調的回調」——幾個異步列隊都完成後,再執行另一批回調。這些後續回調同樣用 done、fail 添加,但 when 返回的對象已經具備了 Promise 的性質:只負責添加回調與讓外界窺探狀態,一旦前段回調全部觸發,它就自然進入正常列隊(deferred)或錯誤列隊(failDeferred)。
$.when({aa:1}, {aa:2}).done(function(a, b) {
console.log(a.aa); // 1
console.log(b.aa); // 2
});
對於普通數據類型,when 有多少個參數,後面的 done、fail 回調就有多少個參數:
function fn() { return 4; }
function log(s) { window.console && console.log(s); }
$.when({ num: 1 }, 2, '3', fn()).done(function(o1, o2, o3, o4) {
log(o1.num); // 1
log(o2); // 2
log(o3); // 3
log(o4); // 4
});
若想得到各個異步任務的真實結果,需要用 resolve / resolveWith / reject / rejectWith 傳遞:
var log = function(msg) { window.console && console.log(msg); };
function asyncThing1() {
var dfd = $.Deferred();
setTimeout(function() {
log('asyncThing1 seems to be done...');
dfd.resolve('1111');
}, 1000);
return dfd.promise();
}
function asyncThing2() {
var dfd = $.Deferred();
setTimeout(function() {
log('asyncThing2 seems to be done...');
dfd.resolve('222');
}, 1500);
return dfd.promise();
}
function asyncThing3() {
var dfd = $.Deferred();
setTimeout(function() {
log('asyncThing3 seems to be done...');
dfd.resolve('333');
}, 2000);
return dfd.promise();
}
$.when(asyncThing1(), asyncThing2(), asyncThing3()).done(function(res1, res2, res3) {
log('all done!');
log(res1 + ', ' + res2 + ', ' + res3);
});
異步列隊推出後採用率一直不高(概念太抽象、方法名太糟糕),只能在內部自產自銷。第一個被改造的是 queue 模塊——1.4 為了支持 delay 插件,特地把它從 data 模塊中分化出來,而 data 又是從 event 模塊分出去的。規律很明顯:jQuery 新模塊的誕生,往往源於用戶對既有 API 限制的不滿。
最早的 queue 實現要點:
jQuery.extend({
queue: function( elem, type, data ) {
if ( !elem ) { return; }
type = (type || "fx") + "queue";
var q = jQuery.data( elem, type );
if ( !data ) { return q || []; } // 純查詢時快速返回
if ( !q || jQuery.isArray(data) ) {
q = jQuery.data( elem, type, jQuery.makeArray(data) );
} else {
q.push( data );
}
return q;
},
dequeue: function( elem, type ) {
type = type || "fx";
var queue = jQuery.queue( elem, type ), fn = queue.shift();
if ( fn === "inprogress" ) { fn = queue.shift(); }
if ( fn ) {
if ( type === "fx" ) { queue.unshift("inprogress"); } // 進度哨兵
fn.call( elem, function() { jQuery.dequeue( elem, type ); });
}
}
});
隊列的本意是讓函數同屬一個隊伍、動畫一個接一個執行。而 "inprogress" 這個哨兵值的巧妙之處在於:它能阻止 fx 隊列被自動出隊,保證動畫按序播放。
1.6 添加了 _mark、_unmark 和 promise 三個能力:
關鍵的 handleQueueMarkDefer 函數負責收尾判斷——當 mark 與 queue 都清空時,才把 defer 對象從緩存移除並 resolve:
function handleQueueMarkDefer( elem, type, src ) {
var deferDataKey = type + "defer",
queueDataKey = type + "queue",
markDataKey = type + "mark",
defer = jQuery.data( elem, deferDataKey, undefined, true );
if ( defer &&
( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
// 留出時間讓硬編碼的回調先觸發
setTimeout( function() {
if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
!jQuery.data( elem, markDataKey, undefined, true ) ) {
jQuery.removeData( elem, deferDataKey, true );
defer.resolve();
}
}, 0 );
}
}
promise 方法則通過一個計數器 count 等待所有元素各自的 defer 完成:
promise: function( type, object ) {
var defer = jQuery.Deferred(), elements = this, i = elements.length, count = 1;
function resolve() {
if ( !( --count ) ) { defer.resolveWith( elements, [ elements ] ); }
}
while( i-- ) {
if (( tmp = jQuery.data( elements[i], deferDataKey, undefined, true ) ||
( jQuery.data( elements[i], queueDataKey, undefined, true ) ||
jQuery.data( elements[i], markDataKey, undefined, true ) ) &&
jQuery.data( elements[i], deferDataKey, jQuery._Deferred(), true ) )) {
count++;
tmp.done( resolve );
}
}
resolve();
return defer.promise();
}
1.6 中 $.XHR 對象(XMLHttpRequest 的仿造器)由一個 Deferred 與一個 _Deferred 構成:
deferred = jQuery.Deferred(),
completeDeferred = jQuery._Deferred(),
jqXHR = { /**/ }
// ...
deferred.promise( jqXHR );
jqXHR.success = jqXHR.done;
jqXHR.error = jqXHR.fail;
jqXHR.complete = completeDeferred.done;
1.7 從 deferred 模塊中分化出 callback 模塊,本質上是 _Deferred 的增強版,新增了去重、鎖定、return false 時中斷執行下一個回調、清空等功能。
它通過 flags 字符串控制行為:
once —— 只能 fire 一次(類似 Deferred)memory —— 記住之前的值,後加入的回調會立即用最新值執行unique —— 同一個回調只能添加一次stopOnFalse —— 回調返回 false 時中斷後續執行jQuery.Callbacks = function( flags ) {
flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
var list = [], stack = [], memory, firing,
firingStart, firingLength, firingIndex;
var add = function( args ) {
var i, length, elem, type;
for ( i = 0, length = args.length; i < length; i++ ) {
elem = args[ i ];
type = jQuery.type( elem );
if ( type === "array" ) {
add( elem ); // 遞歸展開數組
} else if ( type === "function" ) {
if ( !flags.unique || !self.has( elem ) ) {
list.push( elem );
}
}
}
};
var fire = function( context, args ) {
args = args || [];
memory = !flags.memory || [ context, args ];
firing = true;
firingIndex = firingStart || 0;
firingStart = 0;
firingLength = list.length;
for ( ; list && firingIndex < firingLength; firingIndex++ ) {
if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
memory = true; // 標記為已中止
break;
}
}
firing = false;
// ...
};
// self: add / remove / has / empty / disable / disabled
// lock / locked / fireWith / fire / fired
return self;
};
這期間還有個小插曲:jQuery 團隊曾想增加一個叫 Topic 的模塊,內置發布者—訂閱者機制。但封裝太薄,最終被否決。
jQuery.Topic = function( id ) {
var callbacks, topic = id && topics[ id ];
if ( !topic ) {
callbacks = jQuery.Callbacks();
topic = {
publish: callbacks.fire,
subscribe: callbacks.add,
unsubscribe: callbacks.remove
};
if ( id ) { topics[ id ] = topic; }
}
return topic;
};
儘管大量代碼被搬進 Callbacks,1.7 的 Deferred 體積並沒有變小——它由三個函數列隊組成,返回的是 Promise 對象,比原來多出 pipe、state、progress、always 等方法。AJAX 那邊相應變成:
deferred = jQuery.Deferred(),
completeDeferred = jQuery.Callbacks( "once memory" ),
deferred.promise( jqXHR );
jqXHR.success = jqXHR.done;
jqXHR.error = jqXHR.fail;
jqXHR.complete = completeDeferred.add;
同一時期,hooks 機制正在 jQuery 內部快速擴散:
cssHooksattrHooks、propHooks、boolHooks、nodeHooksfixHooks、keyHooks、mouseHooks_queueHooks有了 _queueHooks,queue 終於瘦身了:
dequeue: function( elem, type ) {
type = type || "fx";
var queue = jQuery.queue( elem, type ),
fn = queue.shift(),
hooks = jQuery._queueHooks( elem, type ),
next = function() { jQuery.dequeue( elem, type ); };
if ( fn === "inprogress" ) { fn = queue.shift(); }
if ( fn ) {
if ( type === "fx" ) { queue.unshift( "inprogress" ); }
delete hooks.stop; // 清理上一次的 stop 函數
fn.call( elem, next, hooks );
}
if ( !queue.length && hooks ) { hooks.empty.fire(); }
},
_queueHooks: function( elem, type ) {
var key = type + "queueHooks";
return jQuery._data( elem, key ) || jQuery._data( elem, key, {
empty: jQuery.Callbacks("once memory").add(function() {
jQuery.removeData( elem, type + "queue", true );
jQuery.removeData( elem, key, true );
})
});
}
1.8 中動畫模塊迎來第三次大重構,引入 Tween.propHooks 鉤子,並派生出兩個新對象:Animation 返回一個異步列隊,Tween 負責處理單個樣式或屬性的變化(相當於舊的 Fx 對象)。曾經近百行的 animate 被徹底抽空:
animate: function( prop, speed, easing, callback ) {
var empty = jQuery.isEmptyObject( prop ),
optall = jQuery.speed( speed, easing, callback ),
doAnimation = function() {
// 操作副本,避免 per-property easing 丟失
var anim = Animation( this, jQuery.extend( {}, prop ), optall );
if ( empty ) { anim.stop( true ); } // 空動畫立即 resolve
};
return empty || optall.queue === false ?
this.each( doAnimation ) :
this.queue( optall.queue, doAnimation );
}
到 1.8 為止,jQuery 把所有異步機制都改造成了異步列隊的「變種」:domReady、動畫、AJAX,以及調用過 promise、delay 或各種特效方法後的 jQuery 對象。這套設計的終極目標是——讓異步代碼能像同步代碼那樣按順序書寫。
而鉤子機制與模塊拆分,則是把早期那些龐大的巨型方法逐步拆解的正確手段。如今超長方法只剩下節點模塊與回調模塊這兩處。