类型

本页记录了出现在 jQuery 函数签名中的数据类型，无论这些类型是由 JavaScript 本身定义的，还是由 jQuery 进一步限制的。 除非明确说明，否则 jQuery 函数需要原始值（如果适用），并且不接受其对象包装形式。 如果你想深入研究这些概念，请查看 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 默认为 false"。

为了使示例简短，使用了反转（“非”）运算符和双重否定来显示布尔值上下文

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

现在进入实际的类型。

内容

  1. 任何类型
  2. 字符串
  3. html 字符串
  4. 数字
  5. 布尔值
  6. 对象
  7. 数组
  8. 类数组对象
  9. PlainObject
  10. 日期
  11. 函数
  12. 错误
  13. 选择器
  14. 事件
  15. 元素
  16. 文本
  17. jQuery
  18. XMLHttpRequest
  19. jqXHR
  20. Thenable
  21. Deferred 对象
  22. Promise 对象
  23. 回调对象
  24. XML 文档
  25. Qunit 的断言对象

任何类型

Anything 虚拟类型在 jQuery 文档中用于指示可以使用或应期望任何类型。

字符串

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 属性。

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

布尔值默认值

空字符串默认为 false

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

html 字符串

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

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

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

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" );

数字

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


数学

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

整数

整数是普通的 Number 类型，但只要明确提及，就表示需要非浮点数。

浮点数

浮点数是普通的 Number 类型，与整数相同，但只要明确提及，就表示需要浮点数。


布尔值

JavaScript 中的布尔值可以是 true 或 false。

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

对象

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

请注意，for-in 循环可能会因扩展 Object.prototype 而被破坏（请参阅 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

原型

所有对象都有一个 prototype 属性。每当解释器查找属性时，如果在对象本身找不到该属性，它也会检查对象的 prototype。jQuery 广泛使用 prototype 向 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();

数组

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 数组，要么是包含非负整数 length 属性和从 0 到 length - 1 的索引属性的 JavaScript 对象。后一种情况包括在基于 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 类型是 JavaScript 中的一个对象，它表示时间中的一个特定时刻。Date 对象使用其构造函数实例化，默认情况下，它创建一个表示当前日期和时间的对象。

1
 
new Date();

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

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

函数

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”。它类似于数组，因为它具有 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

上下文、调用和应用

在 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

作用域

在 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) 可以确保调用者无法注意到原始方法和代理方法之间的区别。

回调

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

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

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

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

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

回调可以检查表单字段的有效性，而不是始终返回 false，并且仅在表单无效时返回 false。

错误

当运行时错误发生时，会将 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"
}

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

如果选择器指定为参数的类型，它将接受 jQuery 构造函数接受的所有内容，例如字符串、元素、元素列表。

事件

jQuery 的事件系统根据 W3C 标准规范化事件对象。事件对象保证传递给事件处理程序（无需检查 window.event）。它规范化了 target、relatedTarget、which、metaKey 和 pageX/Y 属性，并提供 stopPropagation() 和 preventDefault() 方法。

这些属性都在 事件对象 页面上进行了文档说明，并附有示例。

文档对象模型中的标准事件有：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 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 访问文本输入的值，但在这种情况下您将不会获得任何好处。

文本

文本是文档对象模型 (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 数组对象，因此它不具有真实数组对象的所有方法，例如join()。

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

在返回jQuery的 API 调用中，除非该 API 文档另有说明，否则返回的值将是原始 jQuery 对象。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 对象也可能为空。这不是错误；对该 jQuery 对象调用的任何进一步方法都不会产生任何影响，因为它们没有元素可以操作。因此，在本例中，如果页面上没有错误条目，则不会将任何元素着色为红色

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

XMLHttpRequest

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

虽然 XHR 对象是标准，但其在不同浏览器上的行为存在差异。有关更多信息，请参阅 WHATWG 网站和 Mozilla 开发者网络。

jqXHR

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

Thenable

任何具有 then 方法的对象。

Deferred 对象

从 jQuery 1.5 开始，Deferred 对象提供了一种方法，可以将多个回调注册到自管理的回调队列中，根据需要调用回调队列，并中继任何同步或异步函数的成功或失败状态。

Promise 对象

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

回调对象

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

文档

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

XML 文档

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

断言

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