RxJS Sequenz äquivalent zu Versprechen.dann()?

Für den Fluss der Daten (entspricht then):

Rx.Observable.fromPromise(...)
  .flatMap(function(result) {
   //do something
  })
  .flatMap(function(result) {
   //do something
  })
  .subscribe(function onNext(result) {
    //end of chain
  }, function onError(error) {
    //process the error
  });

Versprechen kann umgewandelt werden in eine beobachtbare mit Rx.Beobachtbar ist.fromPromise.

Einige Versprechen die Betreiber haben eine direkte übersetzung. Zum Beispiel RSVP.all oder jQuery.when kann ersetzt werden durch Rx.Observable.forkJoin.

Beachten Sie, dass Sie haben eine Reihe von Operatoren, die es erlaubt, Daten zu transformieren asynchron, und Aufgaben, die Sie nicht oder wäre sehr schwer zu tun mit verspricht. Rxjs enthüllt alle Ihre Kräfte mit asynchronen Sequenzen von Daten (Sequenz, D. H. mehr als 1 asynchrone Wert).

Für Fehler-management, das Thema ist ein wenig komplexer.

• es gibt fangen und schließlich Betreiber zu
• retryWhen kann auch helfen, Sie zu wiederholen einer Sequenz im Falle eines Fehlers
• können Sie sich auch mit Fehlern in der Abonnenten, die sich mit der onError Funktion.

Für präzise Bedeutung, einen tieferen Blick in die Dokumentation und Beispiele finden Sie auf der web -, oder konkrete Fragen stellen hier.

Dies würde auf jeden Fall ein guter Ausgangspunkt für tiefer gehen in Fehler-management mit Rxjs : https://xgrommx.github.io/rx-book/content/getting_started_with_rxjs/creating_and_querying_observable_sequences/error_handling.html

Update Mai 2019, mit RxJs 6

Stimmen mit den zur Verfügung gestellten Antworten vor, wünschte, fügen Sie ein konkretes Beispiel mit einige Spielzeug-Daten - & einfache Versprechen (mit setTimeout) mit RxJs v6 hinzufügen Klarheit.

Aktualisieren Sie einfach die übergebene id (derzeit hart codiert als 1), um etwas, das nicht vorhanden ist, der zum ausführen der Logik zur Fehlerverarbeitung zu. Wichtig ist, auch beachten Sie die Verwendung von of mit catchError Nachricht.

import { from as fromPromise, of } from "rxjs";
import { catchError, flatMap, tap } from "rxjs/operators";

const posts = [
  { title: "I love JavaScript", author: "Wes Bos", id: 1 },
  { title: "CSS!", author: "Chris Coyier", id: 2 },
  { title: "Dev tools tricks", author: "Addy Osmani", id: 3 }
];

const authors = [
  { name: "Wes Bos", twitter: "@wesbos", bio: "Canadian Developer" },
  {
    name: "Chris Coyier",
    twitter: "@chriscoyier",
    bio: "CSS Tricks and CodePen"
  },
  { name: "Addy Osmani", twitter: "@addyosmani", bio: "Googler" }
];

function getPostById(id) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const post = posts.find(post => post.id === id);
      if (post) {
        console.log("ok, post found!");
        resolve(post);
      } else {
        reject(Error("Post not found!"));
      }
    }, 200);
  });
}

function hydrateAuthor(post) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const authorDetails = authors.find(person => person.name === post.author);
      if (authorDetails) {
        post.author = authorDetails;
        console.log("ok, post hydrated with author info");
        resolve(post);
      } else {
        reject(Error("Author not Found!"));
      }
    }, 200);
  });
}

function dehydratePostTitle(post) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      delete post.title;
      console.log("ok, applied transformation to remove title");
      resolve(post);
    }, 200);
  });
}

//ok, here is how it looks regarding this question..
let source$ = fromPromise(getPostById(1)).pipe(
  flatMap(post => {
    return hydrateAuthor(post);
  }),
  flatMap(post => {
    return dehydratePostTitle(post);
  }),
  catchError(error => of(`Caught error: ${error}`))
);

source$.subscribe(console.log);

Output-Daten:

ok, post found!
ok, post hydrated with author info
ok, applied transformation to remove title
{ author:
   { name: 'Wes Bos',
     twitter: '@wesbos',
     bio: 'Canadian Developer' },
  id: 1 }

Den wichtigsten Teil, entspricht der folgende mit klarem Versprechen Ablaufsteuerung:

getPostById(1)
  .then(post => {
    return hydrateAuthor(post);
  })
  .then(post => {
    return dehydratePostTitle(post);
  })
  .then(author => {
    console.log(author);
  })
  .catch(err => {
    console.error(err);
  });

Soweit ich gerade herausgefunden, wenn man wieder ein Ergebnis in einer flatMap, wandelt es in ein Array, auch wenn Sie wieder einen string.

Aber wenn Sie wieder eine Beobachtbare, dass das beobachtbare können einen string zurückgeben;

Dies ist, wie ich es Tat.

Zuvor

  public fetchContacts(onCompleteFn: (response: gapi.client.Response<gapi.client.people.ListConnectionsResponse>) => void) {
    const request = gapi.client.people.people.connections.list({
      resourceName: 'people/me',
      pageSize: 100,
      personFields: 'phoneNumbers,organizations,emailAddresses,names'
    }).then(response => {
      onCompleteFn(response as gapi.client.Response<gapi.client.people.ListConnectionsResponse>);
    });
  }

//caller:

  this.gapi.fetchContacts((rsp: gapi.client.Response<gapi.client.people.ListConnectionsResponse>) => {
      //handle rsp;
  });

Nach(ly?)

public fetchContacts(): Observable<gapi.client.Response<gapi.client.people.ListConnectionsResponse>> {
    return from(
      new Promise((resolve, reject) => {
        gapi.client.people.people.connections.list({
          resourceName: 'people/me',
          pageSize: 100,
          personFields: 'phoneNumbers,organizations,emailAddresses,names'
        }).then(result => {
          resolve(result);
        });
      })
    ).pipe(map((result: gapi.client.Response<gapi.client.people.ListConnectionsResponse>) => {
      return result; //map is not really required if you not changing anything in the response. you can just return the from() and caller would subscribe to it.
    }));
  }

//caller

this.gapi.fetchContacts().subscribe(((rsp: gapi.client.Response<gapi.client.people.ListConnectionsResponse>) => {
  //handle rsp
}), (error) => {
  //handle error
});