Comprensión del orden de ejecución en las promesas de JavaScript

Las promesas en JavaScript ofrecen un modelo de programación asincrónica donde el código se ejecuta una vez que se produce un evento o promesa específica , se cumple. Sin embargo, cuando se trata de promesas múltiples, es esencial comprender el orden de ejecución para evitar comportamientos impredecibles.

Considere el siguiente fragmento de código:

Promise.resolve('A')
  .then(function(a){console.log(2, a); return 'B';})
  .then(function(a){
     Promise.resolve('C')
       .then(function(a){console.log(7, a);})
       .then(function(a){console.log(8, a);});
     console.log(3, a);
     return a;})
  .then(function(a){
     Promise.resolve('D')
       .then(function(a){console.log(9, a);})
       .then(function(a){console.log(10, a);});
     console.log(4, a);})
  .then(function(a){
     console.log(5, a);});
console.log(1);
setTimeout(function(){console.log(6)},0);

Al ejecutar, puede observar el siguiente orden de salida:

1
2 "A"
3 "B"
7 "C"
4 "B"
8 undefined
9 "D"
5 undefined
10 undefined
6

Comprensión del orden de ejecución

1. Las promesas se resuelven de forma asincrónica:
   Las promesas se resuelven independientemente del hilo de ejecución actual. Esto significa que los controladores .then() se llaman de forma asincrónica después de que finaliza el subproceso actual. El manejador completa. Básicamente, están en cola, por lo que ves 1, 2 "A" y 3 "B" impresos en ese orden.
2. Las promesas internas crean cadenas independientes:
   Promesas creadas dentro de los controladores .then() anidados, como Promise.resolve('C') y Promise.resolve('D'), crean cadenas de promesas nuevas e independientes. Estas cadenas internas no se sincronizan inherentemente con la cadena externa.
3. El orden de ejecución no es determinista:
   El orden de ejecución de estas cadenas independientes no está garantizado. En este caso, el motor de promesa elige ejecutar los controladores .then() en las líneas 5 y 12 antes que los de las líneas 6 y 7.
4. Recomendaciones
   

Para garantizar un orden de ejecución específico, evite crear cadenas de promesas no sincronizadas y, en su lugar, confíe en vincular promesas de manera secuencial. Devuelve promesas de los controladores internos .then() para encadenarlas con la promesa principal, como se muestra a continuación:

Promise.resolve('A').then(function (a) { consola.log(2, a); devolver 'B'; }).entonces(función (a) { var p = Promesa.resolve('C').luego(función (a) { consola.log(7, a); }).entonces(función (a) { consola.log(8, a); }); consola.log(3, a); devolver p; // Vincula la promesa interna a la cadena principal }).entonces(función (a) { var p = Promesa.resolve('D').luego(función (a) { consola.log(9, a); }).entonces(función (a) { consola.log(10, a); }); consola.log(4, a); devolver p; // Vincula la promesa interna a la cadena principal }).entonces(función (a) { consola.log(5, a); }); consola.log(1); setTimeout(función() { consola.log(6) }, 0);

Con este enfoque, el orden de ejecución se vuelve completamente determinista: 1, 2 "A", 3 "B", 7 "C", 8 indefinido, 4 indefinido, 9 "D", 10 indefinidos, 5 indefinidos y 6.