Debounce и throttle своими руками

Debounce и throttle своими рукамикогда ждать паузу, когда держать ритм и что умеет браузер

Ввод, прокрутка и изменение окна присылают события десятками в секунду. Пишем debounce и throttle без библиотек и разбираем, где их заменяют встроенные API браузера.

Раздел
JavaScript
Стек
JavaScriptDOMAbortControllerIntersectionObserver
Уровень
Средний
Опубликовано
Обновлено
Чтение
8 мин
Коротко
  • Debounce ждёт паузы, throttle задаёт максимальную частоту.
  • Сохраняйте this и аргументы, отдавайте последний вызов.
  • Для отрисовки при прокрутке берите requestAnimationFrame.
  • Видимость и размеры отслеживают наблюдатели, а не scroll и resize.
Как решаем
  1. Определите, нужен результат после паузы или во время движения
  2. Оберните обработчик в debounce или throttle с apply(this, args)
  3. Добавьте хвостовой вызов и метод cancel()
  4. Отменяйте устаревшие запросы через AbortController
  5. Замените scroll и resize наблюдателями, где это возможно

Две задачи, которые путают#

Браузер умеет генерировать события очень часто. При прокрутке scroll прилетает много раз в секунду, resize сыплется пачкой, пока пользователь тянет окно, а input срабатывает на каждую букву. Если на каждое событие запускать тяжёлую работу, например запрос к серверу или пересчёт раскладки, интерфейс начинает тормозить, а сервер получает десяток лишних запросов на одно слово.

Есть два способа сократить число вызовов, и их постоянно путают. Debounce ждёт паузы: функция выполняется, только когда события перестали приходить на заданное время. Throttle задаёт ритм: функция выполняется не чаще одного раза за интервал, пока события продолжаются. Разница видна на примере поиска. Debounce на 300 мс отправит один запрос, когда человек допечатал слово. Throttle на 300 мс будет слать запросы во время набора, примерно три раза в секунду.

СценарийЧто братьПочему
Поиск и автоподсказки при вводеdebounceнужен результат по законченному запросу
Автосохранение черновикаdebounceсохраняем, когда человек остановился
Индикатор прокрутки, параллаксthrottle или requestAnimationFrameкартинка должна меняться во время движения
Подгрузка ленты у конца страницыIntersectionObserverбраузер сам скажет, когда элемент виден
Перестройка графика по размеру блокаResizeObserverследит за элементом, а не за окном
Защита кнопки от двойного кликаdebounce с leadingпервый клик срабатывает сразу, повторы гасятся

Как это писали в 2012 году#

Классическая реализация держится на замыкании и паре setTimeout/clearTimeout. Каждый новый вызов отменяет предыдущий таймер и ставит новый, поэтому функция срабатывает только после тишины. Throttle запоминает время последнего запуска и пропускает вызовы, пока интервал не истёк.

JavaScript
// 2012: debounce и throttle на замыканиях
function debounce(fn, wait) {
  var timer = null;
  return function () {
    var ctx = this, args = arguments;
    clearTimeout(timer);
    timer = setTimeout(function () {
      fn.apply(ctx, args);
    }, wait);
  };
}

function throttle(fn, wait) {
  var last = 0;
  return function () {
    var now = new Date().getTime();
    if (now - last >= wait) {
      last = now;
      fn.apply(this, arguments);
    }
  };
}

var input = document.getElementById('q');
input.onkeyup = debounce(function () {
  search(this.value);
}, 300);

Главные детали этой версии живы до сих пор. Контекст this и arguments сохраняются в переменные до установки таймера: внутри анонимной функции, которую вызовет setTimeout, this будет уже другим. Без fn.apply(ctx, args) обработчик потеряет и элемент, и событие. Это та же проблема контекста, что мы разбирали в заметке о собственном классе твинов, где колбэк таймера тоже вызывается не от имени объекта.

У простого throttle есть изъян: он отбрасывает последний вызов. Если пользователь прокрутил страницу и остановился внутри интервала, финальное положение так и не обработается, и индикатор застынет чуть раньше конца. Поэтому в нормальных реализациях есть «хвостовой» вызов.

Leading и trailing: когда вызывать#

У обеих техник есть два края. Leading означает вызов на переднем фронте, сразу при первом событии серии. Trailing означает вызов на заднем фронте, после паузы или в конце интервала. Debounce по умолчанию работает по заднему фронту, а leading-режим удобен для кнопок: первое нажатие обрабатывается мгновенно, а повторы в течение интервала игнорируются. Throttle обычно включает оба края, чтобы реакция была быстрой и последнее состояние не терялось.

Ниже версия, которую мы используем в проектах без lodash. Debounce умеет оба режима и метод cancel(), throttle гарантирует хвостовой вызов с последними аргументами.

JavaScript
export function debounce(fn, wait, { leading = false, trailing = true } = {}) {
  let timer = null;
  let lastArgs = null;
  let lastThis = null;

  function debounced(...args) {
    const callNow = leading && timer === null;
    lastArgs = args;
    lastThis = this;
    clearTimeout(timer);
    timer = setTimeout(() => {
      timer = null;
      if (trailing && !callNow) fn.apply(lastThis, lastArgs);
      lastArgs = lastThis = null;
    }, wait);
    if (callNow) fn.apply(this, args);
  }

  debounced.cancel = () => {
    clearTimeout(timer);
    timer = lastArgs = lastThis = null;
  };
  return debounced;
}

export function throttle(fn, wait) {
  let last = -Infinity;
  let timer = null;
  let pending = null;

  return function throttled(...args) {
    const now = performance.now();
    const remaining = wait - (now - last);
    if (remaining <= 0) {
      clearTimeout(timer);
      timer = null;
      last = now;
      fn.apply(this, args);
    } else {
      pending = [this, args];
      timer ??= setTimeout(() => {
        last = performance.now();
        timer = null;
        const [ctx, a] = pending;
        fn.apply(ctx, a);
      }, remaining);
    }
  };
}

Обратите внимание на три мелочи. Время берётся из performance.now(): это монотонные часы, им не мешает перевод системного времени. Хвостовой вызов использует последние аргументы, а не те, что были при постановке таймера. Метод cancel() нужен, чтобы отложенный вызов не выстрелил после того, как компонент уже убран со страницы: иначе вы получите обновление состояния у несуществующего элемента.

Поиск при вводе: debounce плюс отмена запроса#

Debounce уменьшает число запросов, но не решает гонку ответов. Пользователь набрал «реакт», запрос ушёл, потом дописал «react hooks», ушёл второй. Если первый ответ придёт позже второго, на экране окажутся устаревшие результаты. Решение: отменять предыдущий fetch через AbortController.

JavaScript
const input = document.querySelector('#q');
let inflight = null;

const runSearch = debounce(async (query) => {
  inflight?.abort();
  inflight = new AbortController();
  try {
    const res = await fetch(`/api/search?q=${encodeURIComponent(query)}`, {
      signal: inflight.signal,
    });
    renderResults(await res.json());
  } catch (err) {
    if (err.name !== 'AbortError') throw err;
  }
}, 300);

input.addEventListener('input', (e) => runSearch(e.target.value));

Событие input здесь лучше, чем keyup из старого примера: оно срабатывает и при вставке мышью, и при вводе с экранной клавиатуры, и при автозаполнении. Параметры запроса кодируем через encodeURIComponent; разбор такой строки на стороне клиента описан в заметке про парсинг query string. А если ответ сервера отдаёт ваш PHP-бэкенд, не забудьте про подготовленные выражения PDO: поисковая строка приходит прямо от пользователя.

Что изменилось к 2026 году#

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

  • requestAnimationFrame вместо throttle для анимации. Если обработчик что-то рисует, ограничивайте его частотой кадров, а не произвольными 16 мс. Колбэк выполнится перед отрисовкой, и в фоновой вкладке браузер его приостановит.
  • Пассивные слушатели. Опция { passive: true } обещает браузеру, что обработчик не вызовет preventDefault(), и прокрутка не ждёт выполнения вашего кода. Для touchstart и wheel на уровне документа браузеры включают это поведение по умолчанию.
  • AbortController для снятия слушателей. Опция signal в addEventListener позволяет снять сразу все обработчики одним вызовом abort(), не храня ссылки на функции.
  • IntersectionObserver и ResizeObserver. Ленивую загрузку, бесконечную ленту и реакцию на размер блока больше не нужно строить на scroll и resize с троттлингом.
JavaScript
function rafThrottle(fn) {
  let frame = 0;
  let lastArgs;
  return (...args) => {
    lastArgs = args;
    if (frame) return;
    frame = requestAnimationFrame(() => {
      frame = 0;
      fn(...lastArgs);
    });
  };
}

const controller = new AbortController();

window.addEventListener(
  'scroll',
  rafThrottle(() => updateProgressBar(window.scrollY)),
  { passive: true, signal: controller.signal }
);

// при уходе со страницы или размонтировании компонента
controller.abort();

Наблюдатели закрывают самые частые причины, по которым раньше вешали обработчик на scroll. Они вызываются асинхронно и не заставляют пересчитывать раскладку на каждое событие, как это делал getBoundingClientRect() в обработчике прокрутки.

JavaScript
// вместо scroll + getBoundingClientRect
const io = new IntersectionObserver((entries) => {
  for (const entry of entries) {
    if (entry.isIntersecting) loadMore();
  }
}, { rootMargin: '200px' });
io.observe(document.querySelector('#sentinel'));

// вместо window.resize, если важен размер конкретного блока
const ro = new ResizeObserver(([entry]) => {
  chart.resize(entry.contentRect.width);
});
ro.observe(document.querySelector('.chart'));

ResizeObserver особенно полезен для компонентов: блок может поменять ширину без изменения окна, например при открытии боковой панели. Для чисто визуальных правок по ширине сначала подумайте о container queries в CSS: часто JavaScript там вообще не нужен.

Короткий чек-лист#

  1. Нужен результат после паузы: debounce, обычно 200-400 мс для ввода.
  2. Нужна реакция во время движения: throttle, а если код рисует, то requestAnimationFrame.
  3. Нужно знать, что элемент виден или изменил размер: наблюдатели вместо событий окна.
  4. Сохраняйте this и аргументы, отдавайте последний вызов, давайте способ отмены.
  5. Слушатели прокрутки делайте пассивными и снимайте через signal.

И пара слов о тестировании. Код с таймерами неприятно проверять реальным ожиданием: тесты становятся медленными и нестабильными. В Jest и Vitest есть поддельные таймеры (useFakeTimers), которые позволяют мгновенно «прокрутить» время и проверить, что функция вызвана ровно один раз и с последними аргументами. Отдельно проверяйте cancel(): после него отложенный вызов не должен случиться никогда.

Если в проекте уже есть lodash, его debounce и throttle поддерживают опции leading, trailing и maxWait, и тащить свою реализацию незачем. Свои двадцать строк оправданы, когда библиотеку ради двух функций подключать не хочется. Больше заметок о браузерном коде собрано в разделе JavaScript.

2края вызова: leading и trailing
passive: trueпрокрутка не ждёт обработчик
signalснятие слушателей через abort()

«Debounce ждёт, пока пользователь закончит; throttle отвечает, пока он ещё двигается.»

Главный вывод заметки

Вопросы и ответы

Вопросы и ответы

Какую задержку ставить для debounce при поиске?
Обычно 200-400 мс. Меньше почти не экономит запросы, больше ощущается как задержка интерфейса. Проверьте на реальных пользователях: при медленном наборе на телефоне иногда разумно увеличить паузу, а отмену устаревших запросов через AbortController добавить в любом случае.
Почему внутри debounced-функции пропадает this?
Функцию вызывает setTimeout, а не элемент, поэтому контекст теряется. Сохраните this в момент вызова обёртки (или используйте обычную функцию-обёртку и стрелочную внутри таймера) и вызывайте исходный обработчик через fn.apply(ctx, args).
Чем throttle отличается от requestAnimationFrame?
Throttle ограничивает вызовы произвольным интервалом в миллисекундах. requestAnimationFrame привязывает вызов к отрисовке кадра и приостанавливается в фоновых вкладках. Для визуальных изменений лучше кадр, для запросов к серверу и логирования лучше throttle с явным интервалом.
Нужен ли debounce, если я использую IntersectionObserver?
Как правило, нет. Наблюдатель вызывает колбэк только при пересечении заданных порогов видимости, а не на каждый пиксель прокрутки. Дополнительное ограничение может понадобиться, если в колбэке вы запускаете дорогую загрузку и хотите не дублировать её при быстрой прокрутке.
Заметка обновлена 12 ноября 2026: код проверен на актуальных версиях, добавлены современные варианты.

Читайте также