freeCodeCamp

3.7 KiB

Raw Blame History

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 operador async em sua declaração. Isso irá dizer ao interpretador JS para que ele espere até que a Promise 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

3.7 KiB Raw Blame History