Usando promesas en JavaScript

De vez en cuando publicamos materiales que de una forma u otra se relacionan con el uso de promesas en JavaScript.


¿Por qué se presta tanta atención a las promesas? Creemos que el punto es que esta tecnología tiene mucha demanda y que es bastante difícil de entender.

Por lo tanto, si desea comprender mejor las promesas, le ofrecemos una traducción del próximo artículo sobre este tema. Su autor dice que ha estado desarrollando Java y PHP durante los últimos 10 años, pero todo este tiempo ha estado buscando con interés en JavaScript. Recientemente, decidió participar seriamente en JS, y las promesas se convirtieron en el primer tema que le interesó.



Creemos que este material será interesante para los desarrolladores novatos que sienten que, aunque usan promesas, no los entienden lo suficientemente bien. Es posible que la historia de alguien que mira JavaScript con una mirada fresca y quiera explicar a otros lo que él mismo entendió, sin creer que algunas cosas son entendibles para todos sin una explicación, ayudará a los principiantes a dominar los mecanismos de JavaScript.

JavaScript a través de los ojos de un principiante

Cualquiera que comience a escribir en JavaScript, puede sentir lo que se llama "fuera de lugar". Algunos dicen que JS es un lenguaje de programación síncrono, otros dicen que es asíncrono. Un principiante escucha sobre el código que bloquea el hilo principal, y sobre el código que no lo bloquea, sobre los patrones de diseño basados ​​en eventos, sobre el ciclo de vida de los eventos, sobre la pila de llamadas a funciones, sobre la cola de eventos y su ascenso, sobre polyfills. Aprende que existen cosas como Babel, Angular, React, Vue y una miríada de otras bibliotecas. Si acaba de reconocerse como un "novato", no se preocupe por eso. No eres ni el primero ni el último. Incluso hay un término para esto: la llamada "fatiga de JavaScript". Lucas F Costa habló acertadamente sobre este tema: "La fatiga de JavaScript es algo que se puede observar cuando las personas usan herramientas que no necesitan para resolver problemas que no tienen ".

Pero no hablemos de cosas tristes. Entonces, JavaScript es un lenguaje de programación síncrono que, gracias al mecanismo de devolución de llamada, le permite llamar a funciones de la misma manera que en lenguajes asíncronos.

Una historia simple sobre promesas

La palabra promesa se traduce como promesa. Los objetos de promesa en la programación, que llamamos "promesas", son muy similares a las promesas habituales que las personas se hacen en la vida real. Entonces hablemos de estas promesas primero.

En Wikipedia, puede encontrar la siguiente definición de la palabra "promesa": "obligación, el consentimiento de alguien para cumplir algo o, por el contrario, no hacer". En el diccionario de Ozhegov, "promesa" es "un compromiso voluntario de hacer algo".

Entonces, ¿qué sabemos sobre las promesas?

1. Una promesa le garantiza que se hará algo. No importa quién hace exactamente esto: el que hizo la promesa, o alguien más, a petición del que hizo la promesa. Una promesa da confianza en algo, basándose en esta confianza, el que recibió la promesa puede, por ejemplo, hacer algunos planes.
2. Una promesa puede cumplirse o no.
3. Si se cumple la promesa, entonces, como resultado, espera algo que pueda usar en el futuro para llevar a cabo cualquier acción o implementar cualquier plan.
4. Si la promesa no se cumple, entonces querrá saber por qué el que la dio no pudo cumplirla. Después de descubrir el motivo de lo sucedido y de estar seguro de que la promesa no se ha cumplido, puede pensar qué hacer a continuación o cómo hacer frente a la situación.
5. Después de que le hayan prometido algo, todo lo que tiene es algún tipo de garantía. No puede aprovechar lo que le prometieron de inmediato. Puede determinar por sí mismo: qué debe hacer si se cumple la promesa (por lo tanto, recibirá la promesa) y qué debe hacer si se rompe (en este caso, sabe el motivo de lo que sucedió y, por lo tanto, puede considerar un plan de acción de respaldo )
6. Es probable que la persona que hizo la promesa simplemente desaparezca. En tales casos, es útil que la promesa esté vinculada a algún tipo de marco de tiempo. Por ejemplo, si el que le hizo la promesa no aparece en 10 días, puede suponer que tuvo algunos problemas y que rompió la promesa. Como resultado, incluso si el que hizo la promesa la cumple en 15 días, no importará, por lo que ya está actuando en el plan alternativo, no confiando en la promesa.

Ahora pase a JavaScript.

Promesas de JavaScript

Tengo una regla: cuando hago JavaScript, siempre leo la documentación que se puede encontrar en MDN. Me parece que este recurso se compara favorablemente con los otros en especificidad y claridad de presentación. Por lo tanto, mientras estudiaba las promesas, me familiaricé con el material relevante y experimenté con el código para acostumbrarme a las nuevas construcciones de sintaxis.

Para entender las promesas, debe lidiar con dos cosas principales. El primero es la creación de promesas. El segundo es procesar los resultados devueltos por las promesas. Aunque la mayor parte del código que escribimos está dirigido a trabajar con promesas creadas, por ejemplo, por ciertas bibliotecas, una comprensión completa de los mecanismos de trabajo de las promesas será indudablemente útil. Además, para un programador que ya tiene algo de experiencia, saber cómo crear promesas es tan importante como saber cómo trabajar con ellas.

Crea promesas

Así es como se crean las promesas:

new Promise( /* executor */ function(resolve, reject) { ... } ); 

El constructor acepta una función que realiza ciertas acciones, aquí la llamamos executor . Esta función toma dos parámetros: resolve y reject , que, a su vez, también son funciones. Las promesas se usan generalmente para realizar operaciones asíncronas o códigos que pueden bloquear el hilo principal, por ejemplo, uno que trabaja con archivos, realiza llamadas a ciertas API, realiza consultas a la base de datos, trata de E / S, etc. El inicio de tales operaciones asincrónicas se realiza en la función executor . Si la operación asincrónica se completa con éxito, el resultado esperado de la promesa se devolverá llamando a la función de resolve . La situación en la que se llama esta función está determinada por el creador de la promesa. De manera similar, cuando ocurre un error, la información sobre lo que sucedió se devuelve llamando a la función de reject .

Ahora que sabemos, en términos generales, cómo crear promesas, crearemos una promesa simple para comprender mejor todo.

 var keepsHisWord; keepsHisWord = true; promise1 = new Promise(function(resolve, reject) { if (keepsHisWord) {   resolve("The man likes to keep his word"); } else {   reject("The man doesnt want to keep his word"); } }); console.log(promise1); 

Esto es lo que generará este código:


Promise tiene un estado (PromiseStatus) y un valor (PromiseValue)

Dado que nuestra promesa se resuelve instantáneamente, no podemos investigar su estado inicial. Por lo tanto, creemos una nueva promesa que, para su resolución, necesita algo de tiempo. La forma más fácil de hacerlo es mediante la función setTimeout .

 promise2 = new Promise(function(resolve, reject) { setTimeout(function() {   resolve({     message: "The man likes to keep his word",     code: "aManKeepsHisWord"   }); }, 10 * 1000); }); console.log(promise2); 

En este código, se crea una promesa que ciertamente se resolverá en 10 segundos. Esto nos da la oportunidad de ver el estado de una promesa no autorizada.


Promesa no resuelta

Después de que hayan pasado 10 segundos, la promesa se resolverá. Como resultado, tanto PromiseStatus como PromiseValue se actualizarán en consecuencia. Como puede ver, en este ejemplo cambiamos la función llamada cuando la promesa se resolvió con éxito, ahora no devuelve una cadena ordinaria, sino un objeto. Esto se hace para demostrar la capacidad de devolver estructuras de datos complejas utilizando la función resolve .


Promesa resuelta después de 10 segundos y devolviendo un objeto

Veamos ahora la promesa, que decidimos no permitir, sino rechazar. Para hacer esto, modificamos el código que ya se usó en el primer ejemplo.

 keepsHisWord = false; promise3 = new Promise(function(resolve, reject) { if (keepsHisWord) {   resolve("The man likes to keep his word"); } else {   reject("The man doesn't want to keep his word"); } }); console.log(promise3); 

Como no manejamos la situación de rechazo de la promesa, se mostrará un mensaje de error en la consola del navegador (aquí se usa Google Chrome). Hablaremos más sobre esto a continuación.


Promesa rechazada

Ahora, después de analizar los tres ejemplos, podemos ver que tres valores diferentes pueden aparecer en PromiseStatus : pending (pendiente), resolved (resolución exitosa) y rejected (rechazada). Cuando se crea una promesa, en PromiseStatus estará pending y en PromiseValue estará undefined . Estos valores permanecerán hasta que se resuelva o rechace la promesa. Cuando una promesa se encuentra en un estado resolved o rejected , se llama promesa settled . Tal promesa ha pasado de un estado de espera a un estado en el que tiene un estado resolved o un estado rejected .

Ahora que hemos aprendido cómo se crean las promesas, podemos hablar sobre cómo procesar lo que devuelven. Para resolver esto, necesitamos entender la estructura del objeto Promise .

Objeto de promesa

Según la documentación de MDN, un objeto Promise es el resultado de una finalización exitosa o incorrecta de una operación asincrónica.

El objeto Promise tiene métodos estáticos y métodos prototipo del objeto. Se pueden invocar métodos estáticos sin crear una instancia del objeto, y para llamar a los métodos prototipo, se necesita una instancia del objeto Promise . Tenga en cuenta que los métodos estáticos y regulares devuelven objetos Promise . Esto facilita el trabajo.

▍ Promete métodos de prototipos de objetos

Hablemos primero sobre los métodos prototipo del objeto Promise . Hay tres de estos métodos. No olvide que estos métodos se pueden invocar en la instancia del objeto Promise y que ellos mismos devuelven las promesas. Gracias a todos estos métodos, puede asignar controladores que respondan a los cambios en el estado de las promesas. Como ya hemos visto, cuando se crea una promesa, está en estado pending . Cuando una promesa pasa a un estado resolved o rejected , se llamará al menos uno de los siguientes métodos:

 Promise.prototype.catch(onRejected) Promise.prototype.then(onFulfilled, onRejected) Promise.prototype.finally(onFinally) 

A continuación se muestra un diagrama del funcionamiento de la promesa y los eventos que condujeron a la llamada de los .catch .then y .catch . Como estos métodos devuelven objetos Promise , sus llamadas se pueden encadenar, esto también se refleja en el diagrama. Si la promesa usa el método .finally , se llamará cuando la promesa pase al estado settled , independientemente de si la promesa se resolvió o rechazó con éxito.


Esquema de trabajo de Promis (imagen tomada de aquí )

Aquí hay una historia corta. Eres estudiante y le pides a tu madre que te compre un teléfono celular. Ella dice: "Si nuestros ahorros son más que el costo del teléfono, se lo compraré". Ahora vuelve a contar esta historia en JavaScript.

 var momsPromise = new Promise(function(resolve, reject) { momsSavings = 20000; priceOfPhone = 60000; if (momsSavings > priceOfPhone) {   resolve({     brand: "iphone",     model: "6s"   }); } else {   reject("We donot have enough savings. Let us save some more money."); } }); momsPromise.then(function(value) { console.log("Hurray I got this phone as a gift ", JSON.stringify(value)); }); momsPromise.catch(function(reason) { console.log("Mom coudn't buy me the phone because ", reason); }); momsPromise.finally(function() { console.log(   "Irrespecitve of whether my mom can buy me a phone or not, I still love her" ); }); 

Esto es lo que generará este código:


Mamá no cumplió una promesa

Si cambiamos el valor de los momsSavings variables de las momsSavings a 200,000, entonces mamá podrá comprar un regalo para su hijo. En este caso, el código anterior generará lo siguiente.


Mamá cumplió una promesa

Ahora imaginemos que el código en cuestión está diseñado como una biblioteca, y usamos esta biblioteca. Hablemos sobre el uso efectivo de los .catch .then y .catch .

Dado que el método .then se puede asignar tanto al controlador onFulfilled que se llama cuando la promesa se resuelve con éxito como al controlador onRejected que se llama cuando se rechaza la promesa, en lugar de utilizar el método .catch y el método .catch , podemos lograr el mismo efecto con solo uno .then método. Así es como podría verse:

 momsPromise.then( function(value) {   console.log("Hurray I got this phone as a gift ", JSON.stringify(value)); }, function(reason) {   console.log("Mom coudn't buy me the phone because ", reason); } ); 

Este es un ejemplo de trabajo, pero para evitar la legibilidad del código, es mejor usar métodos .then y .catch lugar de un .then universal.

Para que estos ejemplos se ejecuten en un navegador, y específicamente en Google Chrome, intenté evitar dependencias externas. Para comprender mejor lo que consideraremos más adelante, creemos una función que devuelva una promesa, cuya resolución o rechazo se produce al azar. Esto nos permitirá experimentar varios escenarios de trabajo con promesas. Para comprender las características de las funciones asincrónicas, estableceremos retrasos aleatorios en nuestras promesas. Como necesitamos números aleatorios, creamos una función que devuelve un número aleatorio entre x e y . Aquí está la función.

 function getRandomNumber(start = 1, end = 10) { //,      start  end >=1  end > start return parseInt(Math.random() * end) % (end-start+1) + start; } 

Ahora cree una función que devuelva promesas. promiseTRRARNOSG . El nombre de esta función significa promiseThatResolvesRandomlyAfterRandomNumnberOfSecondsGenerator , es decir, es un generador de promesas que se resuelven o rechazan aleatoriamente después de un número aleatorio de segundos. Esta función creará una promesa que se permitirá o rechazará después de un período de tiempo aleatorio entre 2 y 10 segundos. Para permitir o rechazar una promesa al azar, obtenemos un número aleatorio entre 1 y 10. Si este número es mayor que 5, se permitirá la promesa, de lo contrario, será rechazada.

 function getRandomNumber(start = 1, end = 10) { //,      start  end >=1  end > start return (parseInt(Math.random() * end) % (end - start + 1)) + start; } var promiseTRRARNOSG = (promiseThatResolvesRandomlyAfterRandomNumnberOfSecondsGenerator = function() { return new Promise(function(resolve, reject) {   let randomNumberOfSeconds = getRandomNumber(2, 10);   setTimeout(function() {     let randomiseResolving = getRandomNumber(1, 10);     if (randomiseResolving > 5) {       resolve({         randomNumberOfSeconds: randomNumberOfSeconds,         randomiseResolving: randomiseResolving       });     } else {       reject({         randomNumberOfSeconds: randomNumberOfSeconds,         randomiseResolving: randomiseResolving       });     }   }, randomNumberOfSeconds * 1000); }); }); var testProimse = promiseTRRARNOSG(); testProimse.then(function(value) { console.log("Value when promise is resolved : ", value); }); testProimse.catch(function(reason) { console.log("Reason when promise is rejected : ", reason); }); //             ,    .     ,  - . for (i=1; i<=10; i++) { let promise = promiseTRRARNOSG(); promise.then(function(value) {   console.log("Value when promise is resolved : ", value); }); promise.catch(function(reason) {   console.log("Reason when promise is rejected : ", reason); }); } 

Ejecute este código en la consola del navegador para ver cómo se comportan las promesas permitidas y rechazadas. A continuación, hablaremos sobre cómo puede crear muchas promesas y verificar los resultados de su implementación, utilizando otros mecanismos.

▍ Métodos estáticos de un objeto Promise

Hay cuatro métodos estáticos de un objeto Promise .

Aquí hay dos métodos: Promise.reject(reason) y Promise.resolve(value) , que le permiten crear, respectivamente, promesas rechazadas y permitidas.

Aquí se explica cómo trabajar con el método Promise.reject , que crea promesas rechazadas.

 var promise3 = Promise.reject("Not interested"); promise3.then(function(value){ console.log("This will not run as it is a rejected promise. The resolved value is ", value); }); promise3.catch(function(reason){ console.log("This run as it is a rejected promise. The reason is ", reason); }); 

Aquí hay un ejemplo usando el método Promise.resolve que crea promesas resueltas exitosamente.

 var promise4 = Promise.resolve(1); promise4.then(function(value){ console.log("This will run as it is a resovled promise. The resolved value is ", value); }); promise4.catch(function(reason){ console.log("This will not run as it is a resolved promise", reason); }); 

Cabe señalar que una promesa puede tener varios controladores. Por ejemplo, según el ejemplo anterior, puede obtener el código que se muestra a continuación.

 var promise4 = Promise.resolve(1); promise4.then(function(value){ console.log("This will run as it is a resovled promise. The resolved value is ", value); }); promise4.then(function(value){ console.log("This will also run as multiple handlers can be added. Printing twice the resolved value which is ", value * 2); }); promise4.catch(function(reason){ console.log("This will not run as it is a resolved promise", reason); }); 

Esto es lo que muestra en la consola del navegador:


Usar múltiples .then al trabajar con Promise

Los siguientes dos métodos, Promise.all y Promise.race , están diseñados para funcionar con conjuntos de promesas. Si, para resolver un problema determinado, es necesario procesar varias promesas, lo más conveniente es colocar estas promesas en una matriz y luego realizar las acciones necesarias con ellas. Para comprender la esencia de los métodos considerados aquí, no podremos utilizar nuestra función conveniente promiseTRRARNOSG , ya que el resultado de su trabajo depende demasiado de la voluntad del caso. Será más conveniente para nosotros usar algo que produzca promesas más predecibles, lo que nos permitirá comprender su comportamiento. Por lo tanto, crearemos dos nuevas funciones. Uno de ellos ( promiseTRSANSG ) creará promesas que se resuelven después de n segundos, el segundo ( promiseTRJANSG ): promesas que se rechazan después de n segundos.

 var promiseTRSANSG = (promiseThatResolvesAfterNSecondsGenerator = function( n = 0 ) { return new Promise(function(resolve, reject) {   setTimeout(function() {     resolve({       resolvedAfterNSeconds: n     });   }, n * 1000); }); }); var promiseTRJANSG = (promiseThatRejectsAfterNSecondsGenerator = function( n = 0 ) { return new Promise(function(resolve, reject) {   setTimeout(function() {     reject({       rejectedAfterNSeconds: n     });   }, n * 1000); }); }); 

Ahora usaremos estas funciones para comprender las características del método Promise.all .

▍ Método Promise.all

A partir de la documentación de MDN, puede descubrir que el Promise.all(iterable) devuelve una promesa que se resolverá cuando se resuelvan todas las promesas aprobadas como un argumento iterable , o cuando este argumento no contenga promesas. Esta promesa será rechazada si alguna de las promesas transferidas es rechazada.
Veamos algunos ejemplos.

Ejemplo no 1

Todas las promesas serán permitidas aquí. Este escenario es el más común.

 console.time("Promise.All"); var promisesArray = []; promisesArray.push(promiseTRSANSG(1)); promisesArray.push(promiseTRSANSG(4)); promisesArray.push(promiseTRSANSG(2)); var handleAllPromises = Promise.all(promisesArray); handleAllPromises.then(function(values) { console.timeEnd("Promise.All"); console.log("All the promises are resolved", values); }); handleAllPromises.catch(function(reason) { console.log("One of the promises failed with the following reason", reason); }); 

Esto es lo que este código enviará a la consola:


Todas las promesas permitidas

Después de analizar los resultados de este ejemplo, se pueden hacer dos observaciones importantes.

En primer lugar, la tercera promesa, cuya resolución lleva 2 segundos, se completa antes de la segunda, pero, como se puede ver en la salida generada por el código, se preserva el orden de las promesas en la matriz.

En segundo lugar, el código contiene un temporizador que se utiliza para averiguar cuánto tiempo lleva ejecutar la instrucción Promise.all .

Si las promesas se ejecutaran secuencialmente, el tiempo de ejecución de esta instrucción sería de 7 segundos (1 + 4 + 2). Sin embargo, el temporizador nos informa que toda la operación tomó 4 segundos si redondeamos el resultado. Esta es una prueba de que todas las promesas se ejecutan en paralelo.

Ejemplo no 2

Ahora considere la situación cuando no hay promesas en la matriz pasada a Promise.all. Creo que este es el caso de uso menos común para esta característica.

 console.time("Promise.All"); var promisesArray = []; promisesArray.push(1); promisesArray.push(4); promisesArray.push(2); var handleAllPromises = Promise.all(promisesArray); handleAllPromises.then(function(values) { console.timeEnd("Promise.All"); console.log("All the promises are resolved", values); }); handleAllPromises.catch(function(reason) { console.log("One of the promises failed with the following reason", reason); }); 

Aquí está el resultado que generará este código:


Invoque Promise.all y pase una matriz que no contenga promesas a este método

Como no hay promesas en la matriz, Promise.all casi al instante.

Ejemplo no 3

Ahora veamos qué sucede cuando una de las promesas pasa a Promise.all es rechazada.

 console.time("Promise.All"); var promisesArray = []; promisesArray.push(promiseTRSANSG(1)); promisesArray.push(promiseTRSANSG(5)); promisesArray.push(promiseTRSANSG(3)); promisesArray.push(promiseTRJANSG(2)); promisesArray.push(promiseTRSANSG(4)); var handleAllPromises = Promise.all(promisesArray); handleAllPromises.then(function(values) { console.timeEnd("Promise.All"); console.log("All the promises are resolved", values); }); handleAllPromises.catch(function(reason) { console.timeEnd("Promise.All"); console.log("One of the promises failed with the following reason ", reason); }); 

Como puede ver en los resultados de ejecución de código que se muestran a continuación, Promise.all ejecución se detiene después de la primera promesa rechazada con la salida del mensaje que entrega esta promesa.


La ejecución se detiene después de la primera promesa rechazada

▍ Método Promise.race

MDN informa que el Promise.race(iterable) devuelve una promesa permitida o rechazada con un valor o motivo de rechazo después de que una de las promesas transmitidas se permita o rechace respectivamente.

Veamos ejemplos de trabajo con Promise.race .

Ejemplo no 1

Muestra lo que sucede cuando una de las promesas pasadas a Promise.race se resuelve antes que nadie.

 console.time("Promise.race"); var promisesArray = []; promisesArray.push(promiseTRSANSG(4)); promisesArray.push(promiseTRSANSG(3)); promisesArray.push(promiseTRSANSG(2)); promisesArray.push(promiseTRJANSG(3)); promisesArray.push(promiseTRSANSG(4)); var promisesRace = Promise.race(promisesArray); promisesRace.then(function(values) { console.timeEnd("Promise.race"); console.log("The fasted promise resolved", values); }); promisesRace.catch(function(reason) { console.timeEnd("Promise.race"); console.log("The fastest promise rejected with the following reason ", reason); }); 

Esto es lo que llega a la consola después de ejecutar este ejemplo.


Promis, que se resolvió más rápido que todos los demás

Todas las promesas aquí se realizan en paralelo. La tercera promesa se resuelve después de 2 segundos. Tan pronto como esto sucede, la promesa devuelta por Promise.race se resuelve.

Ejemplo no 2

Ahora considere la situación cuando una de las promesas pasadas a Promise.race es rechazada.

 console.time("Promise.race"); var promisesArray = []; promisesArray.push(promiseTRSANSG(4)); promisesArray.push(promiseTRSANSG(6)); promisesArray.push(promiseTRSANSG(5)); promisesArray.push(promiseTRJANSG(3)); promisesArray.push(promiseTRSANSG(4)); var promisesRace = Promise.race(promisesArray); promisesRace.then(function(values) { console.timeEnd("Promise.race"); console.log("The fasted promise resolved", values); }); promisesRace.catch(function(reason) { console.timeEnd("Promise.race"); console.log("The fastest promise rejected with the following reason ", reason); }); 

Después de ejecutar este ejemplo, lo siguiente llegará a la consola:


Promesa rechazada antes que los demás

Las promesas aquí, como en los ejemplos anteriores, se realizan en paralelo. La cuarta promesa se rechaza después de 3 segundos. Tan pronto como esto sucede, la promesa devuelta por Promise.race es rechazada.

Ejemplo general y experimentos

Recopilé todos los ejemplos que consideramos en este material en un solo lugar, lo que hará que sea más fácil experimentar con ellos, explorar varios escenarios de trabajo con promesas. Este código está diseñado para ejecutarse en un navegador, por lo que aquí no usamos ninguna llamada API, no accedemos a las operaciones de archivo y no trabajamos con bases de datos. Aunque todo esto tiene aplicación en el desarrollo de proyectos reales, creo que trabajar con estos mecanismos puede distraernos de nuestro objetivo principal: las promesas. Y el uso de funciones simples que simulan retrasos en el tiempo da resultados similares y no nos carga con detalles adicionales.

Al explorar estos ejemplos usted mismo, puede experimentar con el código, con los valores de las variables y estudiar diferentes escenarios para usar promesas. En particular, puede utilizar una combinación de los promiseTRJANSG , promiseTRSANSG y promiseTRRARNOSG para simular muchos escenarios para usar promesas, lo que le permitirá comprenderlos mejor. Además, tenga en cuenta que el uso del comando console.time permite averiguar el tiempo requerido para ejecutar un determinado fragmento de código y, por ejemplo, averiguar si las promesas se ejecutan en paralelo o secuencialmente. Aquí hay un enlace a la página principal con el código. Y, por cierto, si lo desea, eche un vistazo a la biblioteca Bluebird , que contiene algunos métodos interesantes para trabajar con promesas.

Resumen

Le ofrezco una lista de reglas a las que me adhiero cuando trabajo con promesas para usarlas correctamente.

1. Use promesas en situaciones en las que trabaje con código asíncrono o de bloqueo.
2. Para manejar la situación de resolver con éxito una promesa, use el método .then ; para los casos en que la promesa sea rechazada, use .catch .
3. Utilice los .catch .then y .catch en todas las promesas.
4. - , , .finally .
5. , , , .
6. , .
7. Promise , , , .
8. Promise.all , .

, , , .

Estimados lectores! , , ?