Verkettung verspricht mit RxJS

Question

Ich bin neu bei RxJS und FRP im Allgemeinen. Ich hatte die Idee, eine bestehende Versprechungskette in meiner ExpressJS-Anwendung so umzuwandeln, dass sie für die Praxis beobachtbar ist. Ich bin mir bewusst, dass dies wahrscheinlich nicht das beste Beispiel ist, aber vielleicht kann jemand helfen, etwas Licht zu geben.

Was ich versuche zu tun:

1. Ich habe zwei Versprechen - PROM1 und Prom2
2. I PROM1 vor Prom2
3. ausgeführt werden soll Wenn PROM1 a (err) sendet ablehnen, Ich möchte prom2 abbrechen, bevor es startet.
4. Ich möchte, dass die Fehlermeldung prom1 retains für die onError-Methode für den Beobachter verfügbar ist.

---

var prom1 = new Promise(function(resolve, reject) { 
    if (true) { 
     reject('reason'); 
    } 
    resolve(true); 
}); 

var prom2 = new Promise(function(resolve, reject) { 
    resolve(true); 
}); 

// What do I do here? This is what I've tried so far... 
var source1 = Rx.Observable.fromPromise(prom1); 
var source2 = source1.flatMap(Rx.Observable.fromPromise(prom2)); 

var subscription = source2.subscribe(
    function (result) { console.log('Next: ' + result); }, 

    // I want my error 'reason' to be made available here 
    function (err) { console.log('Error: ' + err); }, 

    function() { console.log('Completed'); }); 

Answer 1

Wenn ich verstanden, was Sie zu tun versuchen - Sie zwei latente Observablen von Funktionen erstellen müssen, die Versprechen und verketten sie zurück:

var shouldFail = false; 

function action1() { 
    return new Promise(function (resolve, reject) {  
     console.log('start action1'); 
     if (shouldFail) { 
      reject('reason'); 
     } 
     resolve(true); 
    }); 
} 

function action2() { 
    return new Promise(function (resolve, reject) {  
     console.log('start action2'); 
     resolve(true); 
    }); 
} 

var source1 = Rx.Observable.defer(action1); 
var source2 = Rx.Observable.defer(action2); 

var combination = Rx.Observable.concat(source1, source2); 

var logObserver = Rx.Observer.create(

function (result) { 
    console.log('Next: ' + result); 
}, 

function (err) { 
    console.log('Error: ' + err); 
}, 

function() { 
    console.log('Completed'); 
}); 

dann für Normalfall:

combination.subscribe(logObserver); 
// start action1 
// Next: true 
// start action2 
// Next: true 
// Completed 

Und Fall, in dem fisrt Versprechen nicht:

shouldFail = true; 
combination.subscribe(logObserver); 
// start action1 
// Error: reason 

http://jsfiddle.net/cL37tgva/

Answer 2

flatMap wendet eine beobachtbare von Observablen in einer beobachtbaren. Es wird in vielen Beispielen mit Promises verwendet, da Sie oft eine Observable haben und in der Map-Funktion ein Versprechen für jedes "Objekt" der beobachtbaren Emmits erstellen möchten. Weil jeder fromPromise-Aufruf ein neues Observable erstellt, das macht es zu einer "beobachtbaren Observablen". flatMap reduziert das auf ein "flaches" Observable.

In deinem Beispiel machst du etwas anderes, du verwandelst ein einzelnes Versprechen in eine beobachtbare und willst es mit einer anderen beobachtbaren verknüpfen (auch aus einem einzigen Versprechen). Concat macht, was Sie suchen, es kettet zwei Observable zusammen.

Der Fehlerfall funktioniert wie erwartet.

Answer 3

Observable.forkJoin funktioniert gut hier erhalten Array von anderen Observables.

Rx.Observable.forkJoin([this.http.get('http://jsonplaceholder.typicode.com/posts'), this.http.get('http://jsonplaceholder.typicode.com/albums')]).subscribe((data) => { 
     console.log(data); 
    });