Les promesses peuvent-elles avoir plusieurs arguments pour onFulfilled?

Je suis la spécification ici et je ne sais pas si cela permet à onFulfilled d'être appelé avec plusieurs arguments. Par exemple:

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

tel que mon code:

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

recevrait à la fois arg1et arg2?

Je me fiche de la façon dont une mise en œuvre de promesses spécifiques le fait, je souhaite suivre de près les spécifications du w3c pour les promesses.

Je suis la spécification ici et je ne sais pas si cela permet à onFulfilled d'être appelé avec plusieurs arguments.

Non, seul le premier paramètre sera traité comme valeur de résolution dans le constructeur de promesse. Vous pouvez résoudre avec une valeur composite comme un objet ou un tableau.

Je me fiche de la façon dont une mise en œuvre de promesses spécifiques le fait, je souhaite suivre de près les spécifications du w3c pour les promesses.

C'est là que je crois que vous vous trompez. La spécification est conçue pour être minimale et est conçue pour interopérer entre les bibliothèques de promesse. L'idée est d'avoir un sous-ensemble que les futurs DOM, par exemple, peuvent utiliser de manière fiable et que les bibliothèques peuvent consommer. Les implémentations Promise font ce que vous demandez .spreaddepuis un moment maintenant. Par exemple:

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

Avec Bluebird . Une solution si vous voulez cette fonctionnalité est de la polyfill.

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

Cela vous permet de faire:

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

Avec les promesses natives à l'aise violon . Ou utilisez la diffusion qui est maintenant (2018) courante dans les navigateurs:

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

Ou avec wait:

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

Vous pouvez utiliser la déstructuration E6:

Déstructuration d'objets:

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

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

Déstructuration du tableau:

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

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

La valeur de réalisation d'une promesse est parallèle à la valeur de retour d'une fonction et la raison de rejet d'une promesse est parallèle à l'exception lancée d'une fonction. Les fonctions ne peuvent pas renvoyer plusieurs valeurs, les promesses ne doivent donc pas avoir plus d'une valeur d'exécution.

Pour autant que je sache, en lisant la spécification ES6 Promise et la spécification standard de la promesse, il n'y a pas de clause empêchant une implémentation de gérer ce cas - cependant, elle n'est pas implémentée dans les bibliothèques suivantes:

• Promesse RSVP (# L516-544)
• Promesse Q (# 787)

Je suppose que la raison pour laquelle ils omettent les résolutions multi-arg est de rendre l'ordre de changement plus succinct (c'est-à-dire que vous ne pouvez renvoyer qu'une seule valeur dans une fonction, cela rendrait le flux de contrôle moins intuitif) Exemple:

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

Voici une solution CoffeeScript.

Je cherchais la même solution et j'ai trouvé quelque chose de très intéressant dans cette réponse: Rejeter les promesses avec plusieurs arguments (comme $ http) dans AngularJS

la réponse de ce mec 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 

Et pour l'utiliser:

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

Excellente question et excellente réponse de Benjamin, Kris et al - merci beaucoup!

J'utilise ceci dans un projet et j'ai créé un module basé sur le code de Benjamin Gruenwald . Il est disponible sur npmjs:

npm i -S promise-spread

Ensuite, dans votre code, faites

require('promise-spread');

Si vous utilisez une bibliothèque telle que any-promise

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

Peut-être que d'autres trouvent cela utile aussi!

L'affectation de déstructuration dans ES6 serait utile ici.

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

Étant donné que les fonctions en Javascript peuvent être appelées avec n'importe quel nombre d'arguments et que le document ne place aucune restriction sur les onFulfilled()arguments de la méthode en plus de la clause ci-dessous, je pense que vous pouvez passer plusieurs arguments à la onFulfilled()méthode tant que la valeur de la promesse est le premier argument.

2.2.2.1 il doit être appelé après que la promesse est accomplie, avec la valeur de la promesse comme premier argument.

Pour citer l'article ci-dessous, "" puis "prend deux arguments, un rappel pour un cas de réussite et un autre pour le cas d'échec. Les deux sont facultatifs, vous pouvez donc ajouter un rappel pour le cas de réussite ou d'échec uniquement."

Je regarde généralement cette page pour toute question de base sur les promesses, faites-moi savoir si je me trompe

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