As promessas podem ter vários argumentos para onFulfilled?

Estou seguindo as especificações aqui e não tenho certeza se permite que onFulfilled seja chamado com vários argumentos. Por exemplo:

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

tal que meu código:

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

receberia ambos arg1e arg2?

Não me importo com o modo como qualquer implementação específica de promessas faz isso, desejo seguir de perto as especificações do w3c.

Estou seguindo as especificações aqui e não tenho certeza se permite que onFulfilled seja chamado com vários argumentos.

Não, apenas o primeiro parâmetro será tratado como valor de resolução no construtor da promessa. Você pode resolver com um valor composto como um objeto ou matriz.

Não me importo com o modo como qualquer implementação específica de promessas faz isso, desejo seguir de perto as especificações do w3c.

É aí que eu acredito que você está errado. A especificação foi projetada para ser mínima e foi criada para interoperar entre bibliotecas de promessas. A idéia é ter um subconjunto que os futuros do DOM, por exemplo, possam usar com segurança e as bibliotecas possam consumir. As implementações promissoras fazem o que você pede .spreadhá um tempo. Por exemplo:

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

Com Bluebird . Uma solução, se você deseja essa funcionalidade, é polifillá-la.

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

Isso permite que você faça:

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

Com promessas nativas à vontade, brinque . Ou use propagação que é agora (2018) comum nos navegadores:

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

Ou com aguardar:

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

Você pode usar a desestruturação E6:

Destruição de objetos:

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

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

Destruição da matriz:

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

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

O valor de cumprimento de uma promessa é paralelo ao valor de retorno de uma função e o motivo de rejeição de uma promessa é paralelo à exceção lançada de uma função. As funções não podem retornar vários valores, portanto, as promessas não devem ter mais de 1 valor de cumprimento.

Tanto quanto posso dizer, lendo a especificação ES6 Promise e a especificação padrão de promessa, não há nenhuma cláusula que impeça uma implementação de lidar com esse caso - no entanto, ela não é implementada nas seguintes bibliotecas:

• Compromisso RSVP (# L516-544)
• Q promessa (# 787)

Suponho que a razão pela qual eles omitem as resoluções com vários argumentos é tornar a ordem de mudança mais sucinta (ou seja, como você pode retornar apenas um valor em uma função, isso tornaria o fluxo de controle menos intuitivo).

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

Aqui está uma solução CoffeeScript.

Eu estava procurando a mesma solução e achei algo muito interessante nesta resposta: Rejeitar promessas com vários argumentos (como $ http) no AngularJS

a resposta desse cara 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 para usá-lo:

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

Ótima pergunta e ótima resposta de Benjamin, Kris, et al - muito obrigado!

Estou usando isso em um projeto e criei um módulo baseado no código de Benjamin Gruenwald . Está disponível no npmjs:

npm i -S promise-spread

Então, no seu código, faça

require('promise-spread');

Se você estiver usando uma biblioteca como any-promise

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

Talvez outros achem isso útil também!

A desestruturação da atribuição no ES6 ajudaria aqui.

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

Como as funções em Javascript podem ser chamadas com qualquer número de argumentos, e o documento não impõe nenhuma restrição aos onFulfilled()argumentos do método além da cláusula abaixo, acho que você pode passar vários argumentos para o onFulfilled()método desde que o valor da promessa seja o primeiro argumento.

2.2.2.1 deve ser chamado após a promessa ser cumprida, com o valor da promessa como seu primeiro argumento.

Para citar o artigo abaixo, "" then "recebe dois argumentos, um retorno de chamada para um caso de sucesso e outro para o caso de falha. Ambos são opcionais, portanto, você pode adicionar um retorno de chamada apenas para o caso de sucesso ou falha."

Normalmente, olho para esta página todas as perguntas básicas sobre promessas, deixe-me saber se estou errado

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