Können Versprechen mehrere Argumente für onFulfilled haben?

Ich folge hier der Spezifikation und bin mir nicht sicher, ob onFulfilled mit mehreren Argumenten aufgerufen werden kann. Beispielsweise:

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

so dass mein Code:

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

würde beides erhalten arg1und arg2?

Es ist mir egal, wie eine bestimmte Versprechen-Implementierung funktioniert, ich möchte die w3c-Spezifikation für Versprechen genau befolgen.

Ich folge hier der Spezifikation und bin mir nicht sicher, ob onFulfilled mit mehreren Argumenten aufgerufen werden kann.

Nein, nur der erste Parameter wird im Versprechen-Konstruktor als Auflösungswert behandelt. Sie können mit einem zusammengesetzten Wert wie einem Objekt oder Array auflösen.

Es ist mir egal, wie eine bestimmte Versprechen-Implementierung funktioniert, ich möchte die w3c-Spezifikation für Versprechen genau befolgen.

Da glaube ich, dass du falsch liegst. Die Spezifikation ist minimal ausgelegt und für die Zusammenarbeit zwischen Versprechensbibliotheken konzipiert. Die Idee ist, eine Teilmenge zu haben, die DOM-Futures beispielsweise zuverlässig nutzen und Bibliotheken nutzen können. Vielversprechende Implementierungen machen das, womit Sie schon seit einiger Zeit fragen .spread. Beispielsweise:

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

Mit Bluebird . Eine Lösung, wenn Sie diese Funktionalität wünschen, besteht darin, sie zu füllen.

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

So können Sie Folgendes tun:

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

Mit einheimischen Versprechungen beruhigen Geige . Oder verwenden Sie Spread, der heute (2018) in Browsern üblich ist:

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

Oder mit warten:

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

Sie können die E6-Destrukturierung verwenden:

Objektzerstörung:

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

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

Array-Destrukturierung:

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

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

Der Erfüllungswert eines Versprechens entspricht dem Rückgabewert einer Funktion, und der Ablehnungsgrund eines Versprechens entspricht der ausgelösten Ausnahme einer Funktion. Funktionen können nicht mehrere Werte zurückgeben, daher dürfen Versprechen nicht mehr als einen Erfüllungswert haben.

Soweit ich das Lesen der ES6-Versprechen-Spezifikation und der Standard-Versprechen-Spezifikation beurteilen kann, gibt es keine Klausel, die eine Implementierung daran hindert, diesen Fall zu behandeln - sie ist jedoch nicht in den folgenden Bibliotheken implementiert:

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

Ich gehe davon aus, dass der Grund dafür, dass sie Multi-Arg-Auflösungen weglassen, darin besteht, die Reihenfolge der Änderungen prägnanter zu gestalten (dh da Sie nur einen Wert in einer Funktion zurückgeben können, würde dies den Steuerungsfluss weniger intuitiv machen). Beispiel:

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

Hier ist eine CoffeeScript-Lösung.

Ich suchte nach der gleichen Lösung und fand etwas sehr Interessantes an dieser Antwort: Ablehnen von Versprechungen mit mehreren Argumenten (wie $ http) in AngularJS

die Antwort dieses Typen Florian

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 

Und um es zu benutzen:

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

Tolle Frage und tolle Antwort von Benjamin, Kris ua - vielen Dank!

Ich verwende dies in einem Projekt und habe ein Modul erstellt, das auf dem Code von Benjamin Gruenwald basiert . Es ist auf npmjs verfügbar:

npm i -S promise-spread

Dann tun Sie es in Ihrem Code

require('promise-spread');

Wenn Sie eine Bibliothek wie verwenden any-promise

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

Vielleicht finden das auch andere nützlich!

Eine De-Strukturierung der Zuweisung in ES6 würde hier helfen. Zum Beispiel:

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

Da Funktionen in Javascript mit einer beliebigen Anzahl von Argumenten aufgerufen werden können und das Dokument onFulfilled()die Argumente der Methode neben der folgenden Klausel nicht einschränkt , können Sie meiner Meinung nach mehrere Argumente an die onFulfilled()Methode übergeben, solange der Wert des Versprechens der ist erstes Argument.

2.2.2.1 Es muss aufgerufen werden, nachdem das Versprechen erfüllt wurde, wobei der Wert des Versprechens das erste Argument ist.

Um den folgenden Artikel zu zitieren, benötigt "" dann "zwei Argumente, einen Rückruf für einen Erfolgsfall und ein weiteres für den Fehlerfall. Beide sind optional, sodass Sie einen Rückruf nur für den Erfolgs- oder Fehlerfall hinzufügen können."

Normalerweise schaue ich auf dieser Seite nach grundlegenden Versprechungsfragen. Lassen Sie mich wissen, wenn ich falsch liege

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