Async/await ainda pode te surpreender... MUITO!

Eu amo tecnologia ❤, e o fato de que não importa o quanto você saiba ainda vai existir algo para te supreender. Algum tempo atras, um amigo meu (@Rafael_Toscano) me mostrou algo e minha reação automática foi mais ou menos assim:

Ele compartilhou comigo um artigo do blog da V8 sobre "Faster async functions and promises." e entre várias coisas interessantes, uma particular capturou minha atenção de uma forma que na hora eu pensei "Isso não pode ser real, vou ter que testar."

Era sobre o comportamento do async/await e como podem ser usados com qualquer função que seja considerada "thenable". O que isso significa? Qualquer objeto que tenha um método then() pode ser usado com async/await

No artigo ele da o seguinte exemplo:

class Sleep {
  constructor(timeout) {
    this.timeout = timeout;
  }
  then(resolve, reject) {
    const startTime = Date.now();
    setTimeout(() => resolve(Date.now() - startTime),
               this.timeout);
  }
}

(async () => {
  const actualTime = await new Sleep(1000);
  console.log(actualTime);
})();

Yeaaah, por favor me diz que não fui só eu que ficou tão surpreso.

Acho que ajuda a gente a entender um pouco mais sobre como async/await funciona e as possibilidades das coisas que podemos fazer fazer. Mas como diria tio Ben, isso tudo vem com grandes responsabilidades também, não vai sair colocando objetos com then no projeto só para parecer fodão 💣

Você provavelmente nunca vai precisar de usar async/await dessa forma direta e se você encontrar um caso de uso para isso por favor compartilha com a gente. Um caso que eu considerei foi para implementar algo chamado "retry strategy", segue o exemplo:

const ServerMock = {
  count: 0,
  getData() {
    if (this.count === 2) {
      return Promise.resolve([{ name: "SomeName" }]);
    } else {
      this.count++;
      return Promise.reject("Error");
    }
  }
};

function fetchData(limit, time) {
  return {
    then(resolve, reject) {
      const retry = setInterval(async () => {
        limit--;
        try {
          console.log("Trying....");
          const data = await ServerMock.getData();
          if (data) {
            console.log("Resolve");
            clearInterval(retry);
            resolve(data);
          }
        } catch {
          if (limit === 0) {
            clearInterval(retry);
            reject("Limit Reached");
          }
        }
      }, time);
    }
  };
}

(async () => {
  try {
    const result = await fetchData(3, 1000);
    console.log(result);
  } catch (err) {
    console.log(err);
  }
})();

Me diz o que você achou sobre essa nova descoberta nos comentários...

Comments

[Tadeu Barbosa]

Nossa, que da hora! Bem interessante isso!
Claro, não é algo para se aplicar em qualquer lugar, como você disse haha, mas ajuda a entender melhor o funcionamento do async/await.