var calresolve = $.Callbacks('once memory'),calreject  = $.Callbacks('once memory'),calnotify  = $.Callbacks('memory');var state = function(){state = stateString;
}calresolve.add(state,calreject.disable,calnotify.lock);
calreject.add(state,calresolve.disable,calnotify.lock);

var fn1 = function(value){alert('fn1:' + value)
}
var def = $.Deferred();
def.done(fn1);              //相当于$.Callbacks('once memory').add(fn1)
def.resolve('littledu');    //相当于$.Callbacks('once memory').fire('littledu')

Deferred: function( func ) {//声明一个二维数组，分别存放3个状态的数组，需先了解jQuery.Callbacks。var tuples = [// 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",   //回调状态值，分别有pending,resolved和rejectedpromise = {state: function() {return state;},always: function() {deferred.done( arguments ).fail( arguments );return this;},then: function( /* fnDone, fnFail, fnProgress */ ) {var fns = arguments;return jQuery.Deferred(function( newDefer ) {jQuery.each( tuples, function( i, tuple ) {var action = tuple[ 0 ],fn = fns[ i ];// deferred[ done | fail | progress ] for forwarding actions to newDeferdeferred[ tuple[1] ]( jQuery.isFunction( fn ) ?function() {var returned = fn.apply( this, arguments );if ( returned && jQuery.isFunction( returned.promise ) ) {returned.promise().done( newDefer.resolve ).fail( newDefer.reject ).progress( newDefer.notify );} else {newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );}} :newDefer[ action ]);});fns = null;}).promise();},// Get a promise for this deferred// If obj is provided, the promise aspect is added to the objectpromise: function( obj ) {return obj != null ? jQuery.extend( obj, promise ) : promise;}},deferred = {};  //声明deferred对象// Keep pipe for back-compatpromise.pipe = promise.then;// Add list-specific methods//jQuery.each( tuples, function( i, tuple ) {var list = tuple[ 2 ],  //保存Callbacks对象stateString = tuple[ 3 ];  //保存状态值// promise[ done | fail | progress ] = list.add// 给promise添加方法，分别为done,fail,progress，绑定对应Callbacks的add方法，相当于调用deferred对象的done,fail,progress时，都是调用其Callbacks对象的add方法。// promise.done = list.add// promise.fail = list.add// promise.progress = list.addpromise[ tuple[1] ] = list.add;// Handle state// action, add listener, listener list, final state//[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],//[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],//将状态函数等扔进队列if ( stateString ) { //stateString只有前两个数组有值，为前两个数组的Callbacks对象添加回调，均有一个存储state的匿名函数和另外两个Callbacks方法。其中第一个数组添加的是第二个数组的Callbacks对象的disable方法，第二个添加的是第一个数组的Callbacks对象的disable方法。lock方法则均为第3个数组的Callbacks对象所有//[state,reject.disable,notify.lock]//[state,resolve.disable,notify.lock]//var dfd = $.Deferred();//dfd.done(fn1) => [state,reject.disable,notify.lock,fn1]//dfd.state() => 在执行done的时候，第一个匿名函数就是设置state值的list.add(function() {// state = [ resolved | rejected ]state = stateString;// [ reject_list | resolve_list ].disable; progress_list.lock// 0^1=1 1^1=0}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );}// deferred[ resolve | reject | notify ] = list.fire// 这里，相当于deferred对象调用resolve,reject,notify时，都执行回调队列里的回调deferred[ tuple[0] ] = list.fire;deferred[ tuple[0] + "With" ] = list.fireWith;});// Make the deferred a promise// 将promise的方法推入deferred，此时promise有的deferred都有，deferred有的promise不一定有，如resolve和rejectpromise.promise( deferred );// Call given func if any// 如果jQuery.Deferred(fn)有传入函数，则会执行这里，函数的context将会是deferred，参数也是deferred，在then中有用到，也可以外部直接传入函数中使用if ( func ) {func.call( deferred, deferred );}// All done!return deferred;},// Deferred helper// when，可以理解为deferred的一个中转站，比如我有一个函数，我要在这个函数执行完后再触发回调，when就是做这样的工作，它需要这个函数返回deferred对象，然后返回的是deferred.promise对象，从而可以实现$.when(fn).done(fnDone)的链式操作，因为done其实也就是Callbacks.add，所以这里相当于fnDone这个回调push进回调数组，然后在所传的函数里面有一句resolve()或reject()执行一下回调数组，从而触发回调。就是这样。// PS:对于when我还有很多不明白，比如传多个函数，有人说要两个函数都resolve，才能执行done，但我测试回调的done或fail是以第一个函数为准的，也就是说如果它为resolve，那么回调会进入done，否则则进入fail，还有待观察when: function( subordinate /* , ..., subordinateN */ ) {var i = 0,resolveValues = core_slice.call( arguments ),  //将deferred对象转化为数组length = resolveValues.length,// the count of uncompleted subordinates// 如果length不等于1，则直接返回length，如果length==1，则要看所传的函数是不是deferred对象，如果不是返回0，是的话返回length(1)remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,// the master Deferred. If resolveValues consist of only a single Deferred, just use that.// 如果remaining==1，则说明所传函数是deferred对象，直接使用它，否则重新创建一个新的deferred对象deferred = remaining === 1 ? subordinate : jQuery.Deferred(),// Update function for both resolve and progress valuesupdateFunc = 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// 如果所传函数不是deferred对象，则立即执行回调，这里用了resolveWidth，表明执行的都是done方法，resolveContexts为undefined，表明回调执行的上下文在windowif ( !remaining ) {deferred.resolveWith( resolveContexts, resolveValues );}return deferred.promise();}