Executando Múltiplas Promises com Segurança Usando Promise.allSettled em JavaScript

Ao realizar requisições assíncronas paralelas em JavaScript, o uso de Promise.all() pode interromper o processamento inteiro se apenas uma chamada falhar. O método nativo Promise.allSettled() resolve esse problema aguardando a conclusão de todas as promessas, retornando o status individual e os dados tanto das operações bem-sucedidas quanto das rejeitadas.

JavaScript

// Simulação de chamadas assíncronas (ex: requisições HTTP)
const buscarUsuario = () => Promise.resolve({ id: 1, nome: 'Lucas' });
const buscarPedidos = () => Promise.reject(new Error('Servidor indisponível (500)'));
const buscarNotificacoes = () => Promise.resolve(['Notificação 1', 'Notificação 2']);

async function carregarDashboard() {
  // Executa todas as promises em paralelo sem falhar o fluxo inteiro
  const resultados = await Promise.allSettled([
    buscarUsuario(),
    buscarPedidos(),
    buscarNotificacoes()
  ]);

  // Processa e exibe o estado de cada resultado
  resultados.forEach((resultado, indice) => {
    if (resultado.status === 'fulfilled') {
      console.log(`Promise ${indice + 1} com sucesso:`, resultado.value);
    } else {
      console.error(`Promise ${indice + 1} falhou:`, resultado.reason.message);
    }
  });
}

// Exemplo de uso prático funcionando
carregarDashboard();

Pontos-chave

• Garantia de Execução Completa: Ao contrário do Promise.all(), que entra no bloco de erro (fail-fast) na primeira falha, o Promise.allSettled() espera todas as promessas terminarem antes de resolver.
• Estrutura de Retorno Padronizada: Retorna um array de objetos, onde cada item contém a propriedade status ('fulfilled' ou 'rejected'), acompanhada de value (se resolvida) ou reason (se rejeitada).
• Casos de Uso Ideais: Perfeito para carregar dashboards ou dados independentes da interface, onde a falha de um componente não deve quebrar a renderização dos demais.
• Performance e Escalabilidade: Mantém o processamento concorrente e paralelo das requisições, garantindo respostas rápidas sem a necessidade de envolver cada chamada individual em um try/catch separado.