Типы

На этой странице документируются типы данных, встречающиеся в сигнатурах функций jQuery, независимо от того, определены ли они самим JavaScript или дополнительно ограничены jQuery. Если не указано иное, функции jQuery требуют примитивных значений, где это применимо, и не принимают их обёртки в объектах. Если вы хотите изучить эти концепции подробно, ознакомьтесь с MDN.

Вы должны иметь возможность опробовать большинство примеров ниже, просто скопировав их в консоль JavaScript вашего браузера.

Всякий раз, когда пример упоминает, что тип по умолчанию имеет значение boolean, результат полезно знать при использовании этого типа в контексте boolean:

var x = "";
if ( x ) {
  console.log( "x defaulted to true" );
} else {
  console.log( "x defaulted to false" );
}

В этом случае, "x defaulted to false" выводится.

Чтобы примеры были короткими, используется оператор инверсии ("не") и двойное отрицание для демонстрации контекста boolean:

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

Переходим к реальным типам.

Содержание

Любое значение
Строка
- Кавычки
- Встроенные методы
- Свойство длины
- Значение по умолчанию boolean
htmlСтрока
Число
- Значение по умолчанию boolean
- Математические функции
- Разбор чисел
- Числа в строки
- NaN и Бесконечность
- Целое число
- Число с плавающей точкой
Булево
Объект
- Точечная нотация
- Нотация массива
- Итерация
- Значение по умолчанию boolean
- Прототип
Массив
- Итерация
- Значение по умолчанию boolean
- Нотация массива<Тип>
Объект-массивоподобный объект
Простой объект
Дата
Функция
- Аргументы
- Контекст, вызов и применение
- Область видимости
- Замыкания
- Шаблон прокси
Ошибка
Селектор
Событие
Элемент
Текст
jQuery
XMLHttpRequest
jqXHR
Thenable
Объект Deferred
Объект Promise
Объект Callbacks
XML документ
Объект Assert Qunit

Любое значение

Виртуальный тип Любое значение используется в документации jQuery для указания того, что может быть использован любой тип или что ожидается любой тип.

Строка

Строка в JavaScript — это неизменяемое примитивное значение, содержащее ноль, одну или несколько символов.

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

Тип строки — "строка".

typeof "some string"; // "string"

Кавычки

Строку можно определить, используя одинарные или двойные кавычки. Можно вкладывать одинарные кавычки в двойные, и наоборот. Чтобы смешивать двойные кавычки с двойными кавычками (или одинарные с одинарными), вложенные кавычки должны быть экранированы обратной косой чертой.

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

Встроенные методы

В JavaScript у строки есть некоторые встроенные методы для работы со строкой, хотя результат всегда — новая строка — или что-то ещё, например, split возвращает массив.

"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.

"Hello".length // 5
"".length // 0

Значение по умолчанию boolean

Пустая строка по умолчанию равна false:

!"" // true
!!"" // false
!"hello" // false
!"true" // false
!new Boolean( false ) // false

htmlСтрока

В документации jQuery строка обозначается как htmlСтрока, когда она используется для представления одного или нескольких элементов DOM, обычно для создания и вставки в документ. При передаче в качестве аргумента функции jQuery(), строка идентифицируется как HTML, если она начинается с <tag ... >) и анализируется как таковая до последнего > символа. Перед jQuery 1.9 строка считалась HTML, если она содержала <tag ... > в любой точке строки.

Когда строка передаётся в качестве аргумента методу обработки, такому как .append(), она всегда рассматривается как HTML, поскольку другое общее толкование jQuery строки (CSS-селекторы) не применяется в этих контекстах.

Для явного разбора строки в HTML доступен метод $.parseHTML() начиная с jQuery 1.8.

// 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, доступны для работы с числами (+, -, *, /, %, =, +=, -=, *=, /=, ++, --).

12
3.543

Тип числа — "число".

typeof 12 // "number"
typeof 3.543 // "number"

Значение по умолчанию boolean

Если число равно нулю, оно по умолчанию равно false:

!0 // true
!!0 // false
!1 // false
!-1 // false

Из-за реализации чисел как значений двойной точности, следующий результат не является ошибкой:

0.1 + 0.2 // 0.30000000000000004

Математические функции

JavaScript предоставляет утилиты для работы с числами в объекте Math:

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

Разбор чисел

parseInt и parseFloat помогают разбить строки на числа. Оба выполняют неявное преобразование, если база не указана:

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; // "12"
"" + ( 1 + 2 ); // "3"
"" + 0.0000001; // "1e-7"
parseInt( 0.0000001 ); // 1 (!)

Или используйте класс String, предоставляемый JavaScript, который пытается преобразовать значение в строку:

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

NaN и Бесконечность

Разбор чего-либо, что не является числом, приводит к NaN. isNaN помогает обнаружить эти случаи:

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

Деление на ноль приводит к Бесконечности:

1 / 0 // Infinity

И NaN, и Бесконечность имеют тип "число":

typeof NaN // "number"
typeof Infinity // "number"

Обратите внимание, что NaN сравнивается необычным образом:

NaN === NaN // false (!)

Но:

Infinity === Infinity // true

Целое число

Целое число — это обычный тип Number, но когда оно явно упоминается, это указывает на то, что ожидается число без дробной части.

Число с плавающей точкой

Число с плавающей точкой — это обычный тип Number, как и целое число, но когда оно явно упоминается, это указывает на то, что ожидается число с дробной частью.

Булево

Булево значение в JavaScript может быть либо true, либо false:

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

Объект

Всё в JavaScript является объектом, хотя некоторые объекты более «объективны» (шутка). Самый простой способ создать объект — это литерал объекта:

var x = {};
var y = {
  name: "Pete",
  age: 15
};

Тип объекта — "объект":

typeof {} // "object"

Точечная нотация

Вы можете записывать и читать свойства объекта с помощью точечной нотации:

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

Нотация массива

Или вы можете записывать и читать свойства с помощью нотации массива, которая позволяет динамически выбирать свойство:

var operations = {
  increase: "++",
  decrease: "--"
};
var operation = "increase";
operations[ operation ] // "++"
operations[ "multiply" ] = "*"; // "*"

Итерация

Итерирование по объектам легко выполняется с помощью цикла for-in:

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 для итерирования по свойствам объектов, а также по элементам массивов:

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

Недостатки заключаются в том, что обратный вызов вызывается в контексте каждого значения, и поэтому вы теряете контекст собственного объекта, если это применимо. Подробнее об этом ниже в разделе Функции.

Значение по умолчанию boolean

Объект, независимо от наличия свойств, никогда не имеет значения по умолчанию false:

!{} // false
!!{} // true

Прототип

Все объекты имеют свойство prototype. Всякий раз, когда интерпретатор ищет свойство, он также проверяет в прототипе объекта, если свойство не найдено в самом объекте. jQuery широко использует прототип для добавления методов к экземплярам jQuery. Внутренне jQuery делает jQuery.fn псевдонимом для jQuery.prototype, так что вы можете использовать любой из них (хотя разработчики плагинов стандартизировали на fn).

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 представляют собой изменяемые списки с несколькими встроенными методами. Вы можете определить массивы с помощью литерала массива:

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

Тип массива — "объект":

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

Чтение и запись элементов в массив выполняется с использованием нотации массива:

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

Итерация

Массив имеет свойство length, полезное для итерации:

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

Когда производительность имеет решающее значение, чтение свойства length только один раз может помочь ускорить процесс. Это следует использовать только в том случае, если был обнаружен узкий производительности:

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

Другой вариант определяет переменную, которая заполняется для каждой итерации, удаляя нотацию массива из тела цикла. Он не работает, когда массив содержит 0 или пустые строки!

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

jQuery предоставляет универсальную функцию each для итерации по элементам массивов, а также по свойствам объектов:

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

Недостатки заключаются в том, что обратный вызов вызывается в контексте каждого значения, и вы, следовательно, теряете контекст собственного объекта, если применимо. Подробнее об этом ниже в разделе Функции.

Свойство length также можно использовать для добавления элементов в конец массива. Это эквивалентно использованию метода push:

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

Вы часто увидите оба варианта, просматривая код библиотек JavaScript.

Другие встроенные методы — reverse, join, shift, unshift, pop, slice, splice и sort:

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() не возвращает свойство length в Internet Explorer.

Значение по умолчанию Boolean

Массив, независимо от наличия элементов, никогда не имеет значение по умолчанию false:

![] // false
!![] // true

Нотация Array<Type>

В API jQuery вы часто найдете нотацию Array<Type>:

dragPrevention    Array<String>

Это указывает, что метод ожидает не только массив в качестве аргумента, но также определяет ожидаемый тип. Нотация заимствована из нотации дженериков Java 5 (или шаблонов C++).

Объект, подобный массиву

Это либо настоящий массив JavaScript, либо объект JavaScript, содержащий свойство с целым неотрицательным length значением и свойства индексов от 0 до length - 1. Этот последний случай включает в себя объекты, похожие на массивы, которые часто встречаются в коде на основе веб-технологий, такие как объект arguments и объект NodeList, возвращаемый многими методами DOM.

Когда API jQuery принимает как простые объекты, так и объекты, похожие на массивы, простой объект с числовым length свойством вызовет поведение, подобное массиву.

Простой объект

Тип PlainObject — это объект JavaScript, содержащий ноль или более пар ключ-значение. Простой объект, другими словами, это Object объект. В документации jQuery он обозначен как "простой", чтобы отличить его от других типов объектов JavaScript: например, null, пользовательские массивы и хост-объекты, такие как document, у которых значение свойства typeof равно "объект". Метод jQuery.isPlainObject() определяет, является ли переданный аргумент простым объектом или нет, как показано ниже:

  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 создаются с помощью их конструктора, который по умолчанию создает объект, представляющий текущую дату и время.

new Date();

Для создания объекта Date для другой даты и времени передайте числовые аргументы в следующем порядке: год, месяц, день, час, минута, секунда, миллисекунда — хотя обратите внимание, что месяц имеет нулевой индекс, в то время как другие аргументы — единичные. Следующее создает объект Date, представляющий 1 января 2014 года в 8:15.

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

Функция

Функция в JavaScript может быть именованной или анонимной. Любую функцию можно присвоить переменной или передать методу, но передача функций-членов таким образом может привести к тому, что они будут вызываться в контексте другого объекта (т. е. с другим объектом "this").

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

Вы часто видите анонимные функции в коде jQuery:

$( document ).ready(function() {});
$( "a)" ).on( "click", function() {});
$.ajax({
  url: "someurl.php",
  success: function() {}
});

Тип функции — "функция".

Аргументы

Внутри функции всегда доступна специальная переменная "arguments". Она похожа на массив тем, что имеет свойство length, но не имеет встроенных методов массива. Элементы псевдомассива — это аргументы вызова функции.

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

Объект arguments также имеет свойство callee, которое ссылается на функцию, внутри которой вы находитесь. Например:

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

Контекст, Call и Apply

В JavaScript переменная "this" всегда ссылается на текущий контекст. По умолчанию "this" ссылается на объект window. Внутри функции контекст this может изменяться в зависимости от того, как вызывается функция.

Все обработчики событий в jQuery вызываются с элементом обработки как контекстом.

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

Вы можете указать контекст для вызова функции с помощью встроенных методов функции call и apply. Разница между ними заключается в том, как они передают аргументы. Call передает все аргументы как аргументы функции, а apply принимает массив в качестве аргументов.

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 все переменные, определенные внутри функции, видимы только в области видимости этой функции. Рассмотрим следующий пример:

// global
var x = 0;
(function() {
  // private
  var x = 1;
  console.log( x ); // 1
})();
console.log( x ); // 0

Он определяет переменную x в глобальной области видимости, затем определяет анонимную функцию и немедленно ее выполняет (дополнительные скобки необходимы для немедленного выполнения). Внутри функции определяется другая переменная x с другим значением. Она видна только внутри этой функции и не перезаписывает глобальную переменную.

Закрытия

Закрытия создаются всякий раз, когда переменная, определенная вне текущей области видимости, используется внутри некоторой внутренней области видимости. В следующем примере переменная counter видна внутри функций create, increment и print, но не снаружи их.

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):

(function() {
  // log all calls to setArray
  var proxied = jQuery.fn.setArray;
  jQuery.fn.setArray = function() {
    console.log( this, arguments );
    return proxied.apply( this, arguments );
  };
})();

Вышеприведенный код обернут в функцию для скрытия переменной "прокси". Он сохраняет метод setArray jQuery в закрытии и перезаписывает его. Затем прокси регистрирует все вызовы метода и делегирует вызов исходному методу. Использование apply(this, arguments) гарантирует, что вызывающий метод не заметит разницы между исходным и прокси-методом.

Обратный вызов

Обратный вызов — это обычная JavaScript-функция, передаваемая методу в качестве аргумента или опции. Некоторые обратные вызовы — это просто события, вызываемые, чтобы дать пользователю возможность среагировать, когда срабатывает определенное состояние. Система событий jQuery использует такие обратные вызовы повсюду:

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

Большинство обратных вызовов предоставляют аргументы и контекст. В примере обработчика событий обратный вызов вызывается с одним аргументом, Event. Контекст устанавливается в элемент обработки, в данном случае document.body.

Некоторые обратные вызовы обязаны возвращать что-либо, другие делают это значение возврата необязательным. Для предотвращения отправки формы обработчик события submit может возвращать false:

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

Вместо того чтобы всегда возвращать false, обратный вызов мог проверить поля формы на валидность и возвращать false только тогда, когда форма недействительна.

Ошибка

Экземпляр объекта Error выбрасывается как исключение при возникновении ошибки во время выполнения. Error также может быть использован в качестве базового класса для определения пользовательских классов исключений. В JavaScript ошибка может быть выброшена, как показано ниже:

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

Ошибка также может быть выброшена движком в определенных обстоятельствах. Например, при попытке получить доступ к свойству null:

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

Селектор

Селектор используется в jQuery для выбора элементов DOM из документа DOM. В большинстве случаев этот документ — DOM-документ, присутствующий во всех браузерах, но также может быть XML-документом, полученным через Ajax.

Селекторы — это сочетание CSS и пользовательских добавлений. Все доступные в jQuery селекторы документированы на странице API Селекторов.

Существует много плагинов, которые используют селекторы jQuery другими способами. Плагин валидации принимает селектор для указания зависимости, требуется ли вход или нет:

emailrules: {
  required: "#email:filled"
}

Это сделало бы флажок с именем «emailrules» обязательным только в том случае, если пользователь ввел адрес электронной почты в поле email, выбранное по его id, отфильтрованное с помощью пользовательского селектора «:filled», который предоставляет плагин валидации.

Если тип аргумента указан как селектор, он принимает все, что принимает конструктор jQuery, например, строки, элементы, списки элементов.

Событие

Система событий jQuery стандартизирует объект события в соответствии со стандартами W3C. Объект события гарантированно передается обработчику событий (не нужны проверки на window.event). Он нормализует target, relatedTarget, metaKey и свойства pageX/Y, а также предоставляет методы stopPropagation() и preventDefault().

Все эти свойства документированы и сопровождаются примерами на странице объекта события.

Стандартные события в Document Object Model: 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) может иметь атрибуты, текст и дочерние элементы. Он предоставляет методы для обхода родительских и дочерних элементов, а также для доступа к его атрибутам. Однако из-за несоответствий в спецификациях и реализациях API DOM эти методы могут быть сложными в использовании. jQuery предоставляет «обёртку» вокруг этих элементов, чтобы помочь взаимодействовать с DOM. Но иногда вам придётся работать напрямую с элементами DOM или вы увидите методы, которые (также) принимают элементы DOM в качестве аргументов.

Всякий раз, когда вы вызываете метод jQuery .each() или один из его методов событий на коллекции jQuery, контекст функции обратного вызова — this — устанавливается на элемент DOM.

Некоторые свойства элементов DOM достаточно согласованы между браузерами. Рассмотрим этот пример простой валидации при потере фокуса:

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

Вы могли бы заменить this.value на $(this).val(), чтобы получить значение текстового поля через jQuery, но в этом случае вы ничего не выиграете.

Текст

Текст — это узел модели объекта документа (DOM), который представляет текстовое содержимое элемента элемента или атрибута. Рассмотрим следующий код:

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

Если вы извлечёте дочерние элементы абзаца из примера следующим образом:

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

Вы получите два дочерних элемента. Первый — это элемент, представляющий тег b. Второй дочерний элемент — это текстовый узел, содержащий строку " world".

jQuery

Объект jQuery содержит коллекцию элементов модели объекта документа (DOM), которые были созданы из строки HTML или выбраны из документа. Поскольку методы jQuery часто используют CSS-селекторы для сопоставления элементов из документа, набор элементов в объекте jQuery часто называется набором «сопоставленных элементов» или «выбранных элементов».

Сам объект jQuery ведёт себя как массив; у него есть свойство length, и к элементам в объекте можно получить доступ по их числовым индексам [0] до [length-1]. Обратите внимание, что объект jQuery фактически не является объектом Javascript Array, поэтому у него нет всех методов истинного объекта Array, таких как join().

Чаще всего вы будете использовать функцию jQuery() для создания объекта jQuery. jQuery() также можно получить по его привычному псевдониму с одной буквой $(), если вы не вызвали jQuery.noConflict() для отключения этого варианта. Многие методы jQuery возвращают сам объект jQuery, что позволяет цепочку вызовов методов:

В вызовах API, которые возвращают jQuery, возвращаемый значение будет исходным объектом jQuery, если не указано иное в документации этого API. Методы API, такие как .filter() или .not(), изменяют свой входной набор и, таким образом, возвращают новый объект jQuery.

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

Всякий раз, когда вы используете «деструктивный» метод jQuery, который потенциально изменяет набор элементов в объекте jQuery, например, .filter() или .find(), этот метод фактически возвращает новый объект jQuery с полученными элементами. Чтобы вернуться к предыдущему объекту jQuery, используйте метод .end().

Объект jQuery может быть пустым, не содержащим элементов DOM. Вы можете создать пустой объект jQuery с помощью $() (то есть, не передавая вообще никаких аргументов). Объект jQuery также может быть пустым, если селектор не выбирает никаких элементов или если цепочный метод отфильтровывает все элементы. Это не ошибка; любые дальнейшие методы, вызываемые на этом объекте jQuery, просто не оказывают никакого влияния, так как у них нет элементов для воздействия. Таким образом, в этом примере, если на странице нет плохих записей, то элементы не будут окрашены в красный цвет:

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

XMLHttpRequest

Некоторые функции Ajax jQuery возвращают собственный объект XMLHttpRequest (XHR) или передают его в качестве аргумента обработчикам success/error/complete, чтобы вы могли выполнить дополнительную обработку или мониторинг запроса. Обратите внимание, что функции Ajax возвращают или передают объект XHR только тогда, когда в запросе фактически используется объект XHR. Например, запросы JSONP и запросы GET к различным доменам используют элемент сценария вместо объекта XHR.

Хотя объект XHR является стандартным, его поведение может отличаться в разных браузерах. Для получения дополнительной информации посетите сайт WHATWG и Mozilla Developer Network:

jqXHR

Начиная с jQuery 1.5, метод $.ajax() возвращает объект jqXHR, который является супермножеством объекта XMLHTTPRequest. Для получения дополнительной информации см. раздел jqXHR в разделе $.ajax

Thenable

Любой объект, у которого есть метод then.

Объект отложенного выполнения

Начиная с jQuery 1.5, объект Deferred предоставляет способ регистрации нескольких функций обратного вызова в управляемых самими собой очередях функций обратного вызова, вызывать очереди функций обратного вызова по мере необходимости и передавать состояние успешного или неудачного завершения любой синхронной или асинхронной функции.

Объект Promise

Этот объект предоставляет подмножество методов объекта Deferred (then, done, fail, always, pipe, progress, state и promise), чтобы предотвратить изменение состояния Deferred пользователем.

Объект Callbacks

Многоцелевой объект, который предоставляет мощный способ управления списками функций обратного вызова. Он поддерживает добавление, удаление, вызов и отключение функций обратного вызова. Объект Callbacks создаётся и возвращается функцией $.Callbacks и впоследствии возвращается большинством методов этой функции.

Документ

Объект документа, созданный парсером DOM браузера, обычно из строки, представляющей HTML или XML.

XML-документ

Объект документа, созданный XML-парсером DOM браузера, обычно из строки, представляющей XML. XML-документы имеют другую семантику, чем HTML-документы, но большинство методов обхода и манипулирования, предоставляемых jQuery, будут работать с ними.

Assert

Ссылка на или экземпляр объекта, содержащего все утверждения QUnit. См. документацию API для QUnit.assert для получения подробностей.