Skip to content

jQuery Шпаргалка

Быстрая компактная JavaScript-библиотека с широкими возможностями.

01

Начало работы

Подключение jQuery

Подключайте jQuery через CDN для быстрой загрузки из кеша. Минифицированная версия (.min.js) — для production, несжатая — для отладки. Всегда предусматривайте локальный запасной вариант на случай недоступности CDN. С npm jQuery можно импортировать как модуль — удобно для сборщиков вроде Webpack/Vite. Актуальная ветка — jQuery 3.7.x; старые IE больше не поддерживаются.

jquery
<!-- Production (CDN, minified) -->
<script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>

<!-- Development (CDN, uncompressed) -->
<script src="https://code.jquery.com/jquery-3.7.1.js"></script>

<!-- Fallback: load local if CDN fails -->
<script>
window.jQuery || document.write(
  '<script src="js/jquery-3.7.1.min.js"><\/script>'
)
</script>

<!-- npm install -->
<!-- npm install jquery -->

Готовность документа

Оборачивайте код, работающий с DOM, в $(document).ready(), чтобы он выполнялся только после разбора дерева DOM (изображения ждать не нужно). $(fn) — сокращённая запись. Если ваш <script> стоит в конце <body>, DOM уже доступен и ready можно пропустить. ready в jQuery похож на DOMContentLoaded: срабатывает до window.load, который ждёт изображения и iframe.

jquery
// run code after DOM is fully parsed
$(document).ready(function () {
  console.log('DOM ready')
})

// shorter equivalent
$(function () {
  console.log('DOM ready')
})

// modern preferred (no ready needed at end of body)
// <script> at the end of <body> runs after DOM exists

// pass a function to $ — jQuery treats it as ready handler
$(function () {
  $('.btn').on('click', function () {
    alert('clicked')
  })
})

Объект jQuery ($)

$ — просто псевдоним jQuery, оба работают одинаково. Как функция $ выбирает элементы (возвращает коллекцию jQuery). Как пространство имён $.foo даёт утилиты. Если $ занят другой библиотекой, вызовите $.noConflict(), чтобы освободить его; при этом можно использовать jQuery или передать $ в колбэк ready как локальный псевдоним.

jquery
// $ is an alias for jQuery
console.log($ === jQuery)  // true

// $ as a function: select elements
$('p')             // all paragraphs
$('#main')         // element with id main
$('.btn.primary')  // elements with class btn and primary

// $ as a namespace: utility methods
$.each([1, 2, 3], function (i, v) { console.log(i, v) })
$.extend({}, defaults, options)
$.type([])         // 'array'

// noConflict: release $ back to other libraries
$.noConflict()
jQuery(function ($) { /* $ available here */ })

Цепочки методов

Большинство методов jQuery возвращают ту же коллекцию, поэтому вызовы можно объединять в цепочку — фирменная возможность jQuery. Используйте .end(), чтобы вернуться к предыдущему набору после метода обхода (.find(), .filter()). Отступы делают цепочки обхода читаемыми. Избегайте слишком длинных цепочек: их трудно отлаживать. Нецепочечные методы вроде геттера .width() разрывают цепочку, так как возвращают значение, а не коллекцию.

jquery
// most methods return the jQuery object, enabling chains
$('.box')
  .addClass('active')
  .css('color', 'red')
  .slideDown(300)
  .text('Hello')

// break across lines for readability
$('#nav')
  .find('.item')
    .addClass('highlight')
    .end()
  .find('.link')
    .attr('target', '_blank')

// .end() pops the current filter back to previous set

Режим без конфликтов

$.noConflict() возвращает управление $ той библиотеке, которая определила его первой. После вызова используйте полное имя jQuery или присвойте jQuery свою переменную. Паттерн IIFE (function($){...})(jQuery) — классический способ оставить $ локальным псевдонимом внутри модуля, сохранив глобальный $ для других библиотек. Это необходимо в WordPress и устаревших окружениях.

jquery
// release $ to other libraries (e.g., Prototype)
$.noConflict()

// use jQuery full name
jQuery('.btn').on('click', function () { /* ... */ })

// or assign jQuery to a custom alias
const jq = $.noConflict()
jq('.btn').hide()

// IIFE pattern: keep $ inside a local scope
(function ($) {
  $('.btn').on('click', function () { /* ... */ })
})(jQuery)
02

Селекторы

Базовые селекторы

jQuery использует CSS-селекторы (в основном совместимые с querySelectorAll). Три основных: имя тега, #id, .class. Запятая объединяет селекторы (объединение). #id самый быстрый (использует getElementById). Универсальный * медленный — избегайте его в больших документах. Результат всегда коллекция jQuery (похожа на массив), даже если совпало 0 или 1 элемент.

jquery
// element selector
$('div')          // all <div> elements
$('p')            // all <p> elements

// id selector
$('#header')      // element with id="header"

// class selector
$('.btn')         // all elements with class="btn"
$('.btn.primary') // .btn AND .primary

// multiple (comma = OR)
$('div, p, .btn') // divs, paragraphs, and .btn

// universal
$('*')            // all elements (slow — avoid)

Иерархия и комбинаторы

Комбинаторы описывают отношения: пробел (потомок), > (прямой ребёнок), + (соседний следующий), ~ (любой следующий сосед). Вычисление справа налево означает, что $('ul li') сначала находит все <li>, затем фильтрует те, что внутри <ul>, поэтому конкретные селекторы справа работают быстрее. Избегайте глубоких комбинаторов на больших документах: ограничивайте область через $(container).find(...) для производительности.

jquery
// descendant: space (any depth)
$('ul li')        // <li> anywhere inside <ul>

// child: > (direct children only)
$('ul > li')      // <li> directly inside <ul>

// adjacent sibling: + (immediately next)
$('h2 + p')       // <p> right after <h2>

// general sibling: ~ (all following siblings)
$('h2 ~ p')       // all <p> siblings after <h2>

// multiple levels
$('#nav .item > a span')

Селекторы атрибутов

Селекторы атрибутов выбирают элементы по значениям атрибутов: [attr] (наличие), [attr=val] (точное), [attr^=val] (начинается), [attr$=val] (заканчивается), [attr*=val] (содержит), [attr~=val] (слово). Для надёжности заключайте значения в кавычки. [attr!=val] — расширение только jQuery (для совместимости с CSS используйте .not('[attr=val]')). Полезно для форм (типы input), ссылок (шаблоны href) и атрибутов data-*.

jquery
// has attribute
$('[href]')                 // any element with href
$('[data-id]')              // any element with data-id

// exact value
$('[type="text"]')          // type="text"
$('[href="https://example.com"]')

// substring matches
$('[href^="https"]')        // starts with "https"
$('[href$=".pdf"]')         // ends with ".pdf"
$('[href*="example"]')      // contains "example"

// whitespace-separated word
$('[class~="active"]')      // class contains word "active"

// inequality (jQuery extension, not CSS)
$('[href!="https://x.com"]')

Селекторы форм и полей

Псевдоселекторы форм (:input, :text, :checked и т. д.) — расширения jQuery, не часть CSS, поэтому не используют быстрый путь querySelectorAll. Для производительности на больших формах используйте $('input[type=text]') вместо $(':text'). :checked и :selected необходимы для чтения состояния формы. Они динамические — пересчитываются при каждом обращении.

jquery
// :input matches all form controls
$(':input')         // input, textarea, select, button

// by type
$(':text')          // <input type="text">
$(':password')
$(':checkbox')
$(':radio')
$(':submit')
$(':file')

// by state
$(':checked')       // checked checkbox/radio or selected option
$(':selected')      // selected <option>
$(':disabled')
$(':enabled')
$(':focus')

// combined with class
$('input.required:visible')

Фильтры и селекторы содержимого

Фильтры сужают выборку: :first/:last, :even/:odd (с нуля), :eq(n), :gt(n), :lt(n). Фильтры содержимого (:contains, :has, :empty, :parent) совпадают по содержимому. :visible и :hidden основаны на offsetWidth/Height и CSS (учтите: элементы с visibility:hidden в jQuery 3+ считаются :hidden, а раньше были :visible). Многие из них — расширения jQuery: для производительности предпочитайте методы .filter(), .first(), .eq().

jquery
// basic filters
$('li:first')         // first <li>
$('li:last')          // last <li>
$('li:even')          // even-indexed (0, 2, 4...)
$('li:odd')           // odd-indexed
$('li:eq(2)')         // 3rd <li> (0-indexed)
$('li:gt(2)')         // <li> after index 2
$('li:lt(2)')         // <li> before index 2

// content filters
$('div:contains("Hello")')  // divs containing text "Hello"
$('div:empty')              // divs with no children
$('div:has(p)')             // divs containing <p>
$('div:parent')             // divs that have children

// visibility
$(':visible')
$(':hidden')
03

События

Привязка событий через .on()

.on() — современный универсальный способ привязки (заменяет .bind/.delegate/.live). Передайте имя события (или несколько) и обработчик. 'this' внутри обработчика — DOM-элемент (не обёрнутый в jQuery — при необходимости оберните $(this)). Используйте пространства имён (click.myapp), чтобы отвязать конкретные обработчики, не затрагивая остальные. Несколько событий могут делить один обработчик (через пробел) или иметь отдельные (форма объекта).

jquery
// basic binding
$('.btn').on('click', function (e) {
  console.log('clicked!', this)  // 'this' is the DOM element
})

// multiple events, same handler
$('.box').on('mouseenter mouseleave', function () {
  $(this).toggleClass('hover')
})

// multiple events, different handlers
$('.input').on({
  focus: function () { $(this).addClass('focused') },
  blur: function () { $(this).removeClass('focused') }
})

// named events (for targeted unbinding)
$('.btn').on('click.myapp', handler)
$('.btn').off('click.myapp')  // only removes this one

Делегирование событий

Делегирование привязывает один обработчик к родителю, который ловит события детей через всплытие. Второй селектор в .on() ('li') фильтрует, какие дети вызывают обработчик. Плюсы: один обработчик вместо N, автоматическая поддержка динамически добавленных элементов, меньше памяти. Необходимо для длинных списков и SPA. 'this' — совпавший ребёнок (li), а не родитель. Для доступа к родителю используйте e.delegateTarget.

jquery
// delegate: handle events on children, now or future
$('#list').on('click', 'li', function (e) {
  // 'this' is the <li> that was clicked
  $(this).toggleClass('done')
})

// works for <li> added AFTER binding too
$('#list').append('<li>New item (also clickable)</li>')

// WHY: instead of binding to each <li>,
// bind ONCE to the parent; clicks bubble up
// - 1 handler instead of N
// - works for dynamically added elements
// - lower memory, faster setup

Объект события и методы

Объект события (e) несёт информацию и методы управления. preventDefault останавливает действие браузера по умолчанию (переход по ссылке, отправку формы). stopPropagation останавливает всплытие; stopImmediatePropagation ещё и другие обработчики на том же элементе. e.target — фактически кликнутый элемент (может быть потомком); e.currentTarget — элемент с обработчиком (= this). Передавайте данные в обработчики вторым необязательным аргументом .on().

jquery
$('.link').on('click', function (e) {
  e.preventDefault()      // stop default action (e.g., navigation)
  e.stopPropagation()     // stop bubbling to parents
  e.stopImmediatePropagation() // stop other handlers on same element

  console.log(e.type)         // 'click'
  console.log(e.target)       // the actual clicked element
  console.log(e.currentTarget) // the element with the handler (= this)
  console.log(e.which)        // mouse button or key code
  console.log(e.pageX, e.pageY) // mouse coordinates

  // data passed via .on(name, data, handler)
})

$('.btn').on('click', { greeting: 'hi' }, function (e) {
  console.log(e.data.greeting)  // 'hi'
})

Сокращённые методы событий

Сокращения (.click, .focus, .submit и т. д.) привязывают обработчик при вызове с функцией или генерируют событие при вызове без неё. .hover(enter, leave) — удобная обёртка для mouseenter+mouseleave. Они эквивалентны .on('event', fn), но короче. Некоторые сокращения (.load, .error) удалены в jQuery 3 — используйте .on('load', ...). В новом коде предпочитайте .on(): он явнее и поддерживает делегирование.

jquery
// shorthand: bind a handler (or trigger if no handler)
$('.btn').click(function () { /* ... */ })
$('.btn').click()  // trigger click

// common shorthands
$('.box').hover(enterFn, leaveFn)   // mouseenter + mouseleave
$('.input').focus(function () { /* ... */ })
$('.input').blur(function () { /* ... */ })
$('.form').submit(function (e) {
  e.preventDefault()
  /* ... */
})
$('.el').mouseenter(fn).mouseleave(fn).mousemove(fn)
$(window).resize(fn).scroll(fn)

// deprecated: .load(), .unload(), .error() (removed in jQuery 3)

Генерация и разовые события

.trigger('event') вызывает и обработчики, И поведение браузера (например, переход); .triggerHandler() вызывает только обработчики jQuery и возвращает результат обработчика (нецепочечно). .one() привязывает обработчик, который сам удаляется после первого вызова, — идеально для подсказок при первом клике и разовой настройки. Свои события позволяют компонентам общаться: $(document).trigger('myapp:ready'), а слушатели подписываются через .on('myapp:ready', fn).

jquery
// trigger an event programmatically
$('.btn').trigger('click')
$('.btn').click()  // shorthand

// trigger with extra data
$('.box').trigger('custom', [1, 2, 3])

// custom events
$('.box').on('custom', function (e, a, b, c) {
  console.log(a, b, c)  // 1 2 3
})

// fire handler only once
$('.btn').one('click', function () {
  alert('This fires only once')
})

// trigger only native handlers, not custom
$('.link').triggerHandler('click')
04

Работа с DOM

Чтение и установка содержимого

.html() работает с HTML-разметкой (как innerHTML): теги разбираются. .text() — для простого текста: теги экранируются и показываются буквально (безопаснее для пользовательского ввода с точки зрения XSS). .val() — для элементов форм (input, select, textarea). Все три работают как геттеры (возвращают значение первого элемента) без аргумента и как сеттеры (применяются ко всем совпавшим элементам) с аргументом. Сеттеры принимают колбэк (index, oldValue) => newValue.

jquery
// .html(): get or set HTML content
$('#box').html()                    // get innerHTML
$('#box').html('<p>Hello</p>')      // set innerHTML

// .text(): get or set text (HTML-escaped)
$('#box').text()                    // get text content
$('#box').text('<p>Not parsed</p>') // displays literally

// setter with callback (index, old value)
$('p').text(function (i, oldText) {
  return i + ': ' + oldText
})

// .val(): form value
$('input').val()                    // get
$('input').val('new value')         // set
$('select').val()                   // get selected value
$('select').val(['a', 'b'])         // multi-select

Вставка элементов

Создавайте элементы, передавая HTML в $(): $('<div class="x">...</div>'). append/prepend вставляют внутрь (в конец/начало); before/after — снаружи (как соседей). Варианты «To» (appendTo, prependTo, insertBefore, insertAfter) меняют субъект местами — удобно для цепочек на новом элементе. Только что вставленные элементы наследуют обработчики, привязанные делегированием, но не привязанные напрямую до вставки.

jquery
// create new element
const $li = $('<li class="item">New item</li>')

// add as last child of each matched element
$('ul').append($li)
$('ul').append('<li>Direct string</li>')

// add as first child
$('ul').prepend('<li>First</li>')

// insert before/after matched elements
$('.box').before('<hr>')
$('.box').after('<hr>')

// reverse direction (insert target into container)
$('<p>Hi</p>').appendTo('#main')   // same as $('#main').append(...)
$('<p>Hi</p>').insertBefore('#nav')

Удаление и замена

.remove() удаляет элементы и очищает их данные и события. .detach() убирает из DOM, но сохраняет данные и события — удобно для временного перемещения. .empty() очищает детей, оставляя элемент. .replaceWith() заменяет каждый элемент новым содержимым. .unwrap() удаляет родителя, поднимая элемент выше. Всегда используйте .remove() или .detach() — никогда просто .html('') на родителе, это оставляет утечки данных и событий у детей.

jquery
// remove element (and its data + events)
$('.box').remove()

// detach: remove but keep events/data (for re-insertion)
const $el = $('.box').detach()
// ... later
$('body').append($el)  // events still work

// empty: remove all children (keep element)
$('.box').empty()

// replace with new content
$('.old').replaceWith('<div class="new">New</div>')

// unwrap: remove parent (keep element)
$('.box').unwrap()

Обёртывание и клонирование

.wrap() оборачивает каждый элемент отдельно; .wrapAll() оборачивает весь набор как группу; .wrapInner() оборачивает содержимое (не сам элемент). .clone() создаёт глубокую копию — передайте true, чтобы клонировать также обработчики и данные (по умолчанию false, поэтому обработчики на копии не срабатывают). .unwrap() удаляет непосредственного родителя. Всё это мощно для перестройки разметки без переписывания HTML-строк.

jquery
// wrap each element in a structure
$('p').wrap('<div class="wrapper"></div>')
// each <p> becomes <div class="wrapper"><p>...</p></div>

// wrap all matched elements together
$('p').wrapAll('<div class="all"></div>')

// wrap inner contents
$('p').wrapInner('<span></span>')
// <p><span>...</span></p>

// clone (with events)
const $copy = $('.box').clone(true)  // true = clone events too
$('body').append($copy)

// unwrap (remove wrapper)
$('.box').unwrap()

Перебор и фильтрация

.each() перебирает элементы: 'this' — исходный DOM-элемент; верните false, чтобы прервать, любое другое значение — чтобы продолжить. .map() преобразует в новую коллекцию jQuery; вызовите .get(), чтобы получить обычный массив. .filter() сужает по селектору или колбэку; .not() — наоборот. .is() возвращает булево (совпал ли хоть один элемент) — полезно в условиях. Избегайте циклов с .eq(i); для идиоматичного jQuery используйте .each() или .map().

jquery
// .each: iterate (this = DOM element, i = index)
$('li').each(function (i, el) {
  console.log(i, this, el)  // el === this
  if (i === 2) return false  // break
  // return true to continue
})

// .map: transform to new array
const ids = $('li').map(function (i, el) {
  return $(el).data('id')
}).get()  // .get() converts to plain array

// .filter: keep matching
$('li').filter('.active').addClass('on')
$('li').filter(function (i) { return i % 2 === 0 })

// .not: remove matching
$('li').not('.active').addClass('off')

// .is: returns boolean (does ANY match?)
if ($('li').is('.active')) { /* at least one is active */ }
05

Работа с CSS

Чтение и установка CSS-свойств

.css() читает вычисленные стили (всегда итоговое значение, даже из CSS-правил) или задаёт inline-стили. Для геттера передайте одно имя свойства (вернёт строку). Для сеттера — (prop, value) или объект пар prop:value. Имена могут быть в camelCase или kebab-case (вторые требуют кавычек). Числовые значения для большинства свойств по умолчанию в пикселях. Не используйте .css() для вёрстки: классы и таблицы стилей поддерживаемее.

jquery
// get computed style (first matched element)
$('.box').css('color')           // 'rgb(255, 0, 0)'
$('.box').css('font-size')       // '14px'

// set single property
$('.box').css('color', 'red')

// set multiple properties
$('.box').css({
  color: 'red',
  'background-color': '#eee',  // kebab-case needs quotes
  fontSize: '16px',            // or use camelCase
  marginTop: '10px'
})

// setter with callback (index, old value)
$('div').css('width', function (i, old) {
  return (parseInt(old) + 50) + 'px'
})

Работа с классами

Методы классов — предпочтительный способ стилизации: представление остаётся в CSS, а не в JS. .addClass, .removeClass, .toggleClass принимают списки классов через пробел. .toggleClass(name, bool) добавляет или удаляет по булеву значению — удобно для UI по состоянию. .hasClass(name) возвращает булево (проверяет только первый элемент). Классы гораздо быстрее .css() для сложной стилизации: они группируют изменения и дают браузеру оптимизировать.

jquery
// add class
$('.box').addClass('active')

// remove class
$('.box').removeClass('active')

// toggle (add if absent, remove if present)
$('.box').toggleClass('active')

// toggle based on boolean
$('.box').toggleClass('active', isValid)

// add/remove multiple (space-separated)
$('.box').addClass('active highlighted urgent')
$('.box').removeClass('active highlighted')

// check if has class (boolean)
if ($('.box').hasClass('active')) { /* ... */ }

// callback form (index, hasClass)
$('div').toggleClass('even', function (i) {
  return i % 2 === 0
})

Ширина и высота

.width()/.height() — контентная область (без padding и border). .innerWidth()/.innerHeight() — контент + padding. .outerWidth()/.outerHeight() — контент + padding + border. .outerWidth(true) включает margin. Сеттеры принимают число (px) или строку. Для window/document используйте $(window) для viewport и $(document) для всей страницы. Они возвращают числа (не строки, как .css('width')), что удобно для вычислений.

jquery
// content size (excludes padding, border, margin)
$('.box').width()          // e.g., 200
$('.box').width(300)       // set content width to 300px
$('.box').height()

// inner (content + padding)
$('.box').innerWidth()
$('.box').innerHeight()

// outer (content + padding + border)
$('.box').outerWidth()
$('.box').outerHeight()

// outer including margin
$('.box').outerWidth(true)

// window & document
$(window).width()    // viewport width
$(document).height() // full document height

Позиция и offset

.offset() возвращает {top, left} относительно документа (полезно для абсолютного позиционирования и drag-drop). .position() возвращает координаты относительно offset-родителя (ближайшего предка с position: relative/absolute/fixed). .scrollTop()/.scrollLeft() читают или задают позицию прокрутки — $(window).scrollTop(0) прокручивает наверх. .offsetParent() находит позиционированного предка. Это необходимо для анимаций, drag-drop и бесконечной прокрутки.

jquery
// .offset(): position relative to document
const off = $('.box').offset()
console.log(off.left, off.top)  // e.g., 100, 50
$('.box').offset({ top: 200, left: 100 })  // set

// .position(): position relative to offset parent
const pos = $('.box').position()
console.log(pos.left, pos.top)

// .scrollTop() / .scrollLeft(): scroll position
$(window).scrollTop()       // how far scrolled down
$(window).scrollTop(0)      // scroll to top
$('.container').scrollTop(100)

// .offsetParent(): nearest positioned ancestor
$('.box').offsetParent()

Прокрутка и координаты

Обработка прокрутки обычна для «липких» меню, бесконечного скролла и анимаций по скроллу. $('html, body').animate({scrollTop: n}) плавно прокручивает. Для производительности троттлите обработчики scroll (они срабатывают много раз за прокрутку). Помощник isVisible проверяет, находится ли элемент в viewport, — полезно для ленивой загрузки изображений и запуска анимаций. Современный IntersectionObserver эффективнее для определения видимости — рассмотрите его в новых проектах.

jquery
// scroll to top smoothly
$('html, body').animate({ scrollTop: 0 }, 500)

// scroll to an element
const top = $('#section').offset().top
$('html, body').animate({ scrollTop: top }, 500)

// detect scroll position
$(window).on('scroll', function () {
  const scrolled = $(window).scrollTop()
  if (scrolled > 100) {
    $('.nav').addClass('fixed')
  } else {
    $('.nav').removeClass('fixed')
  }
})

// check if element is in viewport
function isVisible($el) {
  const t = $el.offset().top
  const h = $el.outerHeight()
  const wTop = $(window).scrollTop()
  const wH = $(window).height()
  return t >= wTop && (t + h) <= (wTop + wH)
}
06

AJAX

$.ajax (полный контроль)

$.ajax — низкоуровневый метод с полным контролем. method — HTTP-глагол, data (в query для GET или в теле для POST), dataType подсказывает ожидаемый ответ (разбирается автоматически). success/error/complete — устаревшие колбэки. beforeSend позволяет изменить xhr (добавить заголовки). timeout прерывает запрос через N мс. В современном коде предпочитайте fetch() или $.ajax с промисами .done()/.fail() вместо колбэков success/error.

jquery
$.ajax({
  url: '/api/users',
  method: 'GET',                // or 'POST', 'PUT', 'DELETE'
  data: { page: 1, limit: 10 }, // query string or body
  dataType: 'json',             // expected response type
  contentType: 'application/json',
  timeout: 5000,                // ms
  headers: { 'X-Token': 'abc' },
  beforeSend: function (xhr) { /* ... */ },
  success: function (data, status, xhr) {
    console.log('got', data)
  },
  error: function (xhr, status, error) {
    console.error('failed', status, error)
  },
  complete: function (xhr, status) {
    // runs on both success and error
  }
})

Сокращения: $.get и $.post

$.get и $.post — сокращения для простых GET/POST. Интерфейс, похожий на промис (.done/.fail/.always), чище колбэков success/error и позволяет навешивать несколько .done. Для JSON-тела запроса нужно задать contentType: 'application/json' И применить JSON.stringify к data (jQuery не преобразует объекты в JSON автоматически). Учтите: промис jQuery — это Deferred, а не нативный Promise, но в большинстве случаев работает так же.

jquery
// GET request
$.get('/api/users', { page: 1 }, function (data) {
  console.log(data)
}, 'json')

// promise-based (preferred)
$.get('/api/users', { page: 1 })
  .done(function (data) { console.log(data) })
  .fail(function (xhr, status, err) { console.error(err) })

// POST request
$.post('/api/users', { name: 'Alice' })
  .done(function (data) { /* created */ })

// POST JSON
$.ajax({
  url: '/api/users',
  method: 'POST',
  contentType: 'application/json',
  data: JSON.stringify({ name: 'Alice' })
})

Загрузка HTML в элементы

.load() — специализированное сокращение: получить HTML по URL и вставить в совпавшие элементы. Синтаксис 'url #fragment' загружает только часть ответа (совпавшую с #fragment). .load() отлично подходит для частичного обновления страницы без полной перезагрузки — обычно в устаревших SPA. По умолчанию GET, POST при передаче данных. Колбэк получает (responseText, status, xhr). В современных приложениях предпочитают fetch с ручным обновлением DOM.

jquery
<!-- load HTML from server into element -->
<div id="content">Loading...</div>

<script>
$('#content').load('/partials/header.html')

// load a fragment (selector after URL space)
$('#content').load('/page.html #main')

// with callback (response, status, xhr)
$('#content').load('/page.html', function (resp, status, xhr) {
  if (status === 'error') {
    $('#content').html('Failed to load')
  }
})

// POST with data
$('#content').load('/api', { id: 5 })
</script>

getJSON и getScript

$.getJSON — сокращение для $.ajax с dataType:'json': ответ разбирается автоматически. Приём '?callback=?' включает JSONP для межсайтовых запросов (устаревший — сейчас используйте CORS). $.getScript загружает и выполняет JavaScript-файл — удобно для ленивой загрузки плагинов или аналитики по требованию. Оба возвращают объекты jqXHR (похожие на промисы). Для межсайтовых запросов сегодня настройте CORS-заголовки на сервере; JSONP — до-CORS обходной путь с оговорками по безопасности.

jquery
// fetch and parse JSON
$.getJSON('/api/users', { page: 1 })
  .done(function (data) {
    console.log(data.users)
  })
  .fail(function (xhr, status, err) {
    console.error('JSON fetch failed:', err)
  })

// fetch and execute a script
$.getScript('/js/analytics.js')
  .done(function (script, status) {
    console.log('analytics loaded')
    // script is now available
  })
  .fail(function () {
    console.error('script failed')
  })

// JSONP (cross-domain, legacy)
$.getJSON('https://api.example.com/data?callback=?')
  .done(function (data) { /* ... */ })

Глобальные события AJAX и настройки

Глобальные события AJAX (ajaxStart, ajaxStop, ajaxComplete, ajaxError, ajaxSuccess) срабатывают на каждый AJAX-запрос — идеально для глобальных индикаторов загрузки и обработки ошибок. $.ajaxSetup задаёт значения по умолчанию для всех последующих вызовов (базовый URL, заголовки, таймаут). .serialize() превращает форму в query-строку; .serializeArray() возвращает массив объектов {name, value} — удобно для сборки JSON или своих данных. Всегда включайте CSRF-токен в изменяющие запросы.

jquery
// global ajax event handlers (bind on document)
$(document)
  .ajaxStart(function () { $('#loader').show() })
  .ajaxStop(function () { $('#loader').hide() })
  .ajaxError(function (e, xhr, settings, error) {
    console.error('AJAX error:', settings.url, error)
  })

// default settings for all AJAX
$.ajaxSetup({
  baseURL: '/api',
  timeout: 10000,
  headers: { 'X-CSRF-Token': $('meta[name=csrf]').attr('content') }
})

// now $.get('/users') -> GET /api/users with the headers
$.get('/users').done(/* ... */)

// serialize a form for AJAX
const data = $('form').serialize()       // "name=Alice&age=30"
const arr = $('form').serializeArray()   // [{name, value}, ...]
07

Эффекты и анимации

Базовые show/hide

.show()/.hide()/.toggle() меняют display. Без аргументов показывают или скрывают мгновенно. С длительностью анимируют width/height/opacity. 'slow' = 600 мс, 'fast' = 200 мс, или число в мс. Колбэк срабатывает по завершении анимации. Анимации jQuery по умолчанию используют requestAnimationFrame (без рывков). Учтите: .hide() ставит display:none; .show() восстанавливает исходное значение display. Для большего контроля используйте .animate() напрямую.

jquery
// instantly show/hide/toggle
$('.box').show()
$('.box').hide()
$('.box').toggle()

// animated (duration in ms or 'slow'/'fast')
$('.box').show(400)         // fade in over 400ms
$('.box').hide('slow')      // ~600ms
$('.box').toggle(300)

// with callback (runs when animation completes)
$('.box').hide(300, function () {
  console.log('hidden')
})

// easing (default 'swing', also 'linear' with plugin)
$('.box').hide({ duration: 300, easing: 'linear' })

Затухание

Анимации затухания меняют только opacity (display остаётся). .fadeTo() анимирует до конкретной прозрачности — удобно, чтобы приглушить элементы, не скрывая их полностью. Анимации ставятся в очередь для каждого элемента: цепочка .fadeOut().fadeIn() выполняется последовательно, а не одновременно. Для параллельного выполнения используйте .animate() с несколькими свойствами или опцию queue. Затухание плавнее show/hide для UI на основе прозрачности, например уведомлений.

jquery
// fade in / out / toggle (opacity only)
$('.box').fadeIn(400)
$('.box').fadeOut(400)
$('.box').fadeToggle(400)

// fade to a specific opacity (0.0 - 1.0)
$('.box').fadeTo(400, 0.5)  // 50% opacity

// with callback
$('.box').fadeOut(300, function () {
  // runs after fade out completes
  $(this).remove()
})

// sequence: fade out, then fade in
$('.box')
  .fadeOut(300)
  .fadeIn(300)  // queued automatically

Скольжение

Скольжение анимирует высоту (и display). .slideDown раскрывает элемент (от display:none до естественной высоты), .slideUp скрывает (сжимает до 0, затем display:none), .slideToggle переключает состояние. Идеально для аккордеонов, выпадающих меню и сворачиваемых панелей. В сочетании с siblings() для поведения аккордеона (закрывать другие при открытии одного). Скольжение — самая частая анимация jQuery: плавная и дружелюбная к доступности при правильном ARIA.

jquery
// slide down (reveal) / up (hide) / toggle
$('.panel').slideDown(400)
$('.panel').slideUp(400)
$('.panel').slideToggle(400)

// accordion pattern
$('.accordion .header').on('click', function () {
  $(this).next('.content').slideToggle(300)
       .siblings('.content').slideUp(300)
})

// callback after slide completes
$('.panel').slideUp(300, function () {
  console.log('panel closed')
})

Свой .animate()

.animate() плавно меняет числовые CSS-свойства за длительность. Используйте относительные значения ('+=50') для инкрементальных изменений. Имена свойств должны быть в camelCase (marginLeft, а не margin-left). Цвета требуют плагина jQuery Color или jQuery UI: ядро jQuery анимирует только числа. Форма с опциями даёт больше контроля: queue:false выполняет параллельно, а не последовательно. Easing по умолчанию 'swing' (замедление); 'linear' — равномерно. За один вызов можно анимировать много свойств.

jquery
// animate numeric CSS properties
$('.box').animate({
  width: '+=50',       // relative: add 50px
  height: '300px',
  opacity: 0.5,
  marginLeft: '20px',  // camelCase for hyphenated props
  fontSize: '20px'
}, 800, 'swing', function () {
  console.log('animation done')
})

// options object form
$('.box').animate({
  left: 500
}, {
  duration: 1000,
  easing: 'linear',
  complete: function () { /* done */ },
  queue: false  // run immediately, not queued
})

// NOTE: colors can't be animated without jQuery UI / color plugin

Остановка и цепочки

.stop() останавливает анимации; (clearQueue, jumpToEnd) даёт контроль. Без stop быстрые наведения накапливают анимации (элемент продолжает двигаться спустя долго после ухода мыши) — .stop(true) перед .animate() это предотвращает. .finish() мгновенно переводит все анимации в очереди в конечное состояние. .delay(ms) вставляет паузу в очередь — удобно для последовательностей. Всегда сочетайте hover-анимации с .stop(), чтобы избежать рывков.

jquery
// .stop(): stop current animation
$('.box').stop()              // stop, leave at current state
$('.box').stop(true)          // clear queue too
$('.box').stop(true, true)    // clear queue AND jump to end

// prevent animation buildup on rapid hover
$('.box').hover(function () {
  $(this).stop(true).animate({ width: 300 }, 200)
}, function () {
  $(this).stop(true).animate({ width: 100 }, 200)
})

// .finish(): jump all queued animations to end state
$('.box').finish()

// .delay(): pause between queued animations
$('.box')
  .fadeOut(300)
  .delay(500)        // wait 500ms
  .fadeIn(300)
08

Обход DOM

Движение вверх (родители)

Движение вверх: .parent() (непосредственный родитель), .parents() (все предки до document), .parents(selector) фильтрует их, .closest(selector) идёт вверх и возвращает первое совпадение (включая сам элемент — чаще всего для поиска объемлющего компонента). .parentsUntil(selector) возвращает предков до совпадения, не включая его. .closest() — рабочая лошадка делегирования: по кликнутому элементу найти его карточку, строку или компонент.

jquery
// direct parent
$('#item').parent()

// all ancestors (up to <html> or selector)
$('#item').parents()              // all ancestors
$('#item').parents('.container')  // first .container ancestor

// closest ancestor (incl. self) matching selector
$('#item').closest('.box')  // very common - find enclosing box

// parentsUntil: ancestors up to (not including) match
$('#item').parentsUntil('.wrapper')

// offsetParent: nearest positioned ancestor
$('#item').offsetParent()

Движение вниз (дети)

.children() возвращает только прямых детей (на один уровень вниз); .find() спускается по всем уровням. .find() самый частый: по контейнеру найти подходящих потомков (например, все поля внутри формы). .children() быстрее, когда нужны только прямые дети. .contents() включает текстовые узлы и комментарии (полезно для обработки текста и iframe). Оба можно фильтровать селектором. Всегда ограничивайте обход через .find(), чтобы не сканировать весь документ.

jquery
// direct children (optionally filtered)
$('#list').children()             // all direct children
$('#list').children('.item')      // direct children with class .item

// all descendants (filtered)
$('#list').find('li')             // all <li> anywhere inside
$('#list').find('.active')        // all .active descendants

// contents: children including text/comment nodes
$('#box').contents()

// first/last child
$('#list').children().first()
$('#list').children().last()

Движение в сторону (соседи)

Обход соседей: .siblings() (все), .next()/.prev() (непосредственные), .nextAll()/.prevAll() (все в одном направлении), .nextUntil()/.prevUntil() (до совпадения). Фильтруются селектором. Классический паттерн активной вкладки ($(this).addClass('active').siblings().removeClass('active')) использует siblings для сброса состояния остальных. Соседи имеют одного родителя: если элементы вложены иначе, они не соседи.

jquery
// all siblings (excluding self)
$('#item').siblings()
$('#item').siblings('.active')  // siblings with class .active

// next/prev: immediate sibling
$('#item').next()
$('#item').prev()

// nextAll/prevAll: all following/preceding siblings
$('#item').nextAll()
$('#item').prevAll('.item')

// nextUntil/prevUntil: siblings up to a match
$('#item').nextUntil('.stop')

// common: highlight active tab
$('.tab').on('click', function () {
  $(this).addClass('active').siblings().removeClass('active')
})

Фильтрация выборки

Фильтрация сужает текущий набор без нового запроса к DOM. .filter(selector) оставляет совпадения; .not(selector) — наоборот. .has(selector) оставляет элементы, содержащие подходящего потомка. .eq(n) сокращает до одного элемента (отрицательное n считается с конца). .first()/.last() — удобные обёртки. .slice(start, end) берёт диапазон. Используйте их, чтобы уточнить выборку после обхода, вместо сложных селекторов — часто понятнее и быстрее.

jquery
// .filter: keep matching
$('li').filter('.active')
$('li').filter(function (i) { return i % 2 === 0 })  // even index

// .not: remove matching (inverse of filter)
$('li').not('.active')
$('li').not(':first')

// .has: keep elements that contain a descendant
$('div').has('p')  // divs that contain <p>

// .eq: reduce to one element by index
$('li').eq(2)      // 3rd <li> (0-indexed)
$('li').eq(-1)     // last <li>

// .first / .last
$('li').first()
$('li').last()

// .slice: range
$('li').slice(2, 5)  // indices 2, 3, 4

Цепочки с .end() и .addBack()

.end() снимает стек обхода, возвращая предыдущий набор, — необходимо для читаемых цепочек, где нужно пройти по DOM и продолжить работу с исходником. .addBack() (ранее .andSelf) объединяет текущий набор с предыдущим, чтобы исходный элемент участвовал в дальнейших операциях. Так строят мощные однострочные цепочки: найти детей, изменить их, end() вернуться к родителю, изменить родителя. Делайте отступы в цепочках, чтобы структура обхода была понятна.

jquery
// .end(): pop back to previous set after a traversal
$('ul')              // [ul]
  .find('li')        // [li, li, li]
    .addClass('item')
    .end()           // back to [ul]
  .addClass('has-items')

// .addBack(): include previous set in current
$('ul')
  .children('li')    // [li, li]
    .addClass('item')
    .addBack()       // [li, li, ul]
  .addClass('related')

// without .addBack, the ul would not get .related
// .andSelf (old name) is deprecated, use .addBack
09

Утилиты

Перебор: $.each и $.map

$.each перебирает массивы (index, value) или объекты (key, value) — обратите внимание, порядок аргументов обратен Array.forEach. Верните false, чтобы прервать. $.map преобразует каждый элемент в новый массив (верните null, чтобы пропустить). $.grep фильтрует массив. Это до-ES5 утилиты перебора jQuery; современный код чаще использует нативные методы массивов (forEach, map, filter). Главная причина брать $.each — перебор простых объектов (в современном JS есть Object.entries).

jquery
// $.each: iterate arrays or objects (returns the collection)
$.each([10, 20, 30], function (index, value) {
  console.log(index, value)  // 0 10, 1 20, 2 30
  if (value === 20) return false  // break
})

$.each({ a: 1, b: 2 }, function (key, value) {
  console.log(key, value)  // 'a' 1, 'b' 2
})

// $.map: transform to a new array
const doubled = $.map([1, 2, 3], function (value, index) {
  return value * 2  // [2, 4, 6]
})

// return null/undefined to skip
const evens = $.map([1, 2, 3, 4], function (v) {
  return v % 2 === 0 ? v : null  // [2, 4]
})

// $.grep: filter an array
const evens = $.grep([1, 2, 3, 4], function (v) { return v % 2 === 0 })
// [2, 4]

Проверка типов

$.type возвращает строку типа в нижнем регистре (точнее typeof). $.isArray, $.isFunction, $.isPlainObject, $.isEmptyObject, $.isWindow, $.isNumeric — удобные булевы проверки. $.isPlainObject отличает простой {} от экземпляров вроде new Date или window. $.isNumeric возвращает true для конечных чисел и числовых строк (для hex вроде '0x1F' в новых jQuery — нет). В современном JS Array.isArray и typeof покрывают большинство нужд, но $.isPlainObject всё ещё удобен для безопасности deep-extend.

jquery
// $.type: detailed type
$.type([])         // 'array'
$.type({})         // 'object'
$.type('hi')       // 'string'
$.type(null)       // 'null'
$.type(undefined)  // 'undefined'
$.type(/regex/)    // 'regexp'

// specific checks (all return boolean)
$.isArray([])           // true
$.isFunction(fn => {})  // true
$.isEmptyObject({})     // true
$.isPlainObject({})     // true (created by {} or new Object)
$.isPlainObject([])     // false
$.isWindow(window)      // true
$.isNumeric('42')       // true (also '0x1F')
$.isNumeric('abc')      // false

// $.isEmptyObject: no own enumerable props
$.isEmptyObject({ a: 1 })  // false

Утилиты объектов и массивов

$.extend сливает объекты: более поздние свойства переопределяют ранние. Передайте true первым аргументом для глубокого (рекурсивного) слияния; иначе слияние поверхностное. Всегда передавайте {} первым аргументом, чтобы не мутировать источник. $.merge соединяет массивы (мутирует первый). $.inArray — это indexOf (возвращает -1, если не найдено). $.makeArray превращает array-подобные объекты (NodeList, arguments) в настоящие массивы — современный код использует Array.from или spread [...nl].

jquery
// $.extend: merge objects (mutates first unless deep copy flag)
const defaults = { a: 1, b: 2 }
const options = { b: 3, c: 4 }
const merged = $.extend({}, defaults, options)
// { a: 1, b: 3, c: 4 }  (later overrides earlier)

// deep merge (recurses into nested objects)
const deep = $.extend(true, {},
  { nested: { x: 1, y: 2 } },
  { nested: { y: 3, z: 4 } }
)
// { nested: { x: 1, y: 3, z: 4 } }

// $.merge: combine two arrays (mutates first)
const combined = $.merge([1, 2], [3, 4])  // [1, 2, 3, 4]

// $.inArray: find index (-1 if not found)
const idx = $.inArray(2, [1, 2, 3])  // 1

// $.makeArray: convert array-like to true array
const arr = $.makeArray(document.querySelectorAll('li'))

Утилиты строк и данных

$.trim удаляет пробелы по краям (современно: str.trim()). $.parseHTML превращает HTML-строку в массив DOM-узлов — безопаснее $.fn.html для недоверенного ввода (не выполняет скрипты). $.param сериализует объект в query-строку (обратное parse). $.now — это Date.now(). $.unique убирает дубликаты в массивах DOM-элементов (сейчас нужно редко). У большинства есть нативные современные аналоги; самые полезные из оставшихся — $.param (для AJAX-данных) и $.parseHTML.

jquery
// $.trim: remove leading/trailing whitespace
$.trim('  hello  ')  // 'hello'  (use str.trim() in modern code)

// $.parseHTML: parse string to DOM nodes
const nodes = $.parseHTML('<div><p>Hi</p></div>')
// [div] — array of DOM nodes

// $.parseJSON: parse JSON string (use JSON.parse instead)
const obj = $.parseJSON('{"a":1}')

// $.param: serialize object to query string
$.param({ name: 'Alice', age: 30 })
// 'name=Alice&age=30'
$.param({ tags: ['a', 'b'] })
// 'tags%5B%5D=a&tags%5B%5D=b'

// $.now: current timestamp (Date.now equivalent)
$.now()  // 1700000000000

// $.unique: remove duplicates from DOM element array
$.unique($('.box').get())

Хранение данных ($.data)

$.data / .data() хранят произвольные значения, связанные с элементами, во внутреннем кеше (не видны в DOM, быстрее атрибутов). .data() также автоматически читает атрибуты data-* (с приведением типов: числа, булевы, JSON). Важно: .data(name, value) пишет в кеш, а НЕ в атрибут data-*; используйте .attr('data-name', val), чтобы обновить сам атрибут. .removeData очищает запись кеша. Кеш очищается при .remove() элементов, предотвращая утечки.

jquery
// store data on an element (private, won't appear in DOM)
$.data(document.getElementById('box'), 'key', { count: 1 })

// read it back
const v = $.data(el, 'key')  // { count: 1 }

//.data() method form (more common)
$('.box').data('key', { count: 1 })
$('.box').data('key')        // { count: 1 }

// auto-parses data-* attributes
// <div class="box" data-id="42" data-name="alice"></div>
$('.box').data('id')    // 42 (auto-cast to number)
$('.box').data('name')  // 'alice'

// remove data
$('.box').removeData('key')

// note: .data() does NOT write back to data-* attrs
// use .attr('data-key', val) to update the attribute
10

Плагины и расширения

Написание плагина

Плагины расширяют $.fn (прототип jQuery), чтобы их можно было вызывать на коллекциях. Всегда возвращайте this (или результат метода на this) для цепочечности. Внутри плагина 'this' — коллекция jQuery; внутри .each() 'this' — исходный DOM-элемент. Оборачивайте в IIFE, чтобы безопасно псевдонимировать $ через jQuery. Паттерн $.extend с defaults — стандартный способ принимать опции с разумными значениями по умолчанию. Публикуйте плагины через npm или отдельными скриптами.

jquery
// basic plugin pattern
(function ($) {
  $.fn.highlight = function (color) {
    // 'this' is the jQuery collection
    return this.css('background', color || 'yellow')
  }
}(jQuery))

// usage
$('.box').highlight('red')
$('.box').highlight()  // default 'yellow'

// options pattern
$.fn.tooltip = function (options) {
  const settings = $.extend({
    position: 'top',
    delay: 200
  }, options)

  return this.each(function () {
    // 'this' is a DOM element here
    // ... tooltip logic ...
  })
}

Плагин с методами

Шаблонный паттерн плагина использует объект methods, выбираемый первым аргументом: $('.c').counter({ start: 5 }) для инициализации, $('.c').counter('increment') для вызова метода. Состояние живёт в $.data. Этот паттерн был популярен до эпохи Vue/React для компонентов вроде слайдеров, модалок и datepicker. Сегодня для stateful UI обычно лучше фреймворк (Vue/React), но для доработки устаревших jQuery-сайтов паттерн всё ещё полезен и хорошо понятен.

jquery
// stateful plugin using data + methods
(function ($) {
  $.fn.counter = function (method) {
    const methods = {
      init: function (options) {
        return this.each(function () {
          const $el = $(this)
          $el.data('count', options?.start || 0)
          $el.text($el.data('count'))
        })
      },
      increment: function () {
        return this.each(function () {
          const $el = $(this)
          const c = $el.data('count') + 1
          $el.data('count', c).text(c)
        })
      },
      reset: function () {
        return this.each(function () {
          $(this).data('count', 0).text(0)
        })
      }
    }

    if (methods[method]) {
      return methods[method].apply(this, Array.prototype.slice.call(arguments, 1))
    } else if (typeof method === 'object' || !method) {
      return methods.init.apply(this, arguments)
    } else {
      $.error('Method ' + method + ' does not exist')
    }
  }
}(jQuery))

Популярные плагины

jQuery UI — официальная сопутствующая библиотека виджетов (datepicker, аккордеон, автодополнение, диалог) и взаимодействий (draggable, droppable, sortable). Другие популярные плагины: DataTables (таблицы с богатыми возможностями), Select2 (улучшенные select), Slick (карусели), Magnific Popup (модальные окна). Подключайте CSS и JS плагина после jQuery. Инициализируйте при готовности DOM. Многие плагины поддерживают API методов вида $('#x').plugin('method', args) и обновление опций через plugin('option', name, val).

jquery
<!-- jQuery UI (interactions, widgets, effects) -->
<link rel="stylesheet" href="https://code.jquery.com/ui/1.13.2/themes/base/jquery-ui.css">
<script src="https://code.jquery.com/ui/1.13.2/jquery-ui.min.js"></script>

<script>
// datepicker
$('#date').datepicker({ dateFormat: 'yy-mm-dd' })

// draggable / droppable / sortable
$('.item').draggable()
$('.list').sortable()

// dialog
$('<div>Hello</div>').dialog({ modal: true })
</script>

<!-- Other common plugins -->
<!-- DataTables: tables with sorting, search, pagination -->
<!-- Select2: enhanced <select> with search -->
<!-- Slick: carousel/slider -->
<!-- Magnific Popup: lightbox/modal -->

Widget Factory (jQuery UI)

jQuery UI Widget Factory ($.widget) — структурированный способ строить stateful-плагины с поддержкой наследования. Он даёт _create (конструктор), _destroy (очистка), _setOption, _on (привязка событий с автоочисткой), _trigger (свои события). Опции доступны через API методов: $el.widget('option', name, value). Свои события генерируются как widgetname + eventname. Для сложного stateful UI на jQuery widget factory — самый надёжный паттерн, но для нового кода рассмотрите переход на Vue/React.

jquery
// create a reusable widget with state + inheritance
$.widget('my.counter', {
  options: { start: 0 },

  _create: function () {
    this.count = this.options.start
    this._refresh()
    this._on(this.element, { click: 'increment' })
  },

  increment: function () {
    this.count++
    this._refresh()
    this._trigger('changed', null, { count: this.count })
  },

  _refresh: function () {
    this.element.text(this.count)
  },

  _destroy: function () {
    this.element.text('')
  }
})

// usage
$('#el').counter({ start: 5 })  // init
$('#el').counter('increment')   // call method
$('#el').on('counterchanged', function (e, data) {
  console.log('count is', data.count)
})
$('#el').counter('destroy')     // cleanup

Лучшие практики плагинов

Лучшие практики плагинов: (1) всегда возвращайте this для цепочечности; (2) оборачивайте в IIFE для безопасности $; (3) используйте .each(), чтобы плагин работал с многоэлементными выборками; (4) давайте событиям пространство имён (click.myplugin), чтобы пользователи могли отвязать их, не задев другие; (5) сливайте опции через $.extend и давайте defaults для глобального переопределения; (6) очищайте всё при destroy (события, данные, изменения DOM); (7) добавляйте префикс к имени плагина, чтобы избежать коллизий; (8) открывайте публичные методы и defaults для гибкости.

jquery
// 1. always return this for chainability
$.fn.green = function () { return this.css('color', 'green') }

// 2. use IIFE for $ safety
(function ($) { /* plugin */ })(jQuery)

// 3. iterate with .each() for multi-element support
$.fn.x = function () { return this.each(function () { /* per element */ }) }

// 4. namespace events so users can unbind cleanly
this._on(this.element, { 'click.myplugin': 'handler' })

// 5. accept options via $.extend
const opts = $.extend({}, $.fn.x.defaults, options)
$.fn.x.defaults = { color: 'red' }

// 6. clean up on destroy (events, data, DOM)
// 7. namespace your plugin name to avoid collisions
// 8. provide public methods + defaults accessible for override
11

Атрибуты и свойства

Геттеры и сеттеры атрибутов

.attr() читает и пишет HTML-атрибуты (значения разметки, всегда строки). .prop() читает и пишет DOM-свойства (текущее состояние: например, свойство checked чекбокса может отличаться от атрибута checked после действий пользователя). Используйте .prop() для булевых атрибутов (checked, disabled, selected) и .attr() для остальных (href, src, alt, data-*). .data() читает data-*, но хранит значения во внутреннем кеше с сохранением типов — используйте .attr('data-*'), если нужно обновить сам атрибут DOM.

jquery
// .attr: HTML attribute (what's in the markup)
$('img').attr('src')              // get
$('img').attr('src', 'new.jpg')   // set
$('img').attr({                   // set multiple
  src: 'new.jpg',
  alt: 'Photo',
  width: 200
})

// .removeAttr: remove attribute entirely
$('img').removeAttr('alt')

// .prop: DOM property (current state, may differ from attr)
$('input').prop('checked')        // true/false (current state)
$('input').prop('checked', true)  // check it
$('input').prop('disabled', true)

// data-* attributes
$('div').attr('data-id', 42)      // sets the attribute (string)
$('div').data('id', 42)           // stores in cache (typed)

Атрибуты data-*

.data(name) читает атрибуты data-* с автоматическим приведением типов (числа, булевы, JSON). Установка через .data(name, value) пишет во внутренний кеш, а НЕ в атрибут, поэтому .attr('data-name') всё ещё вернёт исходное значение. Чтобы обновить реальный атрибут DOM (например, для CSS-селекторов или чтения на сервере), используйте .attr('data-name', value). Путаница здесь вызывает ошибки. .removeData очищает кеш. Имена в camelCase: data-foo-bar превращается в .data('fooBar').

jquery
<!-- HTML -->
<div class="box" data-id="42" data-name="alice" data-active="true" data-config='{"x":1}'></div>

<script>
// .data() reads data-* with auto type conversion
$('.box').data('id')       // 42 (number, not string)
$('.box').data('name')     // 'alice'
$('.box').data('active')   // true (boolean)
$('.box').data('config')   // { x: 1 } (parsed JSON)

// set data (stored in cache, NOT the attribute)
$('.box').data('id', 99)
$('.box').data('id')       // 99
$('.box').attr('data-id')  // still '42' (attribute unchanged)

// to update the attribute itself, use .attr
$('.box').attr('data-id', 99)

// remove data
$('.box').removeData('id')
</script>

Свойства форм

Для состояния форм используйте .prop() (булевы DOM-свойства): .prop('checked') отражает текущее состояние, а .attr('checked') возвращает исходный HTML-атрибут (не обновляется при действиях пользователя). .val() единообразно читает и задаёт значения форм. Для radio найдите :checked и прочитайте его .val(). Для multi-select .val() возвращает массив. .is(':checked') — чистая булева проверка. Эти различия важны для валидации и сериализации форм.

jquery
// checkbox state
$('input[type=checkbox]').prop('checked')     // true/false
$('input[type=checkbox]').prop('checked', true)
$('input[type=checkbox]').is(':checked')      // boolean

// disabled / readonly
$('input').prop('disabled', true)
$('input').prop('readOnly', true)  // note: camelCase

// select value
$('select').val()                  // selected value
$('select').val('option2')         // set selected
$('select option:selected').text() // selected text

// multiple select
$('select[multiple]').val()        // ['a', 'b'] array

// radio: value of checked
$('input[name=gender]:checked').val()

//.prop vs .attr for checkboxes:
// .prop('checked') = current state (changes when clicked)
// .attr('checked') = initial HTML value (doesn't change)

Класс против атрибута

Три способа сообщить состояние элемента в CSS и JS: классы (известные, .hasClass), атрибуты data-* (запрашиваемые, несущие значение) и ARIA-атрибуты (доступные скринридерам). Для визуального состояния классы проще всего. Для многозначного состояния (data-state='loading|success|error') чище data-*. Для доступности используйте aria-* (aria-pressed, aria-expanded, aria-busy): они часто дублируют визуальное состояние, поэтому задавайте их вместе. Современные фреймворки упрощают это, но в jQuery выбирайте осознанно.

jquery
// adding behavior tags via class
$('.btn').addClass('loading')
// CSS: .btn.loading { opacity: 0.5; pointer-events: none; }

// via data attribute (cleaner for state)
$('.btn').attr('data-state', 'loading')
// CSS: .btn[data-state="loading"] { ... }

// via aria (accessible)
$('.btn').attr('aria-busy', 'true')

// choosing:
// - class: many CSS hooks, well-known
// - data-*: cleaner for state values, queryable
// - aria-*: exposes state to screen readers

// toggling example
$('.btn').on('click', function () {
  const $b = $(this)
  $b.attr('aria-pressed', $b.attr('aria-pressed') !== 'true')
})

Value (поля форм)

.val() — универсальный геттер и сеттер значений форм: текстовые поля, textarea, select, а для radio и checkbox — значение отмеченного. .serialize() даёт URL-кодированную строку; .serializeArray() — массив {name, value}, который можно превратить в объект через .serializeArray().reduce((o, p) => (o[p.name] = p.value, o), {}). Чтобы сбросить форму, вызовите нативный метод .reset() на исходном DOM-элементе (в jQuery метода .reset() нет).

jquery
// text input
$('input[type=text]').val()              // get current value
$('input[type=text]').val('new value')   // set

// textarea
$('textarea').val()

// select
$('select').val()                        // selected value
$('select').val('opt2')                  // set
$('select').val(['a', 'b'])              // multi-select set

// checkbox (use prop for state)
$('input[type=checkbox]').prop('checked')

// radio
$('input[type=radio][name=g]:checked').val()

// serialize whole form
$('form').serialize()                    // 'name=Alice&age=30'
$('form').serializeArray()               // [{name, value}]

// reset form
$('form')[0].reset()
12

Размеры и позиция

Методы ширины и высоты

Методы ширины и высоты возвращают числа (px), в отличие от .css('width'), который возвращает строки с единицами. .width() — контентная область (CSS width). .innerWidth() — контент + padding. .outerWidth() — контент + padding + border. .outerWidth(true) включает margin. Для window/document: $(window).width() — viewport (видимая область); $(document).height() — полная высота страницы (может быть больше viewport при прокрутке). Сеттеры принимают числа (px) или строки ('50%', '10em').

jquery
// content box (no padding, border, margin)
$('.box').width()       // 200 (number, px)
$('.box').width(300)    // set to 300px

// inner (content + padding)
$('.box').innerWidth()
$('.box').innerHeight()

// outer (content + padding + border)
$('.box').outerWidth()
$('.box').outerHeight()

// outer + margin
$('.box').outerWidth(true)
$('.box').outerHeight(true)

// window & document
$(window).width()       // viewport width
$(window).height()      // viewport height
$(document).height()    // document height (may exceed viewport)

Position против offset

.offset() задаёт координаты относительно документа (абсолютные — полезно для drag-drop и подсказок у курсора). .position() задаёт координаты относительно offset-родителя (ближайшего предка с position:relative/absolute/fixed) — удобно для перепозиционирования внутри контейнера. .offsetParent() находит этого предка. .scrollTop()/.scrollLeft() читают или задают позицию прокрутки — $(window).scrollTop() это прокрутка страницы. Различие offset (документ) и position (родитель) критично для правильных вычислений позиции.

jquery
// .offset(): relative to document (top-left of page)
const o = $('.box').offset()
console.log(o.left, o.top)         // e.g., 100, 200
$('.box').offset({ top: 0, left: 0 })  // move to top-left of page

// .position(): relative to offset parent
const p = $('.box').position()
console.log(p.left, p.top)         // position within parent

// .scrollTop() / .scrollLeft()
$(window).scrollTop()              // how far page is scrolled down
$(window).scrollTop(0)             // scroll to top
$('.container').scrollTop(100)     // scroll inner container

// .offsetParent(): nearest positioned ancestor
$('.box').offsetParent()           // the element .position() is relative to

Помощники адаптивной вёрстки

resize срабатывает много раз при перетаскивании — дебаунсьте через setTimeout, чтобы избежать проблем с производительностью. Добавление классов body (mobile/desktop) позволяет CSS реагировать через body.mobile .nav { ... }. В современном адаптивном коде предпочитайте CSS media queries для стилей и window.matchMedia() в JS: они производительнее и совпадают с брейкпоинтами CSS. Подход jQuery через resize годится для устаревшего кода, но современный стандарт — CSS + matchMedia.

jquery
// check viewport width on resize
$(window).on('resize', function () {
  const w = $(window).width()
  if (w < 768) {
    $('body').addClass('mobile').removeClass('desktop')
  } else {
    $('body').addClass('desktop').removeClass('mobile')
  }
}).resize()  // trigger once to initialize

// debounced resize (avoid firing hundreds of times)
let timer
$(window).on('resize', function () {
  clearTimeout(timer)
  timer = setTimeout(function () {
    console.log('resize settled')
  }, 200)
})

// match media (preferred for responsive checks)
if (window.matchMedia('(max-width: 768px)').matches) {
  // mobile
}

Определение видимости элемента

:visible/:hidden проверяют display, visibility, opacity и размеры: jQuery 3+ считает visibility:hidden и opacity:0 скрытыми (старые версии считали их видимыми). Для определения попадания в viewport помощник inViewport сравнивает границы элемента с позицией прокрутки. Современный код использует IntersectionObserver: он гораздо эффективнее (вычисления делает браузер, колбэки только при изменениях) и не требует слушателей scroll. Подход jQuery работает, но срабатывает на каждое событие прокрутки.

jquery
// :visible / :hidden pseudo-classes
$('.box').is(':visible')   // boolean
$('.box:visible').doSomething()

// note: visibility:hidden is now :hidden in jQuery 3+
// (display:none, opacity:0, width:0/height:0 are also :hidden)

// is element in viewport?
function inViewport($el) {
  const elTop = $el.offset().top
  const elBottom = elTop + $el.outerHeight()
  const docTop = $(window).scrollTop()
  const docBottom = docTop + $(window).height()
  return elBottom >= docTop && elTop <= docBottom
}

// scroll-triggered reveal
$(window).on('scroll', function () {
  $('.reveal').each(function () {
    if (inViewport($(this))) {
      $(this).addClass('shown')
    }
  })
})

Позиция прокрутки и анимация

Плавная прокрутка: анимируйте scrollTop и у html, и у body (кроссбраузерно). Вычитайте высоту «липкой» шапки. Бесконечный скролл: когда позиция прокрутки + высота viewport оказываются в пределах N пикселей от высоты документа, подгружайте ещё. Параллакс: сдвигайте элементы по позиции прокрутки. Всегда троттлите обработчики scroll (они срабатывают десятки раз в секунду) — через _.throttle, дебаунс по таймеру или requestAnimationFrame. Современные альтернативы: CSS scroll-behavior:smooth для прокрутки и IntersectionObserver для триггеров.

jquery
// current scroll position
const scrollTop = $(window).scrollTop()

// smooth scroll to top
$('html, body').animate({ scrollTop: 0 }, 500)

// smooth scroll to element
function scrollTo($el, duration) {
  const top = $el.offset().top - 20  // 20px offset for fixed header
  $('html, body').animate({ scrollTop: top }, duration || 500)
}
scrollTo($('#section2'))

// infinite scroll: load more when near bottom
$(window).on('scroll', function () {
  if ($(window).scrollTop() + $(window).height() >= $(document).height() - 100) {
    loadMore()
  }
})

// parallax (simple)
$(window).on('scroll', function () {
  const y = $(window).scrollTop()
  $('.hero').css('transform', 'translateY(' + (y * 0.5) + 'px)')
})
13

Deferred и промисы

Создание Deferred

$.Deferred — реализация промисов в jQuery (появилась до нативных Promise). Создайте его, затем вызовите .resolve(value) или .reject(reason), чтобы завершить. .promise() возвращает представление только для чтения (потребители не могут его разрешить). Устаревший API использует .done/.fail/.always вместо .then/.catch. Deferred в jQuery 3+ являются thenable, поэтому await и Promise.resolve с ними работают. Для нового кода предпочитайте нативные Promise: Deferred актуален в основном для AJAX и устаревших API.

jquery
// create a Deferred (jQuery's promise source)
const deferred = $.Deferred()

// resolve or reject it later
setTimeout(function () {
  if (Math.random() > 0.5) {
    deferred.resolve('success data')
  } else {
    deferred.reject(new Error('failed'))
  }
}, 1000)

// get the promise (read-only view)
const promise = deferred.promise()

// consume it
promise
  .done(function (data) { console.log('done:', data) })
  .fail(function (err) { console.log('fail:', err) })
  .always(function () { console.log('settled') })

When (параллельная асинхронность)

$.when(deferreds...) ждёт разрешения нескольких Deferred/Promise, затем вызывает .done с массивами результатов. Если хоть один отклонён, .fail срабатывает сразу. Это паттерн параллельной асинхронности (как Promise.all). Колбэк получает по массиву на каждый входной deferred (для AJAX каждый содержит [data, status, xhr]). В современном коде Promise.all + fetch чище и сразу возвращает значения. $.when всё ещё полезен в проектах, плотно завязанных на jQuery.

jquery
// run multiple async ops in parallel, wait for all
$.when(
  $.get('/api/users'),
  $.get('/api/posts'),
  $.get('/api/comments')
).done(function (usersResp, postsResp, commentsResp) {
  // each arg is [data, status, xhr]
  const users = usersResp[0]
  const posts = postsResp[0]
  console.log('all loaded:', users, posts)
}).fail(function (err) {
  console.error('one failed:', err)
})

// modern equivalent
Promise.all([
  fetch('/api/users').then(r => r.json()),
  fetch('/api/posts').then(r => r.json())
]).then(([users, posts]) => {
  console.log('all loaded:', users, posts)
})

Цепочки .then()

В jQuery 3+ .then приведён к спецификации Promises/A+: он принимает (onFulfilled, onRejected) и возвращает новый промис, как нативный Promise.then. Можно связывать асинхронные операции и преобразовывать значения. Возврат промиса из .then ждёт его; возврат значения передаёт его дальше. В 3+ поддерживается и .catch. В jQuery 1.x/2.x .then вёл себя нестандартно — используйте .pipe. По возможности обновитесь до 3+ и используйте .then/.catch для более чистого асинхронного кода.

jquery
// jQuery 3+: .then follows Promises/A+ (like native then)
$.get('/api/users')
  .then(function (users) {
    // transform or chain another async
    return $.get('/api/users/' + users[0].id)
  })
  .then(function (userDetail) {
    console.log('detail:', userDetail)
    return userDetail.name  // pass value downstream
  })
  .then(function (name) {
    console.log('name:', name)
  })
  .catch(function (err) {
    console.error('any error in chain:', err)
  })

// in jQuery 1.x/2.x, .then had different semantics
// use .done/.pipe for old code; .then for new

Промис-интерфейс AJAX

Все вызовы $.ajax (и $.get/$.post) возвращают объект jqXHR, похожий на промис (поддерживает .done/.fail/.always) и в jQuery 3+ являющийся thenable (поэтому работают await и Promise.resolve). Можно навесить несколько колбэков .done — все сработают при успехе. .abort() отменяет запрос (вызывает .fail со статусом 'abort'). В новом коде используйте await $.ajax(...) или оборачивайте в Promise.resolve(), чтобы чисто интегрироваться с нативными цепочками промисов и async/await.

jquery
// $.ajax returns a jqXHR (promise-like)
const req = $.ajax({ url: '/api/data', method: 'GET' })

// multiple callbacks on same request
req.done(function (data) { console.log('handler 1', data) })
req.done(function (data) { console.log('handler 2', data) })
req.fail(function (xhr, status, err) { console.error(err) })
req.always(function () { console.log('settled') })

// abort an in-flight request
req.abort()

// convert to native Promise (jQuery 3+)
Promise.resolve(req).then(function (data) {
  console.log('via native promise:', data)
})

// use with async/await (jQuery 3+)
async function getData() {
  try {
    const data = await $.ajax({ url: '/api/data' })
    console.log(data)
  } catch (err) {
    console.error(err)
  }
}

Свой конвейер промисов

Оборачивайте любую асинхронную операцию в Deferred, чтобы получить промис: создайте, позже вызовите resolve/reject, верните .promise(). Коллекции jQuery тоже дают .promise(), который разрешается, когда все анимации в очереди на элементах завершены, — удобно, чтобы запустить код после пачки анимаций. Это связывает очередь анимаций jQuery с кодом на промисах, позволяя дождаться анимаций или связать их с AJAX и другой асинхронной работой.

jquery
// wrap a callback-based API in a promise
function delay(ms) {
  const d = $.Deferred()
  setTimeout(function () { d.resolve() }, ms)
  return d.promise()
}

// use it
delay(500).then(function () { console.log('500ms passed') })

// animate then continue
$('.box').fadeOut(300).promise().done(function () {
  console.log('fade done')
})

// queue of animations on multiple elements
$('.box').each(function (i) {
  $(this).delay(i * 100).fadeIn().promise()
})

// when animations on a set are done
$('.box').fadeOut().promise().done(function () {
  console.log('all boxes faded')
})
14

Формы

События форм

submit срабатывает при отправке формы — для AJAX всегда вызывайте preventDefault. input срабатывает на каждое нажатие клавиши (текст) или изменение значения — отлично для живой валидации и поиска по мере ввода. change срабатывает на blur у текстовых полей, но сразу у checkbox, radio и select. focus/blur — при получении и потере фокуса. Для динамически добавляемых полей используйте делегирование на форме. Разница change и input важна: input — живое, change — когда пользователь закончил редактирование.

jquery
// submit event
$('form').on('submit', function (e) {
  e.preventDefault()  // stop page reload
  const data = $(this).serialize()
  $.post('/api/save', data)
})

// input event (fires on every keystroke/change)
$('input').on('input', function () {
  console.log('current value:', $(this).val())
})

// change event (fires on blur for text, immediately for checkbox/select)
$('select').on('change', function () {
  console.log('selected:', $(this).val())
})

// focus / blur
$('input').on('focus', function () { $(this).addClass('focused') })
$('input').on('blur', function () { $(this).removeClass('focused') })

// delegated (works for dynamically added fields)
$('form').on('input', '.field', function () { /* ... */ })

Сериализация данных формы

.serialize() даёт URL-кодированную строку, готовую для AJAX-данных. .serializeArray() возвращает массив {name, value} — преобразуйте в объект через reduce. Оба учитывают текущее состояние формы (checkbox попадают только отмеченные; select — выбранный вариант). У checkbox значение по умолчанию 'on', если не задан value. Отключённые поля исключаются. Это стандартный способ собрать данные формы для AJAX-отправки без полной перезагрузки.

jquery
<!-- form -->
<form id="f">
  <input name="name" value="Alice">
  <input name="email" value="[email protected]">
  <select name="role"><option value="admin" selected>Admin</option></select>
  <input type="checkbox" name="agree" checked>
</form>

<script>
// serialize: URL-encoded string
$('#f').serialize()
// 'name=Alice&email=a%40b.com&role=admin&agree=on'

// serializeArray: array of {name, value}
$('#f').serializeArray()
// [{ name: 'name', value: 'Alice' }, ...]

// convert to plain object
const obj = {}
$('#f').serializeArray().forEach(p => { obj[p.name] = p.value })
// { name: 'Alice', email: '[email protected]', role: 'admin', agree: 'on' }

// or one-liner reduce
const obj2 = $('#f').serializeArray().reduce((o, p) =>
  (o[p.name] = p.value, o), {})
</script>

Валидация форм

Ручная валидация: переберите обязательные поля, проверьте .val(), переключите класс 'invalid' для CSS. Регулярное выражение для email — базовая проверка (полное по RFC 5322 избыточно). Для сложных форм используйте jQuery Validation Plugin с декларативными правилами (class='required email') и едиными сообщениями об ошибках. Всегда валидируйте на клиенте для UX И на сервере для безопасности: клиентскую проверку можно обойти. HTML5-атрибуты (required, type='email', pattern) — современная база.

jquery
// simple validation
function validate($form) {
  let valid = true
  $form.find('[data-required]').each(function () {
    const $f = $(this)
    if (!$f.val()) {
      $f.addClass('invalid')
      valid = false
    } else {
      $f.removeClass('invalid')
    }
  })
  $form.find('[type=email]').each(function () {
    if (!/^[^@]+@[^@]+\.[^@]+$/.test($(this).val())) {
      $(this).addClass('invalid')
      valid = false
    }
  })
  return valid
}

$('form').on('submit', function (e) {
  e.preventDefault()
  if (validate($(this))) {
    $.post('/api/save', $(this).serialize())
  }
})

Динамические поля формы

Добавляйте и удаляйте поля формы, создавая элементы через $() и вставляя их. Используйте имена-массивы (tags[]), чтобы сервер получил массив. Делегирование (on('click', '.remove', ...)) обрабатывает клики по динамически добавленным кнопкам удаления. Для переупорядочиваемых полей (кнопки вверх/вниз или drag-drop) перенумеровывайте имена после каждого изменения, чтобы сервер видел чистую последовательность. Паттерн обычен для ввода тегов, динамических строк заказа и форм конфигурации.

jquery
// add a new field
$('.add-field').on('click', function () {
  const $field = $('<input>', {
    type: 'text',
    name: 'tags[]',
    class: 'tag-input',
    placeholder: 'Tag'
  })
  $('#fields').append($field)
})

// remove a field
$('#fields').on('click', '.remove', function () {
  $(this).closest('.field-row').remove()
})

// array field names (tags[]) — server receives an array
// PHP/Rails auto-parse 'name[]' into arrays

// re-number fields after add/remove
function renumber() {
  $('#fields .field').each(function (i) {
    $(this).find('input').attr('name', 'item_' + i)
  })
}

AJAX-отправка формы

Переиспользуемый обработчик AJAX-формы: сериализовать форму, отправить POST на её action URL, обработать успех и ошибку. Отключайте кнопку отправки на время запроса, чтобы избежать двойной отправки. Генерируйте свои события (ajax:success, ajax:error), чтобы другой код мог реагировать. Сбрасывайте форму при успехе. Показывайте ошибки валидации сервера, сопоставляя имена полей с сообщениями. Паттерн превращает любую форму в AJAX-форму добавлением class='ajax' — типичное прогрессивное улучшение.

jquery
// generic AJAX form submission
$('form.ajax').on('submit', function (e) {
  e.preventDefault()
  const $form = $(this)
  const data = $form.serialize()
  const url = $form.attr('action') || window.location.href
  const method = $form.attr('method') || 'POST'

  // show loading state
  $form.find('button').prop('disabled', true).addClass('loading')

  $.ajax({
    url: url,
    method: method,
    data: data,
    dataType: 'json'
  })
  .done(function (resp) {
    $form.trigger('ajax:success', [resp])
    $form[0].reset()
  })
  .fail(function (xhr) {
    $form.trigger('ajax:error', [xhr])
    const errors = xhr.responseJSON?.errors
    if (errors) showErrors($form, errors)
  })
  .always(function () {
    $form.find('button').prop('disabled', false).removeClass('loading')
  })
})
15

Итерация и циклы

$.each против .each()

$.each — универсальная утилита, перебирающая массивы (index, value) или простые объекты (key, value). .each() — метод коллекций jQuery: 'this' — исходный DOM-элемент. Оба принимают возврат false для прерывания и любое другое значение для продолжения. Обратите внимание: порядок аргументов (index, value) — обратен Array.forEach (value, index). В современном коде предпочитают нативные forEach/map/for...of; .each() полезен при работе с коллекциями jQuery, когда элемент нужен как 'this'.

jquery
// $.each: generic iterator (arrays AND objects)
$.each([10, 20, 30], function (index, value) {
  console.log(index, value)  // 0 10, 1 20, 2 30
})

$.each({ a: 1, b: 2 }, function (key, value) {
  console.log(key, value)  // 'a' 1, 'b' 2
})

// .each(): method on jQuery collections only
$('li').each(function (index, element) {
  // 'this' is the DOM element (= element)
  // wrap with $(this) for jQuery methods
  $(this).text(index + ': ' + $(this).text())
})

// breaking out
$('li').each(function (i) {
  if (i === 3) return false  // stop iteration
  // return true (or nothing) to continue
})

$.map против .map()

$.map преобразует массив или объект в новый массив (верните null, чтобы пропустить, верните массив, чтобы развернуть). Порядок аргументов (value, index) — обратен $.each. .map() на коллекциях jQuery возвращает новую коллекцию jQuery (вызовите .get() для обычного массива). Возврат null/undefined из .map() исключает элемент. Это до-нативные методы: современный код использует native map, но .map() jQuery всё ещё удобен для извлечения значений из DOM-коллекций.

jquery
// $.map: transform an array or object
const doubled = $.map([1, 2, 3], function (value, index) {
  return value * 2  // [2, 4, 6]
})

// returning null/undefined removes the item
const evens = $.map([1, 2, 3, 4], function (v) {
  return v % 2 === 0 ? v : null  // [2, 4]
})

// returning an array flattens it
const flat = $.map([1, 2], function (v) {
  return [v, v * 10]  // [1, 10, 2, 20]
})

// .map() on jQuery collections
const ids = $('li').map(function (index, el) {
  return $(el).data('id')  // jQuery collection of ids
}).get()  // .get() converts to plain array [1, 2, 3]

Циклы for/while

Для максимальной производительности на больших коллекциях используйте классический for с $items[i] (исходный DOM-элемент) вместо $items.eq(i) (обёрнутый в jQuery): это не создаёт новый объект jQuery на каждой итерации. Свойство .length работает напрямую. for...of работает с коллекциями jQuery (они итерируемы). Однако предпочитайте .each() ради читаемости, если только не измерили проблему производительности: разница редко заметна, кроме тысяч элементов.

jquery
// classic for loop with .eq(i)
const $items = $('li')
for (let i = 0; i < $items.length; i++) {
  const $item = $items.eq(i)
  $item.text('Item ' + i)
}

// or use the raw DOM elements (faster, no jQuery wrapping)
for (let i = 0; i < $items.length; i++) {
  $items[i].textContent = 'Item ' + i  // raw DOM
}

// while loop
let i = 0
while (i < $items.length) {
  $($items[i]).addClass('item-' + i)
  i++
}

// for...of (modern, on the collection)
for (const el of $items) {
  $(el).addClass('processed')
}

Фильтрация во время итерации

Фильтруйте до перебора — $('li').filter('.active').each(...) идиоматичнее, чем условия внутри .each(). Чтобы собрать подмножество, складывайте подходящие DOM-элементы в массив и в конце оберните через $(). Для извлечения значений чище всего .map().get(). Избегайте построения коллекций jQuery в цикле (каждый $() имеет накладные расходы): собирайте исходные элементы и оборачивайте один раз.

jquery
// filter then iterate
$('li').filter('.active').each(function () {
  $(this).addClass('highlighted')
})

// iterate with conditional logic
$('li').each(function (i) {
  if (i % 2 === 0) {
    $(this).addClass('even')
  } else {
    $(this).addClass('odd')
  }
})

// collect matching items
const active = []
$('li').each(function () {
  if ($(this).hasClass('active')) {
    active.push(this)  // push raw DOM element
  }
})
const $active = $(active)  // wrap in jQuery

// or use .map().get()
const ids = $('li.active').map(function () {
  return $(this).data('id')
}).get()

Вложенность и сложная итерация

Вложенные .each() обрабатывают сетки и матрицы. Для построения DOM из данных вставляйте в document fragment и добавляйте один раз (намного быстрее, чем вставка на каждый элемент: каждая вставка вызывает reflow). $(document.createDocumentFragment()) создаёт обёрнутый фрагмент. Для очень больших списков рассмотрите конкатенацию строк + .html() (быстрее всего) или шаблонизатор. Современные фреймворки (Vue/React) делают это декларативно, но паттерн фрагмента остаётся полезной оптимизацией jQuery.

jquery
// nested iteration over rows and cells
$('table tr').each(function (rowIdx, row) {
  $(row).find('td').each(function (colIdx, cell) {
    $(cell).text('R' + rowIdx + 'C' + colIdx)
  })
})

// iterate over a JSON response and build DOM
$.get('/api/users').done(function (users) {
  const $list = $('#users')
  $.each(users, function (i, user) {
    $list.append(
      $('<li>').text(user.name).data('id', user.id)
    )
  })
})

// build with a document fragment (faster)
const $frag = $(document.createDocumentFragment())
$.each(users, function (i, user) {
  $frag.append('<li>' + user.name + '</li>')
})
$('#users').append($frag)  // one DOM update
16

Хранение данных и кеширование

$.data против .data()

$.data(el, key, val) — низкоуровневая функция для исходного DOM-элемента; .data() — удобный метод на коллекциях jQuery. Оба хранят значения во внутреннем кеше (не в DOM), поэтому это быстрее доступа к атрибутам. .data() также автоматически читает атрибуты data-* с приведением типов (числа, булевы, JSON). Установка через .data(key, val) НЕ обновляет атрибут data-*; для этого используйте .attr('data-key', val). Для очистки — $.removeData(el, key) или .removeData(key).

jquery
// $.data: low-level, on raw DOM element
const el = document.getElementById('box')
$.data(el, 'count', 1)
$.data(el, 'count')       // 1
$.data(el, 'count', 2)
$.data(el, 'count')       // 2
$.removeData(el, 'count')

// .data(): method on jQuery collection (more common)
$('.box').data('count', 1)
$('.box').data('count')   // 1
$('.box').removeData('count')

// auto-reads data-* attributes (with type conversion)
// <div data-id="42" data-active="true"></div>
$('.box').data('id')      // 42 (number)
$('.box').data('active')  // true (boolean)

Состояние на элемент

Состояние на элемент — главная фича .data(): храните конфигурацию, счётчики, флаги или объекты, связанные с каждым элементом, не засоряя DOM. Вызов .data() без аргументов возвращает все сохранённые данные объектом. Учтите: если сохранить объект, его мутация меняет сохранённую ссылку (переустанавливать не нужно). Внутренний кеш автоматически очищается при .remove(), предотвращая утечки, но не при удалении нативными методами DOM (parentNode.removeChild).

jquery
// store per-element state on plugin init
$('.counter').each(function () {
  $(this).data('count', 0)
})

// increment on click
$('.counter').on('click', function () {
  const $el = $(this)
  const c = $el.data('count') + 1
  $el.data('count', c)
  $el.text('Count: ' + c)
})

// retrieve all data
const all = $('.counter').data()  // { count: 5, ... }

// store objects
$('.box').data('config', { color: 'red', size: 10 })
$('.box').data('config').color = 'blue'  // mutates the stored object
$('.box').data('config').color  // 'blue'

Кеширование выборок

Кеширование выборок jQuery избегает повторных запросов к DOM — значительный выигрыш в циклах и частых обработчиках. Соглашение: префикс $ у кешированных объектов jQuery ($boxes, $nav), чтобы отличать их от исходных DOM-элементов. Осторожно: кешированные выборки устаревают при изменении DOM (добавлении и удалении подходящих элементов). Делайте новый запрос после вставки динамического содержимого. Для обработчиков кеширование вне обработчика (в той же области) избавляет от повторного запроса на каждое событие.

jquery
// BAD: re-querying the DOM on every use
function update() {
  $('.box').text('updated')     // queries every call
  $('.box').addClass('done')    // queries again
}

// GOOD: cache the selection
const $boxes = $('.box')        // query once
function update() {
  $boxes.text('updated')
  $boxes.addClass('done')
}

// re-query when content changes
$('#container').load('/partial', function () {
  // $boxes is stale — re-query
  const $newBoxes = $('.box')
})

// convention: prefix cached jQuery objects with $
const $nav = $('#nav')
const $items = $('.item')

Атрибуты data-* из HTML5

Атрибуты data-* позволяют декларативно встраивать конфигурацию в HTML — идеально для прогрессивного улучшения (сервер рендерит конфигурацию, JS читает). .data() читает с приведением типов (числа, булевы, JSON-объекты); .attr() читает исходную строку. Многословные имена в HTML используют kebab-case (data-foo-bar), в JS — camelCase (.data('fooBar')). Для JSON-значений используйте одинарные кавычки в HTML, чтобы обернуть JSON (в котором двойные). Обновление data-* через .attr() сохраняется в DOM; .data() пишет только в кеш.

jquery
<!-- declarative config in HTML -->
<div class="widget"
     data-id="42"
     data-mode="advanced"
     data-config='{"timeout":5000,"retries":3}'
     data-enabled="true">
  Widget
</div>

<script>
// .data() reads with type conversion
const $w = $('.widget')
$w.data('id')        // 42 (number)
$w.data('mode')      // 'advanced'
$w.data('config')    // { timeout: 5000, retries: 3 } (parsed JSON)
$w.data('enabled')   // true (boolean)

// .attr() reads raw strings
$w.attr('data-id')   // '42' (string)
$w.attr('data-config') // '{"timeout":5000,...}' (string)

// camelCase mapping: data-foo-bar -> .data('fooBar')
$('[data-foo-bar]').data('fooBar')
</script>

Память и очистка

Используйте .remove() для удаления элементов: он автоматически очищает связанные данные и события. .detach() убирает из DOM, но сохраняет данные и события (для повторной вставки). .empty() удаляет детей И очищает их данные и события. НИКОГДА не применяйте .html('') для очистки детей: он не очищает их данные и события, вызывая утечки памяти. Для плагинов открывайте метод destroy, который отвязывает события и удаляет данные. Автоочистка jQuery — важная причина использовать .remove(), а не нативное удаление из DOM.

jquery
// .remove() cleans up data and events
$('.box').remove()  // safe — data and events gone

// .detach() preserves data and events for re-insertion
const $box = $('.box').detach()
$('#elsewhere').append($box)  // events still fire

// .empty() removes children AND their data/events
$('.container').empty()  // children's data/events cleaned

// .html('') does NOT clean up children's data/events (leak!)
// use .empty() instead

// manual cleanup before removal
$('.box').off().removeData().remove()

// custom cleanup in a plugin
$.fn.myPlugin = function () {
  this.on('click.myplugin', handler)
  this.data('myplugin', { /* state */ })

  // expose destroy for manual cleanup
  // ... or use .on('remove') event (non-standard)
17

Свои анимации

Основы .animate()

.animate() плавно меняет числовые CSS-свойства за длительность. Используйте относительные значения ('+=50', '-=20') для инкрементальных изменений. Имена свойств должны быть в camelCase (marginLeft, а не margin-left). Специальные значения 'toggle', 'show', 'hide' работают как одноимённые методы. Числа по умолчанию в пикселях. Цвета требуют плагина jQuery Color: ядро jQuery анимирует только числа. Колбэк срабатывает по завершении анимации (для каждого элемента, поэтому для коллекций может сработать несколько раз).

jquery
// animate numeric CSS properties
$('.box').animate({
  width: '500px',
  height: 200,         // number = px
  opacity: 0.5,
  marginLeft: '+=50',  // relative
  fontSize: '20px'     // camelCase for hyphenated props
}, 1000)  // duration in ms

// with callback
$('.box').animate({ left: 300 }, 1000, function () {
  console.log('done')
})

// 'slow' = 600, 'fast' = 200
$('.box').animate({ height: 'toggle' }, 'slow')

// special values: 'toggle', 'show', 'hide'
$('.box').animate({ width: 'toggle' })

Easing и опции

Easing управляет кривой скорости: 'swing' (по умолчанию, медленный старт и финиш, быстрая середина) и 'linear' (равномерно). jQuery UI или плагин easing добавляют 30+ вариантов (easeInOutCubic, easeOutBounce). Форма с опциями даёт тонкий контроль: step вызывается на каждом кадре анимации (полезно для синхронизации других элементов), queue:false выполняет параллельно (по умолчанию true — последовательно), specialEasing задаёт easing для отдельных свойств. step получает (now, fx), где fx.prop — имя свойства, а fx.start/fx.end — границы.

jquery
// easing: 'swing' (default, ease-out) or 'linear'
$('.box').animate({ left: 300 }, 1000, 'linear')

// options object form
$('.box').animate({ left: 300 }, {
  duration: 1000,
  easing: 'swing',
  complete: function () { console.log('done') },
  step: function (now, fx) {
    console.log(fx.prop, now)  // called each frame
  },
  queue: true,         // default true (sequential)
  specialEasing: {
    width: 'linear',   // per-property easing
    height: 'swing'
  }
})

// jQuery UI adds more easings: easeInOutCubic, etc.
// or include jquery.easing plugin

Очередь анимаций

У каждого элемента есть очередь 'fx': анимации на одном элементе по умолчанию выполняются последовательно. queue:false включает параллельность. .delay(ms) вставляет паузу. .queue(fn) вставляет свою функцию в очередь — вызовите next() (или dequeue()), чтобы продолжить. Это позволяет смешивать анимации с произвольным кодом (AJAX, колбэками) в последовательности. .clearQueue() опустошает очередь, не затрагивая текущую анимацию. .dequeue() переходит к следующему элементу очереди.

jquery
// animations queue per element (default)
$('.box')
  .animate({ width: 500 }, 500)  // runs first
  .animate({ height: 300 }, 500) // runs after
  .animate({ opacity: 0.5 }, 500) // runs after that

// total: 1500ms (sequential)

// run in parallel: queue: false
$('.box').animate({ width: 500 }, { duration: 500, queue: false })
$('.box').animate({ height: 300 }, { duration: 500, queue: false })
// both run simultaneously

// .delay(): pause in the queue
$('.box')
  .animate({ width: 500 }, 500)
  .delay(300)              // wait 300ms
  .animate({ height: 300 }, 500)

// .queue(): insert custom function into the queue
$('.box').animate({ width: 500 }, 500).queue(function (next) {
  console.log('between animations')
  next()  // must call to continue
})

Анимация цветов

Ядро jQuery не умеет анимировать цвета (они нечисловые). Плагин jQuery Color (небольшой, самостоятельный) или jQuery UI добавляют анимацию цветов: backgroundColor, color, borderColor и др. jQuery UI также включает анимацию классов: .addClass('foo', 500) плавно переходит к стилям нового класса за 500 мс. Для современных сайтов предпочитайте CSS-переходы (transition: background 0.3s): они аппаратно ускоряются и не требуют JS. Анимацию цветов jQuery используйте только для устаревшей поддержки.

jquery
<!-- jQuery core does NOT animate colors -->
<!-- include jQuery Color plugin or jQuery UI -->
<script src="https://code.jquery.com/color/jquery.color-2.2.0.min.js"></script>

<script>
// now color animations work
$('.box').animate({
  backgroundColor: '#ff0000',
  color: '#ffffff',
  borderColor: '#000000'
}, 1000)

// jQuery UI also enables:
// - class animations: .toggleClass('active', 500)
// - more easing functions
// - color transitions on hover
$('.box').hover(function () {
  $(this).animate({ backgroundColor: '#eee' }, 300)
}, function () {
  $(this).animate({ backgroundColor: '#fff' }, 300)
})
</script>

Остановка и очистка

.stop() останавливает текущую анимацию. С (clearQueue=true) он ещё и очищает очередь. С (jumpToEnd=true) переводит текущую анимацию в конечное состояние. .finish() мгновенно переводит все анимации в очереди в конечные состояния. Селектор :animated совпадает с элементами в процессе анимации. Всегда сочетайте hover-анимации с .stop(true), чтобы избежать накопления при быстром входе и выходе мыши: без этого анимации выстраиваются в очередь и доигрываются спустя долго после ухода курсора, вызывая рывки.

jquery
// .stop([clearQueue], [jumpToEnd])
$('.box').stop()              // stop current, stay at current state
$('.box').stop(true)          // also clear the queue
$('.box').stop(true, true)    // clear queue AND jump current to end
$('.box').stop(false, true)   // jump current to end, keep queue

// .finish(): jump ALL queued animations to end state
$('.box').finish()

// prevent hover animation buildup
$('.box').hover(function () {
  $(this).stop(true).animate({ width: 300 }, 200)
}, function () {
  $(this).stop(true).animate({ width: 100 }, 200)
})

// check if currently animating
if (!$(':animated').length) { /* nothing animating */ }
if ($('.box').is(':animated')) { /* still animating */ }
18

Делегирование событий

Зачем делегирование?

Делегирование привязывает один обработчик к родителю; клики по детям всплывают и вызывают его. Плюсы: (1) один обработчик вместо N (память), (2) автоматическая работа для динамически добавленных элементов, (3) быстрее установка (одна привязка вместо N). Второй аргумент .on() ('li') — фильтр селектора: 'this' внутри обработчика — совпавший ребёнок, а не родитель. Используйте делегирование для любого списка, таблицы или контейнера, где дети делят поведение. Единственная цена — небольшие накладные расходы на событие (проверка селектора), что ничтожно.

jquery
// ANTI-PATTERN: bind to each <li> directly
$('li').on('click', function () {
  $(this).toggleClass('done')
})
// - 1 handler PER <li> (100 items = 100 handlers)
// - NEW <li> added later DON'T get the handler
// - high memory, slow setup

// PATTERN: delegate to parent
$('ul').on('click', 'li', function (e) {
  $(this).toggleClass('done')
})
// - 1 handler total
// - works for future <li>
// - low memory, fast setup
// - 'this' is the <li> (not the <ul>)

Делегирование на практике

Этот паттерн списка задач показывает силу делегирования: два делегированных обработчика на #tasks обслуживают кнопки удаления и переключение элементов для всех текущих и будущих задач. Добавление нового <li> не требует перепривязки. e.stopPropagation() на кнопке удаления не даёт клику по li тоже сработать (иначе при удалении переключался бы .done). .closest('li') находит объемлющий <li> от нажатой кнопки. Этот паттерн — основа jQuery-SPA до фреймворков, и он всё ещё полезен для виджетов.

jquery
<!-- dynamic list -->
<ul id="tasks">
  <li>Task 1 <button class="delete">×</button></li>
</ul>

<script>
// ONE delegated handler handles all current AND future items
$('#tasks').on('click', '.delete', function (e) {
  e.stopPropagation()
  $(this).closest('li').remove()
})

$('#tasks').on('click', 'li', function () {
  $(this).toggleClass('done')
})

// adding new items works without re-binding
$('.add').on('click', function () {
  $('#tasks').append('<li>New task <button class="delete">×</button></li>')
})
</script>

Делегированная и прямая привязка

Прямая привязка вешает обработчик на совпавшие элементы; делегированная — на родителя с фильтрацией по селектору. Ключевая разница внутри обработчика: при прямой e.currentTarget === this === элемент. При делегированной e.currentTarget — родитель (где привязан обработчик), this — совпавший ребёнок (результат селектора), а e.target — фактически кликнутый элемент (может быть потомком совпавшего ребёнка). Для доступа к родителю в делегированных обработчиках используйте e.delegateTarget.

jquery
// DIRECT: bind directly to element
// - element must exist at bind time
// - handler attached to element itself
// - e.target === e.currentTarget === this
$('.btn').on('click', function (e) {
  console.log(e.currentTarget === this)  // true
})

// DELEGATED: bind to parent, filter by selector
// - works for future children
// - handler attached to parent
// - e.currentTarget = parent (the bound element)
// - this = child (matched selector)
// - e.target = actual clicked element (may be deeper child)
$('ul').on('click', 'li', function (e) {
  console.log(e.currentTarget)  // the <ul>
  console.log(this)              // the <li>
  console.log(e.target)          // clicked element (maybe <span> in li)
})

Отвязка делегированных обработчиков

Пространства имён (click.task) — самый чистый способ отвязать конкретные обработчики, не затрагивая другие. .off('click', 'li') удаляет делегированные обработчики с этим селектором. .off('click') удаляет все обработчики click (прямые и делегированные). .off() удаляет всё — используйте осторожно. Чтобы удалить конкретный обработчик, передайте ссылку на исходную функцию. В плагинах всегда давайте событиям пространство имён (click.myplugin), чтобы пользователи могли чисто отвязать, не зная ваших внутренностей.

jquery
// delegate with namespace
$('ul').on('click.task', 'li', handler)

// remove just this delegated handler (by namespace)
$('ul').off('click.task')

// remove all delegated click handlers
$('ul').off('click')

// remove all delegated handlers with a specific selector
$('ul').off('click', 'li')

// remove ALL handlers (including delegated)
$('ul').off()

// remove with reference to the original handler
function handler() { /* ... */ }
$('ul').on('click', 'li', handler)
$('ul').off('click', 'li', handler)  // exact match

Подводные камни делегирования

Ограничивайте делегирование ближайшим стабильным предком — не делегируйте всё на document/body (каждое событие всплывает и проверяется на селектор, это медленно). Избегайте слишком широких селекторов ('div'). Осторожно с stopPropagation в детях: он мешает делегированным обработчикам предков. Если ребёнок останавливает всплытие, делегированный обработчик родителя не выполнится. Компромисс: делегирование гибко, но добавляет небольшие накладные расходы на событие (сопоставление селектора) — обычно ничтожные, но заметные на огромных страницах.

jquery
// PITFALL 1: delegated handler on a parent that's too high
$(document).on('click', '.btn', handler)
// works, but EVERY click bubbles to document and is checked
// (slow on large pages — scope to nearest stable parent)

// BETTER: scope to the nearest container that won't be replaced
$('#sidebar').on('click', '.btn', handler)

// PITFALL 2: selector that matches too broadly
$('body').on('click', 'div', handler)  // fires on every div click

// PITFALL 3: stopping propagation in a child breaks delegation
$('.btn').on('click', function (e) {
  e.stopPropagation()  // parent's delegated handler won't fire!
})

// PITFALL 4: delegated handlers don't fire if a parent
// stops propagation before reaching the delegate target
19

Лучшие практики

Советы по производительности

Ключевые советы: (1) кешируйте выборки; (2) ограничивайте запросы контейнером через .find(); (3) предпочитайте селекторы #id (внутри getElementById); (4) избегайте *; (5) делегируйте события; (6) группируйте изменения DOM через фрагменты: каждая вставка вызывает reflow, поэтому соберите фрагмент и вставьте один раз; (7) отсоединяйте перед тяжёлыми манипуляциями (операции на отсоединённых элементах не вызывают reflow). Для списков 1000+ элементов быстрее всего конкатенация строк + .html(), но фрагмент чище.

jquery
// 1. cache selections
const $items = $('.items')  // query once

// 2. scope queries to a container
$('.item', $container)      // search within container
$container.find('.item')    // equivalent, slightly faster

// 3. use ID selectors when possible (fastest)
$('#header')                // getElementById

// 4. avoid universal selector
$('*').doSomething()        // SLOW

// 5. delegate events instead of binding many
$('ul').on('click', 'li', fn)  // 1 handler

// 6. batch DOM updates (use document fragment)
const $frag = $(document.createDocumentFragment())
for (let i = 0; i < 1000; i++) {
  $frag.append('<li>Item ' + i + '</li>')
}
$('ul').append($frag)  // one reflow, not 1000

// 7. detach before heavy manipulation
const $list = $('ul').detach()
// ... modify $list ...
$('#container').append($list)

Производительность вставки в DOM

Вставка в DOM — главное узкое место производительности. Каждый .append() вызывает reflow (браузер пересчитывает вёрстку). Для массовых вставок: (1) соберите HTML-строку и установите через .html() (быстрее всего для простого содержимого); (2) используйте document fragment и вставьте один раз (чище для сложных элементов); (3) отсоедините контейнер, измените, верните обратно (избегает reflow на живом DOM во время изменений). Для 1000+ элементов строковый подход заметно быстрее, чем .append() на каждый.

jquery
// SLOW: appending in a loop (reflow per iteration)
for (let i = 0; i < 1000; i++) {
  $('ul').append('<li>Item ' + i + '</li>')
}

// FASTER: build string, append once
let html = ''
for (let i = 0; i < 1000; i++) {
  html += '<li>Item ' + i + '</li>'
}
$('ul').html(html)

// FASTEST: detached node + fragment
const $list = $('ul').detach()
const $frag = $(document.createDocumentFragment())
for (let i = 0; i < 1000; i++) {
  $frag.append($('<li>').text('Item ' + i))
}
$list.append($frag).appendTo('#container')

// even faster: array.join
const html = new Array(1000).fill(0).map((_, i) =>
  '<li>Item ' + i + '</li>'
).join('')
$('ul').html(html)

Современные паттерны jQuery

Современный jQuery (3.x): используйте .on()/.off() (устаревшие .bind/.live/.delegate удалены или не рекомендуются). Используйте промис-интерфейс (.done/.fail) вместо колбэков success/error. Ограничивайте код IIFE или ES-модулями — не засоряйте глобальную область. Пропускайте $(document).ready, если скрипт в конце body. Предпочитайте CSS-переходы и анимации методу .animate() (аппаратное ускорение, плавнее). Используйте 'use strict'. Для новых проектов оцените, не лучше ли фреймворк (Vue/React), чем jQuery.

jquery
// use .on() / .off() (not bind/unbind, live, delegate)
$('.btn').on('click', fn)

// use promises (.done/.fail) instead of success/error
$.get('/api').done(fn).fail(errFn)

// use IIFE or modules to scope code
(function ($) {
  'use strict'
  // private code
  $('.btn').on('click', fn)
}(jQuery))

// or ES modules
import $ from 'jquery'
$('.btn').on('click', fn)

// don't pollute global scope
// don't use $(document).ready if script is at end of body

// prefer CSS for animations (hardware-accelerated)
// .css({ transition: 'all 0.3s', transform: 'translateX(100px)' })

Доступность

Основы доступности: добавляйте ARIA-роли и состояния (role='dialog', aria-modal, aria-expanded, aria-labelledby). Делайте свои виджеты доступными с клавиатуры: обрабатывайте Enter/Space для кнопок, стрелки для меню, Esc для закрытия модалок. Управляйте фокусом: при открытии модалки переводите фокус внутрь, при закрытии возвращайте на кнопку-триггер. Используйте семантические элементы (<button>, <a>, <nav>), а не div с onclick. Видимость: предпочитайте скрытие через CSS-классы (скринридеры могут игнорировать) вместо display:none (который они игнорируют всегда).

jquery
// add ARIA attributes for screen readers
$('.modal').attr({
  role: 'dialog',
  'aria-modal': true,
  'aria-labelledby': 'modal-title'
})

// toggle aria-expanded for collapsibles
$('.accordion .header').on('click', function () {
  const $h = $(this)
  const expanded = $h.attr('aria-expanded') !== 'true'
  $h.attr('aria-expanded', expanded)
  $h.next('.content').slideToggle()
})

// keyboard navigation
$('.menu-item').on('keydown', function (e) {
  if (e.which === 13 || e.which === 32) {  // Enter or Space
    $(this).trigger('click')
  }
})

// focus management for modals
$('.modal').on('shown', function () {
  $(this).find('input:first').focus()
})

// use button elements for actions (not <div onclick>)
$('<button>').text('Save').on('click', save).appendTo('body')

Безопасность: XSS и инъекция HTML

Никогда не вставляйте недоверенные строки через .html(): он выполняет встроенные теги <script> и обработчики событий (XSS). Для простого текста используйте .text() (автоэкранирование). Когда HTML необходим, сначала санируйте (ручное экранирование или библиотека вроде DOMPurify). Самый безопасный паттерн: строить элементы через $() и применять .text() для динамического содержимого — $('<li>').text(userInput) экранирует автоматически. Особенно осторожно с конструкциями .append('<div>' + data + '</div>'): это вектор XSS, если data контролирует пользователь.

jquery
// DANGEROUS: injecting untrusted HTML
const userInput = '<script>alert("xss")</script>'
$('.box').html(userInput)        // EXECUTES the script!

// SAFE: escape with .text()
$('.box').text(userInput)        // displays as text, no execution

// SAFE: sanitize before injecting
function escapeHtml(str) {
  return str
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#39;')
}
$('.box').html(escapeHtml(userInput))

// SAFE: build elements with .text() for content
const $li = $('<li>').text(userInput)  // text is auto-escaped
$('ul').append($li)

// AVOID .html() with user input. Use .text() or DOMPurify.
// $('div').html('<p>' + data + '</p>')  // BAD if data is user input
20

Частые паттерны

Модальное окно

Паттерн модалки: создайте подложку и модалку, добавьте в body (чтобы выйти из родительских stacking context), покажите с затуханием. Клик по подложке (не по модалке) закрывает — используйте e.target === this для определения. Esc закрывает. Всегда очищайте всё при закрытии (удалить DOM, отвязать обработчики). Для production рассмотрите библиотеку (Magnific Popup, Bootstrap Modal), которая решает доступность (захват фокуса, ARIA, возврат фокуса на триггер), анимации и iframe/ajax-модалки. Приведённый паттерн — минимальная ручная версия.

jquery
// simple modal pattern
function openModal(html) {
  const $overlay = $('<div class="modal-overlay"></div>')
  const $modal = $('<div class="modal"></div>').html(html)
  $overlay.append($modal).appendTo('body').hide().fadeIn(200)

  $overlay.on('click', function (e) {
    if (e.target === this) closeModal()  // click outside to close
  })

  $(document).on('keydown.modal', function (e) {
    if (e.which === 27) closeModal()  // Esc to close
  })
}

function closeModal() {
  $('.modal-overlay').fadeOut(200, function () { $(this).remove() })
  $(document).off('keydown.modal')
}

// usage
$('.open').on('click', function () {
  openModal('<p>Hello from modal!</p>')
})

Вкладки

Классический паттерн вкладок: клик по ссылке вкладки активирует её. href ссылки (#tab1) соответствует id содержимого. Класс active и на ссылке, и на содержимом управляет видимостью (CSS: .tab-content:not(.active) { display: none }). Обработчик использует делегирование (работает с динамически добавленными вкладками). preventDefault не даёт менять хеш URL (или уберите preventDefault, чтобы включить deep-linking по хешу). Для доступности добавьте role='tab', aria-selected и навигацию стрелками.

jquery
<!-- HTML -->
<div class="tabs">
  <ul class="tab-nav">
    <li><a href="#tab1" class="active">Tab 1</a></li>
    <li><a href="#tab2">Tab 2</a></li>
    <li><a href="#tab3">Tab 3</a></li>
  </ul>
  <div id="tab1" class="tab-content active">Content 1</div>
  <div id="tab2" class="tab-content">Content 2</div>
  <div id="tab3" class="tab-content">Content 3</div>
</div>

<script>
$('.tab-nav').on('click', 'a', function (e) {
  e.preventDefault()
  const $a = $(this)
  $a.addClass('active').parent().siblings().find('a').removeClass('active')
  $($a.attr('href')).addClass('active').siblings().removeClass('active')
})
</script>

Аккордеон

Паттерны аккордеона: клик по заголовку переключает его содержимое. Вариант с одним открытым закрывает остальные при открытии одного (уберите блок .not($h) для нескольких открытых). Используйте aria-expanded, чтобы сообщить состояние скринридерам: CSS может стилизовать по нему (.acc-header[aria-expanded="true"] { ... }). slideToggle анимирует содержимое. Для заголовков используйте <button> (доступен с клавиатуры по умолчанию). При множестве элементов делегирование на родителе избавляет от привязки к каждому заголовку.

jquery
<!-- HTML -->
<div class="accordion">
  <div class="acc-item">
    <button class="acc-header" aria-expanded="false">Section 1</button>
    <div class="acc-content">Content 1</div>
  </div>
  <!-- more items -->
</div>

<script>
$('.accordion').on('click', '.acc-header', function () {
  const $h = $(this)
  const $c = $h.next('.acc-content')

  // close others (single-open accordion)
  $h.closest('.accordion')
    .find('.acc-header').not($h)
      .attr('aria-expanded', false)
      .next('.acc-content').slideUp()

  // toggle this one
  const isOpen = $h.attr('aria-expanded') === 'true'
  $h.attr('aria-expanded', !isOpen)
  $c.slideToggle()
})
</script>

Бесконечная прокрутка

Бесконечная прокрутка: определяйте, когда пользователь прокрутил близко к низу, загружайте ещё элементы и добавляйте их. Защищайтесь от параллельных загрузок (флаг loading). Когда сервер вернул пусто, отвязывайте обработчик scroll (больше попыток не нужно). Добавляйте через фрагмент для производительности. Троттлите обработчик scroll (он срабатывает много раз в секунду): через дебаунс/_.throttle или проверку флага loading (как здесь), чтобы пропускать, пока запрос в полёте. Современная альтернатива — IntersectionObserver на sentinel-элементе внизу.

jquery
let loading = false
let page = 1

function loadMore() {
  if (loading) return
  loading = true
  $('.loader').show()

  $.get('/api/items', { page: page })
    .done(function (items) {
      if (items.length === 0) {
        // no more items — unbind the scroll handler
        $(window).off('scroll.inf')
        return
      }
      const $frag = $(document.createDocumentFragment())
      items.forEach(item => {
        $frag.append($('<li>').text(item.name))
      })
      $('ul.items').append($frag)
      page++
    })
    .always(function () {
      loading = false
      $('.loader').hide()
    })
}

// trigger when near bottom
$(window).on('scroll.inf', function () {
  if ($(window).scrollTop() + $(window).height() > $(document).height() - 200) {
    loadMore()
  }
})

Живой поиск (с дебаунсом)

Живой поиск: по мере ввода запрашивайте сервер и показывайте результаты. Дебаунс обязателен: без него каждое нажатие отправляет запрос (быстрый набор = десятки запросов). Дебаунс ждёт N мс после последнего нажатия. 300 мс — хорошее значение по умолчанию. Всегда обрабатывайте пустой запрос (очищайте результаты). В production отменяйте текущие запросы при старте нового (используйте .abort() на предыдущем jqXHR), чтобы избежать ответов не по порядку. Современная альтернатива — AbortController с fetch.

jquery
// debounce: wait until user pauses typing
function debounce(fn, wait) {
  let timer
  return function () {
    clearTimeout(timer)
    const args = arguments
    const ctx = this
    timer = setTimeout(() => fn.apply(ctx, args), wait)
  }
}

// live search
const $input = $('#search')
const $results = $('#results')

$input.on('input', debounce(function () {
  const q = $(this).val()
  if (!q) { $results.empty(); return }

  $.get('/api/search', { q: q })
    .done(function (items) {
      $results.empty()
      items.forEach(item => {
        $results.append($('<li>').text(item.name))
      })
    })
}, 300))  // wait 300ms after last keystroke

// without debounce, a search fires on every keystroke (too many requests)

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.