En este tutorial aprenderás a resolver y rechazar Promises en JavaScript de manera fácil y sencilla
En este tutorial te enseñaremos a resolver y rechazar Promises en JavaScript de una manera fácil y sencilla. Antes de comenzar, es importante entender qué son las Promises y por qué son útiles.
Las Promises son objetos en JavaScript que representan el resultado eventual de una operación asíncrona. En lugar de utilizar callbacks anidados que pueden dificultar la legibilidad del código, las Promises proveen una interfaz más clara y fácil de usar.
Una Promise puede estar en tres estados: pendiente, resuelta o rechazada. Cuando se crea la Promise, está en un estado pendiente. Luego, puede pasar al estado resuelta si la operación asíncrona se completó satisfactoriamente, o al estado rechazado si falló.
Para crear una Promise, utilizamos el constructor Promise, que toma una función callback con dos argumentos: resolve y reject. Resolve es llamado cuando la operación asíncrona se completa correctamente, y reject es llamado si ocurre un error.
Veamos un ejemplo:
const promise = new Promise((resolve, reject) => {
// Simulamos una operación asíncrona que se completa después de 2 segundos
setTimeout(() => {
const resultado = true;
if (resultado) {
resolve("La operación se completó correctamente.");
} else {
reject("La operación falló.");
}
}, 2000);
});
promise
.then((mensaje) => {
console.log(mensaje);
})
.catch((error) => {
console.error(error);
});
En este ejemplo, creamos una Promise que simula una operación asíncrona que se completa después de 2 segundos. Si la operación se completa satisfactoriamente, llamamos a resolve con un mensaje de éxito. Si falla, llamamos a reject con un mensaje de error.
Luego, utilizamos el método then para manejar el caso de éxito y el método catch para manejar el caso de error.
Es importante destacar que si queremos encadenar múltiples operaciones asíncronas, podemos utilizar el método then para pasar la resolución de una Promise a la siguiente. Por ejemplo:
const promise1 = new Promise((resolve) => {
setTimeout(() => resolve(1), 1000);
});
const promise2 = (valor) => {
return new Promise((resolve) => {
setTimeout(() => resolve(valor + 1), 1000);
});
};
promise1
.then((valor1) => promise2(valor1))
.then((valor2) => {
console.log(valor2);
});
En este ejemplo, creamos dos Promises. La primera se resuelve después de 1 segundo, devolviendo el valor 1. La segunda recibe ese valor como parámetro y se resuelve después de otros 1 segundo, devolviendo el valor incrementado en 1.
Al encadenar las Promises con el método then, el valor retornado por la primera es utilizado como parámetro para la segunda y así sucesivamente.
Las Promises son una herramienta poderosa para manejar operaciones asíncronas en JavaScript. Con este tutorial, has aprendido cómo crear, resolver y rechazar Promises, así como también cómo encadenar múltiples Promises para construir operaciones más complejas. Esperamos que esto haya sido de ayuda para ti. ¡A seguir programando!
Un Promise puede estar en tres estados: pendiente, resuelto o rechazado
En el mundo de JavaScript, las promises se han convertido en una herramienta indispensable en la programación asíncrona. Una promise es un objeto que representa el eventual resultado de una operación asincrónica. Sin embargo, lo que no todo el mundo tiene en cuenta es que un promise solo puede estar en uno de tres estados: pendiente, resuelto o rechazado.
Cuando creamos un promise, este siempre comienza en el estado pendiente. Esto significa que la operación asincrónica asociada al promise todavía no ha terminado y no sabemos si será exitosa o no.
Una vez que la operación asincrónica se completa con éxito, el promise se resuelve. Esto significa que el valor o la respuesta de la operación se pasan como argumento a la función resolve del promise. Por ejemplo, si estamos haciendo una solicitud a una API para obtener datos, el valor de la respuesta de la API se pasaría a resolve.
Por otro lado, si la operación asincrónica falla, el promise se rechaza. Esto significa que el motivo del error se pasa como argumento a la función reject del promise. Por ejemplo, si estamos haciendo una solicitud a una API y la conexión falla, el motivo del error se pasa a reject.
Es importante tener en cuenta que una vez que un promise se resuelve o se rechaza, no puede cambiar de estado. Esto significa que si un promise se resuelve exitosamente, no podemos cambiarlo para que se rechace más tarde y viceversa.
Para manejar un promise, podemos encadenar las funciones then y catch. La función then se llama cuando el promise se resuelve y la función catch se llama cuando el promise se rechaza. Por ejemplo:
fetch("https://jsonplaceholder.typicode.com/posts")
.then((response) => response.json())
.then((data) => console.log(data))
.catch((error) => console.error(error));
En este ejemplo, estamos haciendo una solicitud a la API de JSONPlaceholder para obtener una lista de publicaciones. Si la solicitud es exitosa, se llama a la función json en la respuesta para convertirla en un objeto JavaScript legible. Luego, los datos se pasan a console.log. Si algo sale mal, se llama a la función catch y se muestra un mensaje de error en la consola.
Los
promisesson una herramienta esencial en la programación asíncrona de JavaScript. Es importante recordar que tienen tres estados: pendiente, resuelto y rechazado, y que se manejan utilizando las funcionesthenycatch. Al seguir estas reglas, podemos escribir código más legible y confiable en nuestra pila de tecnología.
Para resolver una Promise, se utiliza el método ‘resolve’
Para resolver un Promise en JavaScript, se utiliza el método ‘resolve’. Este método devuelve una Promise que se resuelve con el valor dado. Es importante entender que una Promise se considera resuelta una vez que se ha ejecutado el método ‘resolve’.
La sintaxis completa es la siguiente:
Promise.resolve(valor);
Donde ‘valor’ es el resultado final que se desea obtener.
Un ejemplo de cómo usar este método sería el siguiente:
const promesa = new Promise((resolve, reject) => {
// Realizar una tarea asíncrona...
const resultado = "¡Tarea completa!";
if (resultado === "¡Tarea completa!") {
resolve(resultado);
} else {
reject("La tarea falló.");
}
});
promesa
.then((resultado) => {
console.log(resultado);
})
.catch((error) => {
console.log(error);
});
En este caso, creamos una Promise y hacemos una tarea asíncrona. Si se completa la tarea, llamamos al método ‘resolve’ y le pasamos el resultado deseado como parámetro. Después, utilizamos el método ’then’ para acceder al resultado y mostrarlo en la consola. Si la tarea falla, se llama al método ‘catch’ para manejar el error.
Ten en cuenta que también se puede resolver una Promise utilizando una función asíncrona. Esto se realiza utilizando la palabra clave ‘await’ para esperar el resultado de una Promise. Por ejemplo:
async function obtenerResultado() {
const resultado = awaitPromise.resolve("¡Tarea completada!");
console.log(resultado);
}
obtenerResultado();
En este caso, creamos una función asíncrona ‘obtenerResultado’ que espera el resultado de una Promise resuelta utilizando la palabra clave ‘await’. El resultado se muestra en la consola utilizando el método ‘console.log’.
Para resolver una Promise en JavaScript, se utiliza el método ‘resolve’. Este método devuelve una Promise que se resuelve con el valor dado. También se puede resolver una Promise utilizando una función asíncrona que espera el resultado utilizando la palabra clave ‘await’. Al conocer estas herramientas, podrás manejar las Promise y lograr aplicaciones más eficientes y efectivas.
Para rechazar una Promise, se utiliza el método ‘reject’
En el mundo de las Promises en JavaScript, tenemos siempre dos opciones: cumplir con una Promise (resolvérela) o no cumplir con lo que se ha prometido (rechazado). Resolver una Promise significa que todo ha ido bien, mientras que rechazar una Promise debe ser utilizado cuando algo sale mal, como por ejemplo, cuando se encuentra un error.
En este tutorial, nos enfocaremos en la segunda opción: cómo rechazar una Promise.
Para rechazar una Promise, se utiliza el método ‘reject’. Este método se llama cuando se quiere rechazar una Promise por algún motivo. El método de rechazo es una especie de “lanzamiento” de un error, y es capaz de enviar una determinada razón o mensaje.
new Promise((resolve, reject) => {
// Algunas condiciones...
if (condicion_incorrecta) {
reject(new Error("La condición no se cumplió correctamente"));
} else {
resolve("Todo ha salido bien");
}
});
En este ejemplo, estamos creando una nueva Promise que, dependiendo de la condición en que nos encontremos, puede ser resuelta o rechazada. Si la condición no se cumple, utilizamos el método ‘reject’ para enviar un objeto de error que nos permitirá identificar el problema.
Cuando rechazamos una Promise, podemos pasar un solo argumento, que puede ser cualquier cosa. Sin embargo, es recomendable pasar un Error, para que sea más fácil de identificar e manejar. Para crear un Error, simplemente se crea una instancia de Error: ’new Error()’.
Veamos otro ejemplo donde se utiliza el método ‘reject’ para manejar un problema:
function obtenerUsuario(id) {
return new Promise((resolve, reject) => {
if (!id) {
reject(new Error("No hay ID"));
} else {
// Lógica para obtener el usuario...
resolve({ nombre: "Juan", apellido: "Pérez" });
}
});
}
En este caso, estamos creando una función que recibirá un argumento llamado ‘id’. Si este argumento no está presente, la Promise se rechazará usando el método ‘reject’ y enviando un nuevo Error con el mensaje “No hay ID”.
Es importante resaltar que, cuando rechazamos una Promise, dejamos de ejecutar cualquier código que venga después del método ‘reject’. En otras palabras, si hay alguna instrucción después del ‘reject’, no se ejecutará.
Utilizar el método ‘reject’ es una forma útil de manejar errores en nuestras Promises en JavaScript. Al rechazar una Promise, podemos enviar un mensaje de error o identificar el problema que ocurrió, facilitando su manejo. Siguiendo las buenas prácticas, es recomendable siempre crear una instancia de Error al rechazar una Promise.
Una vez que una Promise se resuelve o se rechaza, no se puede cambiar su estado
Es importante entender esto porque muchas veces, cuando trabajamos con Promises, podemos olvidarnos de que una vez que el estado de una Promise ha sido establecido, ya no podemos cambiarlo. Esto puede llevar a algunos errores sutiles y difíciles de depurar.
Por ejemplo, imaginemos que tenemos una Promise que representa una solicitud HTTP para obtener el clima de una ciudad. Podríamos tener algo como esto:
const obtenerClima = (ciudad) => {
return fetch(
`https://api.openweathermap.org/data/2.5/weather?q=${ciudad}&appid={API_KEY}`
)
.then((respuesta) => {
if (!respuesta.ok) {
throw new Error("No se pudo obtener el clima");
}
return respuesta.json();
})
.then((datos) => {
return {
temperatura: datos.main.temp,
humedad: datos.main.humidity,
};
});
};
En este ejemplo, la Promise retorna un objeto con la temperatura y humedad de la ciudad solicitada. Sin embargo, ¿qué pasaría si, por alguna razón, quisiéramos cambiar el valor de la temperatura después de que la Promise ha sido resuelta? Por ejemplo, si quisieramos convertirla de grados Celsius a Fahrenheit, ¿sería posible?
La respuesta corta es no, una vez que una Promise se ha resuelto con un valor, ese valor no puede ser cambiado. En este caso, si quisieramos convertir la temperatura de Celsius a Fahrenheit, tendríamos que hacerlo antes de resolver la Promise.
Por ejemplo:
const obtenerClima = (ciudad) => {
return fetch(
`https://api.openweathermap.org/data/2.5/weather?q=${ciudad}&appid={API_KEY}`
)
.then((respuesta) => {
if (!respuesta.ok) {
throw new Error("No se pudo obtener el clima");
}
return respuesta.json();
})
.then((datos) => {
const temperaturaCelsius = datos.main.temp;
const temperaturaFahrenheit = (temperaturaCelsius * 9) / 5 + 32;
return {
temperatura: temperaturaFahrenheit,
humedad: datos.main.humidity,
};
});
};
En este ejemplo, convertimos la temperatura de Celsius a Fahrenheit antes de resolver la Promise.
Es importante recordar que, aunque no podemos cambiar el estado de una Promise después de que ha sido establecido, podemos usar métodos como Promise.all y Promise.race para combinar o manejar varias Promises simultáneamente. Estos métodos nos permiten trabajar con Promises que aún no han sido resueltas o rechazadas, lo que nos da más flexibilidad para manejar el flujo de nuestro código.
Una vez que una Promise se resuelve o se rechaza, no se puede cambiar su estado. Es importante recordar esto cuando trabajamos con Promises para evitar errores sutiles y difíciles de depurar. Si necesitamos manipular el valor de una Promise antes de resolverla, debemos hacerlo antes de devolver la Promise.
Si queremos ejecutar una función después de que una Promise se resuelva o se rechace, utilizamos ’then’ y ‘catch’, respectivamente
Si estás trabajando con promesas en JavaScript, debes conocer cómo resolverlas o rechazarlas. Esto te permitirá manejar los resultados de una manera adecuada. Aquí te explicaremos cómo utilizar los métodos ’then’ y ‘catch’ para ejecutar una función después de que una Promise se resuelva o se rechace.
Primero, hablemos sobre cómo resolver una Promise. Cuando la ejecución de una función diferida (o asíncrona) se completa, retorna una Promise. Para manejar el resultado, utilizamos el método ’then’. Este método recibe una función que se ejecutará con el valor resuelto de la Promise como argumento. Por ejemplo:
fetch("https://miapi.com/midata")
.then((response) => response.json())
.then((data) => console.log(data))
.catch((error) => console.error(error));
En este ejemplo, utilizamos una llamada a una API con la función ‘fetch’ que retorna una Promise. Luego utilizamos el método ’then’ para recibir la respuesta y convertirla a formato json. Después, utilizamos otro ’then’ para imprimir los datos en la consola. Si algo sale mal, usamos ‘catch’ para recibir el error.
Ahora, hablemos sobre cómo rechazar una Promise. Si algo sale mal, la Promise es rechazada. Para manejar esto, utilizamos el método ‘catch’. Este método recibe una función que se ejecutará con el valor rechazado de la Promise como argumento. Por ejemplo:
fetch("https://miapi.com/midata")
.then((response) => response.json())
.then((data) => console.log(data))
.catch((error) => console.error(error));
En este ejemplo, utilizamos una llamada a una API con la función ‘fetch’. Si algo sale mal, ‘catch’ recibirá el error. Por lo tanto, debes asegurarte de llamar ambos métodos para manejar los casos positivos y negativos.
Utilizar los métodos ’then’ y ‘catch’ es importante para manejar adecuadamente los resultados de una Promise. Si la Promise se resuelve, utilizamos ’then’ para ejecutar una función con el valor resuelto. Si la Promise es rechazada, utilizamos ‘catch’ para ejecutar una función con el valor rechazado. Al utilizar estos métodos, podemos asegurarnos de que nuestro código se ejecute correctamente, sin importar qué suceda en el proceso de ejecución.
Podemos encadenar varias Promises utilizando múltiples ’then’ y ‘catch’
Si bien utilizar Promises en JavaScript puede parecer difícil al principio, una vez que se entienden los conceptos básicos, comenzamos a utilizarlas de forma natural. Algo que resulta muy útil al trabajar con Promises es poder encadenar varias promesas para ejecutar acciones de manera secuencial.
Cuando encadenamos Promises, estamos diciéndole a nuestro código que queremos que se ejecuten una serie de acciones en un orden específico. Por ejemplo, podemos tener una función que llame a un API para obtener información y luego utilize esta información para realizar una segunda petición y así sucesivamente.
Para encadenar varias Promises, debemos utilizar el método ’then’. Este método se utiliza para establecer el código que se debe ejecutar cuando la Promise se resuelve con éxito. Podemos encadenar varias de estas funciones ’then’ para ejecutar un código secuencialmente.
Veamos un ejemplo:
const promesa1 = new Promise((resolve, reject) => {
setTimeout(() => {
resolve("Primera Promise");
}, 1000);
});
const promesa2 = (data) => {
console.log(data);
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve("Segunda Promise");
}, 1000);
});
};
const promesa3 = (data) => {
console.log(data);
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve("Tercera Promise");
}, 1000);
});
};
promesa1
.then(promesa2)
.then(promesa3)
.then((data) => console.log(data))
.catch((error) => console.error(error));
En este ejemplo, creamos tres Promises una después de la otra. Cada Promesa espera un segundo antes de resolverse y luego devuelve un valor. En este caso, solo estamos imprimiendo este valor en la consola.
Luego, utilizamos la función ’then’ en cada Promesa para encadenarla con la siguiente Promesa. De esta manera, podemos ejecutar una serie de Promises secuencialmente. Finalmente, utilizamos el método ‘catch’ para manejar cualquier error que pueda ocurrir durante la ejecución.
Otro aspecto importante en la encadenación de Promises es el uso de los métodos ‘resolve’ y ‘reject’. Mientras que el método ‘resolve’ se utiliza para indicar que la Promise se ha resuelto con éxito, el método ‘reject’ se utiliza para indicar que ha fallado.
Si alguna de las Promises en la cadena falla, el siguiente método ‘catch’ capturará el error. En el ejemplo anterior, si alguna de las Promises falla, el código saltaría directamente al método ‘catch’ y no continuaría con la ejecución de las Promises restantes.
Encadenar varias Promises es una gran herramienta para ejecutar una serie de acciones de forma secuencial. Para hacer esto, debemos utilizar el método ’then’ para encadenar Promises y los métodos ‘resolve’ y ‘reject’ para indicar si una Promise se ha resuelto con éxito o ha fallado. Utiliza esta técnica para crear código más eficiente y legible.
También podemos utilizar ‘Promise.all’ para ejecutar varias Promises al mismo tiempo
En JavaScript, las Promises son una estructura fundamental que se utiliza para manejar tareas asíncronas. Una Promise representa un valor que puede o no estar disponible en el futuro, y nos permite realizar operaciones adicionales una vez que ese valor se resuelve.
Existen tres estados posibles en los que una Promise puede estar: pendiente, resuelta o rechazada. Cuando una Promise pasa a estar en uno de estos estados, podemos realizar diferentes acciones para continuar con nuestro flujo de trabajo.
Ahora bien, ¿qué ocurre cuando necesitamos ejecutar varias Promises al mismo tiempo? Para solucionar esto, JavaScript nos ofrece un método llamado ‘Promise.all’. Con ‘Promise.all’, podemos pasar una matriz de Promises y esperar a que todas se resuelvan antes de continuar con el flujo de trabajo.
Este es un ejemplo de cómo usar ‘Promise.all’:
const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
setTimeout(resolve, 100, "foo");
});
Promise.all([promise1, promise2, promise3]).then((values) => {
console.log(values);
});
// Salida esperada:
// [3, 42, 'foo']
En este caso, creamos tres Promises: ‘promise1’, que se resuelve inmediatamente con el valor de 3, ‘promise2’, que se resuelve inmediatamente con el valor de 42, y ‘promise3’, que se resuelve después de 100 milisegundos con el valor de ‘foo’.
Luego, pasamos una matriz con las tres Promises al método ‘Promise.all’ y, usando una función de devolución de llamada, imprimimos los valores de todas las Promises en la consola. En este caso, la salida esperada es [3, 42, ‘foo’].
Es importante tener en cuenta que, si cualquiera de las Promises pasadas a ‘Promise.all’ es rechazada, todas las Promises se consideran rechazadas y se llama a la función de devolución de llamada ‘catch’ en lugar del método ’then’. Por ejemplo:
const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => {
setTimeout(reject, 100, "Fallo");
});
Promise.all([promise1, promise2])
.then((values) => {
console.log(values);
})
.catch((reason) => {
console.log(reason);
});
// Salida esperada:
// Fallo
En este caso, la Promesa ‘promise2’ es rechazada después de 100 milisegundos, y se llama a la función de devolución de llamada ‘catch’ en lugar del método ’then’. La salida esperada es ‘Fallo’.
‘Promise.all’ es una herramienta muy útil para manejar varias Promises al mismo tiempo. Nos permite esperar a que todas las Promises se resuelvan antes de continuar con el flujo de trabajo, y nos ayuda a manejar errores de una manera clara y sencilla.
Es importante manejar adecuadamente los errores en las Promises para evitar problemas en nuestra aplicación
Cuando trabajamos con Promises, es fundamental asegurarnos de que todas las excepciones sean capturadas y manejadas adecuadamente. Si no hacemos esto, nuestras aplicaciones pueden verse afectadas por errores inesperados y difíciles de rastrear.
Un punto importante a tener en cuenta es que las Promises pueden estar en uno de tres estados: pendiente, resuelto o rechazado. El estado pendiente significa que la promesa está en proceso de completarse. El estado resuelto significa que la promesa se ha completado con éxito y ha devuelto un resultado. El estado rechazado significa que la promesa ha fallado y ha lanzado una excepción.
Es recomendable manejar específicamente cada uno de estos estados mediante la utilización de las cláusulas .then() y .catch(). La cláusula .then() se ejecutará cuando la promesa se resuelva, mientras que la cláusula .catch() se ejecutará cuando la promesa se rechace.
Veamos el siguiente ejemplo:
let promesa = new Promise((resolve, reject) => {
setTimeout(() => {
reject("Ha surgido un error");
}, 2000);
});
promesa
.then((resultado) => {
console.log("Resultado: " + resultado);
})
.catch((error) => {
console.log("Error: " + error);
});
En este ejemplo, creamos una promesa que se rechaza después de dos segundos. Usamos las cláusulas .then() y .catch() para manejar los distintos estados de la promesa. En este caso, el resultado que se imprimirá en la consola será “Error: Ha surgido un error”.
Otra opción muy útil para manejar errores en Promises es el uso de la cláusula .finally(). Esta cláusula se ejecutará siempre al final de la promesa, ya sea que esta se haya resuelto o rechazado.
let promesa = new Promise((resolve, reject) => {
setTimeout(() => {
reject("Ha surgido un error");
}, 2000);
});
promesa
.then((resultado) => {
console.log("Resultado: " + resultado);
})
.catch((error) => {
console.log("Error: " + error);
})
.finally(() => {
console.log("La promesa ha finalizado");
});
En este ejemplo, veremos en la consola la impresión de “Error: Ha surgido un error” y posteriormente “La promesa ha finalizado”. Esto es muy útil para realizar limpieza de código después de haber procesado la Promesa.
Es fundamental manejar adecuadamente los errores en las Promises para evitar errores inesperados en nuestras aplicaciones. Utilizar las cláusulas .then(), .catch() y .finally() nos dará la garantía de que la promesa se está manejando adecuadamente en todos los estados posibles.Podemos estar seguros de que con estas herramientas podemos mejorar la calidad de nuestro código y prevenir posibles errores futuros en nuestras aplicaciones.
¡Ya estás listo para utilizar Promises con confianza en tus proyectos JavaScript!
¡Felicitaciones! Ahora que has aprendido cómo resolver o rechazar Promises en JavaScript, ya estás listo para utilizar Promises con confianza en tus proyectos JavaScript.
Luego de haber entendido las mecánicas básicas de las Promises, puedes empezar a explorar y experimentar su funcionalidad de manera más profunda. Puedes empezar por buscar algunas bibliotecas que ofrezcan soporte para Promises, como son: Axios, Superagent, Fetch, y muchas más.
También puedes mejorar tus habilidades en el manejo de Promises, yendo más allá de lo básico. A continuación, te mostramos algunos consejos que puedes tener en cuenta:
1. Encadenar Promises:
Puedes usar la función then del objeto Promise para encadenar múltiples Promises. Esto te permite emplear solamente un manejador catch al final de la cadena. A modo de ejemplo, imagina que deseas realizar múltiples llamados a una API, uno detrás del otro. Aquí va el código:
fetch("my-api.com/products")
.then((response) => response.json())
.then((data) => console.log(data))
.catch((error) => console.error(error));
2. Utilizar el método Promise.all para procesar varias Promises al mismo tiempo:
Si ejecutas muchas Promises de manera simultánea con veloz procesamiento, puedes utilizar el método Promise.all para obtener un solo resultado. Aquí va un ejemplo que te ilustrará:
const promises = [
fetch("my-api.com/products/1"),
fetch("my-api.com/products/2"),
fetch("my-api.com/products/3"),
];
Promise.all(promises)
.then((responses) =>
Promise.all(responses.map((response) => response.json()))
)
.then((data) => console.log(data))
.catch((error) => console.error(error));
3. Usar el método Promise.race para el manejo de solicitudes:
Si solicitas conexiones a múltiples servidores y deseas que la respuesta más rápida sea la que se muestre, debes utilizar Promise.race. Este método te ofrece una respuesta tan pronto como recibe la primera respuesta. Aquí un ejemplo:
const promises = [
fetch("server1.com/products"),
fetch("server2.com/products"),
fetch("server3.com/products"),
];
Promise.race(promises)
.then((response) => console.log(response))
.catch((error) => console.error(error));
Hacer uso de Promises puede resultar bastante útil en el manejo de asincronismo en tus proyectos JavaScript. Estamos seguros de que estos consejos te serán muy útiles para mejorar en su manejo. No olvides practicar constantemente y buscar nuevos retos en el manejo de Promises. ¡Continúa cultivando tus habilidades en JavaScript!