Las promesas en JavaScript son el mecanismo que convierte tu código síncrono en asíncrono, permitiendo que el navegador trabaje ciertas funciones por separado y devuelva el resultado cuando esté listo. Si estás aprendiendo a manejar peticiones a APIs o tareas que tardan en resolverse, dominar las promesas es el paso que cambia la forma en que escribes JavaScript.
¿Qué es una promesa en JavaScript y para qué sirve?
Una promesa es un objeto que representa el resultado futuro de una operación asíncrona. En lugar de bloquear el call stack esperando a que termine una tarea lenta, le dices al navegador: trabaja esto aparte y avísame cuando esté listo.
¿Qué es una promesa en JavaScript? Es un objeto que representa el resultado eventual de una operación asíncrona. Puede resolverse con éxito o fallar, y tú decides qué hacer en cada caso.
Imagina dos funciones que se disparan de forma asíncrona y, en medio, una promesa. Aunque la promesa se invoque entre ambas, su resultado llega al final, porque es lo último que se resuelve [01:00].
¿Cuáles son los tres estados de una promesa?
Toda promesa atraviesa estados muy concretos durante su ciclo de vida [01:40]. Conocerlos te ayuda a depurar y a anticipar el comportamiento de tu código.
- pending: el estado inicial, cuando la promesa se acaba de crear y aún no tiene resultado.
- fulfilled: la promesa se resolvió correctamente y entregó un valor.
- rejected: la promesa falló y devuelve un error.
Además, las promesas manejan dos callbacks clave: resolve, que se ejecuta cuando todo sale bien, y reject, que entra cuando algo falla [02:30].
¿Qué hacen los métodos then y catch?
Una vez creada la promesa, necesitas reaccionar a su resultado. Para eso existen dos métodos esenciales [02:50]:
- then: se ejecuta cuando la promesa se resuelve con éxito. Aquí pones el código que depende del valor devuelto.
- catch: se dispara cuando la promesa es rechazada. Te entrega el error para que puedas inspeccionarlo y entender qué falló.
¿Cómo crear una promesa paso a paso con un ejemplo real?
El patrón básico arranca con una constante que instancia un objeto Promise recibiendo dos parámetros: resolve y reject [03:30]. Dentro, se simula una operación asíncrona, normalmente con un setTimeout que actúa como si estuvieras esperando la respuesta de un API.
javascript
const promesa = new Promise((resolve, reject) => {
setTimeout(() => {
const operationSuccessFull = true;
if (operationSuccessFull) {
resolve("La operación fue exitosa");
} else {
reject("La operación falló");
}
}, 2000);
});
El setTimeout le da dos segundos a la operación antes de decidir si se resuelve o se rechaza [05:30]. Si operationSuccessFull es true, entra al resolve; si es false, dispara el reject.
¿Por qué se usa setTimeout dentro de una promesa? Porque simula el tiempo que tarda una petición real, como una llamada a un API, sin necesidad de hacer una petición verdadera durante la práctica.
¿Cómo obtener el resultado con then y catch?
Llamar a promesa directamente en consola devuelve el objeto con su estado fulfilled o rejected, pero para trabajar con el valor necesitas encadenar los métodos [07:10]:
javascript
promesa
.then((successMessage) => {
console.log(successMessage);
})
.catch((error) => {
console.log(error);
});
Cuando la operación es exitosa, el then recibe el mensaje y lo imprime. Si algo falla, el catch captura el error para mostrarlo. Esto te permite separar claramente el camino feliz del manejo de errores.
¿Cuándo conviene usar promesas en tu código?
Las promesas brillan cuando trabajas con tareas que no son inmediatas: peticiones HTTP con fetch, lectura de archivos, temporizadores o cualquier operación que dependa de un recurso externo. En lugar de bloquear la ejecución, dejas que el navegador siga atendiendo otras tareas y respondes cuando llega el resultado.
¿Qué pasa si una promesa nunca se resuelve? Se queda en estado pending indefinidamente y los métodos then y catch nunca se ejecutan, lo que puede generar memory leaks o lógica colgada en tu aplicación.
Probar ambos caminos en consola es el mejor ejercicio: cambia operationSuccessFull a false y verás cómo el catch toma el control después de los dos segundos del setTimeout. Ese contraste entre éxito y error es lo que vuelve predecible tu código asíncrono.
¿Ya intentaste construir tu primera promesa? Cuéntame en los comentarios qué operación asíncrona te gustaría modelar.
