Ir a la página de inicio
Home / Posts
Compartir en Twitter
Go to Homepage

GUÍA COMPLETA DE MÉTODOS DE PROMESAS EN JAVASCRIPT 2025

November 25, 2025

Introducción a las Promesas en JavaScript

Las promesas en JavaScript son un pilar fundamental para manejar operaciones asíncronas, como solicitudes HTTP, lecturas de archivos o temporizadores. Introducidas en ECMAScript 2015, ofrecen una alternativa robusta a los callbacks, mejorando la legibilidad y la gestión de errores asíncronos. Una promesa representa un valor que puede estar disponible ahora, en el futuro o nunca, existiendo en tres estados: pendiente, resuelta o rechazada. Este tutorial explora los métodos clave de las promesas, actualizados al contexto de 2025, con ejemplos prácticos para programadores que buscan dominar la programación asíncrona en entornos web y servidores.

En JavaScript, una promesa se crea con el constructor Promise, que acepta una función ejecutora con dos parámetros: resolve y reject. Estos métodos determinan si la promesa se cumple o falla. Por ejemplo, una promesa puede simular una solicitud a una API:

const miPromesa = new Promise((resolve, reject) => {
    setTimeout(() => {
        const exito = true;
        if (exito) {
            resolve("¡Operación exitosa!");
        } else {
            reject("Error en la operación");
        }
    }, 1000);
});

Este código crea una promesa que se resuelve tras un segundo si la condición es verdadera, o se rechaza si falla. Los métodos de promesas permiten manejar estos resultados de forma estructurada, como veremos a continuación.

Método then

El método then es el principal para manejar promesas resueltas. Se ejecuta cuando la promesa pasa al estado resuelto, recibiendo el valor pasado a resolve. Acepta hasta dos funciones: una para el caso de éxito y otra opcional para el caso de error, aunque esta última se usa raramente, ya que catch es más común para errores.

Por ejemplo, para procesar el resultado de la promesa anterior:

miPromesa.then(
    (resultado) => {
        console.log(resultado); // ¡Operación exitosa!
    },
    (error) => {
        console.log(error);
    }
);

La salida en la consola sería:

¡Operación exitosa!

then es encadenable, lo que permite realizar múltiples operaciones en secuencia. Cada llamada a then devuelve una nueva promesa, facilitando la transformación de datos. Por ejemplo, para convertir un resultado a mayúsculas:

miPromesa
    .then((resultado) => resultado.toUpperCase())
    .then((resultadoMayusculas) => {
        console.log(resultadoMayusculas); // ¡OPERACIÓN EXITOSA!
    });

La salida sería:

¡OPERACIÓN EXITOSA!

Este encadenamiento es clave para flujos asíncronos complejos, como procesar datos de una API antes de mostrarlos en una interfaz.

Método catch

El método catch maneja errores cuando una promesa es rechazada. Es una forma más clara de capturar errores que usar la segunda función de then. Se recomienda usar catch para mantener el código legible y separar la lógica de éxito de la de error.

Modifiquemos la promesa para que falle:

const miPromesaFallo = new Promise((resolve, reject) => {
    setTimeout(() => {
        reject("Error en la operación");
    }, 1000);
});

miPromesaFallo
    .then((resultado) => {
        console.log(resultado);
    })
    .catch((error) => {
        console.log(error); // Error en la operación
    });

La salida sería:

Error en la operación

catch también captura errores síncronos lanzados dentro de un bloque then. Por ejemplo:

miPromesa
    .then((resultado) => {
        throw new Error("Error síncrono");
    })
    .catch((error) => {
        console.log(error.message); // Error síncrono
    });

La salida sería:

Error síncrono

Usar catch al final de una cadena de promesas asegura que cualquier error, ya sea asíncrono o síncrono, sea manejado adecuadamente, mejorando la robustez del código.

Método finally

El método finally se ejecuta siempre, independientemente de si la promesa se resuelve o se rechaza. Es útil para tareas de limpieza, como ocultar un indicador de carga o cerrar una conexión. No recibe argumentos, ya que no distingue entre éxito o error.

Por ejemplo, para simular un indicador de carga:

console.log("Cargando...");

miPromesa
    .then((resultado) => {
        console.log(resultado);
    })
    .catch((error) => {
        console.log(error);
    })
    .finally(() => {
        console.log("Operación finalizada");
    });

La salida sería:

Cargando...
¡Operación exitosa!
Operación finalizada

Si la promesa falla, la salida sería:

Cargando...
Error en la operación
Operación finalizada

En aplicaciones web, finally es ideal para garantizar que los recursos se liberen o que la interfaz se actualice tras una operación asíncrona, mejorando la experiencia del usuario.

Método Promise.all

El método Promise.all toma un arreglo de promesas y devuelve una nueva promesa que se resuelve cuando todas las promesas del arreglo se resuelven, o se rechaza si alguna falla. Es útil para ejecutar múltiples operaciones asíncronas en paralelo, como cargar varios recursos simultáneamente.

Por ejemplo, para simular tres solicitudes a una API:

const promesa1 = Promise.resolve("Resultado 1");
const promesa2 = new Promise((resolve) =>
    setTimeout(() => resolve("Resultado 2"), 1000)
);
const promesa3 = Promise.resolve("Resultado 3");

Promise.all([promesa1, promesa2, promesa3]).then((resultados) => {
    console.log(resultados); // ["Resultado 1", "Resultado 2", "Resultado 3"]
});

La salida sería:

["Resultado 1", "Resultado 2", "Resultado 3"]

Si alguna promesa falla, Promise.all se rechaza inmediatamente:

const promesaFallo = new Promise((resolve, reject) => {
    setTimeout(() => reject("Error en promesa"), 500);
});

Promise.all([promesa1, promesaFallo, promesa3])
    .then((resultados) => {
        console.log(resultados);
    })
    .catch((error) => {
        console.log(error); // Error en promesa
    });

La salida sería:

Error en promesa

Promise.all es ideal para escenarios como cargar imágenes o datos de múltiples endpoints, optimizando el tiempo total de ejecución al ejecutar las promesas en paralelo.

Método Promise.allSettled

A diferencia de Promise.all, el método Promise.allSettled espera a que todas las promesas se resuelvan o rechacen, devolviendo un arreglo de objetos que describen el estado de cada promesa. Cada objeto tiene una propiedad status (fulfilled o rejected) y un valor o razón.

Por ejemplo:

const promesaExito = Promise.resolve("Éxito");
const promesaFallo = Promise.reject("Fallo");

Promise.allSettled([promesaExito, promesaFallo]).then((resultados) => {
    console.log(resultados);
});

La salida sería:

[
  { status: "fulfilled", value: "Éxito" },
  { status: "rejected", reason: "Fallo" }
]

Este método es útil cuando necesitas conocer el resultado de todas las promesas, incluso si algunas fallan, como en auditorías o procesos por lotes. Por ejemplo, para procesar resultados:

Promise.allSettled([promesaExito, promesaFallo]).then((resultados) => {
    resultados.forEach((resultado, index) => {
        if (resultado.status === "fulfilled") {
            console.log(`Promesa ${index + 1}: ${resultado.value}`);
        } else {
            console.log(`Promesa ${index + 1}: ${resultado.reason}`);
        }
    });
});

La salida sería:

Promesa 1: Éxito
Promesa 2: Fallo

Promise.allSettled es especialmente útil en aplicaciones donde el fallo de una operación no debe detener el procesamiento de otras.

Método Promise.race

El método Promise.race toma un arreglo de promesas y devuelve una nueva promesa que se resuelve o rechaza tan pronto como una de las promesas lo hace. Es útil para establecer límites de tiempo o priorizar la primera respuesta.

Por ejemplo, para simular una carrera entre promesas:

const promesaLenta = new Promise((resolve) =>
    setTimeout(() => resolve("Lenta"), 2000)
);
const promesaRapida = new Promise((resolve) =>
    setTimeout(() => resolve("Rápida"), 500)
);

Promise.race([promesaLenta, promesaRapida]).then((resultado) => {
    console.log(resultado); // Rápida
});

La salida sería:

Rápida

Un caso práctico es establecer un tiempo máximo para una solicitud:

const solicitud = new Promise((resolve) =>
    setTimeout(() => resolve("Datos recibidos"), 3000)
);
const tiempoLimite = new Promise((resolve, reject) => {
    setTimeout(() => reject("Tiempo agotado"), 2000);
});

Promise.race([solicitud, tiempoLimite])
    .then((resultado) => {
        console.log(resultado);
    })
    .catch((error) => {
        console.log(error); // Tiempo agotado
    });

La salida sería:

Tiempo agotado

Promise.race es ideal para escenarios como pruebas de rendimiento o cancelación de operaciones lentas, mejorando la eficiencia de aplicaciones.

Método Promise.any

El método Promise.any toma un arreglo de promesas y se resuelve en cuanto una de ellas se resuelve, ignorando las promesas rechazadas hasta que todas fallen. Si todas las promesas fallan, devuelve un error agregado con todas las razones.

Por ejemplo:

const promesa1 = Promise.reject("Error 1");
const promesa2 = new Promise((resolve) =>
    setTimeout(() => resolve("Éxito"), 1000)
);
const promesa3 = Promise.reject("Error 2");

Promise.any([promesa1, promesa2, promesa3]).then((resultado) => {
    console.log(resultado); // Éxito
});

La salida sería:

Éxito

Si todas fallan:

const promesasFallidas = [
    Promise.reject("Error 1"),
    Promise.reject("Error 2"),
    Promise.reject("Error 3"),
];

Promise.any(promesasFallidas).catch((error) => {
    console.log(error.errors); // ["Error 1", "Error 2", "Error 3"]
});

La salida sería:

["Error 1", "Error 2", "Error 3"]

Promise.any es útil para buscar la primera respuesta válida, como en sistemas distribuidos donde múltiples servidores pueden responder.

Método Promise.resolve

El método Promise.resolve crea una promesa resuelta con un valor dado. Es útil para estandarizar valores en flujos asíncronos o para pruebas.

Por ejemplo:

Promise.resolve("Valor directo").then((valor) => {
    console.log(valor); // Valor directo
});

La salida sería:

Valor directo

También convierte valores no promesas en promesas:

const valor = 42;
Promise.resolve(valor).then((resultado) => {
    console.log(resultado); // 42
});

La salida sería:

42

Este método es común en funciones que deben devolver promesas de forma consistente, incluso si el resultado ya está disponible.

Método Promise.reject

El método Promise.reject crea una promesa rechazada con una razón dada. Es útil para pruebas o para señalar errores inmediatos.

Por ejemplo:

Promise.reject("Error inmediato").catch((error) => {
    console.log(error); // Error inmediato
});

La salida sería:

Error inmediato

Un caso práctico es rechazar una operación si los parámetros son inválidos:

function procesarDato(dato) {
    if (!dato) {
        return Promise.reject("Dato inválido");
    }
    return Promise.resolve(`Procesado: ${dato}`);
}

procesarDato(null).catch((error) => {
    console.log(error); // Dato inválido
});

La salida sería:

Dato inválido

Promise.reject asegura que los errores se manejen de forma predecible en flujos asíncronos.

Conclusiones

Las promesas en JavaScript, con sus métodos como then, catch, finally, all, allSettled, race, any, resolve y reject, ofrecen un conjunto poderoso para manejar operaciones asíncronas. Estas herramientas permiten a los desarrolladores escribir código más legible, modular y robusto, enfrentando desafíos como la gestión de errores, la ejecución paralela y los límites de tiempo. En 2025, con el estándar ECMAScript evolucionando, las promesas siguen siendo esenciales para aplicaciones web y servidores, integrándose con tecnologías como async/await para flujos aún más claros. Dominar estos métodos no solo mejora la calidad del código, sino que también prepara a los programadores para enfrentar los retos de la programación moderna, desde aplicaciones web interactivas hasta sistemas backend escalables.