¿En cadena de promesas, dónde conviene manejar error de forma global?

Un manejo consistente evita errores perdidos y duplicacin.

JavaScript

Promesas en JavaScript: encadenado limpio y manejo de errores

Domina `then/catch/finally`, composición de promesas y patrones para evitar callback hell.

¿Cuánto sabes de JavaScript?

📘 Teoría

Estados y ciclo de una promesa

pending -> fulfilled o rejected.

Mientras está `pending`, aún no tienes valor final. Cuando se resuelve, pasa a `fulfilled`; si falla, a `rejected`.

Tu código debe contemplar ambos caminos para no dejar errores silenciados.

Promesa básica

const p = new Promise((resolve, reject) => {
  const ok = true;
  if (ok) resolve('Datos listos');
  else reject(new Error('Fallo al cargar'));
});

p.then((msg) => console.log(msg)).catch((err) => console.error(err.message));

Encadenar transformaciones con then

Cada `then` recibe la salida del anterior.

Devuelve valor o promesa desde `then`.
No mezcles callbacks anidados innecesarios.
Centraliza el manejo de error en un `catch` final.

Pipeline de promesas

Promise.resolve(5)
  .then((n) => n * 2)
  .then((n) => n + 1)
  .then((n) => console.log('resultado:', n))
  .catch((err) => console.error('error:', err.message));

Componer promesas en paralelo

Si tareas son independientes, ejecútalas juntas.

`Promise.all` espera a que todas las promesas se resuelvan. Si una falla, rechaza el conjunto.

Úsalo para cargar recursos en paralelo y reducir tiempo total de espera.

Paralelización con Promise.all

const p1 = Promise.resolve('perfil');
const p2 = Promise.resolve('cursos');

Promise.all([p1, p2])
  .then(([perfil, cursos]) => {
    console.log('ok:', perfil, cursos);
  })
  .catch((err) => {
    console.error('fallo:', err.message);
  });