jquery1.83 之前所有与异步列队相关的模块详细介绍_jquery

(function( jQuery ) {
function handleQueueMarkDefer( elem, type, src ) {
//清空记录deferred个数的队字段，函数列队与异步列
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 ); .resolve();
}
}, 0
}
}
jQuery.extend({
_mark: function( elem, type ) {
if ( elem ) {
type = (type || "fx") "mark";//创建一个以mark为后缀的字段，用于记录此列队中的个数
jQuery.data( elem, type, (jQuery.data(elem,类型,未定义,true) || 0) 1, 正确);
}
},
_unmark: function(force, elem, type ) {
if (force !== true ) {
type = elem;
elem = 力；
力=假；
}
if ( elem ) {
type = type || “fx”；
var key = type "mark",
//让个数减1，如果第一个参数为true，就强逼减至0
count = force ? 0 : ( (jQuery.data( elem, key, 未定义, true) || 1 ) - 1 );
if ( count ) {
jQuery.data( elem, key, count, true );
} else {//如果为0，就移除它
jQuery.removeData( elem, key, true );
handleQueueMarkDefer( elem, type, "mark" );
}
}
},
队列: function( elem, type, data ) {
if ( elem ) {
type = (type || "fx") "queue ”;
var q = jQuery.data( elem, type, undefined, true );
// 如果这只是一个查找，则通过快速退出来加速出队
if ( data ) {
if ( !q || jQuery.isArray(data) ) {
q = jQuery.数据( elem, 类型, jQuery.makeArray(data), true );
} else {
q.push( 数据 );
}
}
返回q || []；
}
},
出队: function( elem, type ) {
type = type || “fx”；
var queue = jQuery.queue( elem, type ),
fn = queue.shift(),
defer;
// 如果 fx 队列出队，总是删除进度标记
if ( fn === "inprogress" ) {
fn = queue.shift();
}
if ( fn ) {
// 添加进度哨兵，防止 fx 队列被
// 自动出列
if ( type === "fx" ) {
queue.unshift("进行中");
}
fn.call(elem, function() {
jQuery.dequeue(elem, type);
});
}
if ( !queue.length ) {
jQuery.removeData( elem, type "queue", true );
handleQueueMarkDefer( elem, type, "queue" );
}
}
});
jQuery.fn.extend({
queue: function( type, data ) {
if ( typeof type !== "string" ) {
data = type;
type = " fx";
}
if ( data === undefined ) {
return jQuery.queue( this[0], type );
}
return this.each(function() {
var queue = jQuery.queue( this, type, data );
if ( type === "fx" && queue[0] !== "inprogress" ) {
jQuery.dequeue(这个，类型 );
}
});
出队：函数( type ) {
返回 this.each(function() {
jQuery.dequeue( this , type );
},
// 基于 Clint Helfers 的插件，经许可。 /07/jquery-delay/
延迟：函数( time, type ) {
time = jQuery.fx ? jQuery.fx.speeds[time] || time : time; "fx";
return this.queue( type, function() {
var elem = this;
setTimeout(function() {
jQuery.dequeue( elem, type );
}, 时间 );
},
clearQueue: function( type ) {
return this.queue( type || "fx",
},
//把 jQuery 对象装进一个异步列队，允许它在一系列动画中再执行之后绑定的回调
promise: function( type, object ) {
if ( typeof type !== "字符串" ) {
对象 = 类型;
类型=未定义；
}
类型 = 类型 || “fx”；
var defer = jQuery.Deferred(),
elements = this,
i = elements.length,
count = 1,
deferDataKey = type "defer",
queueDataKey =输入“队列”，
markDataKey = 输入“标记”；
函数resolve() {
if ( !( --count ) ) {
defer.resolveWith( elements, [ elements ] );
}
}
while( i-- ) {
//如果之前已经使用过unmark、queue等方法，那么我们将生成一个新的延迟传感器硬盘系统
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();
返回 defer.promise();
}
});
})( jQuery );

deferred = jQuery.Deferred(),
completeDeferred = jQuery._Deferred(),
jqXHR ={/**/}
//....
deferred.promise( jqXHR );
jqXHR.success = jqXHR.done;
jqXHR.error = jqXHR.fail;
jqXHR.complete = completeDeferred.done;

(function( jQuery ) {
// 字符串到对象标志格式缓存
var flagsCache = {};
// 将字符串格式的标志转换为对象格式的标志并存储在缓存
function createFlags( flags ) {
var object = flagsCache[ flags ] = {},
i, length;
flags = flags.split( /s / ); i = 0, length = flags.length; i
object[ flags[i] ] = true;
返回对象;
* 使用以下参数创建回调列表：
*
* 标志：以空格分隔的标志的可选列表，将更改
* 回调列表的行为方式
*
* 默认情况下，回调列表将像事件回调列表一样，并且可以
*“触发”多次
*
* 可能的标志：
*
*一次：将确保回调列表只能被触发一次（如延迟）
*
* 内存：将跟踪以前的值，并在列表被立即触发后调用任何添加的回调
* 最新的“记忆”
*值（如延迟）
*
*唯一：将确保回调只能添加一次（列表中没有重复）
*
* stopOnFalse：中断调用当回调返回 false
*
*/
jQuery.Callbacks = function( flags ) {
// 将标志从字符串格式转换为对象格式
// （我们签入首先缓存）
flags = flags ? ( flagsCache[ 标志 ] || createFlags( 标志 ) ) : {};
var // 实际回调列表
list = [],
// 可重复列表的 fire 调用堆栈
stack = [],
// 最后的 fire 值（用于不可忘记的） list)
memory,
// 标记以了解列表当前是否正在触发
firing,
// 第一个触发回调（由 add 和 fireWith 内部使用）
firingStart,
// 触发时循环结束
firingLength,
// 当前触发回调的索引（如果需要，可通过删除进行修改）
firingIndex,
// 将一个或多个回调添加到列表
add = function( args ) {
var i,
长度,
elem,
类型,
实际;
for ( i = 0, length = args.length; i elem = args[ i ];
type = jQuery.type( elem );
if ( type === "array" ) {
// 递归检查
add( elem );
} else if ( type === "function" ) {
// 添加 if 不是唯一模式并且回调不在
if ( !flags.unique || !self.has( elem ) ) {
list.push( elem );
}
}
}
},
// 触发回调
fire = function( context, args ) {
args = args || []；
内存 = !flags.内存 || [上下文，参数]；
开火= true；
fireingIndex = fireStart || 0;
点火开始 = 0;
fireingLength = list.length;
for ( ; list &&fireingIndex if (list[fireingIndex].apply( context, args ) === false && flags.stopOnFalse ) {
内存 = true; // 标记为停止
break;
}
}
开火= false；
if ( list ) {
if ( !flags.once ) {
if ( stack && stack.length ) {
内存 = stack.shift();
self.fireWith( 内存[ 0 ], 内存[ 1 ] );
}
} else if (内存 === true ) {
self.disable();
} else {
list = [];
}
}
},
// 实际回调对象
self = {
// 将回调或回调集合添加到列表
add: function( ) {
if ( list ) {
var length = list.length;
添加（参数）；
// 我们是否需要将回调添加到
// 当前触发批次？
if (fireing) {
firingLength = list.length;
// 有了内存，如果我们没有开火，那么
// 我们应该立即调用，除非之前的
// 开火被停止 (stopOnFalse)
} else if ( memory && memory ! == true ) {
firingStart = 长度;
火（内存[0]，内存[1]）；
}
}
返回此；
},
// 从列表中删除回调
remove: function() {
if ( list ) {
var args = arguments,
argIndex = 0,
argLength = args.length;
for ( ; argIndex for ( var i = 0; i if ( args[ argIndex ] === list[ i ] ) {
// 处理firingIndex 和firingLength
if (firing ) {
if ( i firingLength--;
if ( i fireingIndex--;
}
}
}
//删除元素
list.splice( i--, 1 );
// 如果我们有一些唯一性属性，那么
// 我们只需要执行一次
if ( flags.unique ) {
break;
}
}
}
}
}
返回此；
},
// 控制给定回调是否在列表中
has: function( fn ) {
if ( list ) {
var i = 0,
length =列表长度；
for ( ; i if ( fn === list[ i ] ) {
返回 true;
}
}
}
返回 false；
},
// 从列表中删除所有回调
empty: function() {
list = [];
返回这个；
},
// 让列表不再执行任何操作
disable: function() {
list = stack = memory = undefined;
返回这个；
},
//是否禁用？
禁用：function() {
return !list;
},
// 将列表锁定在当前状态
lock: function() {
stack = undefined;
if ( !内存 || 内存 === true ) {
self.disable();
}
返回此；
},
//是否已锁定？
锁定： function() {
return !stack;
},
// 使用给定的上下文和参数调用所有回调
fireWith: function( context, args ) {
if ( stack ) {
if (fireing ) {
if ( !flags.once ) {
stack.push( [ context, args ] );
}
} else if ( !( flags.once && memory ) ) {
fire( context, args );
}
}
返回此；
},
// 使用给定参数调用所有回调
fire: function() {
self.fireWith( this,arguments );
返回这个；
},
// 了解回调是否已被调用至少一次
fired: function() {
return !!memory;
}
};
返回自我；
}；
})( jQuery );

(function( jQuery ) {
var topic = {},
sliceTopic = [].slice;
jQuery.Topic = function( id ) {
var 回调,
方法,
topic = id && 主题[ id ]; topic ) {
callbacks = jQuery.Callbacks()
topic = {
发布：callbacks.fire，
订阅：callbacks.add，
取消订阅：callbacks.remove
} ;
if ( id ) {
topics[ id ] = topic;
}
返回主题
}
jQuery.extend({
订阅: function( id ) {
var topic = jQuery.Topic( id ),
args = sliceTopic.call(args, 1 );
topic.subscribe.apply( topic, args ); return {
主题：主题，
args
};
取消订阅：函数( id ) {
var topic = id && id.topic || jQuery.主题( id );
topic.unsubscribe.apply( topic, id && id.args ||
sliceTopic.call( 参数, 1 ) );
},
发布: 函数( id ) {
var topic = jQuery.Topic( id );
topic.publish.apply( topic, sliceTopic.call(arguments, 1 ) );
}
});
})( jQuery );


虽然把大量代码移动回调，但1.7的Deferred却一点没变小，它变得更重型，由三个函数列队组成了。并且返回的是Promise对象，比原来多长了pipe, state,progress,always方法。ajax端就变成这样：

jqXHR.success = jqXHR.done;
jqXHR.error = jqXHR.fail;
jqXHR.complete =completeDeferred.add;


队列两边也变了多少。