Могат ли обещанията да имат множество аргументи за onFulfilled?

Следвам спецификацията тук и не съм сигурен дали позволява onFulfilled да бъде извикан с множество аргументи.

Не, само първият параметър ще се третира като стойност на резолюцията в конструктора на обещанието. Можете да разрешите със съставна стойност като обект или масив.

Не ме интересува как го прави някаква конкретна реализация на обещания, искам да следвам отблизо спецификацията на w3c за обещания.

Тук вярвам, че грешите. Спецификацията е разработена да бъде минимална и е създадена за взаимодействие между библиотеки за обещания. Идеята е да има подмножество, което фючърсите на DOM например могат надеждно да използват и библиотеките да консумират. Реализациите на Promise правят това, което поискате с .spread за известно време. Например:

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

С Bluebird. Едно решение, ако искате тази функционалност, е да я попълните.

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

Това ви позволява да правите:

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

С естествени обещания на спокойствие цигулка. Или използвайте разпространение, което сега (2018 г.) е обичайно в браузърите:

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

Или с чакане:

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

Можете да използвате E6 деструктуриране:

Разрушаване на обекти:

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

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

Деструктуриране на масив:

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

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

Стойността на изпълнение на обещание е паралелно на върнатата стойност на функция, а причината за отхвърляне на обещание е паралелно на хвърленото изключение на функция. Функциите не могат да връщат множество стойности, така че обещанията не трябва да имат повече от 1 стойност за изпълнение.

Доколкото мога да преценя, четейки спецификацията на ES6 Promise и стандартна спецификация на обещанието няма клауза, която да пречи на внедряване да обработва този случай - но не е внедрено в следните библиотеки:

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

Предполагам, че причината да пропуснат разрешаването на множество аргументи е да направят промяната на реда по-сбита (т.е. тъй като можете да върнете само една стойност във функция, това би направило контролния поток по-малко интуитивен) Пример:

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

Деструктурирането на присвояването в ES6 би помогнало тук. Например:

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

Ето решение на CoffeeScript.

Търсих същото решение и намерих нещо много интересно от този отговор: https://stackoverflow.com/questions/17686612/rejecting-promises-with-multiple-arguments-like-http-in-angularjs

отговорът на този човек Флориан

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 

И да го използвате:

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

Страхотен въпрос и страхотен отговор от Benjamin, Kris и други - много благодаря!

Използвам това в проект и създадох модул, базиран на кода на Benjamin Gruenwald. Предлага се на npmjs:

npm i -S promise-spread

След това във вашия код направете

require('promise-spread');

Ако използвате библиотека като any-promise

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

Може би и други намират това за полезно!

Тъй като функциите в Javascript могат да бъдат извикани с произволен брой аргументи и документът не поставя никакво ограничение върху аргументите на метода onFulfilled() освен клаузата по-долу, мисля, че можете да подадете множество аргументи към метода onFulfilled(), стига стойността на обещанието да е е първият аргумент.

2.2.2.1 трябва да се извика, след като обещанието е изпълнено, със стойността на обещанието като първи аргумент.

За да цитирам статията по-долу, „„след това“ приема два аргумента, обратно извикване за случай на успех и друг за случай на неуспех. И двата са незадължителни, така че можете да добавите обратно извикване само за случая на успех или неуспех.“

Обикновено разглеждам тази страница за всякакви основни въпроси относно обещанието, уведомете ме, ако греша

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