web-dev-qa-db-ja.com

promise.then（）と同等のRxJSシーケンス？

以前は多くのことを約束して開発していましたが、今はRxJSに移行しています。 RxJSのドキュメントには、PromiseチェーンからObserverシーケンスへの移行方法に関する非常に明確な例はありません。

例えば、私は通常、次のような複数のステップでプロミスチェーンを書きます

// a function that returns a promise
getPromise()
.then(function(result) {
   // do something
})
.then(function(result) {
   // do something
})
.then(function(result) {
   // do something
})
.catch(function(err) {
    // handle error
});

このプロミスチェーンをRxJSスタイルでどのように書き換えるべきですか？

javascriptrxjs
68
Haoliang Yu

データフローの場合（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
  });

Promiseは、 Rx.Observable.fromPromise を使用して監視可能オブジェクトに変換できます。

一部のpromise演算子には直接翻訳があります。たとえば、RSVP.all、またはjQuery.whenはRx.Observable.forkJoinに置き換えることができます。

データを非同期的に変換し、約束では実行できない、または実行が非常に難しいタスクを実行できる演算子がたくさんあることに注意してください。 Rxjsは、データの非同期シーケンス（シーケンス、つまり1つ以上の非同期値）でそのすべての能力を明らかにします。

エラー管理の場合、主題はもう少し複雑です。

  • catch および finally 演算子もあります
  • retryWhenは、エラーの場合にシーケンスを繰り返すのにも役立ちます
  • onError関数を使用して、サブスクライバー自体のエラーに対処することもできます。

正確なセマンティクスについては、Webで見つけることができるドキュメントと例を詳しく調べるか、ここで特定の質問をしてください。

これは間違いなくRxjsでエラー管理を深くするための良い出発点です： https://xgrommx.github.io/rx-book/content/getting_started_with_rxjs/creating_and_querying_observable_sequences/error_handling.html

70
user3743222

より現代的な代替手段：

import {from as fromPromise} from 'rxjs';
import {catchError, flatMap} from 'rxjs/operators';

fromPromise(...).pipe(
   flatMap(result => {
       // do something
   }),
   flatMap(result => {
       // do something
   }),
   flatMap(result => {
       // do something
   }),
   catchError(error => {
       // handle error
   })
)

また、これがすべて機能するためには、このパイプ処理されたsubscribeにObservableする必要があることに注意してください。

23
mik01aj

RxJs 6を使用して2019年5月に更新

上記の回答に同意し、明確にするためにRxJs v6を使用して、いくつかのおもちゃデータと単純な約束（setTimeoutを使用）の具体例を追加します。

渡されたID（現在1としてハードコードされている）を、存在しないものに更新して、エラー処理ロジックも実行します。重要なのは、ofをcatchErrorメッセージとともに使用することにも注意してください。

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

出力データ：

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 }

重要な部分は、単純なプロミス制御フローを使用する次のものと同等です。

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

私が見つけた限り、flatMapで結果を返すと、文字列を返したとしても、配列に変換されます。

しかし、Observableを返す場合、そのObservableは文字列を返すことができます。

0
Samantha Adrichem

getPromise関数がストリームパイプの途中にある場合、関数mergeMap、switchMap、またはconcatMap（通常mergeMap）のいずれかに単純にラップする必要があります。

stream$.pipe(
   mergeMap(data => getPromise(data)),
   filter(...),
   map(...)
 ).subscribe(...);

getPromise()でストリームを開始する場合は、from関数にラップします。

import {from} from 'rxjs';

from(getPromise()).pipe(
   filter(...)
   map(...)
).subscribe(...);
0
Maksim Romanenko

私が正しく理解していれば、値を消費することを意味します。その場合、sbuscribeを使用します。

const arrObservable = from([1,2,3,4,5,6,7,8]);
arrObservable.subscribe(number => console.log(num) );

さらに、次のようにtoPromise（）を使用して、observableをpromiseに変更することができます。

arrObservable.toPromise().then()
0
David Kabii

これが私がやった方法です。

以前

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

After（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
});
0
Anand Rockzz