Hablando de promesas - parte 1

Si alguna vez has desarrollado en javascript ya sea como Backend o Frontend, te habrás enfrentado a operaciones asíncronas, probablemente en alguna operación de red, base de datos u otra operación que tenga que ver con entrada y salida de datos. Si lo has hecho, seguramente conoces los callbacks.

En un principio los callbacks se ven tiernos e indefensos.

fs.readFile('file', (err, data) => {
   if (err) throw err;
   console.log(data);
 });

Normalmente no tendrías problemas con ellos… a menos que tuvieras que realizar una secuencia de operaciones asíncronas, es en ese momento cuando abres la puerta de ese extraño y doloroso lugar llamado “callback hell”.

Aunque existen ciertos métodos para hacer un poco más manejable esta situación, el código se vuelve muy confuso.

Y es aquí cuando las promesas vinieron a salvarnos, no voy a ahondar mucho en detalles sobre que son las promesas, solo tocaré puntos básicos ya que Mozilla y Google pueden explicarlo mejor que yo.

Una promesa es un mecanismo que nos permite la ejecución de operaciones asíncronas y obtener el resultado de esa operación. Una promesa puede ejecutarse satisfactoriamente o fallar.

Una promesa tiene 3 estados :

• pending : aun no se ha terminado la operación o ha fallado.
• fullfilled : la promesa terminó satisfactoriamente.
• rejected : la promesa fue rechazada.

Para capturar el resultado de esa promesa tenemos 2 métodos:

• then : método con el cual podemos capturar una promesa que se ha cumplido y también puede capturar cuando una promesa rechazada.
• catch : método con el cual podemos capturar una promesa que fue rechazada.

Puntos importantes sobre las promesas:

• No son callbacks
• Son poderosas y peligrosas, si creas una promesa, no se resuelve o rechaza y quieres capturar su resultado, podrías dejarla viva en el proceso.
• Al rechazar una promesa esta va hacia el primer catch que encuentre.

En este ejemplo vamos a crear una promesa, esta recibe una función con 2 parámetros resolve y reject, uno de estos debe ejecutarse para indicar el cambio de estado de la promesa. Estos métodos también pueden recibir parámetros al momento de ejecutarse y así cuando se use then o catch podamos recibir lo que se ha enviado.

Ejemplo completo en https://github.com/dezkareid/promises-samples/blob/master/hello_promise.js

Las promesas son encadenables y se ejecutan todas las operaciones en secuencia a menos que haya un error. La desventaja de esto es que no podemos tener pasos opcionales(no de una manera fácil), pero podemos encapsular esas promesas en métodos y con ello podemos elegir si resolver una promesa u otra dependiendo de las condiciones de nuestro programa, como se muestre en este diagrama mal hecho:

Diagrama mal hecho

En la implementación en código, se hizo la simulación de una serie de pasos para validar datos y otra para validar políticas, la primera es obligatoria para cualquier usuario y la última no lo es si es un usuario admin, en caso contrario se aplicara este conjunto de promesas.

Ejemplo completo https://github.com/dezkareid/promises-samples/blob/master/multi_chaining.js

Este tipo de organización en nuestra lógica nos facilita el mantenimiento de cierta funcionalidad específica. Y evita que tengamos que hacer promesas anidadas o tener callbacks dentro de nuestras promesas (fui un monstruo alguna vez).

Gracias por leer, les dejo un repositorio que hice para que vean como podemos utilizar promesas con algunos ejemplos. En la parte 2 hablaremos sobre arreglos de promesas y otras cosillas divertidas.

Si quieren que haga vídeo explicando esto comenten :)