Promise.all: orden de valores resueltos

Al mirar MDN , parece que se valuespasó a la then()devolución de llamada de Promise.all contiene los valores en el orden de las promesas. Por ejemplo:

var somePromises = [1, 2, 3, 4, 5].map(Promise.resolve);
return Promise.all(somePromises).then(function(results) {
  console.log(results) //  is [1, 2, 3, 4, 5] the guaranteed result?
});

¿Alguien puede citar una especificación que indique en qué orden valuesdebe estar?

PD: Ejecutar un código como ese demostró que esto parece ser cierto, aunque eso no es una prueba, podría haber sido una coincidencia.

En breve, se conserva el orden .

Siguiendo la especificación a la que se vinculó, Promise.all(iterable)toma un parámetro iterable(es decir, un objeto que admite la Iteratorinterfaz) y luego lo llama PerformPromiseAll( iterator, constructor, resultCapability), donde este último deja de iterableusarlo IteratorStep(iterator).
Esto significa que si el iterable al que pasas Promise.all()está estrictamente ordenado, aún se ordenarán una vez que lo pases .

La resolución se implementa a través de Promise.all() Resolvedonde cada promesa resuelta tiene una [[Index]]ranura interna , que marca el índice de la promesa en la entrada original.

Todo esto significa que la salida está estrictamente ordenada como entrada, siempre que la entrada esté estrictamente ordenada (por ejemplo, una matriz).

Puede ver esto en acción en el siguiente violín (ES6):

// Used to display results
const write = msg => {
  document.body.appendChild(document.createElement('div')).innerHTML = msg;
};

// Different speed async operations
const slow = new Promise(resolve => {
  setTimeout(resolve, 200, 'slow');
});
const instant = 'instant';
const quick = new Promise(resolve => {
  setTimeout(resolve, 50, 'quick');
});

// The order is preserved regardless of what resolved first
Promise.all([slow, instant, quick]).then(responses => {
  responses.map(response => write(response));
});

Como ya se ha indicado en las respuestas anteriores, Promise.allagrega todos los valores resueltos con una matriz correspondiente al orden de entrada de las Promesas originales (consulte Agregación de promesas ).

Sin embargo, me gustaría señalar que el pedido solo se conserva en el lado del cliente.

Para el desarrollador, parece que las promesas se cumplieron en orden, pero en realidad, las promesas se procesan a diferentes velocidades. Es importante saber cuándo trabaja con un servidor remoto porque el servidor podría recibir sus promesas en un orden diferente.

Aquí hay un ejemplo que demuestra el problema mediante el uso de tiempos de espera:

Promesa.todos

const myPromises = [
  new Promise((resolve) => setTimeout(() => {resolve('A (slow)'); console.log('A (slow)')}, 1000)),
  new Promise((resolve) => setTimeout(() => {resolve('B (slower)'); console.log('B (slower)')}, 2000)),
  new Promise((resolve) => setTimeout(() => {resolve('C (fast)'); console.log('C (fast)')}, 10))
];

Promise.all(myPromises).then(console.log)

En el código que se muestra arriba, se dan tres promesas (A, B, C) Promise.all. Las tres promesas se ejecutan a diferentes velocidades (C es la más rápida y B la más lenta). Es por eso que las console.logdeclaraciones de las Promesas aparecen en este orden:

C (fast) 
A (slow)
B (slower)

Si las Promesas son llamadas AJAX, un backend remoto recibirá estos valores en este orden. Pero del lado del cliente Promise.allasegura que los resultados se ordenan de acuerdo con las posiciones originales de la myPromisesmatriz. Por eso el resultado final es:

['A (slow)', 'B (slower)', 'C (fast)']

Si desea garantizar también la ejecución real de sus Promesas, necesitaría un concepto como una cola Promesa. Aquí hay un ejemplo usando p-queue (tenga cuidado, necesita ajustar todas las promesas en las funciones):

Cola de promesa secuencial

const PQueue = require('p-queue');
const queue = new PQueue({concurrency: 1});

// Thunked Promises:
const myPromises = [
  () => new Promise((resolve) => setTimeout(() => {
    resolve('A (slow)');
    console.log('A (slow)');
  }, 1000)),
  () => new Promise((resolve) => setTimeout(() => {
    resolve('B (slower)');
    console.log('B (slower)');
  }, 2000)),
  () => new Promise((resolve) => setTimeout(() => {
    resolve('C (fast)');
    console.log('C (fast)');
  }, 10))
];

queue.addAll(myPromises).then(console.log);

Resultado

A (slow)
B (slower)
C (fast)

['A (slow)', 'B (slower)', 'C (fast)']

Sí, los valores en resultsestán en el mismo orden que promises.

Uno podría citar la especificación ES6Promise.all , aunque es un poco complicado debido a la API de iterador utilizada y al constructor de promesa genérico. Sin embargo, notará que cada devolución de llamada de resolución tiene un [[index]]atributo que se crea en la iteración de matriz de promesa y se utiliza para establecer los valores en la matriz de resultados.