¿Pueden las promesas tener múltiples argumentos para onFulfilled?

Estoy siguiendo la especificación aquí y no estoy seguro de si permite llamar a onFulfilled con múltiples argumentos. Por ejemplo:

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

tal que mi código:

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

recibiría ambos arg1y arg2?

No me importa cómo lo hace una implementación de promesas específicas, deseo seguir de cerca la especificación w3c para promesas.

Estoy siguiendo la especificación aquí y no estoy seguro de si permite llamar a onFulfilled con múltiples argumentos.

No, solo el primer parámetro será tratado como valor de resolución en el constructor de promesa. Puede resolver con un valor compuesto como un objeto o matriz.

No me importa cómo lo hace una implementación de promesas específicas, deseo seguir de cerca la especificación w3c para promesas.

Ahí es donde creo que te equivocas. La especificación está diseñada para ser mínima y está diseñada para interoperar entre bibliotecas prometedoras. La idea es tener un subconjunto que los futuros de DOM, por ejemplo, puedan usar de manera confiable y las bibliotecas puedan consumir. Las implementaciones prometedoras hacen lo que pides .spreadpor un tiempo ahora. Por ejemplo:

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

Con Bluebird . Una solución si desea esta funcionalidad es rellenarla.

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

Esto te permite hacer:

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

Con promesas nativas a gusto violín . O use spread, que ahora es (2018) común en los navegadores:

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

O con esperar:

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

Puede usar la desestructuración E6:

Desestructuración de objetos:

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

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

Desestructuración de la matriz:

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

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

El valor de cumplimiento de una promesa es paralelo al valor de retorno de una función y la razón de rechazo de una promesa es paralela a la excepción lanzada de una función. Las funciones no pueden devolver múltiples valores, por lo que las promesas no deben tener más de 1 valor de cumplimiento.

Por lo que puedo decir, leer la especificación de Promesa ES6 y la especificación de promesa estándar no hay cláusula que impida que una implementación maneje este caso; sin embargo, no está implementado en las siguientes bibliotecas:

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

Supongo que la razón por la que omiten las resoluciones de múltiples argumentos es hacer que el orden de cambio sea más sucinto (es decir, como solo puede devolver un valor en una función, haría que el control fluya menos intuitivo) Ejemplo:

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

Aquí hay una solución CoffeeScript.

Estaba buscando la misma solución y encontré algo muy interesante de esta respuesta: Rechazar promesas con múltiples argumentos (como $ http) en AngularJS

la respuesta de este chico 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 

Y para 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

Gran pregunta y gran respuesta de Benjamin, Kris y otros. ¡Muchas gracias!

Estoy usando esto en un proyecto y he creado un módulo basado en el código de Benjamin Gruenwald . Está disponible en npmjs:

npm i -S promise-spread

Luego, en su código, haga

require('promise-spread');

Si está utilizando una biblioteca como any-promise

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

¡Quizás otros también encuentren esto útil!

La desestructuración de la asignación en ES6 ayudaría aquí. Por ejemplo:

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

Dado que las funciones en Javascript se pueden invocar con cualquier número de argumentos, y el documento no impone ninguna restricción a los onFulfilled()argumentos del método además de la cláusula siguiente, creo que puede pasar múltiples argumentos al onFulfilled()método siempre que el valor de la promesa sea el primer argumento

2.2.2.1 debe llamarse después de que se cumpla la promesa, con el valor de la promesa como primer argumento.

Para citar el siguiente artículo, "" luego "toma dos argumentos, una devolución de llamada para un caso de éxito y otro para el caso de falla. Ambos son opcionales, por lo que puede agregar una devolución de llamada solo para el caso de éxito o falla".

Por lo general, busco en esta página cualquier pregunta básica sobre promesas, avíseme si estoy equivocado

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