Sözlerin onFulfilled için birden fazla argümanı olabilir mi?

Buradaki özellikleri takip ediyorum ve onFulfilled'in birden çok bağımsız değişkenle çağrılmasına izin verip vermediğinden emin değilim. Örneğin:

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

öyle ki benim kodum:

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

ikisini de alacaktı arg1ve arg2?

Herhangi bir vaat uygulamasının bunu nasıl yaptığı umurumda değil, vaatler için w3c şartnamesini yakından takip etmek istiyorum.

Buradaki özellikleri takip ediyorum ve onFulfilled'in birden çok bağımsız değişkenle çağrılmasına izin verip vermediğinden emin değilim.

Hayır, yalnızca ilk parametre promise yapıcısında çözünürlük değeri olarak değerlendirilecektir. Bir nesne veya dizi gibi bileşik bir değerle çözümleyebilirsiniz.

Herhangi bir vaat uygulamasının bunu nasıl yaptığı umurumda değil, vaatler için w3c şartnamesini yakından takip etmek istiyorum.

Yanlış olduğuna inandığım yer burası. Spesifikasyon minimum olacak şekilde tasarlanmıştır ve vaat edilen kitaplıklar arasında birlikte çalışacak şekilde oluşturulmuştur. Buradaki fikir, örneğin DOM geleceklerinin güvenilir bir şekilde kullanabileceği ve kitaplıkların tüketebileceği bir alt kümeye sahip olmaktır. Söz uygulamaları .spreadbir süredir istediğinizi yapın . Örneğin:

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

İle Bluebird . Bu işlevselliği istiyorsanız bir çözüm, onu çoklu doldurmaktır.

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

Bu şunları yapmanızı sağlar:

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

Yerli vaatlerle keman . Veya tarayıcılarda artık (2018) yaygın olan spread'i kullanın:

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

Veya beklerken:

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

E6 yıkımını kullanabilirsiniz:

Nesne yok etme:

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

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

Dizi bozma:

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

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

Bir vaadin yerine getirilme değeri, bir fonksiyonun dönüş değeri ile paraleldir ve bir vaadin reddedilme nedeni, bir fonksiyonun atılan istisnası ile paraleldir. İşlevler birden fazla değer döndüremez, bu nedenle vaatler 1'den fazla yerine getirme değerine sahip olmamalıdır.

ES6 Promise spesifikasyonunu ve standart vaat spesifikasyonunu okurken söyleyebildiğim kadarıyla, bir uygulamanın bu durumu ele almasını engelleyen hiçbir hüküm yoktur - ancak aşağıdaki kütüphanelerde uygulanmamıştır:

• RSVP. Söz (# L516-544)
• Q vaadi (# 787)

Çoklu argüman çözümlerini ihmal etmelerinin nedeninin, sırayı değiştirmeyi daha özlü hale getirmek olduğunu varsayıyorum (yani bir işlevde yalnızca bir değer döndürebileceğiniz için, kontrol akışını daha az sezgisel hale getirir) Örnek:

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

İşte bir CoffeeScript çözümü.

Aynı çözümü arıyordum ve bu yanıttan çok ilginç bir şey buldum: AngularJS'de birden çok argümanla ($ http gibi) vaatleri reddetmek

Bu adamın cevabı 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 

Ve kullanmak için:

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 ve diğerleri tarafından harika bir soru ve harika bir cevap - çok teşekkürler!

Bunu bir projede kullanıyorum ve Benjamin Gruenwald'ın koduna dayalı bir modül oluşturdum . Npmjs'de mevcuttur:

npm i -S promise-spread

Sonra kodunuzda yapın

require('promise-spread');

Gibi bir kitaplık kullanıyorsanız any-promise

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

Belki başkaları da bunu faydalı buluyor!

ES6'da Atamayı yeniden yapılandırmak burada yardımcı olacaktır. Örn:

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

Javascript'teki fonksiyonlar herhangi bir sayıda argümanla çağrılabildiğinden ve belge onFulfilled(), aşağıdaki cümlenin yanı sıra yöntemin argümanlarına herhangi bir kısıtlama onFulfilled()getirmediğinden, promise'ın değeri olduğu sürece yönteme birden fazla argüman iletebileceğinizi düşünüyorum . ilk argüman.

2.2.2.1 Söz yerine getirildikten sonra, sözün değeri ilk argümanı olacak şekilde çağrılmalıdır.

Aşağıdaki makaleden alıntı yapmak gerekirse, "" sonra "iki bağımsız değişken alır, bir başarı durumu için bir geri arama ve bir başarısızlık durumu için bir geri arama. Her ikisi de isteğe bağlıdır, böylece yalnızca başarı veya başarısızlık durumu için bir geri arama ekleyebilirsiniz."

Söz verilmiş temel sorular için genellikle bu sayfaya bakıyorum, yanılıyorsam bana haber ver

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