RxJS Promise Composition (passage de données)

Je suis tout nouveau à Rx et je suis de trouver qu'il est difficile de trouver de la documentation sur la composition de promesses, telles que les données de la première promesse est passé dans le deuxième et ainsi de suite. Voici trois très promesses de base, les calculs sur les données ne sont pas importantes, c'est juste que quelque chose asynchrone doit être faite en utilisant les données de la dernière promesse.

 const p1 = () => Promise.resolve(1);
 const p2 = x => { const val = x + 1; return Promise.resolve(val); };
 const p3 = x => {
      const isEven = x => x % 2 === 0;
      return Promise.resolve(isEven(x));
 };

La manière traditionnelle pour atteindre la composition je parle:

 pl().then(p2).then(p3).then(console.log);

Mon préféré de mise en œuvre est Ramda est composeP et pipeP:

R.pipeP(p1, p2, p3, console.log)()

Il semble probable Rx pourriez être en mesure de gérer ce type de situation assez couramment. Cependant, le plus proche que j'ai trouvé pour l'instant est de la RxJS async (bibliothèque), de la comparaison ici https://github.com/Reactive-Extensions/RxJS/blob/master/doc/mapping/async/comparing.md:

 var Rx = require('rx'),
     fs = require('fs'),
     path = require('path');
 var file = path.join(__dirname, 'file.txt'),
     dest = path.join(__dirname, 'file1.txt'),
     exists = Rx.Observable.fromCallback(fs.exists),
     rename = Rx.Observable.fromNodeCallback(fs.rename),
     stat = Rx.Observable.fromNodeCallback(fs.stat);
 exists(file)
    .concatMap(function (flag) {
     return flag ?
         rename(file, dest) :
         Rx.Observable.throw(new Error('File does not exist.'));
    })
    .concatMap(function () {
        return stat(dest);
    })
   .forEach(
      function (fsStat) {
          console.log(JSON.stringify(fsStat));
      },
      function (err) {
          console.log(err);
      }
    );

concatMap semble prometteur, mais le code ci-dessus semble assez horrible. J'étais aussi de la difficulté avec mon exemple parce Rx.Observables.fromPromise(p1) ne fonctionnera pas comme il s'attend à une promesse elle-même, non pas une fonction, et Rx.Observables.reporter(p1) ne semble pas de passer des paramètres comme dans l'exemple.

Merci!

Question similaire, mais sans transmission de données:
Le chaînage des promesses de RxJS

source d'informationauteur low_ghost

19

Je n'ai pas lu en entier, mais si vous voulez atteindre le même que pl().then(p2).then(p3).then(console.log);avec p étant fonction de retour promesses, vous pourriez faire quelque chose comme (exemple ici)
```
Rx.Observable.fromPromise(p1())
             .flatMap(function(p1_result){return p2(p1_result);})
             .flatMap(function(p2_result){return p3(p2_result);})
```
Ou la plus symétrique :
```
 var chainedPromises$ = 
     Rx.Observable.just()
             .flatMap(p1)
             .flatMap(p2)
             .flatMap(p3);
```
Maintenant, si vous voulez exécuter séquentiellement rappel enveloppé par fromCallback ou fromNodeCallbackvous pourriez faire quelque chose comme :
```
function rename (flag){
  return flag
          ? rename(file,dest).flatMap(return Rx.Observable.just(dest))
          : Rx.Observable.throw(new Error('File does not exist.'));
}

Rx.Observable.just(file)
             .flatMap(exists)
             .flatMap(rename)
             .flatMap(stat)
```
Le dernier code n'est pas testé, donc tenez-moi au courant si cela fonctionne.
Dernier commentaire, cela devrait fonctionner si à chaque point vous avez seulement une valeur produite (comme une promesse). Si vous avez plusieurs fichiers au lieu d'un, avec flatMap vous pourriez obtenir la commande de questions (si l'ordre des questions à vous), donc dans ce cas, vous pourriez utiliser concatMap comme un remplacement.

Vous devez vous connecter pour publier un commentaire.