Promesas en JavaScript

• En JavaScript, las promesas son objetos que representan la finalización (éxito) o el fracaso de una operación asíncrona.

Creación de Promesas

• Una promesa se crea utilizando el constructor Promise, que acepta una función como argumento llamada "executor".
• La función executor recibe dos argumentos: resolve y reject, que son funciones proporcionadas por JavaScript.
• resolve se utiliza para indicar que la operación asíncrona se ha completado con éxito.
• reject se utiliza para indicar que la operación asíncrona ha fallado.
• Ejemplo básico:

const miPromesa = new Promise((resolve, reject) => {
  // Operación asíncrona (ejemplo: setTimeout)
  setTimeout(() => {
    const exito = true; // o false
    if (exito) {
      resolve("¡Éxito!"); // La promesa se cumple
    } else {
      reject("¡Error!");  // La promesa se rechaza
    }
  }, 1000);
});

• Para crear una promesa, se utiliza el constructor new Promise(), que toma una función como argumento.
• Esta función recibe dos argumentos: resolve y reject, que son a su vez funciones.
• resolve se llama para indicar que la promesa se resolvió satisfactoriamente, pasando el valor resultante.
• reject se llama para indicar que la promesa falló, pasando un objeto de error o una razón.
• Dentro de la función del constructor, se realiza la operación asíncrona. Si tiene éxito, se llama a resolve; si falla, se llama a reject.
• Una promesa puede estar en uno de tres estados: pendiente (pending), resuelta (fulfilled) o rechazada (rejected).
• Una vez que una promesa se resuelve o se rechaza, su estado es inmutable.

Métodos .then() y .catch()

• Las promesas tienen métodos .then() y .catch() para manejar el resultado de la operación asíncrona.
• .then() se utiliza para manejar el caso donde la promesa se cumple (resolve).
• .catch() se utiliza para manejar el caso donde la promesa se rechaza (reject).
• Ejemplo:

miPromesa
.then((resultado) => {
    console.log("Resultado:", resultado); // Se ejecuta si la promesa se cumple
  })
  .catch((error) => {
    console.error("Error:", error);       // Se ejecuta si la promesa se rechaza
  });

• .then() y .catch() siempre regresan una promesa, lo que permite encadenarlos.
• .then(): Agrega un callback a ser ejecutado cuando la promesa se resuelve.
• .catch(): Agrega un callback a ser ejecutado cuando la promesa se rechaza.

Promesas Encadenadas

• El encadenamiento de promesas permite ejecutar una serie de operaciones asíncronas en secuencia.
• Cada .then() recibe el resultado del .then() anterior (o el resultado de la promesa original si es el primero).
• Si un .then() retorna una promesa, el siguiente .then() esperará a que esa promesa se resuelva antes de ejecutarse.
• Ejemplo:

const obtenerDatos = () => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve("Datos obtenidos");
    }, 1000);
  });
};

const procesarDatos = (datos) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(datos + " procesados");
    }, 1000);
  });
};

obtenerDatos()
  .then((datos) => {
    console.log("Datos:", datos);
    return procesarDatos(datos); // Retorna otra promesa
  })
  .then((datosProcesados) => {
    console.log("Datos Procesados:", datosProcesados);
  })
  .catch((error) => {
    console.error("Error:", error);
  });

• En este ejemplo, obtenerDatos se ejecuta primero, luego procesarDatos con el resultado de obtenerDatos, y finalmente se muestra el resultado procesado.
• Las promesas se pueden encadenar utilizando .then() para secuenciar operaciones asíncronas.
• Cada .then() recibe el resultado de la promesa anterior y puede transformar o procesar ese resultado.
• Si una función dentro de .then() retorna una nueva promesa, la cadena esperará a que esa promesa se resuelva antes de continuar.
• Esto permite una secuencia de operaciones asíncronas más legible y manejable que los callbacks anidados.
• El encadenamiento facilita la ejecución de tareas en un orden específico y el paso de resultados entre ellas.

Manejo de Errores

• Es crucial manejar los errores en las promesas para evitar que la aplicación falle silenciosamente.
• Se puede usar .catch() al final de la cadena de promesas para capturar cualquier error que ocurra en cualquier parte de la cadena.
• También se pueden usar bloques try...catch dentro de las funciones .then() para manejar errores específicos que puedan ocurrir durante el procesamiento.
• Ejemplo:

const promesaFallida = () => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      reject("Promesa fallida");
    }, 1000);
  });
};

promesaFallida()
  .then((resultado) => {
    console.log("Resultado:", resultado); // No se ejecuta
  })
  .catch((error) => {
    console.error("Error capturado:", error); // Se ejecuta
  });

• También se puede utilizar throw dentro de un bloque then para pasar el error al bloque catch más cercano.
• Ejemplo:

obtenerDatos()
  .then(datos => {
        if (!datos) {
            throw new Error("No se encontraron datos")
        }
        return procesarDatos(datos)
    })
  .then((datosProcesados) => {
    console.log("Datos Procesados:", datosProcesados);
  })
  .catch((error) => {
    console.error("Error:", error);
  });

• El manejo de errores en promesas se realiza principalmente a través del método .catch().
• Cualquier error que ocurra dentro de la promesa o en la cadena de promesas se propagará al .catch() más cercano.
• Es fundamental incluir un bloque .catch() al final de la cadena para capturar cualquier error inesperado.
• También se puede usar .finally() para ejecutar código después de que la promesa se resuelva o se rechace, independientemente del resultado.

Asincronía

• La asincronía permite que un programa ejecute múltiples tareas concurrentemente sin bloquear el hilo principal.
• En JavaScript, la asincronía es crucial para manejar operaciones que toman tiempo, como peticiones de red o acceso a la base de datos.
• JavaScript utiliza un modelo de "event loop" para manejar operaciones asíncronas.
• El "event loop" permite al programa responder a eventos y completar tareas en segundo plano sin congelar la interfaz de usuario.

Callbacks Versus Promesas

• Los callbacks son funciones pasadas como argumentos a otras funciones y se ejecutan al completar una operación.
• Las promesas ofrecen una alternativa más estructurada y legible a los callbacks, especialmente para manejar la asincronía.
• Con los callbacks, las operaciones asíncronas anidadas pueden llevar al "callback hell", haciendo el código difícil de leer y mantener.
• Las promesas evitan el "callback hell" al permitir encadenar operaciones de manera secuencial con .then().
• Las promesas mejoran el manejo de errores mediante .catch(), mientras que los callbacks requieren manejo de errores individual para cada operación asíncrona.

API De Promesas

• La API de promesas incluye métodos como .then(), .catch(), .finally(), Promise.all(), Promise.race(), Promise.resolve() y Promise.reject().
• .finally(): Agrega un callback a ser ejecutado cuando la promesa se resuelve o rechaza, sin acceso al valor.
• Promise.all(): Toma un array de promesas y retorna una nueva promesa que se resuelve cuando todas las promesas del array se resuelven.
• Promise.race(): Toma un array de promesas y retorna una nueva promesa que se resuelve o rechaza tan pronto como una de las promesas del array se resuelve o rechaza.
• Promise.resolve(value): Crea una promesa que se resuelve inmediatamente con el valor dado.
• Promise.reject(reason): Crea una promesa que se rechaza inmediatamente con la razón dada.