Promesas en Node.js.

P

Introducción

JavaScript es de un solo hilo, lo que significa que todo, incluidos los eventos, se ejecuta en el mismo hilo. Si el hilo no está libre, la ejecución del código se retrasa hasta que lo esté. Esto puede ser un cuello de botella para nuestra aplicación, ya que puede crear serios problemas de rendimiento.

Hay varias formas en las que podemos superar esta limitación. En este artículo, exploraremos la forma moderna de manejar tareas asincrónicas en JavaScript: Promises.

Devuelve las llamadas y el infierno devuelve las llamadas

Si es un desarrollador de JavaScript, probablemente haya oído hablar de las llamadas, si no se utilizan:

function hello() {
    console.log('Hello World!');
}

setTimeout(hello, 5000);

Este código tiene una función, setTimeout(), que permanece durante el período especificado (en milisegundos), pasado como segundo argumento, 5000. Pasado el tiempo, simplemente ejecuta la función hello, se le pasa como primer parámetro.

La función es un ejemplo de una función de orden superior y se recupera la función que se le transfiere, una función que debe realizarse después de que se complete otra función.

Supongamos que enviamos una aplicación a la API para devolver las fotos que más me gustan a nuestra cuenta. Es posible que tengamos que esperar la respuesta, ya que la API o el servicio pueden estar haciendo algunos cálculos antes de devolver la respuesta.

Esto puede llevar mucho tiempo y no queremos congelar el hilo mientras esperamos la respuesta. En su lugar, crearemos un retiro que se notificará cuando llegue la respuesta.

Hasta entonces, se está ejecutando el resto del código, como presentar publicaciones y anuncios.

Si alguna vez ha trabajado con la devolución de llamada, es probable que haya visto un infierno de devolución de llamada:

doSomething(function(x) {
    console.log(x);
    doSomethingMore(x, function(y) {
        console.log(y);
        doRestOfTheThings(y, function(z) {
            console.log(z);
        });
    });
});

Imagine una situación en la que le pedimos al servidor que obtenga varios recursos: una persona, sus amigos y las publicaciones de sus amigos, los comentarios en las publicaciones de cada amigo, las respuestas, etc.

La gestión de estas dependencias anidadas puede salirse de control rápidamente.

Podemos evitar el infierno de devolución de llamadas y manejar llamadas asincrónicas usando Promises.

Creando un compromiso

Promises, como su nombre lo indica, la función de “dar una palabra” es devolver un valor más tarde. Es un proxy de un valor que no se puede devolver, a menos que la función de la que esperamos una respuesta.

En lugar de devolver valores concretos, estas funciones asincrónicas devuelven un Promise objeto, que se cumplirá en algún momento o no.

A menudo, cuando codificamos, usamos Promises en lugar de crearlos. Son las bibliotecas / marcos los que crean Promises para que los clientes coman.

Aún así, lo bueno está detrás de la creación de un Promise:

let promise = new Promise(function(resolve, reject) {
    // Some imaginary 2000 ms timeout simulating a db call
    setTimeout(()=> {
        if (/* if promise can be fulfilled */) {
            resolve({msg: 'It works', data: 'some data'});
        } else {
            // If promise can not be fulfilled due to some errors like network failure
            reject(new Error({msg: 'It does not work'}));
        }
    }, 2000);
});

El constructor de la promesa tiene un argumento: un retiro. La devolución de llamada puede ser una función normal o una función de flecha. La recuperación toma dos parámetros: resolve y reject. Ambos son referencias de funciones. La revocatoria también se denomina albacea.

El ejecutor se ejecuta inmediatamente cuando se crea una promesa. La promesa se resuelve con una llamada. resolve() si la promesa se cumple y se rechaza por llamada reject() si no se puede cumplir.

Ambos resolve() y reject() un argumento asume – boolean, string, number, array, o la object.

Consumo de compromiso

A través de API, digamos que hemos solicitado algunos datos del servidor y no estamos seguros de cuándo se devolverán, ¿se devolverán en absoluto? Este es un ejemplo perfecto de cuando usamos un Promise Para ayudarnos.

Suponiendo que el modo de servidor que maneja nuestra llamada devuelve un Promise, podemos comerlo:

promise.then((result) => {
    console.log("Success", result);
}).catch((error) => {
    console.log("Error", error);
})

Como vemos, tenemos dos métodos con una cadena: then() y catch(). No hay muchos de estos métodos diferentes proporcionados por el Promise objeto.

then() ejecutar cuando las cosas vayan bien, es decir, que el resolve() método. Y si la promesa fue rechazada, el catch() el método referido como el error enviado a reject.

Compromisos encadenados

Si tenemos una secuencia de tareas asincrónicas, una tras otra, que es necesario realizar, cuanto más incrustada está, más pesado se vuelve el código.

Eso nos lleva a ser llamados infierno, que se puede evitar fácilmente encadenando algunos then() métodos en individuo Promised resultado:

promise.then(function(result) {
    // Register user
    return {account: 'blahblahblah'};
}).then(function(result) {
    // Auto login
    return {session: 'sjhgssgsg16775vhg765'};
}).then(function(result) {
    // Present WhatsNew and some options
    return {whatsnew: {}, options: {}};
}).then(function(result) {
    // Remember the user Choices
    return {msg: 'All done'};
});

Como vemos, el resultado se pone a través de una cadena. then() manipuladores:

  • El frente promise resuelve objeto
  • Entonces la then() Se llama a un controlador para registrar un usuario
  • El valor que devuelve se envía al siguiente valor. then() controlador para registrar automáticamente al usuario
  • … y así

También el then(handler) puede crear y devolver una promesa.

Nota: Si bien técnicamente podemos hacer algo como el ejemplo en el futuro, puede desviarse del punto de encadenamiento. Si bien esta técnica puede ser buena cuando necesita llamar selectivamente métodos asincrónicos:

let promise = new Promise(function(resolve, reject) {
    setTimeout(() => resolve({msg: 'To do some more job'}), 1000);
});

promise.then(function(result) {
    return {data: 'some data'};
});

promise.then(function(result) {
    return {data: 'some other data'};
});

promise.then(function(result) {
    return {data: 'some more data'};
});

Todo lo que estamos haciendo aquí es agregar algunos controladores a un compromiso, y todos ellos hacen lo result independientemente. No se están dando el resultado en la secuencia.

De esta manera, todos los manejadores reciben el mismo resultado, el resultado de esa promesa. {msg: 'To do some more job'}.

Conclusión

Promises, como su nombre lo indica, la función de “dar una palabra” es devolver un valor en un momento posterior. Es un proxy de un valor que no se puede devolver, a menos que la función de la que esperamos una respuesta.

En lugar de devolver valores concretos, estas funciones asincrónicas devuelven un Promise objeto, que se cumplirá en algún momento o no.

Si ha trabajado con llamadas de devolución de llamada, debe respetar una semántica limpia y clara. Promises.

Como desarrollador de nodes / JavaScript, nos ocuparemos de las promesas con más frecuencia. Después de todo, es un mundo asincrónico, lleno de maravillas.

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias para su correcto funcionamiento. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad