Le promesse possono avere più argomenti su onFulfilled?

Sto seguendo le specifiche qui e non sono sicuro che consenta a onFulfilled di essere chiamato con più argomenti. Per esempio:

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

tale che il mio codice:

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

riceverebbe entrambi arg1earg2 ?

Non mi interessa come fa una specifica implementazione delle promesse, desidero seguire da vicino le specifiche w3c per le promesse.

Sto seguendo le specifiche qui e non sono sicuro se consenta a onFulfilled di essere chiamato con più argomenti.

No, solo il primo parametro verrà trattato come valore di risoluzione nel costruttore della promessa. È possibile risolvere con un valore composito come un oggetto o un array.

Non mi interessa come fa una specifica implementazione delle promesse, desidero seguire da vicino le specifiche w3c per le promesse.

Ecco dove credo che tu abbia torto. Le specifiche sono progettate per essere minime e sono progettate per l'interoperabilità tra librerie promesse. L'idea è di avere un sottoinsieme che i futuri DOM possano ad esempio utilizzare in modo affidabile e che le librerie possano consumare. Le implementazioni promettenti fanno quello che chiedi.spread un po 'di tempo. Per esempio:

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

Con Bluebird . Una soluzione se si desidera questa funzionalità è quella di polifillarla.

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

Questo ti permette di fare:

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

Con promesse nativi a proprio agio violino . O usa spread che è ora (2018) banale nei browser:

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

O con wait:

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

Puoi usare la destrutturazione E6:

Distruzione dell'oggetto:

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

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

Distrutturazione di array:

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

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

Il valore di adempimento di una promessa è parallelo al valore di ritorno di una funzione e la ragione del rifiuto di una promessa è parallela all'eccezione generata di una funzione. Le funzioni non possono restituire più valori, quindi le promesse non devono avere più di 1 valore di adempimento.

Per quanto ne so, leggendo la specifica Promessa ES6 e la specifica promessa standard non esiste alcuna clausola che impedisca a un'implementazione di gestire questo caso, tuttavia non è implementata nelle seguenti librerie:

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

Suppongo che la ragione per cui omettono le risoluzioni multi arg sia quella di rendere più succinto l'ordine di cambiamento (cioè, dato che si può restituire un solo valore in una funzione renderebbe il flusso di controllo meno intuitivo) Esempio:

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

Ecco una soluzione CoffeeScript.

Stavo cercando la stessa soluzione e ho trovato il seomething molto interessante da questa risposta: rifiutare le promesse con più argomenti (come $ http) in AngularJS

la risposta di questo ragazzo 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 

E per usarlo:

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

Grande domanda e ottima risposta di Benjamin, Kris e altri - molte grazie!

Sto usando questo in un progetto e ho creato un modulo basato sul codice di Benjamin Gruenwald . È disponibile su npmjs:

npm i -S promise-spread

Quindi nel tuo codice, fallo

require('promise-spread');

Se stai utilizzando una libreria come any-promise

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

Forse anche altri lo trovano utile!

L'assegnazione della destrutturazione in ES6 sarebbe di aiuto in questo caso.

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

Poiché le funzioni in Javascript possono essere richiamate con qualsiasi numero di argomenti e il documento non pone alcuna restrizione agli onFulfilled()argomenti del metodo oltre alla clausola seguente, penso che sia possibile passare più argomenti al onFulfilled()metodo purché il valore della promessa sia il primo argomento.

2.2.2.1 deve essere chiamato dopo che la promessa è stata adempiuta, con il valore della promessa come primo argomento.

Per citare l'articolo di seguito, "" allora "accetta due argomenti, un callback per un caso di successo e un altro per il caso di errore. Entrambi sono facoltativi, quindi è possibile aggiungere un callback solo per il caso di successo o fallimento."

Di solito cerco questa pagina per qualsiasi domanda di base sulla promessa, fammi sapere se sbaglio

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