jquery deferred对象解析
建议先看下callbacks对象的实现
Deferred 是callbacks 方法的封装调用。开启三个队列实例，分别是resolve，reject，notify。将每个队列开启list.add方法，并且分别指向自己的done、fail、progress
。
触发 resolve，reject方法，实际上指向的是callbacks的 fireWith方法，直接触发了队列。所以先使用then方法，加入队列中，然后使用resolve， reject来进行队列的触发，关闭等操作~
简单调用方法
var d = new Deferred();
d.then(function(
console.info('resolve done');
),function(){
console.info('reject fail');
},funciton() {
console.info('notify progress);
});
// ====不能同时触发===可以单个执行===
// 直接触发done
d.resolve();
// fail
d.reject();
// pregress
d.notify();
deferred的中文注解
jQuery.extend({
Deferred: function( func ) {
var tuples = [
// once more 保证添加到队列的，只执行一次，并且一旦add立即触发
// action, add listener, listener list, final state
[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
[ "notify", "progress", jQuery.Callbacks("memory") ]
],
state = "pending",
promise = {
state: function() {
return state;
},
always: function() {
deferred.done( arguments ).fail( arguments );
return this;
},
then: function( /* fnDone, fnFail, fnProgress */ ) {
var fns = arguments;
// jQuery.Defered(func()).promise();
return jQuery.Deferred(function( newDefer ) {
jQuery.each( tuples, function( i, tuple ) {
// resolve/reject/notify
var action = tuple[ 0 ],
// 如果没有fnsi 那么久违undefined
fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
// deferred[ done | fail | progress ] for forwarding actions to newDefer
// deferred['done']() | deferred['fail']() |deferred['progress']() 在下面有定义
// 实际上这里的deferred done 指向的是list.add，将done，fail，progress的方法都进行了队列添加
deferred[ tuple[1] ](function() {
// 直接调用fn方法，得到返回结果（这个returned是deferred对象么？为什么可以调用returned.promise）
var returned = fn && fn.apply( this, arguments );
if ( returned && jQuery.isFunction( returned.promise ) ) {
// 将方法扩展到deferred对象实例，然后执行done，fail，progress方法
// 实际上是进行了callbacks的add调用，不过进行了区分顺序
returned.promise()
.done( newDefer.resolve )
.fail( newDefer.reject )
.progress( newDefer.notify );
} else {
newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
}
});
});
fns = null;
}).promise();
},
// Get a promise for this deferred
// If obj is provided, the promise aspect is added to the object
// 将promise和obj进行合并
promise: function( obj ) {
return obj != null ? jQuery.extend( obj, promise ) : promise;
}
},
deferred = {};
// Keep pipe for back-compat
promise.pipe = promise.then;
// Add list-specific methods
// 建立resolve,reject,notify的队列实例，并且对done,fail,progress指向list.add 使其可以对自己的队列进行添加方法
jQuery.each( tuples, function( i, tuple ) {
// 队列实例
var list = tuple[ 2 ],
stateString = tuple[ 3 ];
// promise[ done | fail | progress ] = list.add
// 将队列实例的add方法赋值给promise的 resolve/reject/notify
// 引用add方法
promise[ tuple[1] ] = list.add;
// Handle state
if ( stateString ) {
list.add(function() {
// state = [ resolved | rejected ]
state = stateString;
// [ reject_list | resolve_list ].disable; progress_list.lock
// 执行了异或运算，将列表置为disable，将最后的notify lock
// 0 ^ 1 = 1
// 1 ^ 1 = 0
}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
}
// deferred[ resolve | reject | notify ]
// 组装deferred对象 添加 resolve,reject,notify属性方法
deferred[ tuple[0] ] = function() {
deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
return this;
};
// 组装deferred对象 添加resolveWith,rejectWith,notifyWith对象指向callbacks的FireWire方法
// fireWith 是用来拼接list的方法~
deferred[ tuple[0] + "With" ] = list.fireWith;
});
// Make the deferred a promise
// 组装deferred对象 将promise合并到deferred
promise.promise( deferred );
// Call given func if any
// 直接调用该方法~
if ( func ) {
func.call( deferred, deferred );
}
// All done!
// deferred 对象包含了 resolve,reject,notify,resolveWith,rejectWith,notifyWith,pipe,done,fail,progress,state,always,then,promise
return deferred;
},
// Deferred helper
when: function( subordinate /* , ..., subordinateN */ ) {
var i = 0,
resolveValues = core_slice.call( arguments ),
length = resolveValues.length,
// the count of uncompleted subordinates
remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
// Update function for both resolve and progress values
updateFunc = function( i, contexts, values ) {
return function( value ) {
contexts[ i ] = this;
values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
if( values === progressValues ) {
deferred.notifyWith( contexts, values );
} else if ( !( --remaining ) ) {
deferred.resolveWith( contexts, values );
}
};
},
progressValues, progressContexts, resolveContexts;
// add listeners to Deferred subordinates; treat others as resolved
if ( length > 1 ) {
progressValues = new Array( length );
progressContexts = new Array( length );
resolveContexts = new Array( length );
for ( ; i < length; i++ ) {
if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
resolveValues[ i ].promise()
.done( updateFunc( i, resolveContexts, resolveValues ) )
.fail( deferred.reject )
.progress( updateFunc( i, progressContexts, progressValues ) );
} else {
--remaining;
}
}
}
// if we're not waiting on anything, resolve the master
if ( !remaining ) {
deferred.resolveWith( resolveContexts, resolveValues );
}
return deferred.promise();
}
});
