3.7 KiB
title | localeTitle |
---|---|
Await Promises | Aguardar Promessas |
Aguardar Promessas
Os operadores async
/ await
facilitam a implementação de muitas promessas assíncronas. Eles também permitem que os engenheiros escrevam códigos mais claros, mais sucintos e testáveis.
Para entender esse assunto, você deve ter uma compreensão sólida de como as Promessas funcionam.
Sintaxe Básica
function slowlyResolvedPromiseFunc (string) {
return new Promise (resolve => {
setTimeout (() => { resolver (string); }, 5000);
});
}
função assíncrona doIt () {
const myPromise = aguardar lentamenteResolvedPromiseFunc ("foo");
console.log (myPromise); // "foo"
}
faça();
Há outras coisas para se prestar atenção:
- A função que contém alguma declaração de
await
precisa incluir o operadorasync
em sua declaração. Isso irá dizer ao interpretador JS para que ele espere até que aPromise
seja resolvida ou rejeitada. - O operador
await
precisa ser declarado inline.const something = await thisReturnsAPromise()
- Isso funciona tanto para a rejeição ou a resolução de uma
Promise
.
Promises aninhadas vs. Async
/ Await
Implementar uma unica promise é muito facil. Por outro lado promises aninhadas ou a criação de uma "dependency pattern" pode produzir um código spagetti.
Os exemplos a seguir assumem que request-promise
está disponível como rp
.
Promises encadeadas/aninhadas
// Primeira Promisse
const fooPromise = rp("http://domain.com/foo");
fooPromise.then(resultFoo => {
// deve esperar por "foo" para resolver
console.log (resultFoo);
})
const barPromise = rp("http://domain.com/bar");
const bazPromise = rp("http://domain.com/baz");
Promise.all([barPromise, bazPromise])
.then(resultArr => {
// Lidar com as resoluções "bar" e "baz" aqui
console.log(resultArr [0]);
console.log(resultArr [1]);
});
async
and await
Promises
// Enrole tudo em uma função assíncrona função assíncrona
async doItAll () {
// Pega dados do ponto de extremidade "foo", mas aguarde a resolução
console.log (await rp("http://domain.com/foo"));
// Concorrência aconteceConcurrently kick off the next two async calls,
// não espere por "bar" para disparar "baz"
const barPromise = rp("http://domain.com/bar");
const bazPromise = rp("http://domain.com/baz");
// Depois que as duas foram disparadas, espere pelas duas
const barResponse = await barPromise;
const bazResponse = await bazPromise;
console.log(barResponse);
console.log(bazResponse);
}
// Finalmente, invoque a função assíncrona
doItAll().then(() => console.log ('Feito!'));
As vantagens de usar async
e await
deve estar claro. O codigo é mais modular, testavel e legível.
Entretanto há um senso de concorrencia, os processos computacionais que ocorrem são os mesmos do exemplo anterior.
Lidando com Errors / Rejection
Um bloco try-catch
consegue lidar com rejeição de promises.
async errorExample () {
try {
const rejectedPromise = await Promise.reject ("Oh-oh!");
} catch (erro) {
console.log (erro);
}
errorExample ();
Mais Informações:
await
Operador MDN Docs- Documentos do MDN do operador de funções
async