es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Existe alguna forma de retornar todas las promesas exitosas de fetch hasta que falle una?

La función de JavaScript Promise.allSettled espera a que todas las promesas resueltas o rechazadas terminen. Promise.all no devolverá las promesas resueltas si alguna de ellas es rechazada, y Promise.race y Promise.any solo dan la primera promesa resuelta o cumplida.

¿Existe alguna forma de enviar varias promesas (digamos 100) y luego, tan pronto como una falle (quizás con 20 exitosas), cancelar las promesas no resueltas (de las cuales hay 100 – 20 – 1 = 79 sin resolver)? Ni siquiera necesito los detalles de cuáles fallaron, sino más bien una especie de función Promise.someSettled.

Para contextualizar, estoy mapeando entre datos y llamadas fetch, y me gustaría saber qué fetches deben volver a intentarse.

¿Es eso posible?

Tags:  ,

Answer

  1. Avatar for davy.ai

    Sí, es posible lograr esta funcionalidad utilizando una combinación de Promise.race y Promise.allSettled.

    Aquí hay un ejemplo de implementación:

    const promises = []; // arreglo de 100 promesas
    
    for (let i = 0; i < 100; i++) {
      promises.push(fetchData(i)); // fetchData devuelve una promesa
    }
    
    const settledPromises = Promise.allSettled(promises);
    const firstToFail = Promise.race(promises);
    
    firstToFail.catch(() => {
      // Cancelar todas las promesas restantes
      settledPromises.then((results) => {
        const failedIndexes = [];
    
        // Encontrar todas las promesas fallidas
        for (let i = 0; i < results.length; i++) {
          if (results[i].status === 'rejected') {
            failedIndexes.push(i);
          }
        }
    
        console.log(`Reintentando fetches en los índices: ${failedIndexes}`);
      });
    });
    

    En este ejemplo, comenzamos creando un arreglo de 100 promesas. Luego utilizamos Promise.allSettled para esperar a que todas las promesas se resuelvan (ya sea resueltas o rechazadas). También utilizamos Promise.race para obtener la primera promesa que falla.

    Si una promesa falla, capturamos el error y utilizamos el arreglo settledPromises para encontrar todas las promesas fallidas. Luego podemos utilizar esta información para volver a intentar las recuperaciones fallidas.

    Tenga en cuenta que esta implementación asume que solo hay una promesa que fallará. Si varias promesas pueden fallar, deberemos modificar la implementación para manejar este caso.

Comments are closed.