类型

此页面记录了出现在 jQuery 函数签名中的数据类型，无论它们是由 JavaScript 本身定义的，还是由 jQuery 进一步限制的。除非另有明确说明，否则 jQuery 函数在适用的情况下需要原始值，并且不接受它们的 Object 包装形式。如果您想深入研究这些概念，请查看 MDN。

您应该能够通过将下面的大多数示例复制到浏览器的 JavaScript 控制台中来试用它们。

每当一个示例提到某个类型默认为布尔值时，结果对于在布尔上下文中使用该类型非常重要

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. Array-Like Object（类数组对象）
  9. PlainObject（纯对象）
  10. Date（日期）
  11. Function（函数）
  12. Error（错误）
  13. Selector（选择器）
  14. Event（事件）
  15. Element（元素）
  16. Text（文本）
  17. jQuery
  18. XMLHttpRequest
  19. jqXHR
  20. Thenable
  21. 延迟对象 (Deferred Object)
  22. Promise Object（Promise 对象）
  23. 回调对象 (Callbacks Object)
  24. XML Document（XML 文档）
  25. Qunit's Assert Object（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 返回一个 数组。

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

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

当字符串作为操作方法（如 .append()）的参数传入时，它始终被视为 HTML，因为 jQuery 对字符串的其他常见解释（CSS 选择器）在这些上下文中不适用。

要显式地将字符串解析为 HTML，可以使用 $.parseHTML() 方法（从 jQuery 1.8 开始可用）。

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 格式的值。它们是不可变的原始值，就像 字符串一样。所有在基于 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

数字转字符串

将数字附加到字符串时，结果始终是字符串。运算符是相同的，所以要小心：如果您想先添加数字，然后再将它们附加到字符串，请在数字周围加上括号

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

除以零会导致 Infinity

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（整数）

整数是一种普通的 Number 类型，但每当明确提及时，表示期望一个非浮点数。

Float（浮点数）

浮点数是一种普通的 Number 类型，与 Integer 一样，但每当明确提及时，表示期望一个浮点数。

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-loop 迭代对象很容易

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 ] );
}

请注意，for-in-loop 可能会被扩展 Object.prototype 破坏（请参阅 Object.prototype is verboten），因此在使用其他库时要小心。

jQuery 提供了一个通用的 each 函数 来迭代对象的属性以及数组的元素

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

缺点是回调函数是在每个值的上下文中调用的，因此如果适用，您会失去自己对象的上下文。有关更多信息，请参阅下面的 Functions 部分。

布尔默认值

一个对象，无论它是否有属性，都不会默认为 false

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

原型

所有对象都有一个 prototype 属性。每当解释器查找属性时，如果对象本身未找到该属性，它也会在对象的原型中查找。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 );
});

缺点是回调函数是在每个值的上下文中调用的，因此如果适用，您会失去自己对象的上下文。有关更多信息，请参阅下面的 Functions 部分。

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++ 模板）。

Array-Like Object（类数组对象）

一个真正的 JavaScript Array 或一个包含非负整数 length 属性和从 0 到 length - 1 的索引属性的 JavaScript Object。后一种情况包括在基于 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();

要为另一个日期和时间创建 Date 对象，请按以下顺序传递数字参数：年、月、日、小时、分钟、秒、毫秒 — 但请注意，月份是从零开始的，而其他参数是从一开始的。以下创建一个表示 2014 年 1 月 1 日 8:15 的 Date 对象。

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)" ).on( "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（调用）和 Apply（应用）

在 JavaScript 中，变量 "this" 始终引用当前上下文。默认情况下，"this" 引用 window 对象。在函数内部，此上下文可以更改，具体取决于函数的调用方式。

jQuery 中的所有事件处理程序都以处理元素作为上下文调用。

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

您可以使用函数的内置方法 call 和 apply 指定函数调用的上下文。它们之间的区别在于它们如何传递参数。Call 将所有参数作为参数传递给函数，而 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

Scope（作用域）

在 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，具有不同的值。它仅在该函数内可见，并且不会覆盖全局变量。

Closures（闭包）

每当从某个内部作用域访问在当前作用域之外定义的变量时，就会创建闭包。在以下示例中，变量 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

这种模式允许您创建具有操作对外部不可见的数据的方法的对象——这是面向对象编程的基础。

Proxy Pattern（代理模式）

结合上述知识，作为 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) 可确保调用者无法注意到原始方法和代理方法之间的差异。

Callback（回调）

回调是一个作为参数或选项传递给某些方法的普通 JavaScript 函数。某些回调只是事件，在触发特定状态时调用以使用户有机会做出反应。jQuery 的事件系统在任何地方都使用此类回调

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

大多数回调提供参数和上下文。在事件处理程序示例中，回调以一个参数 Event 调用。上下文设置为处理元素，在上面的示例中为 document.body。

某些回调需要返回某些内容，而其他回调则使该返回值可选。要防止表单提交，提交事件处理程序可以返回 false

1
2
3
 
$( "#myform" ).on( "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() );

Selector（选择器）

选择器在 jQuery 中用于从 DOM 文档中选择 DOM 元素。在大多数情况下，该文档是所有浏览器中都存在的 DOM 文档，但也可以是通过 Ajax 接收的 XML 文档。

选择器是 CSS 和自定义添加的组合。jQuery 中所有可用的选择器都记录在 选择器 API 页面上。

有许多插件以其他方式利用 jQuery 的选择器。验证插件接受一个选择器来指定依赖项，即输入是否是必需的

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

这将使名为 "emailrules" 的复选框仅在用户在通过其 id 选择的电子邮件字段中输入电子邮件地址时才必需，并通过验证插件提供的自定义选择器 ":filled" 进行过滤。

如果将 Selector 指定为参数类型，它接受 jQuery 构造函数接受的所有内容，例如 Strings、Elements、Lists of Elements。

Event（事件）

jQuery 的事件系统根据 W3C 标准规范化事件对象。事件对象保证会传递给事件处理程序（无需检查 window.event）。它规范化了 target、relatedTarget、which、metaKey 和 pageX/Y 属性，并提供了 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 树（如果有）。

Element（元素）

文档对象模型 (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（文本）

Text 是文档对象模型 (DOM) 的一个节点，表示 元素 或属性的文本内容。考虑以下代码

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

如果您如下检索示例段落的子元素

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

您会获得两个子元素。第一个是表示 b 标签的 元素。第二个子元素是包含字符串 " world" 的文本节点。

jQuery

jQuery 对象包含从 HTML 字符串创建或从文档中选择的文档对象模型 (DOM) 元素的集合。由于 jQuery 方法经常使用 CSS 选择器从文档中匹配元素，因此 jQuery 对象中的元素集通常称为“匹配元素集”或“选定元素集”。

jQuery 对象本身的行为很像一个数组；它有一个 length 属性，并且对象中的元素可以通过它们的数字索引 [0] 到 [length-1] 访问。请注意，jQuery 对象实际上不是 JavaScript Array 对象，因此它不具有真实 Array 对象的所有方法，例如 join()。

最常见的是，您将使用 jQuery() 函数创建 jQuery 对象。jQuery() 也可以通过其熟悉的单字符别名 $() 访问，除非您已调用 jQuery.noConflict() 来禁用此选项。许多 jQuery 方法返回 jQuery 对象本身，以便可以链式调用方法

在返回 jQuery 的 API 调用中，返回的值将是原始 jQuery 对象，除非该 API 另有说明。诸如 .filter() 或 .not() 之类的 API 方法会修改它们的传入集，因此会返回一个新的 jQuery 对象。

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

每当您使用可能更改 jQuery 对象中元素集的“破坏性”jQuery 方法时，例如 .filter() 或 .find()，该方法实际上会返回一个包含结果元素的新 jQuery 对象。要返回到上一个 jQuery 对象，您可以使用 .end() 方法。

jQuery 对象可能为空，不包含任何 DOM 元素。您可以使用 $() 创建一个空 jQuery 对象（即根本不传递参数）。如果选择器没有选择任何元素，或者如果链式方法过滤掉了所有元素，jQuery 对象也可能为空。这不是错误；对该 jQuery 对象调用的任何进一步方法都没有效果，因为它们没有元素可操作。因此，在这个示例中，如果页面上没有不良条目，则不会有任何元素被染成红色

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

XMLHttpRequest

jQuery 的一些 Ajax 函数返回原生的 XMLHttpRequest (XHR) 对象，或者将其作为参数传递给 success/error/complete 处理程序，以便您可以对请求执行额外的处理或监视。请注意，Ajax 函数仅在请求中实际使用 XHR 对象时才返回或传递 XHR 对象。例如，JSONP 请求和跨域 GET 请求使用脚本元素而不是 XHR 对象。

尽管 XHR 对象是标准，但它在不同浏览器中的行为有所不同。有关更多信息，请参阅 WHATWG 网站和 Mozilla Developer Network

jqXHR

从 jQuery 1.5 开始，$.ajax() 方法返回 jqXHR 对象，它是 XMLHTTPRequest 对象的超集。有关更多信息，请参阅 $.ajax 条目的 jqXHR 部分

Thenable

任何具有 then 方法的对象。

延迟对象 (Deferred Object)

从 jQuery 1.5 开始，Deferred 对象提供了一种将多个回调注册到自我管理的 callback queues 中、在适当的时候调用 callback queues，并中继任何同步或异步函数的成功或失败状态的方法。

Promise Object（Promise 对象）

此对象提供了 Deferred 对象方法的一个子集（then、done、fail、always、pipe、progress、state 和 promise），以防止用户更改 Deferred 的状态。

回调对象 (Callbacks Object)

一个多用途对象，提供了一种管理回调列表的强大方式。它支持添加、删除、触发和禁用回调。Callbacks 对象由 $.Callbacks 函数创建并返回，随后由该函数的大多数方法返回。

Document（文档）

由浏览器的 DOM 解析器创建的文档对象，通常来自表示 HTML 或 XML 的字符串。

XML Document（XML 文档）

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

Assert（断言）

对包含所有 QUnit 断言的对象的引用或实例。有关详细信息，请参阅 QUnit.assert 的 API 文档。