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