O que é uma promessa?

Uma promessa em JavaScript é como uma “promessa” que você faz de fazer algo no futuro. É um objeto que representa a eventual conclusão (ou falha) de uma tarefa assíncrona e seu valor resultante. Simplificando, uma promessa atua como um espaço reservado para um valor que ainda não está disponível, mas estará no futuro.

Estados prometidos

As promessas podem existir em um dos três estados:

1. Pendente: o estado inicial de uma promessa, onde ainda está aguardando a conclusão da tarefa assíncrona.
2. Cumprido: o estado em que a promessa é concluída com êxito e o valor resultante está disponível.
3. Rejeitado: o estado em que a promessa falha e um erro é retornado em vez do valor esperado.

Como funciona uma promessa?

Uma Promise é criada usando o construtor Promise, que usa dois parâmetros: resolver e rejeitar – ambos são funções.

Se a operação assíncrona for bem-sucedida, você chama a função de resolução para cumprir a promessa.
Se algo der errado, você chama a função de rejeição para indicar que a promessa foi rejeitada devido a um erro.
Você pode lidar com o resultado de uma promessa usando .then() para sucesso e .catch() para tratamento de erros.

Exemplo: Criando e Consumindo uma Promessa

const fetchData = new Promise((resolve, reject) => {
  // Simulate an asynchronous task like fetching data from a server
  setTimeout(() => {
    const data = "Some data from the server";

    // Simulate success and resolve the promise
    resolve(data);

    // You can also simulate an error by rejecting the promise
    // reject(new Error("Failed to fetch data"));
  }, 1000);
});

// Consuming the Promise
fetchData
  .then((data) => {
    console.log("Data fetched:", data);
  })
  .catch((error) => {
    console.error("Error fetching data:", error);
  });

O resolve(data) retornará os dados bem-sucedidos quando a promessa for cumprida.
Se algo der errado, rejeitar(error) gerará um erro que pode ser tratado com .catch().

O que é encadeamento de promessas?

Promise Chaining é o processo de execução de uma sequência de tarefas assíncronas, uma após a outra, usando Promises. Cada método .then() na cadeia é executado após o anterior ter sido cumprido.

Por que usar o encadeamento de promessas?

Ele permite que você escreva código limpo e legível para lidar com várias operações assíncronas em uma ordem específica. Cada .then() pode retornar um valor que é passado para o próximo .then() na cadeia, permitindo que você lide com as tarefas passo a passo.

Exemplo: encadeamento de múltiplas promessas

new Promise((resolve, reject) => {
  setTimeout(() => resolve(1), 1000); // Initial async task resolves with 1
})
  .then((result) => {
    console.log(result); // Logs: 1
    return result * 2;   // Returns 2 to the next .then()
  })
  .then((result) => {
    console.log(result); // Logs: 2
    return result * 3;   // Returns 6 to the next .then()
  })
  .then((result) => {
    console.log(result); // Logs: 6
    return result * 4;   // Returns 24 to the next .then()
  });

Neste exemplo:

A promessa começa resolvendo com 1 após 1 segundo.
Cada .then() subsequente recebe o resultado do anterior, duplica ou triplica e passa para o próximo .then().
O resultado é registrado passo a passo: 1, 2, 6.
Tratamento de erros no encadeamento
Você pode detectar qualquer erro na cadeia Promise usando .catch(). Se algum .then() falhar, a cadeia para e o erro é passado para o bloco .catch().

new Promise((resolve, reject) => {
  setTimeout(() => resolve(1), 1000);
})
  .then((result) => {
    console.log(result); // Logs: 1
    return result * 2;
  })
  .then((result) => {
    throw new Error("Oops, something went wrong!");
  })
  .catch((error) => {
    console.error("Caught error:", error.message); // Catches the error
  });

Principais benefícios das promessas

• Evita o inferno de retorno de chamada: as promessas simplificam o gerenciamento de múltiplas operações assíncronas, o que de outra forma leva a retornos de chamada profundamente aninhados (também conhecido como inferno de retorno de chamada).
• Tratamento de erros: você pode tratar todos os erros em uma cadeia com um único .catch() no final.
• Execução sequencial: o encadeamento de promessas garante que as tarefas assíncronas sejam executadas em ordem, tornando o código mais fácil de raciocinar.

Conclusão

As promessas são uma ferramenta poderosa em JavaScript para lidar com tarefas assíncronas. Com o Promise Chaining, você pode gerenciar várias operações assíncronas de maneira limpa, legível e sequencial. Ao entender como criar e consumir Promises e encadeá-las, você estará no caminho certo para dominar a programação assíncrona em JavaScript!