Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / JavaScript

Debounce et throttle : contrôler les appels de fonction

Le debounce reporte l’exécution jusqu’à ce qu’une série d’appels s’interrompe, tandis que le throttle limite la fréquence d’exécution pendant cette série. Distinguez les variantes leading et trailing : elles déterminent si le premier appel, le dernier ou les deux sont conservés.

Version : ECMAScript and Web APIs; exact feature edition and browser support reviewed per entry; Node 24 in repository does not prove browser API support

Syntaxe

const debounced = debounce(fn, wait);
const throttled = throttle(fn, wait);
debounced(...args);
throttled(...args);

debounce / throttle sont des modèles de contrôle des appels, et non des fonctions intégrées à ECMAScript. Un debounce trailing exécute une fonction après une période de silence de wait : chaque nouvel appel annule le minuteur précédent et en programme un autre. Il conserve les derniers arguments et this. Cela convient, par exemple, pour lancer une recherche après une pause de saisie ; des appels continus peuvent reporter l’exécution indéfiniment.

Le throttle limite la fréquence d’exécution même lorsque les appels continuent d’arriver. La variante leading de l’exemple exécute immédiatement le premier appel, puis écarte les suivants jusqu’à ce qu’un minuteur la débloque. Elle n’exécute pas le dernier appel écarté. Elle peut servir à limiter la fréquence du traitement du défilement. Leading signifie une exécution au début d’une fenêtre ; trailing, une exécution différée à sa fin. Les implémentations peuvent proposer les deux variantes : définissez explicitement ces règles.

L’exemple utilise la syntaxe ECMAScript 2015 ainsi que setTimeout() et clearTimeout() du navigateur, définis par HTML et non par ECMAScript. Les minuteurs sont disponibles dans les contextes window et worker ; leur prise en charge dans Node 24 ne prouve pas celle de l’API navigateur. Dans le navigateur, setTimeout() convertit le délai en entier signé sur 32 bits. Par exemple, 2147483648 ms devient une valeur négative qui est traitée comme zéro. Un délai ne garantit pas une heure d’exécution exacte : d’autres tâches peuvent la retarder et les minuteurs suffisamment imbriqués ont un minimum de 4 ms. Ce n’est pas un mécanisme temps réel.

Créez le wrapper une fois et réutilisez-le ; le recréer pour chaque événement fait perdre l’état partagé. L’exemple suppose un fn valide et une valeur entière de wait en millisecondes telle que 0 <= wait && wait <= 2147483647. Il ne transmet pas la valeur de retour de la fonction et ne propose ni cancel(), ni flush(), ni maxWait. En production, prévoyez l’annulation du travail en attente lors du retrait d’un composant. Annuler un minuteur n’arrête pas une requête déjà lancée et ne protège pas contre les réponses obsolètes.

Exemples

function debounce(fn, wait) {
  let timer;
  return function (...args) {
    clearTimeout(timer);
    timer = setTimeout(() => {
      timer = undefined;
      fn.apply(this, args);
    }, wait);
  };
}

function throttle(fn, wait) {
  let blocked = false;
  return function (...args) {
    if (blocked) return;
    blocked = true;
    setTimeout(() => { blocked = false; }, wait);
    fn.apply(this, args);
  };
}

const debounced = debounce(value => console.log('debounce:', value), 50);
const throttled = throttle(value => console.log('throttle:', value), 50);

for (const value of ['A', 'B', 'C']) {
  debounced(value);
  throttled(value);
}

Résultat

throttle: A
debounce: C

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources