คำสัญญาสามารถมีข้อโต้แย้งหลายข้อถึง onFulfilled ได้หรือไม่?

ฉันทำตามข้อมูลจำเพาะที่นี่และฉันไม่แน่ใจว่าอนุญาตให้เรียก onFulfilled ด้วยอาร์กิวเมนต์หลายรายการหรือไม่ ตัวอย่างเช่น:

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

ดังนั้นรหัสของฉัน:

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

จะได้รับทั้งสองarg1และarg2?

ฉันไม่สนใจว่าจะมีการดำเนินการตามสัญญาใด ๆ อย่างไรฉันต้องการทำตามข้อกำหนด w3c สำหรับคำสัญญาอย่างใกล้ชิด

ฉันทำตามข้อมูลจำเพาะที่นี่และฉันไม่แน่ใจว่าอนุญาตให้เรียก onFulfilled ด้วยอาร์กิวเมนต์หลายรายการหรือไม่

ไม่เพียงแค่พารามิเตอร์แรกเท่านั้นที่จะถือว่าเป็นค่าความละเอียดในตัวสร้างสัญญา คุณสามารถแก้ไขด้วยค่าผสมเช่นอ็อบเจ็กต์หรืออาร์เรย์

ฉันไม่สนใจว่าจะมีการดำเนินการตามสัญญาใด ๆ อย่างไรฉันต้องการทำตามข้อกำหนด w3c สำหรับคำสัญญาอย่างใกล้ชิด

นั่นคือสิ่งที่ฉันเชื่อว่าคุณคิดผิด ข้อกำหนดถูกออกแบบมาให้น้อยที่สุดและสร้างขึ้นเพื่อการทำงานร่วมกันระหว่างไลบรารีสัญญา แนวคิดคือการมีชุดย่อยที่ตัวอย่างเช่นฟิวเจอร์ส DOM สามารถใช้งานได้อย่างน่าเชื่อถือและไลบรารีสามารถใช้งานได้ การใช้งานตามสัญญาจะทำในสิ่งที่คุณขอ.spreadมาระยะหนึ่งแล้ว ตัวอย่างเช่น:

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

ด้วยคราม วิธีแก้ปัญหาอย่างหนึ่งหากคุณต้องการฟังก์ชันนี้คือการเติมเต็ม

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 สัญญา (# 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);
});

นี่คือโซลูชัน CoffeeScript

ฉันกำลังมองหาวิธีแก้ปัญหาเดียวกันและพบว่ามีบางสิ่งที่รบกวนมากจากคำตอบนี้: การปฏิเสธสัญญาที่มีข้อโต้แย้งหลายข้อ (เช่น $ http) ใน AngularJS

คำตอบของผู้ชายคนนี้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 

และวิธีใช้:

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 และอื่น ๆ - ขอบคุณมาก!

ฉันใช้ในโครงการและได้สร้างโมดูลซึ่งเป็นไปตามรหัสเบนจามิน Gruenwald ของ พร้อมใช้งานบน npmjs:

npm i -S promise-spread

จากนั้นในโค้ดของคุณให้ทำ

require('promise-spread');

หากคุณกำลังใช้ไลบรารีเช่น any-promise

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

บางทีคนอื่นก็พบว่ามีประโยชน์เช่นกัน!

การยกเลิกการกำหนดโครงสร้างใน ES6 จะช่วยได้ที่นี่สำหรับตัวอย่าง:

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

เนื่องจากฟังก์ชันใน Javascript สามารถเรียกใช้ด้วยอาร์กิวเมนต์จำนวนเท่าใดก็ได้และเอกสารไม่ได้กำหนดข้อ จำกัด ใด ๆ เกี่ยวกับonFulfilled()อาร์กิวเมนต์ของเมธอดนอกเหนือจากส่วนคำสั่งด้านล่างฉันคิดว่าคุณสามารถส่งอาร์กิวเมนต์หลายตัวไปยังonFulfilled()เมธอดได้ตราบเท่าที่ค่าของสัญญาคือ อาร์กิวเมนต์แรก

2.2.2.1 จะต้องถูกเรียกหลังจากที่สัญญาสำเร็จโดยมีค่าของสัญญาเป็นอาร์กิวเมนต์แรก

หากต้องการอ้างอิงบทความด้านล่าง "" จากนั้น "จะใช้อาร์กิวเมนต์สองรายการการเรียกกลับสำหรับกรณีความสำเร็จและอีกข้อสำหรับกรณีความล้มเหลวทั้งสองเป็นทางเลือกดังนั้นคุณสามารถเพิ่มการเรียกกลับสำหรับกรณีความสำเร็จหรือความล้มเหลวเท่านั้น"

ฉันมักจะมองไปที่หน้านี้สำหรับคำถามพื้นฐานเกี่ยวกับสัญญาโปรดแจ้งให้เราทราบหากฉันผิด

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