Czy obietnice mogą mieć wiele argumentów do wypełnienia?

Postępuję zgodnie ze specyfikacją tutaj i nie jestem pewien, czy pozwala ona na wywołanie onFulfilled z wieloma argumentami. Na przykład:

promise = new Promise(function(onFulfilled, onRejected){
    onFulfilled('arg1', 'arg2');
})

taki, że mój kod:

promise.then(function(arg1, arg2){
    // ....
});

otrzyma oba arg1i arg2?

Nie obchodzi mnie, jak robi to jakakolwiek konkretna realizacja obietnic, chciałbym ściśle przestrzegać specyfikacji w3c dotyczących obietnic.

Postępuję zgodnie ze specyfikacją tutaj i nie jestem pewien, czy pozwala ona na wywołanie onFulfilled z wieloma argumentami.

Nie, tylko pierwszy parametr będzie traktowany jako wartość rozdzielczości w konstruktorze obietnicy. Możesz rozwiązać za pomocą wartości złożonej, takiej jak obiekt lub tablica.

Nie obchodzi mnie, jak robi to jakakolwiek konkretna realizacja obietnic, chciałbym ściśle przestrzegać specyfikacji w3c dotyczących obietnic.

Myślę, że właśnie tam się mylisz. Specyfikacja została zaprojektowana jako minimalna i została stworzona do współdziałania między bibliotekami obietnic. Chodzi o to, aby mieć podzbiór, który na przykład DOM futures może niezawodnie wykorzystywać, a biblioteki mogą wykorzystywać. Implementacje Promise .spreadod jakiegoś czasu robią to, o co prosisz . Na przykład:

Promise.try(function(){
    return ["Hello","World","!"];
}).spread(function(a,b,c){
    console.log(a,b+c); // "Hello World!";
});

Z Bluebird . Jednym z rozwiązań, jeśli chcesz mieć tę funkcjonalność, jest wypełnienie jej.

if (!Promise.prototype.spread) {
    Promise.prototype.spread = function (fn) {
        return this.then(function (args) {
            return Promise.all(args); // wait for all
        }).then(function(args){
         //this is always undefined in A+ complaint, but just in case
            return fn.apply(this, args); 
        });
    };
}

Dzięki temu możesz:

Promise.resolve(null).then(function(){
    return ["Hello","World","!"]; 
}).spread(function(a,b,c){
    console.log(a,b+c);    
});

Z rodzimymi obietnicami swobodnie bawią się . Lub użyj spreadu, który jest teraz (2018) powszechny w przeglądarkach:

Promise.resolve(["Hello","World","!"]).then(([a,b,c]) => {
  console.log(a,b+c);    
});

Lub z oczekiwaniem:

let [a, b, c] = await Promise.resolve(['hello', 'world', '!']);

Możesz użyć destrukturyzacji E6:

Destrukturyzacja obiektów:

promise = new Promise(function(onFulfilled, onRejected){
    onFulfilled({arg1: value1, arg2: value2});
})

promise.then(({arg1, arg2}) => {
    // ....
});

Destrukturyzacja macierzy:

promise = new Promise(function(onFulfilled, onRejected){
    onFulfilled([value1, value2]);
})

promise.then(([arg1, arg2]) => {
    // ....
});

Wartość spełnienia obietnicy jest analogiczna do wartości zwracanej funkcji, a przyczyna odrzucenia obietnicy jest analogiczna do rzuconego wyjątku funkcji. Funkcje nie mogą zwracać wielu wartości, więc obietnice nie mogą mieć więcej niż 1 wartość realizacji.

O ile wiem, czytając specyfikację ES6 Promise i standardową specyfikację obietnicy, nie ma klauzuli uniemożliwiającej implementacji obsługę tego przypadku - jednak nie jest ona zaimplementowana w następujących bibliotekach:

• RSVP.promise (# L516-544)
• Obietnica Q (# 787)

Zakładam, że powodem pomijania rozwiązań wieloskładnikowych jest sprawienie, aby zmiana kolejności była bardziej zwięzła (tj. Ponieważ można zwrócić tylko jedną wartość w funkcji, sprawiłoby to, że przepływ sterowania byłby mniej intuicyjny) Przykład:

new Promise(function(resolve, reject) {
   return resolve(5, 4);
})
.then(function(x,y) {
   console.log(y);
   return x; //we can only return 1 value here so the next then will only have 1 argument
})
.then(function(x,y) {
    console.log(y);
});

Oto rozwiązanie CoffeeScript.

Szukałem tego samego rozwiązania i znalazłem coś bardzo interesującego w tej odpowiedzi: Odrzucanie obietnic z wieloma argumentami (np. $ Http) w AngularJS

odpowiedź tego gościa Floriana

promise = deferred.promise

promise.success = (fn) ->
  promise.then (data) ->
   fn(data.payload, data.status, {additional: 42})
  return promise

promise.error = (fn) ->
  promise.then null, (err) ->
    fn(err)
  return promise

return promise 

I aby z niego skorzystać:

service.get().success (arg1, arg2, arg3) ->
    # => arg1 is data.payload, arg2 is data.status, arg3 is the additional object
service.get().error (err) ->
    # => err

Świetne pytanie i świetna odpowiedź od Benjamina, Krisa i innych - wielkie dzięki!

Używam tego w projekcie i stworzyłem moduł oparty na kodzie Benjamina Gruenwalda . Jest dostępny na npmjs:

npm i -S promise-spread

Następnie w swoim kodzie zrób

require('promise-spread');

Jeśli używasz biblioteki, takiej jak any-promise

var Promise = require('any-promise');
require('promise-spread')(Promise);

Może inni też uznają to za przydatne!

Pomogłaby tutaj dezstrukturyzacja przypisania w ES6. Na przykład:

let [arg1, arg2] = new Promise((resolve, reject) => {
    resolve([argument1, argument2]);
});

Ponieważ funkcje w Javascript można wywołać z dowolną liczbą argumentów, a dokument nie nakłada żadnych ograniczeń na onFulfilled()argumenty metody poza poniższą klauzulą, myślę, że można przekazać do onFulfilled()metody wiele argumentów, o ile wartość obietnicy jest równa pierwszy argument.

2.2.2.1 należy go nazwać po spełnieniu obietnicy, z wartością obietnicy jako pierwszym argumentem.

Aby zacytować poniższy artykuł, "" to "przyjmuje dwa argumenty, wywołanie zwrotne dla przypadku powodzenia i inny dla przypadku niepowodzenia. Oba są opcjonalne, więc możesz dodać wywołanie zwrotne tylko dla przypadku sukcesu lub niepowodzenia."

Zwykle zaglądam na tę stronę w poszukiwaniu podstawowych pytań dotyczących obietnic, daj mi znać, jeśli się mylę

http://www.html5rocks.com/en/tutorials/es6/promises/