jQuery deferred应用之ajax详细源码分析（二）

 在上一节中，我只贴出了$.Deferred的源码分析，并没用讲解怎么使用它，现在我们先看看$.ajax是如何使用它，让我们进行异步任务的处理。

   如果没看上节的代码，请先稍微了解一下 jQuery Deferred的工作原理，这样ajax你才能用得更好。

   这里我将以一个跨域请求 "http://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js"这个js文件为例，讲解jQuery的ajax工作原理，知道了原理，什么ajax都是浮云了。

  先看这张图片，对$.ajax先来看全局的展望

这里外部有两个变量   prefilters = {}, transports = {}, 他们将会应为addToPrefiltersOrTransports() 通过闭包变为 

  prefilters={json:[fun],jsonp:[fun],script:[fun]}  transports={*:[fun],script:[fun]} 这里先不讨论这两个变量，我们这次用实例开始吧

  var req = $.ajax("http://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js", 
  { dataType: "script", cache: true, timeout: "10000", statusCode: {200: function () { console.log("request finished and response is ready") }, 
   0: function () { console.log("request wrong")} } }).done(function () { console.log("跨域请求成功") }).success(function () { console.log("跨域请求成功2") });;
        req.done(function () { console.log("跨域请求成功3") });

   这里，设置跨域请求js文件,简单的参数配置,前面说过jQuery ajax有强大的ajaxSettings参数配置,这里为什么$.ajax().done().success()呢？其实这个$.ajax()会返回一个jqXHR,然后这个对象

   因为这句代码deferred.promise(jqXHR)，使得jqXHR具有deferred对象的所有只读方法。详情见上章，接下来一步步看这个代码如何执行.

 ajax: function (url, options) {
            //如果url是对象的话，冒充1.5版本之前的方法                 -->$.ajax({url:"xx",data:{},})
            if (typeof url === "object") {
                options = url;
                url = undefined;
            }
            //强制设置options成为一个对象                           -->options为对象
            options = options || {};                       
            //这里创建了ajax的很多私有变量
            var //创建最终的ajax参数对象s
            s = jQuery.ajaxSetup({}, options),                     -->通过$.ajaxSetup改变默认的参数配置，返回给s. 
            // Callbacks context
            callbackContext = s.context || s,
            // Context for global events
            // It's the callbackContext if one was provided in the options
            //如果是Dom node或者jQuery collection
            globalEventContext = callbackContext !== s &&
                (callbackContext.nodeType || callbackContext instanceof jQuery) ?
                        jQuery(callbackContext) : jQuery.event,
            // 创建一个deferred对象
            deferred = jQuery.Deferred(),                                             -->使用到了Deferred对象
            completeDeferred = jQuery._Deferred(),
            // Status-dependent callbacks
            //一组数值的HTTP代码和函数对象，当响应时调用了相应的代码 如$.ajax({statusCode: {404: function() {alert('page not found');}});
              默认为空对象
            statusCode = s.statusCode || {},                                -->这里我们传了一个 statusCode:{200:function(){}..}
            // ifModified key
            ifModifiedKey,
            // 请求头部 (they are sent all at once)
            requestHeaders = {},
            requestHeadersNames = {},
            // 响应 headers
            responseHeadersString,
            responseHeaders,
            // transport
            transport,
            //请求超时时间，异步请求下请求多少时间后中止请求,
            timeoutTimer,                                                  -->timeout:10000
            // 判断是否是跨域请求的变量
            parts,
            // jqXHR state
            state = 0,
            // To know if global events are to be dispatched
            fireGlobals,
            // Loop variable
            i,
            //伪劣的jqXHR,                                                    -->这里就是返回的jqXHR对象,初始一些key
            jqXHR = {

                readyState: 0,

                /*设置dataType,达到预期服务器返回的数据类型，，jQuery 将自动根据 HTTP 包 MIME 信息来智能判断
                */
                setRequestHeader: function (name, value) {
                    //这里状态还为0，表示还在发送请求前，设置请求头
                    if (!state) {
                        var lname = name.toLowerCase();
                        name = requestHeadersNames[lname] = requestHeadersNames[lname] || name;
                        requestHeaders[name] = value; //私有requestHeadersNames
                    }
                    return this;
                },

                // Raw string
                getAllResponseHeaders: function () {
                    return state === 2 ? responseHeadersString : null;
                },

                // Builds headers hashtable if needed
                getResponseHeader: function (key) {
                    var match;
                    if (state === 2) {
                        if (!responseHeaders) {
                            responseHeaders = {};
                            while ((match = rheaders.exec(responseHeadersString))) {
                                responseHeaders[match[1].toLowerCase()] = match[2];
                            }
                        }
                        match = responseHeaders[key.toLowerCase()];
                    }
                    return match === undefined ? null : match;
                },

                // Overrides response content-type header
                overrideMimeType: function (type) {
                    if (!state) {
                        s.mimeType = type;
                    }
                    return this;
                },

                // Cancel the request
                abort: function (statusText) {
                    statusText = statusText || "abort";
                    if (transport) {
                        transport.abort(statusText);
                    }
                    done(0, statusText);
                    return this;
                }
            };

            /* Callback for when everything is done, jQuery作者喜欢函数里嵌套函数,局部调用方便
            * 2: request received 
            * 4: request finished and response is ready   <---readyState                
            * 200: "OK"
            * 404: Page not found                         <----status
            */
            function done(status, nativeStatusText, responses, headers) {      -->这个done函数写到这个函数的内部，处理不同状态的req，
                                                                                 其实这个写法改成var done=function(){}更好   
                // 请求状态为2，表面已经请求过一次，立即返回                          -->我是分析到下面回来的 ,第一次请求默认的state=0
                if (state === 2) {
                    return;
                }

                // State is "done" now
                state = 2;                                         -->哦，处理了，为什么是2呢，因为XMLHttpRequest 状态为2的意思是
                                                                               request received


                // 如果存在超时请求中止，清楚这个timeout
                if (timeoutTimer) {                                      -->timeout有用了，这里被清除了~_~,我都响应请求了，肯定得把你删了
                    clearTimeout(timeoutTimer);
                }

                // Dereference transport for early garbage collection
                // (no matter how long the jqXHR object will be used)
                transport = undefined;

                // Cache response headers
                responseHeadersString = headers || "";

                // Set readyState
                jqXHR.readyState = status > 0 ? 4 : 0;                                              

                var isSuccess,
            success,
            error,
            statusText = nativeStatusText,
            response = responses ? ajaxHandleResponses(s, jqXHR, responses) : undefined,
            lastModified,
            etag;

                // If successful, handle type chaining
                if (status >= 200 && status < 300 || status === 304) {                            -->服务器成功处理了 我们的状态是200

                    // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
                    if (s.ifModified) {

                        if ((lastModified = jqXHR.getResponseHeader("Last-Modified"))) {
                            jQuery.lastModified[ifModifiedKey] = lastModified;
                        }
                        if ((etag = jqXHR.getResponseHeader("Etag"))) {
                            jQuery.etag[ifModifiedKey] = etag;
                        }
                    }

                    // If not modified
                    if (status === 304) {

                        statusText = "notmodified";
                        isSuccess = true;

                        // If we have data
                    } else {          

                        try {
                            success = ajaxConvert(s, response);                           --> 200状态，isSucess=true
                            statusText = "success";
                            isSuccess = true;
                        } catch (e) {
                            // We have a parsererror
                            statusText = "parsererror";
                            error = e;
                        }
                    }
                } else {
                    // We extract error from statusText
                    // then normalize statusText and status for non-aborts
                    error = statusText;
                    if (!statusText || status) {
                        statusText = "error";
                        if (status < 0) {
                            status = 0;
                        }
                    }
                }

                //设置jqXHR.status 其实也就是XMLHttpRequest状态
                jqXHR.status = status;                                                      -->哦，这里设置了jqXHR的状态了 200
                jqXHR.statusText = "" + (nativeStatusText || statusText);

                // 成功请求 resolveWith
                if (isSuccess) {                                                             
                    deferred.resolveWith(callbackContext, [success, statusText, jqXHR]); 
                                                                 ->成功了，当然得resolveWith，是不是发现done或者
                                                                     success进来的函数一个个执行了^_^
                } else {  //失败请求 rejectWith                                  
                                                    ->resolve意味着什么？意味后面不管你done().done() 多少都会被直接触发 ~_~
                    deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);               
                }

                // 状态参数代码,默认为空                                                             
                jqXHR.statusCode(statusCode);
                statusCode = undefined;

                if (fireGlobals) {
                    globalEventContext.trigger("ajax" + (isSuccess ? "Success" : "Error"),
            [jqXHR, s, isSuccess ? success : error]);
                }

                // 不管请求成功与否都执行的complete  resolveWith
                completeDeferred.resolveWith(callbackContext, [jqXHR, statusText]);     
                                                        -->原来$.ajax().complete在这里调用，所以不管成功没有都resolve了

                if (fireGlobals) {
                    globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
                    // Handle the global AJAX counter
                    if (!(--jQuery.active)) {
                        jQuery.event.trigger("ajaxStop");
                    }
                }
            }

            // 给这个jqXHR对象附上deferred对象的只读方法，包括done,always,isResolved等等，这里表明了，为什么$.ajax过后
            //我们可以使用sucess,error,complete方法
            deferred.promise(jqXHR);
            jqXHR.success = jqXHR.done;                        -->作者为了让我们更好的调用，又多了3个借口，哎，其实可以直接不需要的
            jqXHR.error = jqXHR.fail;
            jqXHR.complete = completeDeferred.done;

            // Status-dependent callbacks 其实这个参数变量很少用,不过还可以，目前可以触发两个状态的statusCode: {200: function ()                       
              //{ console.log("request ok") }, 404: function () { console.log("page not found")} }
            jqXHR.statusCode = function (map) {                                                          --> map={200:"..",0:".."}
                if (map) {
                    var tmp;  //临时函数变量
                    if (state < 2) {
                        for (tmp in map) {
                            statusCode[tmp] = [statusCode[tmp], map[tmp]];
                        }
                    } else {
                        tmp = map[jqXHR.status]; //jqXHR返回相应的callback,然后调用then方法触发    
                                                                     --> 我们的状态代码在这里调用,通过jqXHR.then方法调用
                                                                                                      
                        jqXHR.then(tmp, tmp);
                    }
                }
                return this;
            };

            // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
            // We also use the url parameter if available
            //  Remove 将url的hash去掉 rhash=/#.*$/ rprotocol = /^///  ajaxLocParts[1]="http:"
            s.url = ((url || s.url) + "").replace(rhash, "").replace(rprotocol, ajaxLocParts[1] + "//");

            // 取出dataTypes list，不存在则为*  rspacesAjax = /s+/ 如:s.dataType=[*]
            s.dataTypes = jQuery.trim(s.dataType || "*").toLowerCase().split(rspacesAjax);

            //默认设置crossDomain 同域请求为false， 跨域请求为true,如果想强制跨域请求（如JSONP形式）同一域，设置crossDomain为true
            if (s.crossDomain == null) {
                //同ajaxLocParts变量,这里也是通过这个请求的url来判断是否是跨域请求
                parts = rurl.exec(s.url.toLowerCase());
                //这里来判断是否是跨域请求,又是!! 主要判断请求的url parts与 ajaxLocParts      -->这里智能判断你的请求地址是否是跨越，很
                                                                                         牛气吧，这里我们的corssDomain为true

                s.crossDomain = !!(parts &&
            (parts[1] != ajaxLocParts[1] || parts[2] != ajaxLocParts[2] ||
            (parts[3] || (parts[1] === "http:" ? 80 : 443)) !=
            (ajaxLocParts[3] || (ajaxLocParts[1] === "http:" ? 80 : 443)))
            );
            }

            //如果存在data参数并且 processData=true&&s.data为一个对象吧           -->我们没传data参数,processData参数默认为true，
                                                                                  表示默认序列化参数data
            if (s.data && s.processData && typeof s.data !== "string") {
                //调用序列化函数
                s.data = jQuery.param(s.data, s.traditional);
            }

            // Apply prefilters
            inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);                     -->发送请求前，调用过滤器将      

            // If request was aborted inside a prefiler, stop there
            if (state === 2) {
                return false;
            }

            // We can fire global events as of now if asked to
            fireGlobals = s.global;

            // Uppercase the type
            s.type = s.type.toUpperCase();

            // Determine if request has content
            //rnoContent= /^(?:GET|HEAD)$/
            s.hasContent = !rnoContent.test(s.type);

            // Watch for a new set of requests
            if (fireGlobals && jQuery.active++ === 0) {
                jQuery.event.trigger("ajaxStart");
            }

            // More options handling for requests with no content
            if (!s.hasContent) {

                //如果data参数存在,则append to url
                if (s.data) {                                               -->我们以前是不是喜欢xx.php?data="xx"&&.. 这里会把序列化
                                                                                后的data传到问号后面，很简单吧  
                    //rquery = /?/请求的url是否存在"?" 就比如请求"user.php?"    -->这就是为什么data参数会被传到url？后面


                    s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
                    // #9682: remove data so that it's not used in an eventual retry
                    delete s.data;
                }

                // Get ifModifiedKey before adding the anti-cache parameter
                ifModifiedKey = s.url;

                // Add anti-cache in url if needed
                if (s.cache === false) {

                    var ts = jQuery.now(),
                    // try replacing _= if it is there
            ret = s.url.replace(rts, "$1_=" + ts);

                    // if nothing was replaced, add timestamp to the end
                    s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
                }
            }

            // Set the correct header, if data is being sent
            if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
                jqXHR.setRequestHeader("Content-Type", s.contentType);
            }

            // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
            if (s.ifModified) {
                ifModifiedKey = ifModifiedKey || s.url;
                if (jQuery.lastModified[ifModifiedKey]) {
                    jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[ifModifiedKey]);
                }
                if (jQuery.etag[ifModifiedKey]) {
                    jqXHR.setRequestHeader("If-None-Match", jQuery.etag[ifModifiedKey]);
                }



            }


            /*设置dataType,达到预期服务器返回的数据类型，如果没有dataType参数，jQuery 将自动根据 HTTP 包 MIME 信息来智能判断
              默认的s.accepts=  accepts: {xml: "application/xml, text/xml",
              html: "text/html",text: "text/plain",json: "application/json, text/javascript","*": allTypes}  
              allTypes= ['*/']+['*']  如果设置了dataType参数,即 s.dataTypes = jQuery.trim(s.dataType || "*").toLowerCase().split(/s+/);
               比如：$(url,{dataType:"json"}) 这里第二个参数将成为 "application/json, text/javascript"+",*/*;q=0.01"
            */
            jqXHR.setRequestHeader(
            "Accept",
            s.dataTypes[0] && s.accepts[s.dataTypes[0]] ?
                s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") :
                s.accepts["*"]
        );
            //检查头部是否是指了参数 s.headers={} 一个额外的"{键:值}"对映射到请求一起发送                    -->我们没设置头部
            for (i in s.headers) {
                jqXHR.setRequestHeader(i, s.headers[i]);
            }

            // Allow custom headers/mimetypes and early abort
            if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || state === 2)) {
                // Abort if not done already
                jqXHR.abort();
                return false;

            }

            //$.ajax().success(callback).error(callback).complete(callback) 在这里增加callback，这里表面现在的ajax请求可以不止一个回调函数
            for (i in { success: 1, error: 1, complete: 1 }) {
                jqXHR[i](s[i]);
            }

            // Get transport
            transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);

            // If no transport, we auto-abort
            if (!transport) {
                done(-1, "No Transport");
            } else {
                jqXHR.readyState = 1;
                // Send global event
                if (fireGlobals) {
                    globalEventContext.trigger("ajaxSend", [jqXHR, s]);
                }
                // Timeout设置请求超时时间（毫秒）,超时请求后，jqXHR.abort() 中止请求,简单的意思就是在指定的时间内还未响应，停止请求
                if (s.async && s.timeout > 0) {                                     
                    timeoutTimer = setTimeout(function () {      -
                                                           ->这里知道我们为什么设置timeout了吧，就是如果在timeout时间内还没请求到数据
                        jqXHR.abort("timeout");               肯定得停止了，如何停止的，得看abort.提前是我们设置了这个参数并且是异步请求
                    }, s.timeout);
                }

                try {
                    state = 1;
                    transport.send(requestHeaders, done);              
                                                                -->这个方法就能知道jQuery是如何异步跨越请求这个js文件的，见下面分析
                } catch (e) {
                    // Propagate exception as error if not done
                    if (state < 2) {                                      -->处理上面这个方法的异常，万一你传得url不存在呢。。。
                        done(-1, e);
                        // Simply rethrow otherwise
                    } else {
                        jQuery.error(e);
                    }
                }
            }

            return jqXHR;                              -->分析到这里，怎么办了？其实看出来，我们只分析了$.ajax()并没用分析后面那段链式操作,
        },                                                  还有js文件怎么请求的，请求到哪儿了？先回到上面的done方法

     上面代码的-->指出了这段代码关键的运行，以及为什么我们可以直接$.ajax().done().done()异步处理任务，而且可以同时增加多个回调函数，这多得多亏$.Deferred().

     好吧，重点来分析怎么transport.send(requestHeaders,done)来跨域请求我们的js文件吧...怎么jQuery一个ajax这么复杂？还不是为了迎合上千万使用者不同的使用目的。也许对你来说，

    你只需要一个简单的ajax请求，我才不管他跨域了没有！这里就是jQuery的一个缺点吧，木办法啊，你们怎么多使用者，我要每个都照顾啊！好吧，来分析js怎么请求的吧

   

 /* 绑定script分发器,通过在header中创建script标签异步载入js.                   -->看到这里，你会有点了解这个transports分发器在干什么了，
                                                             谁叫你要请求js文件啊，还是跨域的，我平时就请求一个.php，没想这么多~_~,
                                                                      原来ajax可以请求这么多东西
    */
    jQuery.ajaxTransport("script", function (s) {

        if (s.crossDomain) {                                                                             -->我可是跨域请求哦

            var script,
    head = document.head || document.getElementsByTagName("head")[0] || document.documentElement; //一步步的获取head元素

            return {
                /*以下即是异步加载js的常用方法
                */
                send: function (_, callback) {                                    -->尼玛的send方法在这里，藏得太深了

                    script = document.createElement("script");     -->好吧，看到这里，你觉得是不是突然jQuery里怎么会有这么简单的代码了？

                    script.async = "async";

                    if (s.scriptCharset) {
                        script.charset = s.scriptCharset;
                    }

                    script.src = s.url;

                    // script加载完成触发的callback
                    script.onload = script.onreadystatechange = function (_, isAbort) {               -->js文件加载后的callback
                        //中止script回调请求或者不存在readyState|| load|complete状态
                        if (isAbort || !script.readyState || /loaded|complete/.test(script.readyState)) {

                            //处理ie下得内存泄露问题 ,onload事件触发后，销毁事件.
                            script.onload = script.onreadystatechange = null;

                            if (head && script.parentNode) {                 ->head.removeChild(script)?你把我才加载进来的js文件删了
                                                                                    干嘛啊，自己想吧    
                                head.removeChild(script);  //加载过后删除script标签元素
                            }

                            // 注销script变量 
                            script = undefined;          ->真把加载进来的script清的一干而尽,看来只能跨域请求js，然后执行一次callback而已，
                                                         ->有点划不来吧 ~_~

                            // 如果没有被中止调用callback
                            if (!isAbort) {
                                callback(200, "success");           ->这个callback是神马呢?就是上面的done方法,然后这个done方法里面根据不
                                                                      同的status进行不同的请求，你没忘吧！
                            }                                                                   
                        }
                    };
                    //把创建的script加入head头部,但是加载完成后会被清除该script标签
                    head.insertBefore(script, head.firstChild);            
                                                                       -->把我们请求的js文件加到头部,不加到头部没办法执行里面的函数 ~_~，
                                                                              执行了又把人家删了
                },
                /*手动中止script请求
                */
                abort: function () {                                                  -->  好吧，我们没有abort
                    if (script) {
                        script.onload(0, 1);
                    }
                }
            };
        }
    });

这只是一个简单的跨域请求js文件，怎么这么多代码？哎，这个jQuery ajax的参数配置太多了，他会不停的if再if ，这些if造就了jQuery的调用接口这么灵活了，可以这么写，也可以那么写，满足不同

的人的口味。 分析到这里，可能你已经头很大了，木办法，它确实很难，这只是ajax的一部分。

   好吧，我承认上面都是低级$.ajax方法，为了满足调用者使用更简单，作者提供了$.get() $.post(),$.getScript(),$.getJSON()，哎，一切为了减少使用者的负担啊，本来是没必要加这些代码的

  还是来看看，这几个方法怎么基于$.ajax写出来的，其实很简单了，如果你真真看懂了$.ajax ~_~

 /*这里遍历数组扩展$.get()   $.post();其实都还是调用的$.ajax，只是type不同
  *  这里$.ajax还是返回jqXHR,它与以前版本不同之处是它是超集的XMLHTTPRequest，由于deferred.promise(jqXHR);使这个jqXHR多了一些done,fail,always方法，
  * 当然也可以success,fail,complete其实这些方法就是done,fail,always，详情可见$.ajax和$.Deferred对象
  */
    jQuery.each(["get", "post"], function (i, method) {                               -->老生常谈得遍历数组，扩展$.method ,
                                                                                         以后我一定帮你们分析下jQuery核心库代码^_^
        jQuery[method] = function (url, data, callback, type) {
            //这里就是$.get("url",function(){})式的调用方法
            if (jQuery.isFunction(data)) {  //统一成$.get("url",data,function(){})
                type = type || callback;
                callback = data;
                data = undefined;      //把第二个参数设置成undefined,其目的也是是$.get()的接口灵活，
                                       //从这里可以看出jQuery的调用接口灵活还是基于强大的if判断语句
            }
            //这里返回1.5版本之前的ajax调用方式
            return jQuery.ajax({                                                     -->搞来搞去还是$.ajax，只是帮你设置了参数了
                type: method, //get or post    
                url: url,
                data: data,
                success: callback,
                dataType: type
            });
        };
    });

        getScript: function (url, callback) {               ->尼玛的，还是调用的get,话说这个方法可以用了动态加载js文件，也可以按需加载哦，
                                                            相当于jQuery的js加载器吧，好扯的加载器，                                                                          
             return jQuery.get(url, undefined, callback, "script");
        },
        //json文件，所有在JSON字符串表示，无论是属性或值，必须用双引号括起来,如{"key1":"value1","key2",:"value2"}保存在一个test.json文件中
        //$.getJSON("test.json",function(data){$.each(data,function(key,value){})});
      getJSON: function (url, data, callback) {
            return jQuery.get(url, data, callback, "json");                          
        },