JavaScript Promises

 

As Promises são uma maneira de lidar com código assíncrono em JavaScript de forma mais legível e organizada. Uma Promise representa um valor que pode estar disponível agora, no futuro ou nunca. Quando uma operação assíncrona é iniciada, ela retorna uma Promise imediatamente e o código pode continuar a ser executado sem esperar pelo resultado.

Uma Promise pode estar em três estados diferentes:

• Pending (pendente): a Promise está em execução e ainda não foi resolvida nem rejeitada;
• Fulfilled (cumprida): a operação foi concluída com sucesso e a Promise foi resolvida, retornando um valor;
• Rejected (rejeitada): a operação falhou e a Promise foi rejeitada, retornando um motivo.

Para criar uma Promise, usamos a sintaxe new Promise() passando uma função com dois parâmetros: resolve e reject. Dentro dessa função, colocamos o código assíncrono que queremos executar e chamamos resolve quando a operação é concluída com sucesso ou reject quando ocorre um erro.

Por exemplo, podemos criar uma Promise que espera 2 segundos e retorna uma mensagem de sucesso:

javascript
const minhaPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Operação concluída com sucesso!');
  }, 2000);
});

Podemos então usar o método .then() para lidar com o valor retornado pela Promise quando ela for resolvida:

javascript
minhaPromise.then((mensagem) => {
  console.log(mensagem); // "Operação concluída com sucesso!"
});

Também podemos usar o método .catch() para lidar com o motivo pelo qual a Promise foi rejeitada:

javascript
minhaPromise.catch((motivo) => {
  console.log(motivo); // "Ocorreu um erro!"
});

Outra forma de lidar com várias Promises é usando o método Promise.all(). Esse método recebe um array de Promises e retorna uma Promise que é resolvida quando todas as Promises no array forem resolvidas, retornando um array com os valores correspondentes. Se uma das Promises for rejeitada, a Promise retornada pelo Promise.all() também será rejeitada.

javascript
const promessa1 = Promise.resolve(1);
const promessa2 = new Promise((resolve) => setTimeout(resolve, 2000, 2));
const promessa3 = new Promise((resolve, reject) =>
  setTimeout(reject, 1000, 'Ocorreu um erro!')
);

Promise.all([promessa1, promessa2, promessa3])
  .then((valores) => console.log(valores)) // nunca é executado
  .catch((motivo) => console.log(motivo)); // "Ocorreu um erro!"

Por fim, as Promises também podem ser encadeadas usando o método .then(), criando uma sequência de operações assíncronas. O valor retornado por uma Promise é passado como argumento para o próximo .then(). Podemos encadear várias Promises para executar uma sequência de operações assíncronas de forma organizada e legível.

javascript
new Promise((resolve) => resolve('Primeira mensagem'))
  .then((mensagem) => {
    console.log(mensagem); // "Primeira mensagem"
    return 'Segunda mensagem';
  })
  .then
mensagem) => {
console.log(mensagem); // "Segunda mensagem"
return 'Terceira mensagem';
})
.then((mensagem) => {
console.log(mensagem); // "Terceira mensagem"
})
.catch((erro) => {
console.error(erro);
});
((

Neste exemplo, criamos uma nova Promise que retorna a string "Primeira mensagem" quando resolvida. Em seguida, encadeamos duas chamadas do método then(), que recebe a mensagem da promise anterior e retorna uma nova mensagem. Por fim, adicionamos um último método then() que recebe a última mensagem retornada. Caso ocorra algum erro, o método catch() é chamado para tratá-lo.