Promesa en Node.js

Node.js es un entorno de tiempo de ejecución popular que permite a los desarrolladores crear aplicaciones escalables y eficientes. Una de las características principales de Node.js es su capacidad para manejar código asíncrono, que es esencial para crear aplicaciones de alto rendimiento. El código asíncrono puede ser un desafío de administrar, especialmente cuando se trata de operaciones complejas o tareas de ejecución prolongada. Aquí es donde entran las promesas, que brindan una manera simple y efectiva de manejar las operaciones asincrónicas en Node.js.

En este artículo, exploraremos el concepto de promesas en Node.js y por qué son importantes para crear aplicaciones modernas.

¿Qué es una promesa?

En términos simples, una promesa es un objeto que representa un valor que puede no estar disponible todavía. Las promesas se utilizan para manejar operaciones asincrónicas en JavaScript, como realizar solicitudes de red o leer archivos del disco.

Una promesa tiene tres estados:

• Pendiente: el estado inicial de una promesa, que indica que el valor aún no está disponible.
• Cumplido: el estado de una promesa cuando la operación es exitosa y el valor está disponible.
• Rechazado: el estado de una promesa cuando la operación falló y ocurrió un error.

Crear una promesa en Node.js

Crear una promesa en Node.js es sencillo. Usamos el constructor Promise para crear una nueva promesa y pasar una función que realiza la operación asíncrona. La función toma dos argumentos, resolver y rechazar, que indican si la operación fue exitosa o no.

Aquí hay un ejemplo que crea una promesa que se resuelve después de un retraso de un segundo:

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Operation successful!');
  }, 1000);
});

Manejo de resultados de promesa

Una vez que se crea una promesa, podemos usar el método then para manejar los resultados. El método then toma dos funciones como argumentos, una para manejar una operación exitosa y otra para manejar un error.

Aquí hay un ejemplo que usa la promesa creada anteriormente para registrar el resultado en la consola:

myPromise.then((result) => {
  console.log(result);
}).catch((error) => {
  console.error(error);
});

Encadenando Promesas

Una de las características poderosas de las promesas es la capacidad de encadenarlas. Esto nos permite realizar una serie de operaciones asincrónicas en una secuencia, sin devoluciones de llamadas anidadas.

Aquí hay un ejemplo que encadena dos promesas juntas:

const getUser = (id) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const user = { id, name: 'John Doe' };
      resolve(user);
    }, 1000);
  });
};

const getPosts = (user) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const posts = [{ id: 1, title: 'Post 1' }, { id: 2, title: 'Post 2' }];
      resolve({ user, posts });
    }, 1000);
  });
};

getUser(1)
  .then(getPosts)
  .then((result) => {
    console.log(result);
  })
  .catch((error) => {
    console.error(error);
  });

#nodejs #javascript #blockchain #promise #fullstackdeveloper