Wie der "flatmap" Betreiber bedingt ? (Winkel 2/rxjs)

Was ich versuche zu erreichen, laufen eine Reihe von observablen bedingt.

return observable.map(response => response)
       .flatmap(response1 => observable1(response1))
       .flatmap(response2 => observable2(response2))
       .flatmap(response3 => observable3(response3))

Ich brauche, um zu überprüfen, die response1 und berufen sich auf die restlichen observablen, wenn nötig, sonst muss ich zurück response1 und brechen die Ausführung und so weiter.

Ich durchgemacht habe folgende Fragen, aber Sie nicht scheinen, um meine Frage zu beantworten

Bedingt wählen, erkennbar im RxJS

RXJS wenn mit beobachtbaren bedingten

Handle Fehler in RxJs flatMap stream und die Verarbeitung fortzusetzen

Ich bin neu rxjs, so verzeihen Sie mir, wenn die Frage scheint mir zu lahm.

Jede Hilfe wird geschätzt.

Dank

Was ist die Bedingung für? Ist es statisch, hängt es ab response, bedeutet die zweite Bedingung abhängig response2 etc?
ja, der Zustand ist statisch, die zweite Bedingung hängt von der response2

InformationsquelleAutor Joel Raju | 2017-03-09

5

Dies ist, wie der Aufruf, mehrere aufeinander folgende HTTP-Anfragen, wo die Ergebnisse hängen von einander ab. Dies ist, wo Sie verwenden möchten concatMap() statt, weil es warten, bis der Beobachtbaren zurückgegeben, die von der callback-Funktion abgeschlossen ist.

Es ist schwer zu sagen, was genau Sie wollen zu tun, von deiner Beschreibung, aber wenn Sie benötigen, um mit der Propagierung der Ergebnisse (und vermeiden, fordern Sie unnötige HTTP-requests) haben Sie einen Blick takeWhile() Betreiber oder einfach filter() Betreiber.

Mit filter():
```
return observable
    .concatMap(response => response)
    .filter(response1 => response1.whatever === true)
    .concatMap(response1 => observable1(response1))
    .filter(response2 => response2.whatever === true)
    .concatMap(response2 => observable2(response2))
    .filter(response3 => response3.whatever === true)
```
Das einfach nicht vermehren, das Element weiter, wenn es nicht die filter test. Allerdings wird die Quelle observable können noch emittieren Werte, die gehen durch die Kette. In anderen Worten, die filter Betreiber nicht die komplette Kette.

Mit takeWhile():
```
return observable
    .concatMap(response => response)
    .takeWhile(response1 => response1.whatever === true)
    .concatMap(response1 => observable1(response1))
    .takeWhile(response2 => response2.whatever === true)
    .concatMap(response2 => observable2(response2))
    .takeWhile(response3 => response3.whatever === true)
```
Wenn eine der takeWhile() Ergebnis in false, es wird schließen Sie die Kette, und kein anderer Wert kann emittiert werden.
- Was ist der Unterschied zwischen concatMap und die flatMap dass die OP wird mit Hilfe?
- Ich will aufhören, die Ausbreitung zu observable2 wenn response1 ist einen bestimmten Wert und zurück response1 oder anderes laufen observable2 und so weiter
- können Sie ein Beispiel zeigen, wie Sie zu stoppen Ausbreitung über filter() oder takewhile()
- Siehe mein update.
- danke @martin, diese Tat zu helfen.
InformationsquelleAutor martin

Könnte man etwas machen wie:

observable.map(res => res.json())
  .flatMap(json => {
      if (json.something === 'something') {
          return this.http.get('/anotherCall')
              .map(res => 'second response: ' + res);
      } else {
          return Observable.from(['just return something else']);
      }
  });

Sind es nur zwei Anrufe, aber Sie erhalten den Punkt.

Hinweis : die "Rückkehr etwas anderes' kann Observable.empty() wenn Sie möchten, dass die streams sofort vollständig da. Sie können nicht nur nicht wieder einige beobachtbare Sache, diese verursachen einen Laufzeitfehler.

InformationsquelleAutor Patrik

Habe ich nicht gefunden, einfach Weg zu umgehen-Betreiber, wenn Sie sich entscheiden, Sie zu überspringen n letzten Betreiber, das Sie noch zu Durchlaufen haben, die Letzte gültige Antwort, die durch alle Betreiber:

 return observable
   .flatmap(r => {
        return r.value > 1 ? observable1(r) : Observable.of(r);
   })
   .flatmap(r => {
        return r.value > 2 ? observable2(r) : Observable.of(r);
   })
   .flatmap(r => {
        return r.value > 3 ? observable3(r) : Observable.of(r);
   })

InformationsquelleAutor kemsky

0

Alternativ können Sie kombinieren alle observablen in einem einzigen beobachtbaren und abonnieren, die, wie unten,
```
return response
         .concatMapTo(response1,(response2, response3) => 
             `${response2} ${response3}`
          );
```
Abonnieren Sie mit
```
data = response.subscribe(val => console.log(val)); //contains all three responses value
```
Immer noch Sie zugreifen können jeweils separat mit der response2 und response3 benannte Instanz.

Abonnieren für ein einzelnes Objekt mit verschiedenen observablen:
Wenn Sie auf der Suche zu kombinieren, Daten und Eigenschaften aus verschiedenen observablen können Sie einen Blick auf diese Antwort
- Ich will nicht kombinieren die Antworten, ich brauche nur zu laufen observable2 wenn ich das will.
- zurück können Sie dann separat? warum Sie mit flatMap?
- oder was ist sonst werde ich verwenden, wenn ich laufen will observable2 wenn die response1 ist ein bestimmter Wert oder zurück response1 wenn es einen anderen Wert, ohne Verschachtelung
InformationsquelleAutor Aravind

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.