ФАЗА 35. БРАУЗЕР И CSS DOM events

Обязательно

Capture, target, bubble и делегирование

target · currentTarget · closest

Событие проходит элементы от корня к цели и обратно, а один обработчик контейнера может обслуживать множество потомков.

1. Событие проходит три фазы

1 / 5

Capture спускается от window к цели, target достигает элемента, bubble поднимается вверх по предкам.

  • Capture включается опцией.
  • Не каждое событие всплывает.
  • Фазы можно наблюдать логами.
Capture внизTargetBubble вверх

2. target и currentTarget отвечают на разные вопросы

2 / 5

target указывает исходный элемент события, currentTarget элемент, на котором зарегистрирован текущий обработчик.

  • Потомок может быть target.
  • Контейнер остаётся currentTarget.
  • closest ищет нужного предка.
target: источникcurrentTarget: слушатель

3. preventDefault и stopPropagation не взаимозаменяемы

3 / 5

preventDefault отменяет действие браузера, stopPropagation останавливает дальнейший путь события, но не его поведение по умолчанию.

  • Форма может отправиться без preventDefault.
  • Всплытие не равно default action.
  • stopImmediatePropagation останавливает и соседние обработчики.
Отменить действиеОстановить распространение

4. Делегирование сокращает число слушателей

4 / 5

Один обработчик на контейнере находит подходящий target.closest и обслуживает текущих и будущих потомков.

  • Новые элементы не требуют подписки.
  • Выход за контейнер исключается.
  • Динамические списки выигрывают.
Обработчик контейнераtargetclosestДействие элемента

5. Опции управляют производительностью и снятием

5 / 5

passive обещает не вызывать preventDefault, once снимает после вызова, AbortController удаляет группу слушателей.

  • Scroll не блокируется слушателем.
  • Ссылка функции важна для removeEventListener.
  • Signal упрощает cleanup.
addEventListenerРабота обработчикаonce или abort

События DOM: всплытие, погружение, делегирование

← назад к разделу

Клик на кнопке внутри списка — казалось бы, простая вещь. Но браузер не просто «стреляет» событие на элементе: оно проходит сквозь всё дерево DOM в три фазы. Понимание этого механизма позволяет писать обработчики эффективно, избегать лишних слушателей и не удивляться, когда stopPropagation ломает чужой код.

Три фазы: capture → target → bubble

Когда пользователь кликает по элементу, браузер создаёт событие и прогоняет его по дереву дважды.

  1. Capture (погружение) — событие идёт сверху вниз: document → html → body → … → целевой элемент. Обработчики в фазе capture вызываются первыми.
  2. Target — событие достигло целевого элемента. Оба типа обработчиков (capture и bubble) вызываются здесь.
  3. Bubble (всплытие) — событие идёт снизу вверх: целевой элемент → … → body → html → document. Большинство обработчиков слушают именно эту фазу.

Большинство событий всплывают. Исключения: focus, blur, scroll, load — они не всплывают (есть аналоги focusin/focusout, которые всплывают).

document body ul li target ul body document

Первые четыре шага это погружение (capture), последние три всплытие (bubble); обработчик без опций слушает второй проход.

addEventListener и опции

element.addEventListener("click", handler);           // bubble-фаза (по умолчанию)
element.addEventListener("click", handler, true);     // capture-фаза
element.addEventListener("click", handler, {
  capture: false, // bubble
  once: true,     // сработает один раз, затем удалится
  passive: true,  // не вызовет preventDefault — браузер не ждёт
});

once: true — удобная замена ручному removeEventListener для одноразовых обработчиков.

Задачи с собеседований на эту тему часто дают в React-коде: чек-боксы с useState, обработчик onChange. Не пугайтесь: механика слушателей та же, а «кто владеет состоянием поля» - это контролируемый ввод, разобранный в статье Формы в фазе React. Здесь во вспомогательном коде достаточно читать useState(value) как «переменная value с сеттером».

event.target и event.currentTarget

  • event.target — элемент, на котором произошло событие (по которому кликнул пользователь).
  • event.currentTarget — элемент, на котором установлен обработчик.
document.querySelector("ul").addEventListener("click", (e) => {
  console.log(e.target);        // <li> или <button> — куда кликнули
  console.log(e.currentTarget); // <ul> — где висит обработчик
});

При всплытии currentTarget меняется (каждый обработчик на пути получает «себя»), а target остаётся неизменным — это исходный элемент.

stopPropagation и preventDefault

event.stopPropagation() — останавливает распространение события: ни вверх по дереву, ни вниз дальше не идёт. Используйте с осторожностью: вышестоящий код может рассчитывать на то, что событие до него дойдёт. Модальные окна, аналитика, библиотеки компонентов часто слушают события на уровне document.

button.addEventListener("click", (e) => {
  e.stopPropagation(); // клик не всплывёт к родителям
  doSomething();
});

event.preventDefault() — отменяет действие браузера по умолчанию (переход по ссылке, отправка формы, скролл при колёсике). Не останавливает распространение.

link.addEventListener("click", (e) => {
  e.preventDefault(); // браузер не перейдёт по href
  handleNavigation(e.currentTarget.href);
});

stopPropagation нужен редко — чаще достаточно preventDefault. Бесконтрольный stopPropagation — популярный источник трудноуловимых багов в сложных интерфейсах.

Делегирование: один обработчик на контейнер

Вместо того чтобы вешать обработчик на каждый дочерний элемент — вешают один на родителя и внутри смотрят на event.target.

Без делегирования — обработчик на каждой кнопке:

document.querySelectorAll(".item button").forEach((btn) => {
  btn.addEventListener("click", handleDelete);
});

Проблема: при динамическом добавлении новых элементов придётся вешать обработчики заново.

С делегированием — один обработчик на список:

document.querySelector(".list").addEventListener("click", (e) => {
  const btn = e.target.closest("[data-action='delete']");
  if (!btn) return;
  const id = btn.closest(".item").dataset.id;
  handleDelete(id);
});

Element.closest(selector) идёт вверх по дереву и находит ближайшего предка (или сам элемент), соответствующего селектору. Если клик был по иконке внутри кнопки — e.target попадёт на иконку, а closest("[data-action]") найдёт саму кнопку.

Делегирование даёт два преимущества: меньше слушателей в памяти и автоматическая поддержка динамически добавленных элементов.

passive и производительность скролла

Браузер не знает заранее, вызовет ли обработчик preventDefault() на touchstart или wheel. Пока обработчик не завершится — браузер вынужден ждать, прежде чем начать скролл. Это создаёт задержку даже при пустом обработчике.

passive: true сообщает браузеру: «я не вызову preventDefault» — браузер сразу начинает скролл параллельно с вашим кодом.

document.addEventListener("touchstart", onTouch, { passive: true });
document.addEventListener("wheel", onWheel, { passive: true });

Если пометить обработчик passive: true и вызвать preventDefault() — браузер проигнорирует вызов и выдаст предупреждение в консоли.

Custom Events

Иногда нужно передать событие между несвязанными частями приложения без пробрасывания коллбэков вниз через пропсы.

// Создание и диспатч
const event = new CustomEvent("user:logout", {
  bubbles: true,        // всплывает по дереву
  composed: true,       // переходит через shadow DOM
  detail: { userId: 42 },
});
document.dispatchEvent(event);

// Подписка
document.addEventListener("user:logout", (e) => {
  console.log("Вышел пользователь:", e.detail.userId);
});

bubbles: true позволяет слушать событие на любом предке — это то же делегирование, но для кастомных событий.

Как это работает в React

React не вешает обработчики напрямую на DOM-элементы. Начиная с React 17, все обработчики регистрируются на корневом контейнере (root). Это собственное делегирование React.

<button onClick={handleClick}>Нажать</button>
// React вешает обработчик на root, не на <button>

Синтетические события. React оборачивает нативное событие в SyntheticEvent — объект с тем же интерфейсом, но кросс-браузерный. До React 17 события объединялись в пул и обнулялись после обработчика (поэтому нельзя было хранить event в setTimeout). С React 17 пулинг убран — event живёт столько, сколько нужно.

e.stopPropagation() в React останавливает всплытие в дереве React-компонентов. Нативный addEventListener на том же элементе может сработать раньше или позже в зависимости от того, на каком уровне зарегистрирован — это нужно учитывать при смешивании React и нативных обработчиков.

Дополнительно: при первом чтении можно пропустить

Глубже: AbortController снимает слушатели пачкойрасширенное

Компонент повесил пять обработчиков на window и document: resize, scroll, keydown, click вне себя, visibilitychange. При размонтировании каждый надо снять, и для removeEventListener нужна та же ссылка на функцию, что и при подписке. Стрелка, написанная прямо в addEventListener, снять себя не даст. Опция signal решает это одним объектом:

const ac = new AbortController();
window.addEventListener("resize", onResize, { signal: ac.signal });
document.addEventListener("keydown", onKey, { signal: ac.signal });
document.addEventListener("click", onOutsideClick, { signal: ac.signal });

// размонтирование: все три слушателя сняты разом
ac.abort();

Тот же AbortController отменяет и fetch, который компонент запустил: один abort() в cleanup useEffect закрывает и подписки, и запросы. Снимать слушатели обязательно: обработчик держит ссылку на компонент и его состояние, и десяток размонтированных экранов с живыми resize это утечка памяти и обработчики, которые работают с уже несуществующим DOM.

Коротко

  • Событие проходит три фазы: capture (сверху вниз) → target → bubble (снизу вверх).
  • addEventListener по умолчанию слушает bubble-фазу; { capture: true } — capture-фазу.
  • event.target — элемент-источник; event.currentTarget — элемент с обработчиком.
  • stopPropagation останавливает распространение; применять осторожно — ломает чужих слушателей.
  • preventDefault отменяет действие браузера, не останавливает распространение.
  • Делегирование: один обработчик на контейнер + closest() — поддерживает динамические элементы и экономит память.
  • passive: true на touchstart/wheel убирает задержку скролла.
  • React 17+ регистрирует обработчики на root-контейнере — собственный вариант делегирования.

Что почитать дальше