¿Qué son las promesas en JavaScript y cómo crearlas?
JavaScript es un lenguaje de programación que destaca por su versatilidad y eficacia, lo que se debe en parte a su capacidad de realizar operaciones asincrónicas. Al ser «single threaded» (un solo hilo), sólo puede ejecutar una acción al mismo tiempo, por lo que el uso de promesas facilita, en buena medida, el control de flujos de datos asíncronos en una aplicación.
Por ello, si estás pensando en crear una página web, sigue leyendo este artículo para profundizar más en en el concepto de promesa y su utilidad.
¿Qué es una promesa en JavaScript?
Las promesas en JavaScript no solo representan el resultado de una operación asincrónica, sino que también proporcionan métodos que facilitan el manejo y la manipulación de los datos una vez que la promesa se resuelve.
Una promesa es un objeto que representa un valor que puede que esté disponible «ahora», en un «futuro» o que «nunca» lo esté. Como no se sabe cuándo va a estar disponible, todas las operaciones dependientes de ese valor, tendrán que posponerse en el tiempo.
Métodos de las promesas en JavaScript
Aquí están algunos de los métodos más comunes que puedes utilizar:
- .then(): Este método se utiliza para manejar el resultado exitoso de una promesa. Recibe una función que se ejecutará cuando la promesa se resuelva con éxito y puede recibir el resultado como argumento.
- .catch(): Se utiliza para manejar errores que puedan ocurrir durante la ejecución de la promesa. Puedes encadenar .catch() después de .then() para manejar errores específicos.
- .finally(): Este método se utiliza para ejecutar una función después de que la promesa se resuelva o se rechace, independientemente del resultado. Es útil para realizar tareas de limpieza o acciones que deben ocurrir sin importar el resultado de la promesa.
- Promise.all(iterable): Este método permite manejar múltiples promesas al mismo tiempo y resuelve una promesa una vez que todas las promesas del iterable se hayan resuelto o alguna de ellas se haya rechazado.
- Promise.race(iterable): Este método resuelve una promesa tan pronto como una de las promesas en el iterable se resuelva o se rechace. Es útil cuando deseas obtener el resultado más rápido de múltiples promesas.
Estados de las promesas en JavaScript
Una promesa puede estar en los siguientes tres estados:
- Pendiente (pending). Es el estado inicial al crear una promesa.
- Resuelta con éxito (fulfilled). Estará resuelta en el momento que llamemos a resolve y, a continuación, se ejecutará la función que pasamos al método .then. Debemos de tener en cuenta que, una vez resuelta, no podremos modificar el valor de la promesa, aunque sí podríamos correr la misma instrucción para obtener un valor distinto y hacerlo las veces que deseemos.
- Rechazada (rejected). También puede ocurrir que se complete pero sea rechazada por un error, pasando a continuación a ejecutar la función que pasamos a .catch.
Cómo se crea una promesa en JavaScript
Se puede crear una promesa con el constructor promise y pasándole una función con dos parámetros: resolve y reject, que nos deja decirle si ha sido resuelta o rechazada.
const promise = new Promise((resolve, reject) => {
const number = Math.floor(Math.random() * 12);
setTimeout(
() => number > 4
? resolve(number)
: reject(new Error('Menor a 4')),
2000
);
});
promise
.then(number => console.log(number))
.catch(error => console.error(error));
En el ejemplo, hemos creado una promesa que se completará en 2 segundos. Si el número aleatorio que hemos generado es mayor a 4, se resolverá; en caso contrario, se rechaza y se muestra un error.
Promesas en JavaScript en cadena (Chaining)
En ocasiones, necesitamos ejecutar varias operaciones asíncronas una tras otra, o lo que es lo mismo, después de una operación ejecutada con éxito, comienza la siguiente. Esto tiene fácil resolución utilizando una secuencia de promesas en cadena.
El archivo, que vamos a llamar texto.txt, devuelve una cadena con la ubicación de otro archivo y seguido de esto, queremos leer ese segundo archivo. Utilizando promesas, quedaría así:
readFile('./texto.txt')
.then(readFile)
.then(data => console.log(data))
.catch(error => console.error(error));
Lo que hacemos es leer texto.txt.
- Si ocurre un error, la promesa se rechaza y mostramos el error con console.error.
- Si lo lee, ejecutamos su lectura en el primer .then y corremos un nuevo readFile.
Este segundo readFile devuelve una nueva promesa.
- Si hay un error, ejecuta el .catch
- Si no, se ejecuta el segundo .then, que recibe el contenido del segundo archivo y lo muestra en consola.
Podremos encadenar tantos .then como necesitemos y ejecutar funciones que devuelvan promesas.
Ejemplo de promesa en cadena
import { resolve } from 'path';
readFile('./texto.txt.')
.then(resolve)
.then(readFile)
.then(data => console.log(data))
.catch(error => console.error(error));
Conclusiones sobre las promesas en JavaScript
Las promesas en JavaScript son una herramienta que nos ayuda a manejar operaciones asincrónicas de manera eficiente. Por ello, usarlas de manera adecuada es fundamental para el correcto desarrollo de aplicaciones web, ya que son acciones que se resolverán a futuro (cuando se pueda) y que sabremos si se llevaron a cabo con éxito o no.
Así, las promesas son un componente importante dentro de la programación y su dominio es una habilidad valiosa para cualquier desarrollador. Además, su importancia se extiende hasta el ámbito del hosting web y los dominios, donde las operaciones asincrónicas y la eficiencia en la ejecución son clave para el funcionamiento óptimo de sitios web.
Desarrollador web, crea y mantiene los sitios web de Arsys. También idea herramientas internas que facilitan y mejoran los procesos. Es experto en desarrollo FrontEnd y en la optimización del rendimiento web, áreas en las que constantemente busca innovar para ofrecer la mejor experiencia online.