类型

此页文档数据类型出现在jQuery函数签名中，要么是由jQuery本身定义的，要么是由jQuery进一步约束的。除非除了明确声明，否则，jQuery函数需要原始值，不接受它们的对象包装的形式。如果你想进一步学习这些概念，请看一看MDN。

你应该能够试验出下面的的大多数示例，只要把它们复制到你的浏览器的JavaScript控制台（带有开发菜单集活的Chrome、Safari，以及IE8+）或Firebug控制台（Firefox）。

每当一个示例提及类型默认为布尔值时，当在布尔上下文中使用那种类型就很容易知道结果：

1
2
3
4
5
6
 
var x = "";
if ( x ) {
  console.log( "x defaulted to true" );
} else {
  console.log( "x defaulted to false" );
}

在此情形中，打印出了"x defaulted to false"。

为了保持示例简短，反转运算符（“not”）和双重否定运算符用来显示一个布尔上下文：

1
2
3
 
var x = "";
!x // true
!!x // false (Double negation: Since "not (empty string)" is true, negating that makes it false)

言归正传。

内容

  1. Anything
  2. String
  3. htmlString
  4. Number
  5. Boolean
  6. Object
  7. Array
  8. 类数组对象
  9. PlainObject
  10. Date
  11. Function
  12. Error
  13. 选择器
  14. 事件
  15. 元素
  16. 文本
  17. jQuery
  18. XMLHttpRequest
  19. jqXHR
  20. 可延后
  21. 延迟对象
  22. 应答对象
  23. Callbacks 对象
  24. XML 文档
  25. Qunit的断言对象

Anything

用在jQuery文档中的Anything虚拟类型用来指示任何类型都可以使用，或者期待使用。

String

在JavaScript中字符串是不可变的原始值，包含零个、一个或多个字符。

1
2
 
"I'm a String in JavaScript!"
'So am I!'

字符串的类型是“string”。

1
 
typeof "some string"; // "string"

引号

可以用单引号或双引号定义一个字符串。你可以在双引号里面嵌套单引号，反过来也行得通。若要混合带双引号的双引号（或带单引号的单引号），必须用反斜杠转义被嵌套的那个引号。

1
2
3
 
"You make 'me' sad."
'That\'s "cranking" good fun!'
"<a href=\"home\">Home</a>"

内建方法

在JavaScript中，字符串有一些内建的方法，用来操纵字符串，虽然此结果始终是一个新字符串——或者其它，譬如， split方法返回一个array。

1
2
3
4
5
 
"hello".charAt( 0 ) // "h"
"hello".toUpperCase() // "HELLO"
"Hello".toLowerCase() // "hello"
"hello".replace( /e|o/g, "x" ) // "hxllx"
"1,2,3".split( "," ) // [ "1", "2", "3" ]

Length 属性

所有的字符串都具有length属性。

1
2
 
"Hello".length // 5
"".length // 0

布尔默认值

一个空字符串默认为false：

1
2
3
4
5
 
!"" // true
!!"" // false
!"hello" // false
!"true" // false
!new Boolean( false ) // false

htmlString

一个指定为htmlString的字符串，在jQuery文档中，当它用来代表一个或多个DOM元素时，通常用来创建并插入到文档中。如果传递为jQuery()函数的参数，如果它用字符<tag ... >开头，则被标识为HTML，并被解析直到遇到最后的>字符。在jQuery 1.9以前的版本中，如果一个字符串在内部任何位置包含了<tag ... >，它都会被视为HTML。

如果一个字符串被传递为任一种操纵方法的参数，譬如.append()方法，该字符串始终被视为HTML，因为jQuery的其它字符串的公共解释器（CSS选择器）不能应用在那种上下文中。

为了显式把字符串解析为HTML，自从jQuery 1.8以后，可以使用$.parseHTML()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
// Appends <b>hello</b>:
$( "<b>hello</b>" ).appendTo( "body" );
 
// Appends <b>hello</b>:
$( "<b>hello</b>bye" ).appendTo( "body" );
 
// Syntax error, unrecognized expression: bye<b>hello</b>
$( "bye<b>hello</b>" ).appendTo( "body" );
 
// Appends bye<b>hello</b>:
$( $.parseHTML( "bye<b>hello</b>" ) ).appendTo( "body" );
 
// Appends <b>hello</b>wait<b>bye</b>:
$( "<b>hello</b>wait<b>bye</b>" ).appendTo( "body" );

Number

在JavaScript中，数字是双精度的64位IEEE 754值。它们是不可变的原始值，就像strings。所有基于C语言的常用运算符都是可以处理数字的（+、-、*、/、%、=、+=、-=、*=、/=、++、--）。

1
2
 
12
3.543

数字的类型是“number”。

1
2
 
typeof 12 // "number"
typeof 3.543 // "number"

布尔默认值

如果一个数字是零，它默认为false：

1
2
3
4
 
!0 // true
!!0 // false
!1 // false
!-1 // false

由于数字是以双精度值实现的，下面的结果不是错误：

1
 
0.1 + 0.2 // 0.30000000000000004


Math

JavaScript提供了一些实用工具，以在Math对象中处理数字：

1
2
 
Math.PI // 3.141592653589793
Math.cos( Math.PI ) // -1

解析数字

parseInt和parseFloat用来把字符串解析为数字。如果没有指定基数，它们都会作一些潜在的转换：

1
2
3
4
5
6
 
parseInt( "123" ) = 123 // (implicit decimal)
parseInt( "010" ) = 8 // (implicit octal)
parseInt( "0xCAFE" ) = 51966 // (implicit hexadecimal)
parseInt( "010", 10 ) = 10 // (explicit decimal)
parseInt( "11", 2 ) = 3 // (explicit binary)
parseFloat( "10.10" ) = 10.1

Numbers 转换为 Strings

如果把数字追加到字符串后来面，结果始终是一个字符串。运算符也能一样：所以要注意：如果你想加一个数字，然后把它们追加到字符串，请用小括号包围数字：

1
2
3
4
 
"" + 1 + 2; // "12"
"" + ( 1 + 2 ); // "3"
"" + 0.0000001; // "1e-7"
parseInt( 0.0000001 ); // 1 (!)

或者如果你使用JavaScript提供的String类，它会尝试把值解析为一个字符串：

1
2
 
String( 1 ) + String( 2 ); // "12"
String( 1 + 2 ); // "3"

NaN 和 Infinity

解析某些不属于数字的东西会产生NaN。isNaN有助于侦测那种情形：

1
2
 
parseInt( "hello", 10 ) // NaN
isNaN( parseInt("hello", 10) ) // true

除以零会导致无限大或无限小：

1
 
1 / 0 // Infinity

NaN和Infinity都是“number”类型的。

1
2
 
typeof NaN // "number"
typeof Infinity // "number"

请注意，NaN比较的方式比较不寻常：

1
 
NaN === NaN // false (!)

但是：

1
 
Infinity === Infinity // true

Integer

整型数是纯数字类型，但是每当明确提及时，指示期待非浮点数。

Float

浮点数是纯数字类型，就像整型数，但是每当明确提及时，指示期待一个浮点数。


Boolean

JavaScript中的布尔值既可以是true也可以是false：

1
2
 
if ( true ) console.log( "always!" );
if ( false ) console.log( "never!" );

Object

JavaScript中的所有东西都是一个对象，但是某些东西更具有对象性。创建对象的最简单方法是对象迭代：

1
2
3
4
5
 
var x = {};
var y = {
  name: "Pete",
  age: 15
};

对象的类型是“object”：

1
 
typeof {} // "object"

点记号法

你可以利用点记号法来写入或读取对象的属性：

1
2
3
4
 
y.name // "Pete"
y.age // 15
x.name = y.name + " Pan" // "Pete Pan"
x.age = y.age + 1 // 16

数组记号法

你还可以利用数组记号法来写入或读取属性，数组记号法允许你动态选择属性：

1
2
3
4
5
6
7
 
var operations = {
  increase: "++",
  decrease: "--"
};
var operation = "increase";
operations[ operation ] // "++"
operations[ "multiply" ] = "*"; // "*"

叠代

利用for-in循环可以轻松迭代遍整个对象：

1
2
3
4
5
6
7
 
var obj = {
  name: "Pete",
  age: 15
};
for( key in obj ) {
  alert( "key is " + [ key ] + ", value is " + obj[ key ] );
}

请注意，扩展Object.prototype可以破坏for-in循环（请参阅Object.prototype is verboten），所以如果使用了别的库，就务必要小心。

jQuery提供了原生的each 函数以迭代遍对象的属性，以及数组的元素：

1
2
3
 
jQuery.each( obj, function( key, value ) {
  console.log( "key", key, "value", value );
});

缺点是回调函数是在每个值的上下文上调用的，因此如果应用的话，你失去了你自己的对象的上下文。关于这的更多信息在下面的函数中。

布尔默认值

一个对象，无论它是否具有属性，永远不会默认为false：

1
2
 
!{} // false
!!{} // true

原型

所有对象都具有原型属性。每当翻译器查找一个属性时，如果对象本身上没有找到属性，它会检查对象的原型。jQuery广泛使用原型把方法添加到jQuery实例中。在内部，jQuery使jQuery.fn成为jQuery.prototype的别名，从而你可以使用任一个（虽然插件开发者在fn上已经标准化了。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
var form = $("#myform");
console.log( form.clearForm ); // undefined
 
// jQuery.fn === jQuery.prototype
jQuery.fn.clearForm = function() {
  return this.find( ":input" ).each(function() {
    this.value = "";
  }).end();
};
 
// works for all instances of jQuery objects, because
// the new method was added to the prototype
console.log( form.clearForm ); // function
form.clearForm();

Array

JavaScript中的数组是可变的列表，带有一些内置的方法。你可以使用数组常值来定义数组：

1
2
 
var x = [];
var y = [ 1, 2, 3 ];

数组的类型是“object”：

1
2
 
typeof []; // "object"
typeof [ 1, 2, 3 ]; // "object"

使用数组记号法从数组中读取元素或把元素写入数组：

1
2
 
x[ 0 ] = 1;
y[ 2 ] // 3

叠代

具有length属性的数组能用于迭代：

1
2
3
 
for ( var i = 0; i < a.length; i++ ) {
  // Do something with a[i]
}

当性能很关键时，length属性只被读取一次可以有助于加速。这只应该在发现性能瓶颈时才使用：

1
2
3
 
for ( var i = 0, j = a.length; i < j; i++ ) {
  // Do something with a[i]
}

另一个变体定义了填满每个迭代的变量，从循环体中删除了数组记号法。当数组包含0或空字符时，它不起作用。

1
2
3
 
for ( var i = 0, item; item = a[i]; i++ ) {
  // Do something with item
}

jQuery提供了原生的each函数来迭代遍数组的元素，以及对象的属性：

1
2
3
4
 
var x = [ 1, 2, 3 ];
jQuery.each( x, function( index, value ) {
  console.log( "index", index, "value", value );
});

缺点是回调函数是在每个值的上下文上调用的，因此如果应用的话，你失去了你自己的对象的上下文。

还可以用length在数组的末尾添加元素。这等同于使用push方法：

1
2
3
4
 
var x = [];
x.push( 1 );
x[ x.length ] = 2;
x // [ 1, 2 ]

通过JavaScript库代码，你将看到很多变体。

其它内建的主法是reverse、join、shift、unshift、pop、slice、splice和sort：

1
2
3
4
5
6
7
8
 
var x = [ 0, 3, 1, 2 ];
x.reverse()      // [ 2, 1, 3, 0 ]
x.join(" – ")    // "2 - 1 - 3 - 0"
x.pop()          // [ 2, 1, 3 ]
x.unshift( -1 )  // [ -1, 2, 1, 3 ]
x.shift()        // [ 2, 1, 3 ]
x.sort()         // [ 1, 2, 3 ]
x.splice( 1, 2 ) // [ 2, 3 ]

请注意，.unshift()方法在Internet Explorer 中不会返回一个length属性。

布尔默认值

一个数组，无论它是否人元素，默认值都不会是false：

1
2
 
![] // false
!![] // true

Array<Type> 记号法

在jQuery API中，你将能经常看到Array<Type>的记号法：

dragPrevention    Array<String>

这指示着方法并不只期待一个数组作为参数，而且还指定期待的类型。此记号法是借用之Java 5的原生记号法（或C++模板）。

类数组对象

无论是一个真正的JavaScript数组，还是一个JavaScript对象，都包含了一个非负整型数length属性，以及从0到length-1的index属性。后一种情形包括类数组的对象，在基于Web的代码中很常见，譬如arguments对象以及很多DOM方法返回的NodeList对象。

当jQuery API接受扁平对象或类数组的对象时，带有数字length属性的扁平对象将触发类数组行为。

PlainObject

PlainObject类型是一个JavaScript对象，包含了零个或多个键值对。换句话说，扁平对象是一个Object对象。在jQuery文档中，它被称为“扁平”，是为了把它下其它JavaScript对象区分开：例如，null、用户定义的数组，以及宿主对象，譬如document，所有具有typeof值为“object”的对象。jQuery.isPlainObject()方法识别了传递入的参数是不是一个扁平对象，如下面所演示的：

1
2
3
4
5
6
7
8
9
10
11
 
  var a = [];
  var d = document;
  var o = {};
 
  typeof a; // object
  typeof d; // object
  typeof o; // object
 
  jQuery.isPlainObject( a ); // false
  jQuery.isPlainObject( d ); // false
  jQuery.isPlainObject( o ); // true

Null

null关键字是一个JavaScript常值，通常用来表达某个故意值的缺失。

Date

Date类型是一个JavaScript对象，代表了一个时刻点。Date是用它们的构造器函数来实例化的，构造器函数默认创建一个代表当前日期时间和对象。

1
 
new Date();

若要针对一个供选择的日期和时间创建一个日期对象，请按以下的顺序传递数字参数：年、月、日、时、分、秒、毫秒——还得注意月份是从0开始的，而其它参数是从1开始的。下面创建了一个Date对象，代表了2014年1月1日上午8:15。

1
 
new Date( 2014, 0, 1, 8, 15 );

Function

JavaScript中的一个函数，既可以是命名函数也可以是匿名函数。任何函数都可以赋给一个变量，或传递给一个方法，但是用这种方法传递成员函数可能导致它们在另一个对象的上下文中被调用（亦即，用不同的“this”对象调用）。

1
2
 
function named() {}
var handler = function() {}

在jQuery代码中你会看到很多匿名函数：

1
2
3
4
5
6
 
$( document ).ready(function() {});
$( "a" ).click(function() {});
$.ajax({
  url: "someurl.php",
  success: function() {}
});

函数的类型是“function”。

Arguments

在函数内部，一个专有的变量“arguments”始终是可用的。它近似于一个数组，它有length属性，但是它缺少数组内建的方法。此伪数组的元素是函数调用的参数。

1
2
3
4
5
6
 
function log( x ) {
  console.log( typeof x, arguments.length );
}
log(); // "undefined", 0
log( 1 ); // "number", 1
log( "1", "2", "3" ); // "string", 3

arguments对象还具有一个callee属性，它指的是运用到它的函数。例如：

1
2
 
var awesome = function() { return arguments.callee; }
awesome() === awesome // true

Context, Call and Apply

在JavaScript中，变量“this”始终引用当前上下文。默认情况下，“this”引用window对象。在函数内部，此上下文是可变的，取决于如何调用函数。

在jQuery中，调用所有的事件处理函数都是用被处理的元素作为上下文的。

1
2
3
4
5
6
 
$( document ).ready(function() {
  // this refers to window.document
});
$( "a" ).click(function() {
  // this refers to an anchor DOM element
});

你可以使用函数内建的call方法和apply方法，为一个函数调用指定上下文。这两个方法的区别在于如何传递参数。call方法把所有的参数传递为给函数的arguments，与此同时apply接受一个数组作为参数。

1
2
3
4
5
6
 
function scope() {
  console.log( this, arguments.length );
}
scope() // window, 0
scope.call( "foobar", [ 1, 2 ] ); // "foobar", 1
scope.apply( "foobar", [ 1, 2 ] ); // "foobar", 2

作用域

在JavaScript中，所有在函数里面定义的变量只在函数作用域内可见。请考虑下面的示例：

1
2
3
4
5
6
7
8
 
// global
var x = 0;
(function() {
  // private
  var x = 1;
  console.log( x ); // 1
})();
console.log( x ); // 0

它在全局作用域内定义了一个变量x，然后定义了一个匿名函数，并立即执行它（额外的小括号对立即执行来说是必不可少的）。在函数内部，定义了另一个变量x，它带有不同的值。它只在函数内部可见，并不覆盖全局变量。

闭包

每当一个定义在当前作用域之外的变量从某个内部作用域中访问时，就创建了一个闭包。在以下的示例中，变量counter在create、increment和print函数内部可见，但是不能在它们的外部可见。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
function create() {
  var counter = 0;
  return {
    increment: function() {
      counter++;
    },
    print: function() {
      console.log( counter );
    }
  }
}
var c = create();
c.increment();
c.print(); // 1

该模式允许你创建一个对象，对象带有操作数据的方法，这些方法不能在对象外部可见——这是面向对象编程的基础。

代理模式

结合上面的知识，给你很大的能力成为一个JavaScript开发员。结合那些的一种方式是在JavaScript中实现一个代表模式，启用面向概念编程（AOP）的基础：

1
2
3
4
5
6
7
8
 
(function() {
  // log all calls to setArray
  var proxied = jQuery.fn.setArray;
  jQuery.fn.setArray = function() {
    console.log( this, arguments );
    return proxied.apply( this, arguments );
  };
})();

上面在函数中包围它的代码以隐藏“proxied”变量。它把jQuery的setArray方法保存在一个闭包里，并重写它。然后该代理记录了所有对该方法的调用，并把该调用委托到原始对象。使用apply(this, arguments)保证了调用者不能够注意到原始对象和proxied方法之间的差异。

回调函数

回调函数是一个纯JavaScript函数，传递给一些方法，作为参数或选项。有些回调函数就是事件，给用户一个机会来对被触发的特定状态作出反应。jQuery的事件系统处处使用了这种回调函数：

1
2
3
 
$( "body" ).click(function( event ) {
  console.log( "clicked: " + event.target );
});

大多数回调函数提供了参数和上下文。在事件处理函数示例中，用一个参数，即Event来调用回调函数。上下文被设置为处理的原因，在上面的示例中，是document.body。

有些回调函数需要返回一些东西，而另一些回调函数的返回值是可有可无的。为了防止表单提交，submit事件处理函数可以返回false：

1
2
3
 
$( "#myform" ).submit(function() {
  return false;
});

回调函数并非总是返回false，它还可以为校验目的而检查表单的字段，只有当表单不可用时才返回false。

Error

Error对象的一个实例是，当发生运行时错误时，抛出一个异常。Error也可以用作定义用户自定义异常类的基础。在JavaScript中，可以用以下方式抛出错误：

1
 
throw new Error( "The argument provided is incorrect" );

也可以由引擎在某些环境下抛出错误。例如，当试图访问null的属性时：

1
2
 
var obj = null;
console.log( obj.foo() );

jQuery中所用的选择器是用来从DOm文档中选择DOM元素。在多数情形中，那个文档是出现在所有的浏览器中的DOM文档，但是也可能出现在通过Ajax取得的XML文档中。

选择器是由CSS选择器和自定义附加物的合成的。在jQuery中所有可用的选择器列出在选择器API页面中。

有很多插件以其它方式利用jQuery的选择器。校验插件接受一个选择器来指定依赖性，即输入是否是必不可少的：

1
2
3
 
emailrules: {
  required: "#email:filled"
}

如果用户在email字段中输入了一个电子邮箱地址，它将使一个名称为“emailrules”勾选框变成必填项，通过它的id选中它，通过校验证插件提供的自定义的选择器":filled"来筛选它。

如果某个参数的类型被指定为选择器，它接受jQuery构造函数能接受的一切选择器，例如，字符串、元素、元素列表。

事件

jQuery的事件系统根据W3C标准，规范化了event对象。该event对象保证会被传递给事件处理函数（不检查window.event必要）。它规范化了target、relatedTarget、which、metaKey以及pageX和pageY属性，并提供了两个方法stopPropagation()和preventDefault()。

Event object页中列出了所有的属性，并配有示例。

文档对象模型中的标准事件是blur、focus、load、resize、scroll、unload、beforeunload、click、dblclick、mousedown、mouseup、mousemove、mouseover、mouseout、mouseenter、mouseleave、change、select、submit、keydown、keypress,和keyup。因为DOM事件名称对于一些元素来说有预定义的意义，不建议为其它目的而使用它们。jQuery的事件模型可以在某个元素上以任意名称触发事件，而且它会沿着元素所从属的DOM树向上传播，如果存在DOM树的话。

元素

文档对象模型（DOM）中的元素可以具有特性、文本和子元素。DOM提供了一些方法来遍历父元素和子元素以及访问到它的特性。然而，因为DOM API规范文档和实现器的不一致性，这些方法用起来可能会是一个挑战。jQuery在那些元素周围提供了一个包装物，以帮助与DOM交互。但是有时候你可以直接操作DOM元素，或者查看接受DOM元素作为参数的方法。

每当你在一个jQuery集合上调用jQuery的.each()方法或它的事件方法之一时，回调函数的上下文—— this——被设置为DOM元素。

有些DOM元素的属性是相当跨浏览器一致的。请考虑一个简单的onblur校验的示例：

1
2
3
4
5
 
$( "input[type='text']" ).on( "blur", function() {
  if( !this.value ) {
    alert( "Please enter some text!" );
  }
});

你可以用 $(this).val()代替this.value，通过jQuery来访问文本输入框的值，但是这样的话，你也不会有什么收益。

Text

文本是文档对象模型（DOM）的节点，代表一个元素或一个特性的文本内容。请考虑下面的代码：

1
 
<p id="target"><b>Hello</b> world</p>

如果你检索示例的段落的子元素，如下所示：

1
 
var children = document.getElementById( "target" ).childNodes;

你获得了两个子元素。第一个子元素是代表b标签的element。第二个子元素是一个文本节点，包含了字符串“world”。

jQuery

jQuery对象包含了一个文档对象模型（DOM）元素的集合，它们是通过HTML字符串创建的，或者选自文档。因为jQuery方法经常使用CSS选择器来从文档中匹配元素，所以jQuery对象中的元素的集合通常被称为“匹配的元素集合”，或者“选中的元素”。

jQuery对象本身的行为很像数组，它具有length属性，而且对象中的元素可以通过它们的数字索引 [0]到[length-1]来访问。请注意jQuery对象并非是真正的JavaScript数组对象，所以它不具有真正的数组对象的所有方法，譬如join()方法。

你将很频繁地使用jQuery()函数来创建jQuery对象。还可以通过它的广为人知的别名$()来访问jQuery()，除非你已经调用了jQuery.noConfict()来禁用此选项。很多jQuery方法返回jQuery对象本身，所以可以连缀方法调用：

任何调用返回jQuery的API，返回的值将是原始的jQuery对象，除非API中已有说明。API方法，譬如.filter()或.not()，会修改它们的进来的集合，并返回一个新的jQuery对象。

1
 
$( "p" ).css( "color", "red" ).find( ".special" ).css( "color", "green" );

每当你使用一个“破坏性的”jQuery方法时，可能改变jQuery对象中的元素集合，譬如.filter()或.find()，那些方法实际上将返回一个带有结果元素的新的jQuery对象，若要返回先前的jQuery对象，你可以使用.end()方法。

jQuery对象可以是空的，不包含DOM元素。你可以利用$()（也就是，不传递任何参数）来创建空的jQuery对象。如果一个选择器没有选中任何元素，或者连缀的方法筛选出了所有的元素，该jQuery对象也可能是空的。涨不会返回error，在那个jQuery对象上任何进一步的函数调用都仅仅是不产生任何效果，因为它们没有可操作的元素。因此，在此示例中，如果在网页上没有坏的条目，则没有元素会着色成红色：

1
 
$( ".badEntry" ).css({ color: "red" });

XMLHttpRequest

有些jQuery的Ajax函数返回原生的XMLHttpRequest（XHR）对象，或者把它传递为success、error、complete处理函数的参数。请注意，Ajax函数只有当一个XHR对象实际使用在请求中时，才返回或传递一个XHR对象。例如，JSONP请求和跨域GET请求使用脚本元素，而不是使用XHR对象。

虽然XHR对象是标准的，但是在不同的浏览器上，它的行为有一些变体。请参考W3C网站以及浏览器的文档以进一步了解：

Google没有针对Chrome的XHR文档的官方网页。自从第5版以来，Chrome不再支持针对XHR请求的文档协议。

jqXHR

自从jQuery 1.5以来，$.ajax()方法返回jqXHR对象，它是XMLHttpRequest对象的超集。欲进一步了解，请参阅$.ajax条目的jqXHR部分。

可延后

任何具有then方法的对象。

延迟对象

自从jQuery 1.5以来，延迟对象提供了一些方法来把多个回调函数注册到一个自我管理的回调函数队列中，适时调用回调函数队列，取决于任何同步函数或异步函数的成功或失败状态。

应答对象

此对象提供了延迟对象的方法的子集（then、done、fail、always、pipe、progress、state和promise）来防止用户改变延迟对象的状态。

Callbacks 对象

一个多目的的对象，提供了管理回调函数列表的强大的方式。它支持添加回调函数、删除回调函数、引发回调函数和禁用回调函数。通过$.Callbacks函数来创建并返回CAllbacks对象，接下来此函数的大部分方法也能够返回CAllbacks对象。

XML 文档

由浏览器的XML DOM解析器创建的文档对象，通常来自于代表XML的字符串。XML文档具有与HTML文档不同的语义，但是jQuery提供的大多数遍历方法和文档处理方法可以对它们起作用。

Assert

占住所有的QUnit的助手工具的对象的参考或实例。请参阅针对QUnit.assert的API文档以了解详情。