/* -----------ajax模块开始 -----------*/
var
// Document location
ajaxLocParts,
ajaxLocation,
ajax_nonce = jQuery.now(),
ajax_rquery = /\?/,
rhash = /#.*$/,
rts = /([?&])_=[^&]*/,
rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
// #7653, #8125, #8152: local protocol detection
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
rnoContent = /^(?:GET|HEAD)$/,
rprotocol = /^\/\//,
rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/, //例如：["http://localhost:8080", "http:", "localhost", "8080"]
// Keep a copy of the old load method
//在ajax中会给jQuery原型定义load函数。 这里使用_load存储可能的之前就定义了的load函数。
//jquery中，load函数有两种不同的用途。
//$elem.load(fun) load事件的监听器函数
//$elem.load(url, params, callback ) 通过ajax加载文档到当前元素下
_load = jQuery.fn.load,
/* Prefilters
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
* 2) These are called:
* - BEFORE asking for a transport
* - AFTER param serialization (s.data is a string if s.processData is true)
* 3) key is the dataType
* 4) the catchall symbol "*" can be used
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
*/
/*
存储通过ajaxPrefilter函数添加的前置过滤函数；
用途： 针对ajax设置的datatype,添加过滤函数； 例如对请求script的ajax，在序列化参数data之后，发送请求之前，对请求进行修改过滤操作。
例：prefiters = {"script":[function(){},function(){}],"text":[function(){}],"*":[function(){}]}
根据每次ajax请求的数据类型调用不同的函数队列，之后"*"对应的的队列也会被调用
*/
prefilters = {},
/* Transports bindings
* 1) key is the dataType
* 2) the catchall symbol "*" can be used
* 3) selection will start with transport dataType and THEN go to "*" if needed
*/
// transports存储通过ajaxTransport函数添加的传输函数； 传输函数就是发送请求，返回结果这一过程的代理。
//意味着你可以很灵活的针对某一ajax请求的数据类型使用自己方式来得到和处理数据
//其结构同prefilters
//"*"可以用来处理所有数据类型的请求
transports = {},
// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
allTypes = "*/".concat("*"); // "*/*"
// #8138, IE may throw an exception when accessing
// a field from window.location if document.domain has been set
//IE中读取location.href可能会出错。
try {
ajaxLocation = location.href;
} catch( e ) {
// Use the href attribute of an A element
// since IE will modify it given document.location
ajaxLocation = document.createElement( "a" );
ajaxLocation.href = "";
ajaxLocation = ajaxLocation.href;
}
// Segment location into parts
//把页面地址分解。
////例如：["http://localhost:8080", "http:", "localhost", "8080"]
ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
//structure参数可以是前面定义的prefilters或者transports用来存储的对象。
//返回一个函数。 如果structure参数传入的是prefiler对象，那么返回的函数被jQuery.ajaxPrefilter引用。
//如果参数是transport对象，那么返回的函数被jQuery.ajaxTransport引用。 (见后面的代码)
// ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
// ajaxTransport: addToPrefiltersOrTransports( transports ),
// jQuery.ajaxPrefilter 和 jQuery.ajaxTransport 函数的区别就在于，两者使用的存储对象不同。
function addToPrefiltersOrTransports( structure ) {
// dataTypeExpression is optional and defaults to "*"
//dataTypeExpression参数可选,默认为"*"
//dataTypeExpression可以是空格分割的多个dataType。例： "script json"
return function( dataTypeExpression, func ) {
//省略dataTypeExpression时
//参数修正
if ( typeof dataTypeExpression !== "string" ) {
func = dataTypeExpression;
dataTypeExpression = "*";
}
var dataType,
i = 0,
// "script json" --> ["script","json"]
dataTypes = dataTypeExpression.toLowerCase().match( core_rnotwhite ) || []; //切割dataTypeExpression成数组
if ( jQuery.isFunction( func ) ) {
// For each dataType in the dataTypeExpression
while ( (dataType = dataTypes[i++]) ) {
// Prepend if requested
//如果datatype以+开头，表示函数应该被插入到相应的调用函数队列头部
if ( dataType[0] === "+" ) { //string.charAt(0)
dataType = dataType.slice( 1 ) || "*";
//在存储对象中，每种dataType对应一个函数队列。
(structure[ dataType ] = structure[ dataType ] || []).unshift( func );
// Otherwise append
//函数被插入到相应的调用函数队列尾部
} else {
(structure[ dataType ] = structure[ dataType ] || []).push( func );
}
}
}
};
}
// Base inspection function for prefilters and transports
//options:the request options 与ajaxSetting合并后的options
//originalOptions: ajax函数传入的options
//jqXHR: the jqXHR object of the request
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
var inspected = {},
seekingTransport = ( structure === transports );
function inspect( dataType ) {
var selected;
inspected[ dataType ] = true;
jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
//调用绑定的函数
var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
//对于prefilter调用，如果上面函数返回的是代表datatype的字符串，并且此种datatype的前置过滤函数队列未调用过，那么跳转到执行此datatype的前置过滤函数队列
if( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
options.dataTypes.unshift( dataTypeOrTransport );//新的dataType添加到options.dataTypes头部
inspect( dataTypeOrTransport ); //跳转到新的dataType队列
return false; //返回false终止jQuery.each操作。终止当前dataType的前置过滤函数队列的调用。
} else if ( seekingTransport ) { //对于Transport调用，dataTypeOrTransport变量应该是一个表示传输过程的对象。
return !( selected = dataTypeOrTransport ); //返回false终止jQuery.each操作。selected变量指向这个对象。
}
});
return selected; //对于Transport调用,返回得到的传输对象或者undefined。对于prefilter调用，返回undefined
}
//如果dataType不是"*" ，调用inspect(dataType)后，继续调用inspect("*")
//因为inspect函数对于prefilter和transport调用的返回值不一样，所有：
//对于prefilter，先inspect(options.dataTypes[0]),再inspect(dataTypes["*"])
//对于transport，先inspect(options.dataTypes[0]),如果得到传输对象则继续。否则检查"*"尝试得到传输对象。
// 注意：只使用dataTypes[0]
//inspected数组用来防止重复调用，例如dataTypes[0] =="*"的情况。
return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
}
// A special extend for ajax options
// that takes "flat" options (not to be deep extended)
// Fixes #9887
//jQuery.ajaxSettings.flatOptions中定义的的属性为浅扩展，其它属性为深扩展。
function ajaxExtend( target, src ) {
var deep, key,
flatOptions = jQuery.ajaxSettings.flatOptions || {};//不需要深扩展的属性的集合。
//如果属性不需要深扩展，直接赋值给target
//否则添加到deep对象中
for ( key in src ) {
if ( src[ key ] !== undefined ) {
( flatOptions[ key ] ? target : ( deep || (deep = {}) ) )[ key ] = src[ key ];
}
}
if ( deep ) {
jQuery.extend( true, target, deep );//jQuery.extend函数设置第一个参数deep为true，深扩展
}
return target;
}
jQuery.fn.load = function( url, params, callback ) {
//如果第一个参数类型非string,那么此load函数调用的目的是为了绑定javascript load事件处理程序
// $("#image").load(handler)
if ( typeof url !== "string" && _load ) { //_load是对先前定义的load函数的缓存。
return _load.apply( this, arguments );
}
// url --> "tt/test.jsp #selector"
var selector, response, type,
self = this,
off = url.indexOf(" ");
if ( off >= 0 ) {
selector = url.slice( off, url.length );
url = url.slice( 0, off );
}
// If it's a function
//修正参数
if ( jQuery.isFunction( params ) ) {
// We assume that it's the callback
callback = params;
params = undefined;
// Otherwise, build a param string
//如果params是一个对象，修改type为post
} else if ( params && typeof params === "object" ) {
type = "POST";
}
// If we have elements to modify, make the request
//确保当前jQuery对象不是空集合，否则ajax请求毫无意义。
if ( self.length > 0 ) {
jQuery.ajax({
url: url,
// if "type" variable is undefined, then "GET" method will be used
type: type,
dataType: "html",
data: params
}).done(function( responseText ) {
// Save response for use in complete callback
response = arguments;
self.html( selector ?
// If a selector was specified, locate the right elements in a dummy div
// Exclude scripts to avoid IE 'Permission Denied' errors
jQuery("<div>").append( jQuery.parseHTML( responseText ) ).find( selector ) :
// Otherwise use the full result
responseText );
}).complete( callback && function( jqXHR, status ) {
//在jQuery对象上调用each方法。
//each第二个参数是一个数组或者伪数组如arguments,此时数组中的元素就是是遍历过程中每次传递给callback的参数。
self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
});
}
return this;
};
// Attach a bunch of functions for handling common AJAX events
//创建用于绑定全局ajax事件处理器的系列函数
//$(document).ajaxStart(callBack);
jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ){
jQuery.fn[ type ] = function( fn ){
return this.on( type, fn ); //通过on函数绑定对应的事件处理器
};
});
//get和post快捷函数定义
jQuery.each( [ "get", "post" ], function( i, method ) {
jQuery[ method ] = function( url, data, callback, type ) {
// shift arguments if data argument was omitted
//修正参数，如果省略了data参数
if ( jQuery.isFunction( data ) ) {
type = type || callback;
callback = data;
data = undefined;
}
return jQuery.ajax({
url: url,
type: method,
dataType: type,
data: data,
success: callback
});
};
});
jQuery.extend({
// Counter for holding the number of active queries
//此时存在的其它未完成的ajax请求数
active: 0,
// Last-Modified header cache for next request
lastModified: {},
etag: {},
//默认ajax设置
ajaxSettings: {
url: ajaxLocation, //默认url为当前文档地址
type: "GET", //默认get方式
isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ), //是否是本地文件系统 如：浏览器地址以file:///开头
global: true, //是否支持全局ajax事件
processData: true, //是否把data选项值处理成字符串形式。
async: true,//是否异步
contentType: "application/x-www-form-urlencoded; charset=UTF-8", //请求头中默认的contentType
/*
timeout: 0,
data: null,
dataType: null,
username: null,
password: null,
cache: null,
throws: false, //设为true时转换错误时将错误throw
traditional: false,
headers: {},
*/
//如果Ajax请求未设置具体的dataType
//jQuery通过这个对象，根据使用正则来匹配响应头的content-type值，对应于正则的属性名就被认为是返回内容的数据类型。
contents: {
xml: /xml/,
html: /html/,
json: /json/
},
//响应对象中的字段到jqXHR对象中字段的映射
responseFields: {
xml: "responseXML",
text: "responseText"
},
// Data converters
// Keys separate source (or catchall "*") and destination types with a single space
//数据转换工具
//例如 "text json": jQuery.parseJSON 意思就是可以通过jQuery.parseJSON函数，将text类型的数据转换为json类型的数据
converters: {
// Convert anything to text
"* text": window.String,
// Text to html (true = no transformation)
"text html": true,
// Evaluate text as a json expression
"text json": jQuery.parseJSON,
// Parse text as xml
"text xml": jQuery.parseXML
},
// For options that shouldn't be deep extended:
// you can add your own custom options here if
// and when you create one that shouldn't be
// deep extended (see ajaxExtend)
//用来设置那些不应该被深扩展的属性
//ajaxExtend中用到
flatOptions: {
url: true,
context: true
}
},
// Creates a full fledged settings object into target
// with both ajaxSettings and settings fields.
// If target is omitted, writes into ajaxSettings.
//如果调用时只传入一个参数，那么扩展的目标对象是ajaxSettings。 (jQuery用户这样调用来扩展全局默认Ajax设置，所有的ajax请求都会受此影响)
//否则使用setting(jQuery用户设置)和ajaxSettings(默认全局设置)一起扩展到target（目标）对象 (jQuery内部调用)
ajaxSetup: function( target, settings ) {
return settings ?
// Building a settings object
ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
// Extending ajaxSettings
ajaxExtend( jQuery.ajaxSettings, target );
},
//定义ajaxPrefilter和ajaxTransport方法
ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
ajaxTransport: addToPrefiltersOrTransports( transports ),
// Main method
// 调用方式 jQuery.ajax(url[,options])或者jQuery.ajax([options])
/*
*@param options 用户设置的选项，用来配置ajax
*/
ajax: function( url, options ) {
// If url is an object, simulate pre-1.5 signature
//参数修正。
if ( typeof url === "object" ) {
options = url;
url = undefined;
}
// Force options to be an object
options = options || {};
var // Cross-domain detection vars
parts,
// Loop variable
i,
// URL without anti-cache param
cacheURL,
// Response headers as string
responseHeadersString,
// timeout handle
timeoutTimer,
// To know if global events are to be dispatched
fireGlobals,
transport,
// Response headers
responseHeaders,
// Create the final options object
// ajaxSetting 和options都扩展到{}中
//s是默认设置与用户设置的选项两者扩展后的对象，综合了用户选项和默认设置。
s = jQuery.ajaxSetup( {}, options ),
// Callbacks context
//如果用户选项没有设置context，那么callbackContext的值默认为s对象
callbackContext = s.context || s,
// Context for global events is callbackContext if it is a DOM node or jQuery collection
//如果设置的context是一个DOM元素或者jQuery对象，则设置globalEventContext值为此context构建的jquery对象
//否则否则globalEventContext值为jQuery.event对象
globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ?
jQuery( callbackContext ) :
jQuery.event,
// Deferreds
deferred = jQuery.Deferred(),
//jQuery.Callbacks方法构造一个"once memory"的回调队列
completeDeferred = jQuery.Callbacks("once memory"),
// Status-dependent callbacks
//用户设置的status选项
//key为status ，value为函数集合
//根据状态码设置回调函数 (不同的状态码对应不同的函数列表)
statusCode = s.statusCode || {},
// Headers (they are sent all at once)
requestHeaders = {},
requestHeadersNames = {},
// The jqXHR state
state = 0,
// Default abort message
strAbort = "canceled",
// Fake xhr
//JjQuery封装的jqXHR对象
jqXHR = {
readyState: 0,
// Builds headers hashtable if needed
getResponseHeader: function( key ) {
var match;
if ( state === 2 ) { // state==2代表http请求数据过程完成
if ( !responseHeaders ) { // responseHeadersString还未转换到responseHeaders。 转换之。
responseHeaders = {};
while ( (match = rheaders.exec( responseHeadersString )) ) { //正则有g和m，每行匹配一次
responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
}
}
match = responseHeaders[ key.toLowerCase() ];
}
//将undefined转换为null
//返回null或者字符串。
return match == null ? null : match;
},
// Raw string
getAllResponseHeaders: function() {
return state === 2 ? responseHeadersString : null;
},
// Caches the header
//requestHeadersNames中缓存name的小写形式到的映射name --> key is lname , value is name
//requestHeaders中缓存name到value的映射 --> key is name, value is value
setRequestHeader: function( name, value ) {
var lname = name.toLowerCase();
if ( !state ) { //state== 0 代表http请求过程还未开始。
//将name值在requestHeadersNames中作为属性名为小写形式lname的值缓存
//key is lname,value is name;
name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
//set
requestHeaders[ name ] = value;
}
return this;
},
// Overrides response content-type header
//用来设置s.mimeType
overrideMimeType: function( type ) {
if ( !state ) {
s.mimeType = type;
}
return this;
},
// Status-dependent callbacks
//当前jqXHR状态不同，函数的用途不同。
//jqXHR完成状态时，根据其状态码调用回调函数。
//否则添加回调函数。
statusCode: function( map ) {
var code;
if ( map ) {
if ( state < 2 ) {//给statusCode添加回调函数，前提是Ajax请求此时是未完成状态
for ( code in map ) {
// Lazy-add the new callback in a way that preserves old ones
//statusCode[ code ]可能已经设置过。 已经是一个函数或一个函数数组
//新加入的函数或者函数数组放在数组的新建数组的尾部 ，最后触发的时候相当于在时间上后于以前加入的函数处理
// 最后调用的时候，这个多层数组最后会使用Callbacks.add函数添加，这个函数对此进行了处理。
statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
}
} else { //请求已经响应，直接执行对应的回调
// Execute the appropriate callbacks
jqXHR.always( map[ jqXHR.status ] );
}
}
return this;
},
// Cancel the request
//用来取消ajax请求
abort: function( statusText ) {
var finalText = statusText || strAbort;
if ( transport ) { //调用传输对象的abort方法，终止传输
transport.abort( finalText );
}
done( 0, finalText );
return this;
}
};
// Attach deferreds
//通过deferred对象得到的promise对象
//jqXHR对象继承promise对象，并添加complete方法，该方法引用了completeDeferred.add方法
deferred.promise( jqXHR ).complete = completeDeferred.add;
jqXHR.success = jqXHR.done;
jqXHR.error = jqXHR.fail;
// Remove hash character (#7531: and string promotion)
// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
// Handle falsy url in the settings object (#10093: consistency with old signature)
// We also use the url parameter if available
//移除url中的hash字符串
//如果url以//开头，则添加协议名。（IE7的问题）；
s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
// Alias method option to type as per ticket #12004
//method 作为 type的别名
s.type = options.method || options.type || s.method || s.type;
// Extract dataTypes list
//dataTypes可以是以空格分隔的字符串，包含多个dataType。默认为“*” 例如: "text xml" 表示将text的响应当成xml对待
// 转换成数组 "text xml" --> ["text","xml"]
s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( core_rnotwhite ) || [""];
// A cross-domain request is in order when we have a protocol:host:port mismatch
// 非跨域请求需要满足 协议名 主机名 端口都匹配
if ( s.crossDomain == null ) {
parts = rurl.exec( s.url.toLowerCase() );
//比较协议名，域名，端口号，三者任一不同，则为跨域。
s.crossDomain = !!( parts &&
( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) != //如果无端口号，那么对于http协议默认是80,否则为443(主要用于https)
( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
);
}
// Convert data if not already a string
//s.processData 默认为true ，即data选项(请求数据)默认被转换成字符串形式。 值为false时不转换data属性值。
//通过jQuery.param函数来转换
if ( s.data && s.processData && typeof s.data !== "string" ) {
s.data = jQuery.param( s.data, s.traditional ); //s.traditional 可以设置转换是否使用传统模式
}
// Apply prefilters
//应用前置过滤
inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
//如果在prefilters的处理函数中调用了jqXHR的abort函数，state会被设置为2；
// If request was aborted inside a prefilter, stop there
if ( state === 2 ) {
return jqXHR;
}
// We can fire global events as of now if asked to
//是否触发ajax全局事件标志
fireGlobals = s.global;
// Watch for a new set of requests
//global标志为true时，当前不存在其它未完成的ajax请求，触发ajaxStart事件。
// jQuery.active记录未完成的ajax请求数量
if ( fireGlobals && jQuery.active++ === 0 ) {
//jQuery.event.triggerr函数在调用时如果第三个参数elem为空时，默认是在document上触发。
jQuery.event.trigger("ajaxStart");
}
// Uppercase the type
s.type = s.type.toUpperCase();
// Determine if request has content
// post请求有请求体，即数据通过请求体发送，而不是通过url
s.hasContent = !rnoContent.test( s.type );
// Save the URL in case we're toying with the If-Modified-Since
// and/or If-None-Match header later on
cacheURL = s.url;
// More options handling for requests with no content
//get请求
if ( !s.hasContent ) {
// If data is available, append data to url
// 将data数据添加到url中
if ( s.data ) {
cacheURL = ( s.url += ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
// #9682: remove data so that it's not used in an eventual retry
delete s.data; //删除data
}
// Add anti-cache in url if needed
//如果设置不要缓存，在url中加入一个_参数，其值为随机数。以此来破坏浏览器缓存机制
if ( s.cache === false ) {
s.url = rts.test( cacheURL ) ?
// If there is already a '_' parameter, set its value
//如果参数中已经存在一个参数名"_",覆盖它的值。
cacheURL.replace( rts, "$1_=" + ajax_nonce++ ) :
// Otherwise add one to the end
cacheURL + ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ajax_nonce++;
}
}
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
//设置s.ifModified为true后，如果服务器的内容未改变，那么服务器会返回不带数据的304报文。数据直接在缓存中得到
//lastModified和etag同时使用
if ( s.ifModified ) {
if ( jQuery.lastModified[ cacheURL ] ) { //在jquery的lastModified缓存中查找当前url.
jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
}
if ( jQuery.etag[ cacheURL ] ) {
jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
}
}
// 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 Accepts header for the server, depending on the dataType
//学习学习
// Accept-Language: fr; q=1.0, en; q=0.5 法语和英语都可以 最好是法语
// Accept: text/html; q=1.0, text; q=0.8, image/gif; q=0.6, image/jpeg; q=0.6, image/*; q=0.5, *; q=0.1
//逗号分隔不同的选项，分号后面的代表优先级。
jqXHR.setRequestHeader(
"Accept",
s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
// "*/*"表示任意类型，分号后面的q=0.01表示优先级啦。
//多个类型直接用分号隔开
s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
s.accepts[ "*" ]
);
// Check for headers option
//s.headers对象中的元素复制到RequestHeaders中
for ( i in s.headers ) {
jqXHR.setRequestHeader( i, s.headers[ i ] );
}
// Allow custom headers/mimetypes and early abort
//beforeSend事件绑定的函数如果返回false或者在函数中设置state为2，那么调用jqXHR.abort()方法，终止请求
//如果在jqXHR中也调用了abort方法，那么肯定会导致abort方法中的transport.abort方法再次执行，这样不会有问题么。。。
if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
// Abort if not done already and return
return jqXHR.abort();
}
// aborting is no longer a cancellation
strAbort = "abort";
// Install callbacks on deferreds
//将options中的success,error ,complete属性方法使用jqXHR对应的监听器注册。
// 如： jqXHR["success"](callBack);
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; //找到transport后，jqXHR.readyState变为1，标志jqXHR开始
// Send global event
//触发全局ajaxSend事件
if ( fireGlobals ) {
globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
}
// Timeout
//异步模式下，timeout设置最大等待时间
if ( s.async && s.timeout > 0 ) {
timeoutTimer = setTimeout(function() {
jqXHR.abort("timeout");
}, s.timeout );
}
try {
state = 1; //state设置为1，标志传输过程开始
//调用transport的send方法，传入请求头和回调函数
//注意回调函数时done函数
transport.send( requestHeaders, done );
} catch ( e ) {
// Propagate exception as error if not done
if ( state < 2 ) {
done( -1, e );
// Simply rethrow otherwise
} else {
throw e;
}
}
}
// Callback for when everything is done
//transport.send完成后的回调函数，或者出错时手动调用
//四个参数
//status 和 statusText 例如 2 "success"
//responses 对象 例如 {xml:"someString",html:"someString"}
//headers 包含所有响应头信息的字符串
function done( status, nativeStatusText, responses, headers ) {
var isSuccess, success, error, response, modified,
statusText = nativeStatusText;
// Called once
//已经调用过done了
if ( state === 2 ) {
return;
}
// State is "done" now
//state = 2意味着传输过程完成
state = 2;
// Clear timeout if it exists
//清除定时任务
if ( timeoutTimer ) {
clearTimeout( timeoutTimer );
}
// Dereference transport for early garbage collection
// (no matter how long the jqXHR object will be used)
//清除transport传输对象
transport = undefined;
// Cache response headers
//headers复制给responseHeadersString
responseHeadersString = headers || "";
// Set readyState
//设置readyState
//status>0时 jqXHR.readyState设置为4，标志jqXHR过程成功完成。
//jqXHR.readyState设置为0时，表示jqXHR过程失败
jqXHR.readyState = status > 0 ? 4 : 0;
// Get response data
//调用ajaxHandleResponses处理response
if ( responses ) {
response = ajaxHandleResponses( s, jqXHR, responses );
}
// If successful, handle type chaining
//success
if ( status >= 200 && status < 300 || status === 304 ) {
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
if ( s.ifModified ) {
modified = jqXHR.getResponseHeader("Last-Modified");
if ( modified ) {
//缓存当前url的最近修改时间
jQuery.lastModified[ cacheURL ] = modified;
}
modified = jqXHR.getResponseHeader("etag");
if ( modified ) {
//缓存etag值
jQuery.etag[ cacheURL ] = modified;
}
}
// if no content
// 204 no content
if ( status === 204 ) {
isSuccess = true;
statusText = "nocontent";
// if not modified
// 304 notmodified
} else if ( status === 304 ) { //返回304的话，怎么从缓存中拿到数据？
isSuccess = true;
statusText = "notmodified";
// If we have data, let's convert it
// ajaxConvert
//否则就是得到数据的情况了。
} else {
isSuccess = ajaxConvert( s, response );
statusText = isSuccess.state;
success = isSuccess.data;
error = isSuccess.error;
isSuccess = !error;
}
} else { //failed
// We extract error from statusText
// then normalize statusText and status for non-aborts
error = statusText;
if ( status || !statusText ) {
statusText = "error";
if ( status < 0 ) {
status = 0;
}
}
}
// Set data for the fake xhr object
jqXHR.status = status;
//优先使用参数传入的nativeStatusText
jqXHR.statusText = ( nativeStatusText || statusText ) + "";
// Success/Error
//触发success 或者 error
if ( isSuccess ) {
deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
} else {
deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
}
// Status-dependent callbacks
//根据当前响应的状态码触发options选项statusCode属性对象中对应的函数
jqXHR.statusCode( statusCode );
statusCode = undefined;
//如果没给定context,那么调用jQuery.event.trigger函数触发这两个事件,此时默认context为document
//否则在context上触发 ajaxSuccess 或者 ajaxError
if ( fireGlobals ) {
globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
[ jqXHR, s, isSuccess ? success : error ] );
}
// Complete
//触发当前ajax通过complete选项绑定的回调函数
completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
//触发全局绑定的ajaxComplete
// 所有的ajax请求都执行完了就触发"ajaxStop"
if ( fireGlobals ) {
globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
// Handle the global AJAX counter
//--jQuery.active
if ( !( --jQuery.active ) ) { //所有的ajax请求都执行完了就触发ajaxStop
jQuery.event.trigger("ajaxStop");
}
}
}
//返回jqXHR对象
return jqXHR;
},
getScript: function( url, callback ) {
return jQuery.get( url, undefined, callback, "script" );
},
getJSON: function( url, data, callback ) {
return jQuery.get( url, data, callback, "json" );
}
});
/* Handles responses to an ajax request:
* - sets all responseXXX fields accordingly
* - finds the right dataType (mediates between content-type and expected dataType)
* - returns the corresponding response
*/
/*设置jqXHR的responseXXX属性
找到正确的dataType（介于responses中dataType与期待的dataType可以直接转换的类型），并且添加到dataTypes中
返回响应内容*/
//这里需要距离。 因为responses中可能含有多种类型dataType的值，比如xml或者html，对着两种类型都尝试是否能直接转换成期待的dataType
//responses 可能--> {xml:"somestring",html:"someString"}
//把responses中的类型添加到dataTypes中，优先添加能直接转换的，否则添加第一个属性。如果添加的type和dataTypes[0]重合则不需要添加。
//返回responses中对应添加类型的值。
function ajaxHandleResponses( s, jqXHR, responses ) {
var firstDataType, ct, finalDataType, type,
contents = s.contents, //contents选项
/*contents: {
xml: /xml/,
html: /html/,
json: /json/
}*/
dataTypes = s.dataTypes,
responseFields = s.responseFields;
/*responseFields: {
xml: "responseXML",
text: "responseText"
}*/
//responseFields 包含response中需要转换到jqXHR中的字段. key为response中需要转换的属性名 value为转换到jqXHR中的属性名
for ( type in responseFields ) {
if ( type in responses ) {
jqXHR[ responseFields[type] ] = responses[ type ]; //例如： jqXHR["responseXML"] = responses["xml"]
}
}
// Remove auto dataType and get content-type in the process
//将dataTypes数组前面的所有"*"移除
//dataTypes前面必须是一个"*"，ct才会被赋值
while( dataTypes[ 0 ] === "*" ) {
dataTypes.shift();
if ( ct === undefined ) {//初始化ct为content-type
ct = s.mimeType || jqXHR.getResponseHeader("Content-Type"); //s.mimeType选项值覆盖响应的content-type
}
}
// Check if we're dealing with a known content-type
//对于上面： ct未赋值的情况，说明dataTypes[0]!="*" 那么默认dataTypes[0] 就是响应头content-type在contents中对应的属性名
//否则以响应的content-type对应的type作为datatypes的第一个元素
if ( ct ) {
for ( type in contents ) {//遍历contents
if ( contents[ type ] && contents[ type ].test( ct ) ) { //执行type对应的正则来匹配响应头中的content-type
dataTypes.unshift( type ); //匹配到的type添加到dataTypes数组前面
break;
}
}
}
// Check to see if we have a response for the expected dataType
if ( dataTypes[ 0 ] in responses ) {
finalDataType = dataTypes[ 0 ];
} else {
// Try convertible dataTypes
//否则，因为response可能包含多个属性，对每个属性都尝试是否可以直接转换（通过检查s.converters）
for ( type in responses ) {
//直接可以转换或者dataTypes为空时
if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
finalDataType = type;
break;
}
if ( !firstDataType ) { //responses中第一个不能转换的type
firstDataType = type;
}
}
// Or just use first one
//找不到可以直接转换的类型，那么finalDataType就是responses中第一个不能转换的type
finalDataType = finalDataType || firstDataType;
}
// If we found a dataType
// We add the dataType to the list if needed
// and return the corresponding response
if ( finalDataType ) {
if ( finalDataType !== dataTypes[ 0 ] ) { //如果是中间type。
dataTypes.unshift( finalDataType );//添加到dataTypes前面
}
return responses[ finalDataType ];//返回response中对应finalDataType类型的数据
}
}
// Chain conversions given the request and the original response
//链式转换。
//将response转换按照dataTypes中的类型依次转换，最后返回一个封装后的结果。 成功时：{ state: "success", data: response };
function ajaxConvert( s, response ) {
var conv2, current, conv, tmp,
converters = {},
i = 0,
// Work with a copy of dataTypes in case we need to modify it for conversion
//复制s.dataTypes,通过调用s.dataTypes.slice();
dataTypes = s.dataTypes.slice(),
prev = dataTypes[ 0 ];
// Apply the dataFilter if provided
//dataFilter方法先于类型转换。
if ( s.dataFilter ) {
response = s.dataFilter( response, s.dataType );
}
// Create converters map with lowercased keys
if ( dataTypes[ 1 ] ) {
for ( conv in s.converters ) {
converters[ conv.toLowerCase() ] = s.converters[ conv ];
}
}
// Convert to each sequential dataType, tolerating list modification
//循环dataTypes中相邻的两个元素，判断其是否可以直接转换。
//如果不能直接转换，那么尝试曲线救国 即A-->C行不通 找看看A-->B-->C
for ( ; (current = dataTypes[++i]); ) {
// There's only work to do if current dataType is non-auto
if ( current !== "*" ) {
// Convert response if prev dataType is non-auto and differs from current
if ( prev !== "*" && prev !== current ) {
// Seek a direct converter
conv = converters[ prev + " " + current ] || converters[ "* " + current ];
// If none found, seek a pair
//如果不能直接转换
if ( !conv ) {
//遍历converters
for ( conv2 in converters ) {
// If conv2 outputs current
tmp = conv2.split(" ");
if ( tmp[ 1 ] === current ) {
// If prev can be converted to accepted input
conv = converters[ prev + " " + tmp[ 0 ] ] ||
converters[ "* " + tmp[ 0 ] ];
if ( conv ) {
// Condense equivalence converters
if ( conv === true ) {
conv = converters[ conv2 ];
// Otherwise, insert the intermediate dataType
//这里不需要判断converters[ conv2 ] === true的情况。
//因为在这种情况下conv的值已经是转换函数了。
//如果converters[ conv2 ] !== true，将找到的可以用来作过渡转换的type添加到dataTypes中合适的位置
} else if ( converters[ conv2 ] !== true ) {
current = tmp[ 0 ];
dataTypes.splice( i--, 0, current );
}
break; //找到了就中断循环
}
}
}
}
// Apply converter (if not an equivalence)
if ( conv !== true ) {
// Unless errors are allowed to bubble, catch and return them
if ( conv && s["throws"] ) {
response = conv( response );
} else {
try {
response = conv( response );
} catch ( e ) {
return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
}
}
}
}
// Update prev for next iteration
prev = current;
}
}
//转换完成
return { state: "success", data: response };
}
// Install script dataType
//扩展jQuery.ajaxSetting对象
jQuery.ajaxSetup({
accepts: {
script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
},
contents: {
script: /(?:java|ecma)script/
},
converters: {
"text script": function( text ) {
jQuery.globalEval( text );
return text;
}
}
});
// Handle cache's special case and global
//script类型请求的前置处理
//a.默认不使用浏览器缓存
//b.对于跨域请求：使用get方法，并且设置global为false，即不触发全局ajax对象。
jQuery.ajaxPrefilter( "script", function( s ) {
if ( s.cache === undefined ) {
s.cache = false;
}
if ( s.crossDomain ) {
s.type = "GET";
s.global = false;
}
});
// Bind script tag hack transport
//请求script文件使用的传输对象。
jQuery.ajaxTransport( "script", function(s) {
// This transport only deals with cross domain requests
//只处理跨域的部分
//可以看到跨域的script文件请求通过新建script标签完成。
if ( s.crossDomain ) {
var script,
head = document.head || jQuery("head")[0] || document.documentElement;
return {
send: function( _, callback ) {
script = document.createElement("script");
script.async = true;
if ( s.scriptCharset ) {
script.charset = s.scriptCharset;
}
script.src = s.url;
// Attach handlers for all browsers
//isAbort参数在下面定义的abort方法中手动调用script.onload函数时设为true
//IE的 script 元素支持onreadystatechange事件，不支持onload事件。
//FF的script 元素不支持onreadystatechange事件，只支持onload事件。
script.onload = script.onreadystatechange = function( _, isAbort ) {
//isAbort时，做清除script的处理
//!script.readyState 说明是在FF下面，此时表明load完成
///loaded|complete/.test( script.readyState )表明在IE下需要检测到readyState为loaded或者complete时，才算load完成
if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
// Handle memory leak in IE
script.onload = script.onreadystatechange = null;
// Remove the script
if ( script.parentNode ) {
script.parentNode.removeChild( script );
}
// Dereference the script
script = null;
// Callback if not abort
if ( !isAbort ) {
callback( 200, "success" );
}
}
};
// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
// Use native DOM manipulation to avoid our domManip AJAX trickery
head.insertBefore( script, head.firstChild );
},
abort: function() {
if ( script ) {
script.onload( undefined, true );
}
}
};
}
});
var oldCallbacks = [], //回调函数名的回收站
rjsonp = /(=)\?(?=&|$)|\?\?/; // ?= 是正向先行断言
// Default jsonp settings
jQuery.ajaxSetup({
jsonp: "callback",
jsonpCallback: function() {
//回收站里没得时就新建一个随机函数名
var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( ajax_nonce++ ) );
this[ callback ] = true; //this指向s
return callback;
}
});
// Detect, normalize options and install callbacks for jsonp requests
//对json和jsonp类型ajax请求的前置处理
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
var callbackName, overwritten, responseContainer,
/*
先在s.url中寻找jsonp标志'anyCallbackName=?',如果未找到那么尝试在s.data中找标志"anyCallbackName=?" 。 "anyCallbackName"是用于设置回调的参数名，和服务器的设置相关。
对于get请求,s.data字符串已经被添加到了s.url中，所以如果在s.url中未找到而在s.data中找到了那么一定是post请求。
jsonProp --> false||"url"||"data"
*/
jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
"url" :
typeof s.data === "string" && !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && rjsonp.test( s.data ) && "data"
);
/*对于jsonp请求，可以通过在s.url或者s.data字符串中添加
"anyCallbackName=?" 或者设置s.jsonp来告诉jQuery这是一jsonp请求。
s.jsonp选项设置的是服务器相关的jsonp参数名。
s.jsonpCallback参数可以是函数名字符串或者一个返回函数名字符串的函数。
推荐是不手动设置此参数，通过jQuery随机生成（注意：手动设置函数名后，如果用户定义了同名函数，jQuery最终也会调用这个函数）。
*/
// Handle iff the expected data type is "jsonp" or we have a parameter to set
if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
// Get callback name, remembering preexisting value associated with it
//s.jsonpCallback 如果是一个函数就取得函数返回值作为回调函数名，否则直接作为回调函数名
callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
s.jsonpCallback() :
s.jsonpCallback;
// Insert callback into url or form data
//插入callback到url或者data中
if ( jsonProp ) {//s.url或s.data中插入了"anyCallbackName=?"标志
s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
} else if ( s.jsonp !== false ) {//其它情况，即s.url和s.data中都没有手动插入"fun=?"标志，那么自动生成。
s.url += ( ajax_rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
}
// Use data converter to retrieve json after script execution
//设置script类型到json类型的转换
// 因为当前函数最后会 return "script";
s.converters["script json"] = function() {
if ( !responseContainer ) {
jQuery.error( callbackName + " was not called" );
}
return responseContainer[ 0 ];
};
// force json dataType
//强制dataType[0] 为"json" . 意味着"jsonp" 也被设置为"json"
s.dataTypes[ 0 ] = "json";
// Install callback
overwritten = window[ callbackName ];
window[ callbackName ] = function() {
responseContainer = arguments;
};
// Clean-up function (fires after converters)
jqXHR.always(function() {
// Restore preexisting value
window[ callbackName ] = overwritten;
// Save back as free
if ( s[ callbackName ] ) {
// make sure that re-using the options doesn't screw things around
s.jsonpCallback = originalSettings.jsonpCallback;
// save the callback name for future use
oldCallbacks.push( callbackName );
}
// Call if it was a function and we have a response
//用户定义的同名函数也会调用。
if ( responseContainer && jQuery.isFunction( overwritten ) ) {
overwritten( responseContainer[ 0 ] );
}
responseContainer = overwritten = undefined;
});
// Delegate to script
//委派到script类型
return "script";
}
});
var xhrCallbacks, xhrSupported,
xhrId = 0,
// #5280: Internet Explorer will keep connections alive if we don't abort on unload
xhrOnUnloadAbort = window.ActiveXObject && function() {
// Abort all pending requests
var key;
for ( key in xhrCallbacks ) {
xhrCallbacks[ key ]( undefined, true );
}
};
// Functions to create xhrs
function createStandardXHR() {
try {
return new window.XMLHttpRequest();
} catch( e ) {}
}
function createActiveXHR() {
try {
return new window.ActiveXObject("Microsoft.XMLHTTP");
} catch( e ) {}
}
// Create the request object
// (This is still attached to ajaxSettings for backward compatibility 向后兼容)
jQuery.ajaxSettings.xhr = window.ActiveXObject ?
/* Microsoft failed to properly
* implement the XMLHttpRequest in IE7 (can't request local files),
* so we use the ActiveXObject when it is available
* Additionally XMLHttpRequest can be disabled in IE7/IE8 so
* we need a fallback.
*/
//在IE下面，ajax不能请求本地文件。
function() {
return !this.isLocal && createStandardXHR() || createActiveXHR();
} :
// For all other browsers, use the standard XMLHttpRequest object
createStandardXHR;
// Determine support properties
xhrSupported = jQuery.ajaxSettings.xhr();
jQuery.support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
xhrSupported = jQuery.support.ajax = !!xhrSupported;
// Create transport if the browser can provide an xhr
if ( xhrSupported ) {
jQuery.ajaxTransport(function( s ) { //创建"*"对应的transport,即默认处理所有请求的transport
// Cross domain only allowed if supported through XMLHttpRequest
//跨域请求需要支持withCredentials属性的浏览器
if ( !s.crossDomain || jQuery.support.cors ) {
var callback;
return {
send: function( headers, complete ) {
// Get a new xhr
var handle, i,
xhr = s.xhr();
// Open the socket
// Passing null username, generates a login popup on Opera (#2865)
if ( s.username ) {
xhr.open( s.type, s.url, s.async, s.username, s.password );
} else {
xhr.open( s.type, s.url, s.async );
}
// Apply custom fields if provided
/*
例如：xhrFields: {
withCredentials: true
}
用来设置xhr请求的属性。
*/
if ( s.xhrFields ) {
for ( i in s.xhrFields ) {
xhr[ i ] = s.xhrFields[ i ];
}
}
// Override mime type if needed
if ( s.mimeType && xhr.overrideMimeType ) {
xhr.overrideMimeType( s.mimeType );
}
// X-Requested-With header
// For cross-domain requests, seeing as conditions for a preflight are
// akin to a jigsaw puzzle, we simply never set it to be sure.
// (it can always be set on a per-request basis or even using ajaxSetup)
// For same-domain requests, won't change header if already provided.
if ( !s.crossDomain && !headers["X-Requested-With"] ) {
headers["X-Requested-With"] = "XMLHttpRequest";
}
// Need an extra try/catch for cross domain requests in Firefox 3
try {
for ( i in headers ) {
xhr.setRequestHeader( i, headers[ i ] );
}
} catch( err ) {}
// Do send the request
// This may raise an exception which is actually
// handled in jQuery.ajax (so no try/catch here)
xhr.send( ( s.hasContent && s.data ) || null );
// Listener
callback = function( _, isAbort ) {
var status, responseHeaders, statusText, responses;
// Firefox throws exceptions when accessing properties
// of an xhr when a network error occurred
// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
try {
// Was never called and is aborted or complete
if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
// Only called once
callback = undefined;
// Do not keep as active anymore
if ( handle ) {
xhr.onreadystatechange = jQuery.noop;
if ( xhrOnUnloadAbort ) {
delete xhrCallbacks[ handle ];
}
}
// If it's an abort
if ( isAbort ) {
// Abort it manually if needed
if ( xhr.readyState !== 4 ) {
xhr.abort();
}
} else {
responses = {};
status = xhr.status;
responseHeaders = xhr.getAllResponseHeaders();
// When requesting binary data, IE6-9 will throw an exception
// on any attempt to access responseText (#11426)
if ( typeof xhr.responseText === "string" ) {
responses.text = xhr.responseText;
}
// Firefox throws an exception when accessing
// statusText for faulty cross-domain requests
try {
statusText = xhr.statusText;
} catch( e ) {
// We normalize with Webkit giving an empty statusText
statusText = "";
}
// Filter status for non standard behaviors
// If the request is local and we have data: assume a success
// (success with no data won't get notified, that's the best we
// can do given current implementations)
if ( !status && s.isLocal && !s.crossDomain ) {
status = responses.text ? 200 : 404;
// IE - #1450: sometimes returns 1223 when it should be 204
} else if ( status === 1223 ) {
status = 204;
}
}
}
} catch( firefoxAccessException ) {
if ( !isAbort ) {
complete( -1, firefoxAccessException );
}
}
// Call complete if needed
if ( responses ) {
complete( status, statusText, responses, responseHeaders );
}
};
if ( !s.async ) {
// if we're in sync mode we fire the callback
callback();
} else if ( xhr.readyState === 4 ) {
// (IE6 & IE7) if it's in cache and has been
// retrieved directly we need to fire the callback
setTimeout( callback );
} else {
handle = ++xhrId;
if ( xhrOnUnloadAbort ) {
// Create the active xhrs callbacks list if needed
// and attach the unload handler
if ( !xhrCallbacks ) {
xhrCallbacks = {};
jQuery( window ).unload( xhrOnUnloadAbort );
}
// Add to list of active xhrs callbacks
xhrCallbacks[ handle ] = callback;
}
xhr.onreadystatechange = callback;
}
},
abort: function() {
if ( callback ) {
callback( undefined, true );
}
}
};
}
});
}
//ajax模块结束
