jQuery-1.9.1源码分析系列（六） 延时对象续——辅助函数jQuery.when

$.when( { testing: 123 } ).done(
    function(x) { alert(x.testing); } /* alerts "123" */
);

            //
            如果没有传递参数或唯一一个参数且不是一个延时对象,直接解决主延时对象即可
            if ( !remaining ) {
              deferred.resolveWith( resolveContexts, resolveValues );
       }

$.when( $.ajax("test.aspx") ).then(function(data, textStatus, jqXHR){
     alert( jqXHR.status ); // alerts 200
});

            return deferred.promise();

            //
            否则成员延时（Deferred）对象解决的时候才进入该分支判断
            //
            需要等待解决的延时（Deferred）对象数量减一，
            //
            判断还有没有需要等待解决的延时（Deferred）对象，如果有，则判断失败返回
            //
            如果没有则进入分支子代码，执行主延时（Deferred）对象解决deferred.resolveWith（...）
            else
            if ( !( --remaining ) ) {
　　//最终执行到此步的时候values已经变成所有成员延时（Deferred）对象resolve的参数序列
　　deferred.resolveWith( contexts, values );
}

            resolveValues[ i ].promise()
.done( updateFunc( i, resolveContexts, resolveValues ) )

            //
            如果有一个成员延时（Deferred）对象拒绝时，则整个主延时（Deferred）对象直接拒绝
            
.fail( deferred.reject )
.progress( updateFunc( i, progressContexts, progressValues ) );
        

            var d1 = $.Deferred();
var d2 = $.Deferred();
 
$.when( d1, d2 ).done(function ( v1, v2 ) {
    console.log( v1 ); // "Fish"
    console.log( v2 ); // "Pizza"});
 
d1.resolve( "Fish" );
d2.resolve( "Pizza" );

            //
             Deferred helper
when: function( subordinate /* , ..., subordinateN */ ) {
    var i = 0,
        resolveValues = core_slice.call( arguments ),
        length = resolveValues.length, //参数个数//统计没有被解决的成员，//如果参数个数不为1，则remaining为参数个数，//如果参数个数为1且参数是 Deferred（延迟）对象则remaining为参数个数1；否则为0
        remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,

        //初始化主延时对象，如果参数本身是一个延时对象则用参数即可，否则新建.
        deferred = remaining === 1 ? subordinate : jQuery.Deferred(),

        // Update函数处理resolve和progress的值
        updateFunc = function( i, contexts, values ) {
            returnfunction( value ) {
                contexts[ i ] = this;
                values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
                //成员延时（Deferred）对象生成进度通知的时候主延时（Deferred）对象调用进行中的回调
　　　　　　　　　//后面代码.progress( updateFunc( i, progressContexts, progressValues)，往进度回调列表添加函数的时候第三个参数就是progressValuesif( values === progressValues ) {

            
                
                    
                    
                
            
            //
            调用进行中的回调（progressCallbacks ）
                                deferred.notifyWith( contexts, values );

                
            //
            否则成员延时（Deferred）对象解决的时候才进入该分支判断
            //
            需要等待解决的延时（Deferred）对象数量减一，
            //
            判断还有没有需要等待解决的延时（Deferred）对象，如果有，则判断失败返回
            //
            如果没有则进入分支子代码，执行主延时（Deferred）对象解决deferred.resolveWith（...）
                } elseif ( !( --remaining ) ) {
                    //最终执行到此步的时候values已经变成所有成员延时（Deferred）对象resolve的参数序列                    deferred.resolveWith( contexts, values );
                }
            };
        },

        progressValues, progressContexts, resolveContexts;

    //对于没有参数或是有唯一一个非延时对象的，直接认为resolved,也就是后面if ( !remaining ) 分支的处理//对于参数就是一个延时对象的直接将这个延时对象的deferred.promise()返回即可//对于参数多于一个的才进入该分支，添加监听器监听成员被解决if ( length > 1 ) {
        progressValues = new Array( length );
        progressContexts = new Array( length );
        resolveContexts = new Array( length );
        for ( ; i < length; i++ ) {
            //遍历参数成员，只有成员是延时（Deferred）对象的才需要监听器if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
                resolveValues[ i ].promise()
                .done( updateFunc( i, resolveContexts, resolveValues ) )
                //如果有一个成员延时（Deferred）对象拒绝时，则整个主延时（Deferred）对象直接拒绝                .fail( deferred.reject )
                .progress( updateFunc( i, progressContexts, progressValues ) );

            //非延时（Deferred）对象的直接认为已解决，需要等待解决的延时（Deferred）对象数量减一
            } else {
                --remaining;
            }
        }
    }

    //如果没有传递参数或唯一一个参数且不是一个延时对象,直接解决主延时对象即可if ( !remaining ) {
        deferred.resolveWith( resolveContexts, resolveValues );
    }

    return deferred.promise();
}