Skip to content

Latest commit

 

History

History
137 lines (90 loc) · 4.33 KB

26.descubra_timers_javascript.md

File metadata and controls

137 lines (90 loc) · 4.33 KB
Raw

Descubra timers JavaScript

Índice

setTimeout()

Ao escrever código JavaScript, você pode querer atrasar a execução de uma função.

Este é o trabalho de setTimeout(). Você especifica uma função de retorno de chamada para executar mais tarde e um valor que expressa quanto tempo depois você deseja que ela seja executada, em milisegundos:

setTimeout(() => {
  // executa depois de 2 segundos
}, 2000);

setTimeout(() => {
  // executa depois de 50 milisegundos
}, 50)

Essa sintaxe define uma nova função. Você pode chamar qualquer outra função que desejar ou pode passar um nome de função existente e um conjunto de parâmetros:

const myFunction = (firstParam, secondParam) => {
  // faz alguma
};

// executa depois de 2 segundos
setTimeout(myFunction, 200, firstParam, secondParam);

setTimeout retorna o ID do temporizador. Isso geralmente não é usado, mas você pode armazenar esse id e limpá-lo se quiser excluir esta execução de função:

const id = setTimeout(() => {
  // vdeve executar depois 2 segundos
}, 2000);

/ Eu mudei minha mente
clearTimeout(id/);

Zero delay

Se você especificar o tempo limite para 0, a função de retorno de chamada será executado o mais rápida possível, mas após a execução da função atual:

setTimeout(() => {
  console.log('after ');
}, 0);

console.log(' before ');

Este código será impresso

before
after

Isso é especialmente útil para evitar o bloqueio da CPU em tarefas intensivas e permitir que outras funções sejam executadas durante a execução de um cálculo pesado, enfileirando funções no escalonador.

Alguns navegadores (IE e Edge) implementam um método setTimeout() que faz exatamente a mesma funcionalidade, mas não é padrão e não está disponível em outros navegadores. Mas é uma função padrão no Node.js.

setInterval()

setInterval() é uma função semelhante a setTimeout(), com uma diferença: em vez de executar a função de retorno de chamada uma vez, ela a executará para sempre, no intervalo de tempo específico que você especificar (em milissegundos):

setInterval(() => {
  // é executado a cada 2 segundos
}, 2000);

A função acima é executada a cada 2 segundos, a menos que você diga para ela parar, usando clearInterval(), passando o ID do intervalo que setInteval() retornou:

const id = setInterval(() => {
  // é executado a cada 2 segundos
}, 2000);

clearInterval(id);

É comum chamar clearInterval() dentro da função de retorno de chamada setInterval(), para permitir que ela determine automaticamente se deve ser executada novamente ou parar. Por exemplo, este código executa algo, a menos que App.somethingIWait tenha o valor chegado:

const interval = setInterval(() => {
  if (App.somethingIWait == 'arrived') {
    clearInterval(interval);
  }
  // caso contrário, faça as coisas
}, 100);

setTimeout recursivo

setInterval() inicia uma função a cada n milissegundos, sem qualquer consideração sobre quando uma função terminou sua execução.

Se uma função sempre leva a mesma quantidade de tempo, está tudo bem:

Talvez a função leve tempos de execução diferentes, dependendo das condições da rede, por exemplo:

E talvez uma longa execução se sobreponha à próxima:

Para evitar isso, você pode agendar um setTimeout() recursivo para ser chamado quando a função de retorno de chamada terminar:

const myFunction = () => {
  // faz alguma coisa

  setTimeout(myFunction, 1000);
};

setTimeout(myFunction, 1000);

Para alcançar este cenário:

setTimeout() e setInterval() estão disponíveis no Node.js, por meio do módulo Timers.

O Node.js também fornece setImmediate(), que é equivalente a usar setTimeout(() => {}, 0), usado principalmente para trabalhar com o Event Loop do Node.js.