JavaScript
Explica cómo encadenar promesas, propagar y recuperar errores, evitar promesas flotantes y conservar contexto al traducir fallos entre capas.
Una cadena de promesas permite describir pasos donde cada etapa recibe el resultado anterior y decide si continúa con un valor, espera otra operación o propaga un error.
loadUser()
.then(loadOrdersForUser)
.then(calculateSummary)
.then(renderSummary)
.catch(showError);Anidado:
loadUser().then((user) => {
loadOrders(user.id).then((orders) => {
renderOrders(orders);
});
});Encadenado:
loadUser()
.then((user) => loadOrders(user.id))
.then(renderOrders);La cadena mantiene una sola ruta de valores y errores.
Si una etapa no maneja un rechazo, este atraviesa la cadena hasta encontrar un manejador.
loadUser()
.then(parseUser)
.then(renderUser)
.catch(reportError);Un throw dentro de parseUser también llega al catch.
Maneja cerca cuando puedes recuperar de un caso específico.
loadCache()
.catch((error) => {
if (error instanceof CacheUnavailableError) {
return loadDatabase();
}
throw error;
})
.then(renderData);Usa un catch final para fallos que invalidan todo el flujo.
const recovered = Promise.reject(error)
.catch(() => fallback);recovered queda fulfilled con fallback.
Si el catch no retorna:
.catch((error) => {
log(error);
})la cadena continúa cumplida con undefined.
return operation()
.catch((error) => {
logger.error("Operation failed", { error });
throw error;
});Registra una vez en una frontera clara. Registrar en cada capa puede duplicar el mismo incidente.
loadConfiguration()
.catch((cause) => {
throw new ConfigurationError(
"Application configuration could not be loaded",
{ cause },
);
});La nueva capa añade significado sin borrar la causa original.
function save() {
saveToServer();
return true;
}saveToServer queda flotando: el consumidor no puede esperarla ni observar su rechazo.
Mejor:
function save() {
return saveToServer();
}O marca explícitamente una operación fire-and-forget y maneja su error:
void sendTelemetry().catch(reportTelemetryError);promise.then(onFulfilled, onRejected);onRejected maneja el rechazo de promise, pero no un error lanzado por onFulfilled porque ambos pertenecen a la misma llamada a then.
promise
.then(onFulfilled)
.catch(onRejected);El catch sí puede manejar errores producidos por onFulfilled.
Promise.resolve(10)
.finally(() => 99)
.then(console.log);
// 10El valor 99 se ignora. Pero una excepción dentro de finally reemplaza el resultado.
function load(callback) {
return fetchData().then((data) => {
callback(null, data);
return data;
});
}El consumidor puede manejar dos interfaces distintas y producir dobles efectos. Define una única convención por API.
Un host puede reportar un unhandled rejection si el manejador se agrega demasiado tarde.
const promise = Promise.reject(error);
setTimeout(() => {
promise.catch(handleError);
}, 1000);Aunque luego exista un catch, el rechazo estuvo sin manejador durante un periodo observable.
function importProducts(file) {
return readFile(file)
.then(parseCsv)
.then(validateProducts)
.then(saveProducts)
.catch((cause) => {
throw new ImportError(
"Products could not be imported",
{ cause },
);
});
}Cada etapa retorna su resultado y el límite traduce el fallo al lenguaje del caso de uso.
then y perder la cadena exterior.then(success, error) esperando capturar errores del success.catch puede recuperar o relanzar.cause conserva el error original al traducirlo.¿Por qué este catch no recibe un error lanzado por onSuccess?
promise.then(onSuccess, onError);Porque onSuccess y onError manejan el resultado de la promesa anterior. Un error de onSuccess rechaza la nueva promesa retornada por then; necesita un catch posterior.
Combinadores de Promise explica cómo coordinar varias operaciones independientes.