Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / JavaScript

`throttle`: limitar a frequência de execução de uma função

`throttle` limita a frequência de execução de uma função mesmo quando as chamadas são contínuas. Pode reduzir o trabalho durante o deslocamento numa página.

Versão: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxe

const limited = throttle(fn, intervalMs, now);
limited(...args);
// Signature of the helper defined below; now is a function returning milliseconds.

throttle é um nome habitual para uma função auxiliar, não uma função incorporada no ECMAScript nem uma API padrão do navegador. Devolve uma função envolvente que limita a frequência com que fn é iniciada. Por exemplo, podes atualizar a interface com menor frequência durante o deslocamento numa página. Cria a função envolvente uma só vez e reutiliza-a: cada uma guarda o instante do seu último arranque.

No exemplo, a primeira chamada executa fn de imediato (leading edge). Outra chamada pode executá-la quando tiverem decorrido pelo menos intervalMs desde o arranque anterior. As chamadas que chegam demasiado cedo devolvem undefined, não prolongam o intervalo e não ficam em fila de espera. Uma chamada aceite encaminha this e os argumentos e devolve o resultado de fn ou propaga a sua exceção.

Outras variantes podem executar a última chamada pendente no fim do intervalo (trailing edge). Aqui, a simples passagem do tempo não desencadeia nada. Um debounce típico que atua no fim aguarda uma pausa nas chamadas; throttle pode continuar a executar a função mesmo sem uma pausa.

Fornece um intervalo positivo e finito e uma função de relógio now que devolva valores finitos e não decrescentes em milissegundos. O exemplo usa um relógio simulado; num navegador podes passar () => performance.now(). É uma API da plataforma Web: verifica a disponibilidade no ambiente de execução de destino. Se outra variante usar setTimeout(), a sua função de retorno pode ser executada mais tarde do que o previsto.

Exemplos

{
  function throttle(fn, intervalMs, now) {
    let lastRun;
    return function (...args) {
      const time = now();
      if (lastRun !== undefined && time - lastRun < intervalMs) {
        return undefined;
      }
      lastRun = time;
      return Reflect.apply(fn, this, args);
    };
  }

  let time = 0;
  const panel = {
    prefix: "Update",
    update: throttle(function (label) {
      console.log(`${this.prefix}: ${label}`);
    }, 100, () => time),
  };

  panel.update("A");
  time = 40;
  panel.update("B");
  time = 100;
  panel.update("C");
  time = 140;
  panel.update("D");
}

Resultado

Update: A
Update: C

A é executada aos 0 ms, B é ignorada aos 40 ms, C é executada exatamente no limite de 100 ms e D é ignorada aos 140 ms, sem ser executada mais tarde.

Lições relacionadas

  • JavaScript · Lição 21 · Básico · Versão: 4

Fontes