JavaScript Promises Tutorial con ejemplos

Si bien estaba disponible anteriormente en bibliotecas de terceros, se introdujeron promesas en JavaScript, como nativo
característica, con ECMAScript6.

Proporcionan una alternativa a las devoluciones de llamada al tratar con el código asíncrono, proporcionando,
Entre las otras cosas, una forma más limpia de manejar errores. En este tutorial veremos cómo funcionan las promesas, cómo
Crearlos y cómo usar sus métodos.

En este tutorial aprenderás:

• ¿Qué es una promesa de JavaScript?.
• Cómo crear una promesa de JavaScript.
• Cómo se pueden usar promesas para administrar el código asíncrono.
• ¿Cuáles son los métodos que se pueden usar con una promesa?.

Requisitos y convenciones de software utilizados

¿Qué es una "promesa"??

En JavaScript, un promesa es un objeto devuelto como resultado de
una operación asincrónica y no bloqueando, por ejemplo, la realizada por el buscar
función construida. Las promesas se introdujeron como una característica nativa, con ECMAScript6: representan un
Alternativa más limpia a las devoluciones de llamada, gracias a características como el encadenamiento de métodos y el hecho de que proporcionan un
Manera de administrar errores que se asemejan al manejo de excepciones en código síncrono. Hay tres estados un prometido
puede estar en:

• Pendiente
• Resuelto
• Rechazado

Como su nombre indica, decimos que una promesa es pendiente Cuando su resultado aún no se ha decidido,
Entonces todavía se puede resolver o rechazar. Decimos que una promesa es satisfecho Cuando el asíncrono
La operación ha tenido éxito: la promesa se ha resuelto y contiene el resultado de la operación misma.
Finalmente, se dice que una promesa es rechazado Cuando la operación asincrónica falla: en ese caso el
La promesa contendrá el motivo de la falla.

Creando una promesa de JavaScript

Como se mencionó anteriormente, algunas funciones que realizan operaciones asíncronas, como buscar, devolver
Una promesa de forma predeterminada, por lo que podemos usar los métodos y los patrones que describiremos más adelante en este tutorial fuera de la casilla. Otras funciones
todavía no admite promesas, por lo que es posible que deseemos crear una promesa a su alrededor. El constructor de una promesa toma un argumento,
que es una función de devolución de llamada que en sí misma toma dos argumentos: el resolver y rechazar devoluciones de llamada que
están llamados a resolver o rechazar la promesa, respectivamente. Veamos un ejemplo rápido sobre cómo crear una promesa trivial:

const promise = new Promise (function (resolve, rechazar) setTimeOut (resolve, 100, 'éxito!'); ); 

Con el código anterior, creamos una promesa, que en realidad siempre se resolverá, porque al usar el
settimeut función, llamamos al resolver devolución de llamada después de un tiempo de espera de 100 milisegundos,
Pasando la cadena "éxito!"Como el único argumento de la devolución de llamada. De la misma manera, si quisiéramos la promesa
Para ser rechazados, deberíamos haber invocado el rechazar llamar de vuelta. Obviamente una promesa como la
Uno de arriba no es muy útil para nosotros, por lo que ahora intentaremos crear una promesa en torno a una función realmente útil.

El archivo de lectura método del FS módulo, lee asíncronamente el contenido de un archivo, y
Toma tres argumentos: dos de ellos son obligatorios y uno es opcional. El primer argumento es la ruta del archivo
ser leído. El segundo argumento es opcional, y con él, podemos, por ejemplo, especificar el
codificación para ser utilizado. El tercer argumento es una función de devolución de llamada, que toma dos argumentos:
errar y datos.

Si la operación de lectura falla, el primer argumento contendrá un Error
objeto y el segundo estará indefinido; Si la operación es exitosa, en cambio, el segundo argumento será un
cadena que representa el contenido del archivo, o un búfer en bruto si no se especifica la codificación, mientras que el primer argumento
ser nulo. Diga, por ejemplo, quiero leer mi .vimrc archivo usando esta función:

const fs = require ('fs'); FS.readfile ('.vimrc ',' utf-8 ', function (err, data) if (err) throw err console.Dato de registro) ); 

En primer lugar, requerimos el FS módulo y lo asignó al FS constante, que
procedimos a invocar el archivo de lectura método. En la devolución de llamada aceptada como el último argumento de la función, realizamos
las operaciones necesarias dependiendo del resultado obtenido. En el código anterior nosotros tirar Una excepción si se produce algún error
Al intentar leer el archivo, mientras solo imprimimos el contenido del archivo si todo va como se esperaba. En este caso esto sería
el resultado (truncado):

[…] SET fileFormat = unix set textWidth = 79 set noswapFile set foldmethod = sangría set foldLevel = 99 set splitright set splitBeLow set hlsearch set incsearch set ignorecase set smartcase […] 

El método que acabamos de usar, archivo de lectura, Realiza la operación de lectura de forma asincrónica, por lo que no está bloqueando. Por defecto, no lo hace,
Sin embargo, las promesas de apoyo. Si queremos "promisificar" el uso de este método, debemos crear una promesa a su alrededor:

const fs = require ('fs'); function readFilePromise (filePath) return new promise (function (resolve, rechazar) fs.readFile (filePath, 'utf-8', function (err, data) if (err) rechazar (err); else resolve (data);); );  

Mira el código anterior, ¿qué hemos cambiado?? Creamos el readFilePromise Función: dentro de ella
una promesa basada en el resultado del FS.archivo de lectura se crea y devuelve el método. En el ejemplo anterior,
Ajustamos el código para lanzar una excepción si había un error en la operación de lectura: en este caso, ya que nosotros
están desarrollando una promesa, si ocurre un error, llamamos al rechazar devolución de llamada, pasando el error como su único argumento,
De esta manera rechazando la promesa. Si la operación de lectura se realiza con éxito, en su lugar, llamamos resolver, paso
Los datos resultantes de la operación de lectura como argumento, cumpliendo así la promesa. En el próximo párrafo veremos cómo
para consumir realmente la promesa que acabamos de crear.

Métodos de promesa

Un objeto de promesa no sería útil si no tuviéramos formas de interactuar con él y consumirlo. En esta sección lo haremos
Describa los métodos que podemos usar en el objeto de promesa. Cada uno de estos métodos funciona en una promesa y, a su vez, devuelve una promesa
en sí mismo, lo que nos permite crear una "pila" y realizar un método encadenado.

El entonces método

El entonces El método toma dos argumentos, que en realidad son dos devoluciones de llamada para ejecutarse respectivamente cuando la promesa
se cumple y cuando se rechaza, y devuelve una promesa. Pegando con el ejemplo anterior, así es como podríamos usar este método
para interactuar con la promesa devuelta cuando llamamos al readFilePromise función:

readFilePromise ('.vimrc ').luego (function onResolveCallback (datos) consola.Dato de registro); , function OnRjectCallback (razon) consola.log ('El mensaje de error es $ razon'); ) 

Cuando la promesa sale el pendiente estado, y por lo tanto se resuelve o se rechazó, el entonces método su
ejecutado. Si la promesa se resuelve, la primera devolución de llamada (en este caso llamamos las devoluciones de llamada solo para facilitar la comprensión de sus roles)
se ejecuta, su argumento contiene el resultado de la operación asincrónica (en este caso el contenido del ".archivo vimrc "como una cadena).
Si la promesa se rechaza, en cambio, la segunda devolución de llamada (la llamamos onrejectCallback) se ejecutaría: su argumento contendrá el error
lo que hizo que la operación de lectura fallara.

El atrapar método

A diferencia de entonces, que maneja tanto cuando una promesa se resuelve y se rechazó, el atrapar El método es más específico,
y trata solo con el último caso. Usar este método es el equivalente de usar entonces con indefinido como el
Primer argumento, en lugar de la devolución de llamada utilizada para manejar el caso cuando se cumple la promesa, y con una devolución de llamada válida para manejar el
caso cuando se rechaza la promesa, como la segunda. Este método devuelve una promesa, y al usarla, podemos reescribir el código de esta manera:

readFilePromise ('.vimrc ') // adentro' entonces 'gestionamos el caso cuando se cumple la promesa, tratando // con posibles errores dentro de' capturar ' .luego (función (datos) consola.Dato de registro); ) .Catch (función (razón) consola.log ('El mensaje de error es $ razon'); ) 

Observe cómo adjuntamos el atrapar método después entonces: Esto es posible
Porque, como dijimos anteriormente, cada método devuelve una promesa en sí misma, por lo que pueden ser encadenados.

El finalmente método

Como los métodos que vimos arriba, finalmente Devuelve una promesa. Siempre se ejecuta independientemente del estado de la promesa,
Ambos si se resuelve o se rechaza. Por esta razón, la devolución de llamada no toma argumentos, ya que cuando se ejecuta no hay forma de determinar
Si la promesa ha sido rechazada o resuelta. Usamos este método cuando queremos ejecutar código genérico que se debe ejecutar en cualquier caso.

readFilePromise ('.vimrc ') .luego (función (datos) consola.Dato de registro); ) .Catch (función (razón) consola.log ('El mensaje de error es $ razon'); ) .Finalmente (function () consola.log ("Siempre estoy ejecutado!");) 

En el ejemplo anterior, si la promesa se resuelve o rechaza, la cadena "Siempre estoy ejecutada!"Está impreso en la consola.

El carrera método

Este método toma una iterable (una matriz, por ejemplo) como su argumento. Devuelve una promesa que se resuelve o se rechazó tan pronto como un
La promesa contenida en el iterable, existe el estado pendiente y se rechaza o resuelve. La promesa devuelta, tendrá el
valor de cumplimiento o la razón de rechazo de dicha promesa.

const p1 = new promise (function (resolve, rechazar) setTimeOut (resolve, 100, 'resuelto!'); ); const p2 = new promise (function (resolve, rechazar) setTimeOut (rechazar, 50, 'rechazado!'); ); Promesa.raza ([P1, P2]) .luego (función (datos) consola.Dato de registro); ) .Catch (función (razón) consola.registro (razón); ) 

En este ejemplo creamos dos nuevas promesas: la primera, P1, se resolverá después de 100 milisegundos;
el segundo, p2, será rechazado después de 50 milisegundos. Pasamos un iterable que contiene ambas promesas como la
argumento único del Promesa.carrera método. Si ejecutamos el código anterior, obtenemos el siguiente resultado:

rechazado!

Qué pasó? Como se esperaba el p2 La promesa es la primera en resolver (es rechazado), en consecuencia la promesa
devuelto por el Promesa.carrera método, rechaza con la misma razón. Como puede ver, el estado de la promesa no es relevante:
el primero que realmente obtiene un estado más que pendiente es el que importa.

El todo método

Como carrera, el todo El método toma un iterable como su único argumento. Devuelve una promesa que
se resolverá una vez que todas las promesas contenidas en el Iterer se resolverán (o cuando el Iterable no contenga promesas) o Will
rechazar con la razón de la primera promesa en el iterable que rechazará. Por ejemplo:

const p1 = new promise (function (resolve, rechazar) setTimeOut (resolve, 100, 'P1 resuelto!'); ) const p2 = new promise (function (resolve, rechazar) setTimeOut (resolve, 100, 'p2 resuelto!'); ) Promesa.Todos ([P1, P2]) .luego (función (valores) consola.log (valores); ) 

El código anterior volverá:

['P1 resuelto!',' P2 resolvió!']

Todas las promesas contenidas en el iterable resuelto, por lo que la promesa pendiente devuelta por el todo método
Resuelto también, su valor es una matriz que contiene los valores de todas las promesas resueltas. Si uno (y tan pronto como) una de las promesas
En los rechazos iterables, la promesa devuelta por el método también rechaza, con la misma razón. Si el iterable se pasó como argumento
estado vacío, una promesa ya resuelta habría sido devuelta. Si el iterable no contuviera promesas, el método habría devuelto
una promesa resuelta asíncrona o una prometida ya resuelta dependiendo del entorno.

El resolver y rechazar métodos

Estos dos métodos se explican por sí mismos.

El resolver El método toma un argumento que es el valor a resolver por la promesa.
Devuelve una promesa que se resuelve con ese valor. El rechazar El método, de manera similar, toma un argumento que es la razón con
La promesa debe ser rechazada y devolver una promesa que se rechaza con la razón dada. Por ejemplo:

// Resolver una promesa de promesa.resolución ('valor resuelto'); // rechazar una promesa de promesa.rechazar ('razón para rechazar'); 

Conclusiones

En este tutorial aprendimos a conocer y usar promesas en JavaScript. Vimos cómo podemos construir nuestras propias promesas, cuáles son los métodos asociados
con una promesa, y cómo podemos usarlo para administrar el código asíncrono, como una alternativa más limpia a las devoluciones de llamada. Una fuente válida para aumentar aún más
Su conocimiento de las promesas es el proporcionado por Mozilla.
En el próximo tutorial de JavaScript aprenderemos a usar Funciones de flecha. Estén atentos en LinuxConfig.organizar!

Tutoriales de Linux relacionados:

• Cómo construir una aplicación Tkinter utilizando un objeto orientado ..
• Tutorial de depuración de GDB para principiantes
• Cómo trabajar con la API REST de WooCommerce con Python
• Expresiones regulares de Python con ejemplos
• Bash Regex avanzado con ejemplos
• Mastering Bash Script Loops
• Bucles anidados en guiones Bash
• Cómo configurar un servidor OpenVPN en Ubuntu 20.04
• Instale Arch Linux en VMware Workstation
• Bash Loops con ejemplos