Skip to main content

JavaScript Promises

Dominando la Programación Asíncrona Moderna

Published 5 min readMarkdown
JavaScript Promises

Como desarrollador, una de las barreras más complejas que enfrentamos al comenzar con JavaScript es tratar de entender la programación asíncrona. Durante años luchamos con el temido "callback hell" hasta que ES6 nos trajo una solución elegante: las Promises.

¿Qué son realmente las Promises?

Una Promise es un objeto que representa el resultado eventual de una operación asíncrona. Piénsalo como un "contrato" o "promesa" de que algo va a suceder en el futuro, pero no sabemos exactamente cuándo ni si será exitoso.

La analogía que mejor funciona

Imagina que ordenas comida a domicilio. El restaurante te da un número de orden (la Promise) y te "promete" que tu comida llegará. Mientras esperas, puedes hacer otras cosas. Eventualmente, una de dos cosas pasará:

  • Tu comida llega (Promesa cumplida)

  • Te llaman para decirte que no pueden entregar (Promise rejected)

La sintaxis básica que realmente importa

// Crear una Promise
const miPromesa = new Promise((resolve, reject) => {
    // Código que toma tiempo (operación asíncrona)
    const exito = Math.random() > 0.5; // Simulamos éxito/fallo

    if (exito) {
        resolve("¡Operación exitosa!"); // Promesa cumplida
    } else {
        reject("Algo salió mal"); // Promesa rechazada
    }
});

// Consumir la Promise
miPromesa
    .then(resultado => {
        console.log(resultado); // Si fue exitosa
    })
    .catch(error => {
        console.error(error); // Si falló
    });

Los tres estados que debes dominar

Una Promise siempre está en uno de estos estados:

  1. Pending (Pendiente): La operación aún no ha terminado

  2. Fulfilled (Cumplida): La operación se completó exitosamente

  3. Rejected (Rechazada): La operación falló

// Estado: Pending
const promesaPendiente = new Promise((resolve, reject) => {
    // Esta nunca se resuelve, queda en pending
    console.log("Esperando...");
});

// Estado: Fulfilled
const promesaCumplida = Promise.resolve("¡Éxito!");

// Estado: Rejected  
const promesaRechazada = Promise.reject("Error!");

Casos de uso reales que he implementado

1. Llamadas a APIs (El caso más común)

function obtenerUsuario(id) {
    return new Promise((resolve, reject) => {
        fetch(`/api/usuarios/${id}`)
            .then(response => {
                if (response.ok) {
                    return response.json();
                } else {
                    throw new Error(`Usuario no encontrado: ${response.status}`);
                }
            })
            .then(usuario => resolve(usuario))
            .catch(error => reject(error));
    });
}

// Usar la función
obtenerUsuario(123)
    .then(usuario => {
        console.log("Usuario:", usuario.nombre);
        document.getElementById('nombre').textContent = usuario.nombre;
    })
    .catch(error => {
        console.error("Error al obtener usuario:", error);
        mostrarMensajeError("No se pudo cargar el usuario");
    });

2. Simulando delays (Para testing o UX)

function esperarTiempo(millisegundos) {
    return new Promise(resolve => {
        setTimeout(() => {
            resolve(`Esperé ${millisegundos}ms`);
        }, millisegundos);
    });
}

// Mostrar un loading por 2 segundos
function mostrarCargando() {
    console.log("Cargando...");

    return esperarTiempo(2000)
        .then(mensaje => {
            console.log(mensaje);
            console.log("¡Listo!");
        });
}

3. Operaciones que pueden fallar

function procesarArchivo(archivo) {
    return new Promise((resolve, reject) => {
        const reader = new FileReader();

        reader.onload = () => {
            if (reader.result) {
                resolve(reader.result);
            } else {
                reject(new Error("No se pudo leer el archivo"));
            }
        };

        reader.onerror = () => {
            reject(new Error("Error al leer el archivo"));
        };

        reader.readAsText(archivo);
    });
}

// Usar en un input de archivo
document.getElementById('archivo').addEventListener('change', (e) => {
    const archivo = e.target.files[0];

    if (archivo) {
        procesarArchivo(archivo)
            .then(contenido => {
                console.log("Archivo leído:", contenido);
                document.getElementById('contenido').textContent = contenido;
            })
            .catch(error => {
                console.error("Error:", error.message);
                alert("No se pudo procesar el archivo");
            });
    }
});

Métodos de Promise que uso constantemente

Promise.all() - Para operaciones paralelas

// Cargar múltiples recursos al mismo tiempo
const promesas = [
    fetch('/api/usuarios'),
    fetch('/api/productos'), 
    fetch('/api/pedidos')
];

Promise.all(promesas)
    .then(responses => {
        // Todas las peticiones terminaron
        return Promise.all(responses.map(r => r.json()));
    })
    .then(([usuarios, productos, pedidos]) => {
        console.log("Datos cargados:", { usuarios, productos, pedidos });
        inicializarDashboard(usuarios, productos, pedidos);
    })
    .catch(error => {
        console.error("Error cargando datos:", error);
        mostrarErrorGeneral();
    });

Promise.race() - Para timeouts

function conTimeout(promesa, tiempo) {
    const timeout = new Promise((_, reject) => 
        setTimeout(() => reject(new Error("Timeout")), tiempo)
    );

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

// Usar con timeout de 5 segundos
conTimeout(fetch('/api/datos-lentos'), 5000)
    .then(response => response.json())
    .then(datos => console.log("Datos:", datos))
    .catch(error => {
        if (error.message === "Timeout") {
            console.log("La petición tardó demasiado");
        } else {
            console.error("Otro error:", error);
        }
    });

Errores comunes (y cómo evitarlos)

1. No manejar rechazos

// No maneja errores
fetch('/api/datos')
    .then(response => response.json())
    .then(datos => console.log(datos));
    // Si falla, tendrás "Unhandled promise rejection"

// Siempre incluye .catch()
fetch('/api/datos')
    .then(response => response.json())
    .then(datos => console.log(datos))
    .catch(error => console.error("Error:", error));

2. No retornar Promises en .then()

// Se pierde la cadena
fetch('/api/usuario')
    .then(response => {
        response.json(); // ¡No se retorna!
    })
    .then(datos => {
        console.log(datos); // undefined
    });

// Retorna la Promise
fetch('/api/usuario')
    .then(response => {
        return response.json(); // Se retorna
    })
    .then(datos => {
        console.log(datos); // ¡Funciona!
    });

3. Crear Promises innecesarias

// Promise wrapper innecesario
function obtenerDatos() {
    return new Promise((resolve, reject) => {
        fetch('/api/datos')
            .then(response => resolve(response))
            .catch(error => reject(error));
    });
}

// fetch() ya retorna una Promise
function obtenerDatos() {
    return fetch('/api/datos');
}

Setup personal para debugging

Cuando trabajo con Promises, uso esta utilidad:

// Utilidad para debuggear Promises
function debugPromise(promesa, nombre) {
    console.log(`[${nombre}] Iniciando...`);

    return promesa
        .then(resultado => {
            console.log(`[${nombre}] Éxito:`, resultado);
            return resultado;
        })
        .catch(error => {
            console.error(`[${nombre}] Error:`, error);
            throw error; // Re-lanza el error
        });
}

// Uso
debugPromise(
    fetch('/api/usuarios').then(r => r.json()),
    'Cargar usuarios'
).then(usuarios => {
    // Trabajar con usuarios
});

La transición a async/await

Aunque las Promises son poderosas, async/await hace el código más legible:

// Con Promises tradicionales
function procesarPedido(pedidoId) {
    return obtenerPedido(pedidoId)
        .then(pedido => validarPedido(pedido))
        .then(pedidoValidado => procesarPago(pedidoValidado))
        .then(pago => enviarConfirmacion(pago))
        .catch(error => manejarError(error));
}

// Con async/await (más limpio)
async function procesarPedido(pedidoId) {
    try {
        const pedido = await obtenerPedido(pedidoId);
        const pedidoValidado = await validarPedido(pedido);
        const pago = await procesarPago(pedidoValidado);
        return await enviarConfirmacion(pago);
    } catch (error) {
        return manejarError(error);
    }
}

Conclusión

Las Promises transformaron la manera en que escribimos JavaScript asíncrono. Me tomó tiempo dominarlas completamente, pero ahora no puedo imaginar desarrollar sin ellas.

Los puntos clave:

  1. Siempre maneja errores con .catch()

  2. Retorna Promises en las cadenas .then()

  3. Usa Promise.all() para operaciones paralelas

  4. Considera async/await para código más limpio

  5. Debuggea sistémáticamente tus operaciones asíncronas

Las Promises no son solo una característica del lenguaje, son una mentalidad. Una vez que las dominas, tu código asíncrono se vuelve más predecible, mantenible y robusto.


¿Has trabajado con Promises en tus proyectos? ¿Qué desafíos has enfrentado? Compárteme tu experiencia en los comentarios.

About the author

  • Desarrollador apasionado por convertir bugs en funcionalidades (y café en productividad) Amante del código limpio, aunque mi historial de commits podría decir otra cosa. Siempre aprendiendo, siempre depurando, y ocasionalmente negociando con mi teclado para que coopere.

No comments yet. Be the first to comment.

More from this blog