Promise.race en JavaScript: Resolviendo la Promesa Más Rápida

El método Promise.race en JavaScript permite ejecutar varias promesas en paralelo y obtener el resultado de la primera que se resuelva o rechace. A diferencia de Promise.all, que espera que todas las promesas finalicen, Promise.race se resuelve tan pronto como cualquiera de las promesas en el array haya finalizado, lo que es útil en situaciones donde solo necesitas el primer resultado disponible.

¿Qué es Promise.race y Cuándo Usarlo?

Este método es ideal para situaciones en las que necesitas la respuesta más rápida entre varias promesas. Por ejemplo, puedes usarlo para establecer límites de tiempo para una operación o para elegir la primera de varias tareas que se complete.

sintaxis básica:

Promise.race([promesa1, promesa2, promesa3])
  .then(resultado => {
    // Maneja el primer resultado que se resuelva
  })
  .catch(error => {
    // Maneja el error si la primera promesa rechazada fue la que terminó primero
  });

La sintaxis básica de Promise.race es similar a la de otros métodos de promesas. Toma un array de promesas y devuelve una promesa que se resuelve o rechaza tan pronto como cualquiera de las promesas en el array se complete.

Casos Comunes de Uso

• Establecer un tiempo límite para una operación asíncrona y cancelar la tarea si toma demasiado tiempo.
• Obtener la respuesta más rápida entre múltiples solicitudes a diferentes fuentes.
• Crear operaciones de respaldo en caso de fallas o retrasos en una tarea primaria.

Ejemplo Básico: Obteniendo el Primer Resultado

Supongamos que tienes tres promesas que simulan tareas con diferentes tiempos de espera. Promise.race devolverá el resultado de la promesa que termine primero, ignorando las demás.

let promesa1 = new Promise(resolve => setTimeout(() => resolve("Promesa 1 completada"), 3000));
let promesa2 = new Promise(resolve => setTimeout(() => resolve("Promesa 2 completada"), 2000));
let promesa3 = new Promise(resolve => setTimeout(() => resolve("Promesa 3 completada"), 1000));

Promise.race([promesa1, promesa2, promesa3])
  .then(resultado => {
    console.log(resultado);
  })
  .catch(error => {
    console.log("Error en la primera promesa terminada:", error);
  });

"Promesa 3 completada"

En este ejemplo Promise.race devuelve el resultado de promesa3 porque es la que termina primero.

Limitando el Tiempo de Ejecución de una Promesa con Promise.race

Uno de los usos más comunes de Promise.race es establecer un tiempo límite para una operación asíncrona. En este caso creamos una promesa que se rechaza después de un tiempo específico para que este método pueda usarla como límite de tiempo.

Ejemplo: Límite de Tiempo para una Solicitud

function solicitudConLimiteDeTiempo(promesa, tiempoLimite) {
  let limite = new Promise((_, reject) =>
    setTimeout(() => reject("Tiempo límite alcanzado"), tiempoLimite)
  );

  return Promise.race([promesa, limite]);
}

let solicitud = new Promise(resolve => setTimeout(() => resolve("Solicitud completada"), 3000));

solicitudConLimiteDeTiempo(solicitud, 2000)
  .then(resultado => console.log(resultado))
  .catch(error => console.log("Error:", error));

"Error:"
"Tiempo límite alcanzado"

En el ejemplo anterior, si la promesa de solicitud tarda más de 2000 ms en completarse, Promise.race devuelve el error “Tiempo límite alcanzado”.

Manejo de Errores en Promise.race

Si la primera promesa en ser rechazada es la que termina primero Promise.race devuelve el error asociado a esa promesa. Esto es importante en operaciones donde puede haber errores entre varias promesas.

Ejemplo con Promesa Rechazada Primero

let promesaExitosa = new Promise(resolve => setTimeout(() => resolve("Éxito"), 3000));
let promesaFallida = new Promise((_, reject) => setTimeout(() => reject("Error en promesa"), 1000));

Promise.race([promesaExitosa, promesaFallida])
  .then(resultado => console.log("Resultado:", resultado))
  .catch(error => console.log("Error capturado:", error));

"Error capturado:"
"Error en promesa"

En el código anterior Promise.race captura el error de promesaFallida porque es la que termina primero.

Consideraciones al Usar Promise.race

1. Primer Resultado o Error: Promise.race no garantiza que todas las promesas se completen, solo devuelve la primera que se resuelve o rechaza.
2. Uso para Limitar Tiempos de Ejecución: Es excelente para establecer límites de tiempo en operaciones asíncronas.
3. Ignorar Promesas Restantes: Las promesas que terminan después de la primera no afectarán el resultado, lo cual puede ser ventajoso en algunas aplicaciones.

Conclusión

Promise.race es una herramienta poderosa en JavaScript para manejar situaciones donde solo necesitas la primera promesa que termine ya sea con éxito o error. Permite optimizar tiempos de espera, crear límites de ejecución y simplificar el código en escenarios donde la rapidez es clave. Con este método puedes garantizar que siempre tendrás un resultado, ya sea el valor de la primera promesa o un mensaje de error.

En el próximo artículo veremos Promise.allSettled en JavaScript, que devuelve el estado de todas las promesas, sin importar si se resuelven o se rechazan.