Promise.all: Kolejność ustalonych wartości

Patrząc na MDN wygląda na to, że valuesprzekazany do then()wywołania zwrotnego Promise.all zawiera wartości w kolejności obietnic. Na przykład:

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?
});

Czy ktoś może podać specyfikację określającą, w jakiej kolejności valuespowinna być?

PS: Uruchomienie takiego kodu pokazało, że to prawda, chociaż oczywiście nie jest to dowód - mógł to być zbieg okoliczności.

Wkrótce kolejność zostanie zachowana .

Zgodnie ze specyfikacją, z którą się łączysz, Promise.all(iterable)przyjmuje parametr iterable(to znaczy obiekt obsługujący Iteratorinterfejs) jako parametr, a następnie wywołuje PerformPromiseAll( iterator, constructor, resultCapability)z nim wywołania , przy czym ten drugi iterableużywa pętli IteratorStep(iterator).
Oznacza to, że jeśli jeśli iterowalność, którą przekazujesz, Promise.all()jest ściśle uporządkowana, to nadal zostanie zamówiona po przekazaniu.

Rozwiązanie jest realizowane za pośrednictwem miejsca, w Promise.all() Resolvektórym każda rozwiązana obietnica ma wewnętrzne [[Index]]gniazdo, które oznacza indeks obietnicy na oryginalnym wejściu.

Wszystko to oznacza, że ​​dane wyjściowe są ściśle uporządkowane jako dane wejściowe, o ile dane wejściowe są ściśle uporządkowane (na przykład tablica).

Możesz to zobaczyć w akcji w poniższym skrzypcach (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));
});

Jak już wspomniano w poprzednich odpowiedziach, Promise.allagreguje wszystkie rozstrzygnięte wartości za pomocą tablicy odpowiadającej kolejności wprowadzania oryginalnych obietnic (patrz Agregowanie obietnic ).

Chciałbym jednak zaznaczyć, że zamówienie jest zachowywane tylko po stronie klienta!

Dla programisty wygląda na to, że obietnice zostały spełnione w kolejności, ale w rzeczywistości obietnice są przetwarzane z różnymi prędkościami. Jest to ważne, aby wiedzieć, kiedy pracujesz ze zdalnym backendem, ponieważ backend może otrzymywać Twoje obietnice w innej kolejności.

Oto przykład, który pokazuje problem przy użyciu limitów czasu:

Promise.all

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)

W powyższym kodzie podane są trzy obietnice (A, B, C) Promise.all. Trzy obietnice wykonują się przy różnych prędkościach (C jest najszybszy, a B jest najwolniejszy). Dlatego console.logoświadczenia Obietnic pojawiają się w następującej kolejności:

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

Jeśli obietnice są wywołaniami AJAX, zdalny backend otrzyma te wartości w tej kolejności. Ale po stronie klienta Promise.allzapewnia, że ​​wyniki są uporządkowane zgodnie z pierwotnymi pozycjami myPromisestablicy. Właśnie dlatego końcowy wynik to:

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

Jeśli chcesz zagwarantować również faktyczne wykonanie Twoich obietnic, potrzebujesz koncepcji takiej jak kolejka Obietnic. Oto przykład użycia kolejki p (uważaj, musisz zawinąć wszystkie obietnice w funkcje):

Sekwencyjna kolejka obietnic

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);

Wynik

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

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

Tak, wartości w resultssą w tej samej kolejności co promises.

Można zacytować specyfikację ES6Promise.all , choć jest nieco skomplikowana ze względu na zastosowany interfejs iteratora i ogólny konstruktor obietnic. Jednak zauważysz, że każde wywołanie zwrotne resolvera ma [[index]]atrybut, który jest tworzony w iteracji tablicy obietnic i używany do ustawiania wartości w tablicy wyników.