違いは何であるPromise
とObservable
角度では?
それぞれの例は、両方のケースを理解するのに役立ちます。それぞれのケースでどのようなシナリオを使用できますか?
違いは何であるPromise
とObservable
角度では?
それぞれの例は、両方のケースを理解するのに役立ちます。それぞれのケースでどのようなシナリオを使用できますか?
回答:
約束する
AのPromise
ハンドルシングルイベント非同期操作の完了または失敗しました。
注:Promise
キャンセルをサポートするライブラリは世の中にPromise
ありますが、ES6 は今のところサポートしていません。
観察可能
ANはObservable
似ているStream
(多くの言語で)及びコールバックはイベントごとに呼び出され、ゼロ以上のイベントを通過させます。
それ以上の機能を提供するため、多くの場合よりObservable
も推奨されます。ではあなたは0、1、または複数のイベントを処理する場合、それは問題ではありません。どちらの場合も同じAPIを利用できます。Promise
Promise
Observable
Observable
また、キャンセル可能であるという利点Promise
があります。サーバーへのHTTPリクエストの結果またはその他の高額な非同期操作が不要になった場合、のはサブスクリプションのキャンセルを許可しますが、通知が不要な場合でもは最終的に成功または失敗したコールバックを呼び出しますまたはそれが提供する結果。Subscription
Observable
Promise
観測可能では提供事業者のようなmap
、forEach
、reduce
配列に類似し、...
強力なような事業者もありretry()
、またはreplay()
多くの場合、非常に便利です...。
Promise
、async
/ とともにawait
コードを再びフラットにすることを忘れないでください!ほとんどの状況で、そしてロケット科学を扱っていないプロジェクトでは、不必要に複雑なメソッドのチェーンを使用して、これらの恐ろしい入れ子関数を記述する必要はありません。async
/をawait
今日のようなトランスパイラーで使用しTypeScript
、rxjs
ボイラープレートなしで実際の人間が読めるフラットコードを書くことができます。rxjs
それは本当に提供することがたくさんあるので、あなたはおそらくまだ選択された状況で時々まだ必要になるでしょう。
どちらPromises
とObservables
助け、私たちが対処することを抽象化を提供してくれる非同期当社のアプリケーションの性質。それらの違いは@Günterと@Reluによって明確に指摘されました。
コードスニペットは1000語に相当するので、以下の例を理解して理解しやすくしてください。
素晴らしいものを@Christoph Burgdorfに感謝 記事
Angularは、HTTPを扱うための約束の代わりにRx.js Observablesを使用します。
あなたが構築していると仮定します 入力中に結果を即座に表示検索機能を。おなじみのようですが、その作業には多くの課題があります。
HTTP
リクエストでます。基本的に、ユーザーがキーストロークごとではなく、ユーザーが入力を停止したときにのみヒットさせたいと考えています。デモは単純に2つのファイルで構成されます:app.ts
とwikipedia-service.ts
。ただし、実際のシナリオでは、おそらくさらに分割します。
以下は、説明されているエッジケースを処理しないPromiseベースの実装です。
wikipedia-service.ts
import { Injectable } from '@angular/core';
import { URLSearchParams, Jsonp } from '@angular/http';
@Injectable()
export class WikipediaService {
constructor(private jsonp: Jsonp) {}
search (term: string) {
var search = new URLSearchParams()
search.set('action', 'opensearch');
search.set('search', term);
search.set('format', 'json');
return this.jsonp
.get('http://en.wikipedia.org/w/api.php?callback=JSONP_CALLBACK', { search })
.toPromise()
.then((response) => response.json()[1]);
}
}
特定の検索用語を使用して、Wikipedia APIに対してリクエストJsonp
を行うサービスを注入しています。我々は呼んでいることに注意してくださいから得るためにします。最終的には、検索メソッドの戻り値の型としてa になります。GET
toPromise
Observable<Response>
Promise<Response>
Promise<Array<string>>
app.ts
// check the plnkr for the full list of imports
import {...} from '...';
@Component({
selector: 'my-app',
template: `
<div>
<h2>Wikipedia Search</h2>
<input #term type="text" (keyup)="search(term.value)">
<ul>
<li *ngFor="let item of items">{{item}}</li>
</ul>
</div>
`
})
export class AppComponent {
items: Array<string>;
constructor(private wikipediaService: WikipediaService) {}
search(term) {
this.wikipediaService.search(term)
.then(items => this.items = items);
}
}
ここでもそれほど驚きはありません。を挿入WikipediaService
し、検索メソッドを介してその機能をテンプレートに公開します。テンプレートは単にキーアップにバインドして呼び出しますsearch(term.value)
。
WikipediaServiceのsearchメソッドが返すというPromiseの結果を展開し、それを単純な文字列の配列としてテンプレートに公開して、*ngFor
ループしてリストを作成できるようにします。
上の約束ベースの実装の例を参照してくださいPlunker
観測可能な場所本当に輝く
すべてのキーストロークでエンドポイントを叩かないようにコードを変更してみましょう。代わりに、ユーザーが入力を停止したときにのみリクエストを送信します 400ミリ秒
そのような超能力を明らかにするためにObservable<string>
、ユーザーが入力した検索語を運ぶを最初に取得する必要があります。keyupイベントに手動でバインドする代わりに、AngularのformControl
ディレクティブを利用できます。このディレクティブを使用するには、最初にをReactiveFormsModule
アプリケーションモジュールにインポートする必要があります。
app.ts
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { JsonpModule } from '@angular/http';
import { ReactiveFormsModule } from '@angular/forms';
@NgModule({
imports: [BrowserModule, JsonpModule, ReactiveFormsModule]
declarations: [AppComponent],
bootstrap: [AppComponent]
})
export class AppModule {}
インポートしたら、テンプレート内からformControlを使用して、「term」という名前に設定できます。
<input type="text" [formControl]="term"/>
コンポーネントでは、のインスタンスを作成します FormControl
fromの@angular/form
し、コンポーネントの名前termの下のフィールドとして公開します。
舞台裏で、termは自動的にサブスクライブ可能なObservable<string>
asプロパティvalueChanges
を公開します。今、私たちは持っていることをObservable<string>
、ユーザの入力を克服して呼び出すように簡単ですdebounceTime(400)
私たちにObservable
。これはObservable<string>
、400msの間新しい値が来ていない場合にのみ新しい値を放出するnewを返します。
export class App {
items: Array<string>;
term = new FormControl();
constructor(private wikipediaService: WikipediaService) {
this.term.valueChanges
.debounceTime(400) // wait for 400ms pause in events
.distinctUntilChanged() // ignore if next search term is same as previous
.subscribe(term => this.wikipediaService.search(term).then(items => this.items = items));
}
}
私たちのアプリがすでに結果を表示している検索語句の別のリクエストを送信することは、リソースの無駄になります。目的の動作を実現するために必要なのは、呼び出したdistinctUntilChanged
直後に演算子を呼び出すことですdebounceTime(400)
Observableの実装例を参照してくださいPlunker
順不同の応答の扱いについては、記事全体を確認してください http://blog.thoughtram.io/angular/2016/01/06/taking-advantage-of-observables-in-angular2.html
AngularでHttpを使用している限り、通常の使用例ではObservable over Promiseを使用しても大きな違いはないことに同意します。ここで実際に関連する利点はありません。私は将来的にいくつかの高度なユースケースを見ることができることを願っています:)
もっと詳しく知る
PromisesとObservablesはどちらも、JavaScriptの非同期機能の操作に役立ちます。それらは多くの場合非常に似ていますが、2つの間にもいくつかの違いがあり、promiseはhttp呼び出しのasynchronous
ような方法で解決される値です。一方、オブザーバブルは一連の非同期イベントを処理します。それらの主な違いは次のとおりです。
約束する:
観測可能:
また、違いを視覚的に示すために、以下のグラフィックイメージを作成しました。
Promise
は、どのように約束するかについて考えるのに間違った方法です。Promise
唯一の非同期互換性のある方法でハンドル成功または失敗への責任、それ..あなたは、httpリクエストをキャンセルしたい場合は、リクエストではなく、約束をキャンセルし、いずれかの約束を履行または拒絶キャンセルの結果を確認します。jsfiddle.net/greggman/ea0yhd4p
約束
観測可能
ある条件に基づいてオブザーバブルを再試行する必要がある場合も、必要に応じて1つのオペレーターの再試行を使用して再試行できます。retryWhenを使用できます。
注:インタラクティブな図とともにオペレーターのリストは、RxMarbles.comから入手できます。
Observablesの1つの欠点が回答にありません。プロミスはES7の非同期/待機機能の使用を許可します。それらを使用すると、同期関数呼び出しのように非同期コードを記述できるため、コールバックは不要になります。Observableがこれを行う唯一の可能性は、それらをPromiseに変換することです。ただし、それらをPromiseに変換すると、戻り値は1つだけに戻ります。
async function getData(){
const data = await observable.first().toPromise();
//do stuff with 'data' (no callback function needed)
}
PromiseとObservableはどちらも非同期呼び出しのみを処理します。
これらの違いは次のとおりです。
観察可能
約束する
一度に1つの値のみを発行します
.thenおよび.catchなしでサービスを呼び出します
キャンセルできません
オペレーターを提供していません
この答えは遅いですが、私は以下の違いを要約しました、
観察可能:
function
とるan observer
と返します function Observer: an object with next, error.
subscribe/unsubscribe
、そのデータストリームに、観察者に次の値を発し、notify
約オブザーバerrors
約観察者に知らせますstream completion
function to handle next value
、エラーとストリームの終わり(UIイベント、http応答、Webソケットのデータ)を提供します。multiple values
時間とともに機能するcancel-able/retry-able
、そのよう支援事業者をmap,filter,reduce
などObservable.create()
ます--onメソッドを呼び出すことができるObservableを返しますObserver Observable.from()
--配列または反復可能オブジェクトをにObservable Observable.fromEvent()
変換します-- イベントをObservableにObservable.fromPromise()
変換します--PromiseをObservableに変換しObservable.range()
ます--指定された範囲の整数のシーケンスを返します約束:
promiseは、将来終了するタスクを表します。
約束になるresolved by a value
;
約束は例外によって拒否されます。
ないcancellable
、そしてそれは戻るa single value
約束は機能を公開する (then)
-その後、新しいを返します promise
。
-の許可は、attachment
に基づいて実行され
state
ます。
- handlers
ある guaranteed
中で実行しますorder attached
。
私はPromiseが最善の解決策である問題を扱ったばかりであり、役に立つ場合にこの質問に出くわした人のためにここでそれを共有します(これはまさに私が以前に探していた答えでした):
Angular2プロジェクトには、いくつかのパラメーターを取り、フォームのドロップダウンメニューに値を入力するための値リストを返すサービスがあります。フォームコンポーネントが初期化されるとき、同じパラメーターを複数回使用して同じサービスを複数の異なるドロップダウンメニューを定義するために呼び出す必要がありますが、サービスを呼び出すためにすべての変数を単にキューに入れると、最後の1つだけが成功し、残りのエラーが発生しますアウト。データベースからフェッチするサービスは、一度に1つの要求しか処理できませんでした。
すべてのドロップダウンメニュー変数を正常に設定する唯一の方法は、最後のリクエストが完了するまで新しいリクエストが処理されないようにサービスを呼び出すことでした。Promise/ .thenメカニズムは問題をうまく解決しました。
fetchValueList(listCode): Promise<any> {
return this.dataSvc.getValueList(listCode, this.stateSvc.currentContext, this.stateSvc.currentLanguageCode)
.map(response => response.json())
.toPromise();
}
initializeDropDowns() {
this.fetchValueList('First-Val-List')
.then(data => {
this.firstValList = data;
return this.fetchValueList('Second-Val-List')
}).then(data => {
this.secondValList = data;
return this.fetchValueList('Third-Val-List')
}).then(data => {
this.thirdValList = data;
}) }
コンポーネントで関数を定義してから、ngOnInitでinitializeDropDowns()を呼び出しました。
fetchValueList関数はPromiseを返すため、最初の呼び出しは最初のlistCodeを渡し、Promiseが解決されると、戻り値は.thenブロックのデータ変数にあり、this.firstValList変数に割り当てることができます。関数がデータを返したので、サービスが終了し、2番目のlistCodeで再度呼び出しても安全であることがわかります。戻り値は次の.thenブロックのdata変数にあり、this.secondValList変数に割り当てます。
これを必要なだけチェーンして、すべての変数を設定できます。最後のコードブロックでは、returnステートメントを省略してブロックを終了します。
これは、コンポーネントの初期化時に複数回呼び出す必要のある単一のサービスがあり、サービスを再度呼び出す前にフェッチを完了して値を返す必要がある非常に特殊なユースケースですが、この場合は、 Promise / .thenメソッドが理想的でした。
scan()
、順次オブザーバブルのストリームを構築するために使用できます。ただし、アプローチはより明確で理解しやすいかもしれません。
私は他のすべての答えがあなたの疑問を解決するはずだと思います。それにもかかわらず、私はオブザーバブルが関数型プログラミングに基づいていることを追加したかっただけであり、map、flatmap、reduce、zipなどのそれに付属する関数が非常に便利であることがわかりました。特にAPIリクエストに依存しているときにWebが達成する一貫性は、残忍な改善です。
このドキュメントは、reactiveXの公式ドキュメントであり、最も明確であると思うので、強くお勧めします。
オブザーバブルに興味がある場合は、この3部構成の投稿をお勧めします。http: //blog.danlew.net/2014/09/15/grokking-rxjava-part-1/
これはRxJava向けですが、概念は同じであり、非常によく説明されています。reactXのドキュメントでは、各関数に同等のものがあります。RxJSを探す必要があります。
オブザーバブルはpromiseが提供するすべての機能(+追加)を備えているため、非同期動作を処理するために常にオブザーバブルを使用できます。ただし、Observablesが提供するこの追加機能が不要な場合もあります。次に、ライブラリをインポートして使用するためのオーバーヘッドが余分になります。
結果を処理したい非同期操作が1つある場合は、promise を使用します 。例えば:
var promise = new Promise((resolve, reject) => {
// do something once, possibly async
// code inside the Promise constructor callback is getting executed synchronously
if (/* everything turned out fine */) {
resolve("Stuff worked!");
}
else {
reject(Error("It broke"));
}
});
//after the promise is resolved or rejected we can call .then or .catch method on it
promise.then((val) => console.log(val)) // logs the resolve argument
.catch((val) => console.log(val)); // logs the reject argument
したがって、promiseは、解決または拒否するコードを実行します。resolveまたはrejectのいずれかが呼び出されると、promiseは保留状態から解決または拒否状態に移行します。promise状態が解決されると、then()
メソッドが呼び出されます。promise状態が拒否されると、catch()
メソッドが呼び出されます。
処理が必要な(データの)ストリームが長期にわたって存在する場合は、Observablesを使用します。ストリームは、時間の経過とともに利用可能になる一連のデータ要素です。ストリームの例は次のとおりです。
Observable自体は、次のイベントが発生したとき、エラーが発生したとき、またはObservableが完了したときに指定されます。次に、このオブザーバブルをサブスクライブしてアクティブにし、このサブスクリプションで3つのコールバックを渡すことができます(常にすべてを渡す必要はありません)。成功時に実行される1つのコールバック、エラーに対して1つのコールバック、完了時に1つのコールバック。例えば:
const observable = Rx.Observable.create(observer => {
// create a single value and complete
observer.onNext(1);
observer.onCompleted();
});
source.subscribe(
x => console.log('onNext: %s', x), // success callback
e => console.log('onError: %s', e), // error callback
() => console.log('onCompleted') // completion callback
);
// first we log: onNext: 1
// then we log: onCompleted
オブザーバブルを作成する場合、オブザーバーを引数として提供するコールバック関数が必要です。この観測では、あなたがして呼び出すことができますonNext
、onCompleted
、onError
。次に、Observableがサブスクライブされると、サブスクリプションに渡された対応するコールバックが呼び出されます。
const promise = new Promise(resolve => {
setTimeout(() => {
resolve("Hello from a Promise!");
}, 2000);
});
promise.then(value => console.log(value));
現在、観測可能な例。ここでも、非同期タスクを処理するオブザーバーであるオブザーバーに関数を渡します。promiseのresolveとは異なり、次のメソッドがあり、その代わりにサブスクライブします。
したがって、どちらも非同期タスクを処理します。それでは違いを見てみましょう。
const observable = new Observable(observer => {
setTimeout(() => {
observer.next('Hello from a Observable!');
}, 2000);
});
observable.subscribe(value => console.log(value));
約束する
観察可能
PromisesとObservablesの両方は、非同期操作の処理に役立ちます。これらの非同期操作が完了すると、特定のコールバックを呼び出すことができます。
AngularはHTTPを処理するための約束の代わりにRxJSからのObservablesを使用します
Below are some important differences in promises & Observables.
非同期アクティビティが終了または失敗すると、Promiseは単一のイベントを発行します。
Observableは(多くの言語の)ストリームのようなもので、すべてのイベントにコールバックが必要な場合に、少なくとも0個以上のイベントを渡すことができます。
Promiseなどのハイライトを提供するため、Promiseより頻繁に観察可能が推奨されます。Observableでは、0、1、またはさまざまなイベントを処理する必要があるかどうかは問題ではありません。ケースごとに同様のAPIを使用できます。
約束: 約束は単一の値を放出する
例えば:
const numberPromise = new Promise((resolve) => {
resolve(5);
resolve(10);
});
numberPromise.then(value => console.log(value));
// still prints only 5
観察可能: 一定期間に複数の値を出力します
例えば:
const numberObservable = new Observable((observer) => {
observer.next(5);
observer.next(10);
});
numberObservable.subscribe(value => console.log(value));
// prints 5 and 10
ある期間にわたって複数の値を放出するストリームのようなオブザーバブルを考えることができ、放出された各アイテムに対して同じコールバック関数が呼び出されるため、オブザーバブルでは同じAPIを使用して非同期データを処理できます。そのデータが単一の値として送信されるか、一定期間にわたって複数の値として送信されるか。
約束する:
観察可能:
Promiseは単一の値を出力しますが、Observableは複数の値を出力します。したがって、HTTPリクエストを処理している間、Promiseは同じリクエストに対する単一の応答を管理できますが、同じリクエストに対して複数の応答がある場合は、Observableを使用する必要があります。はい、Observableは同じリクエストに対する複数の応答を処理できます。
約束する
const promise = new Promise((data) =>
{ data(1);
data(2);
data(3); })
.then(element => console.log(‘Promise ‘ + element));
出力
Promise 1
観察可能
const observable = new Observable((data) => {
data.next(1);
data.next(2);
data.next(3);
}).subscribe(element => console.log('Observable ' + element));
出力
Observable 1
Observable 2
Observable 3
以下は、promiseとObservableのいくつかの重要な違いです。
約束する
観察可能
よりよく理解するには、https://stackblitz.com/edit/observable-vs-promisesを参照してください
Observableは「キャンセル可能」であるという主張を使用している多くの人々を目にしますが、Promiseを「キャンセル可能」にすることはかなり簡単です
function cancellablePromise(body) {
let resolve, reject;
const promise = new Promise((res, rej) => {
resolve = res; reject = rej;
body(resolve, reject)
})
promise.resolve = resolve;
promise.reject = reject;
return promise
}
// Example 1: Reject a promise prematurely
const p1 = cancellablePromise((resolve, reject) => {
setTimeout(() => resolve('10', 100))
})
p1.then(value => alert(value)).catch(err => console.error(err))
p1.reject(new Error('denied')) // expect an error in the console
// Example: Resolve a promise prematurely
const p2 = cancellablePromise((resolve, reject) => {
setTimeout(() => resolve('blop'), 100)
})
p2.then(value => alert(value)).catch(err => console.error(err))
p2.resolve(200) // expect an alert with 200
簡潔な答え :
Observableの方が優れています。Promiseのすべての機能に加えて、追加機能があります。
長い答え:
約束:
観察可能:
受け入れられた答えは一般的には良いですが、Angular Componentsを扱う場合、キャンセルをサポートしているため、ほとんどの場合にObservableを使用したいと強調しているとは思いません。コンポーネントが破棄されても、約束はキャンセルできず、解決します。Angularは、許容されるまで許容する傾向があります。
たとえば、破棄されたコンポーネントで手動による変更を検出すると、例外が発生します。
ngOnInit() {
// promise api
this.service.getData().then(d => {
this.data = d;
this.changeDetectorRef.detectChanges();
});
// observable api
this.service.getData().pipe(takeUntil(this.unsubscribe)).subscribe((d) => {
this.data = d;
this.changeDetectorRef.detectChanges();
});
}
promiseが解決される前にコンポーネントが破棄されると、promiseが解決されるattempt to use destroyed view
ときにエラーが発生します。
または、takeUntilパターンでオブザーバブルを使用する場合、コンポーネントが破棄されるとすぐにサブスクリプションがキャンセルされます。
これは少し不自然な例ですが、破壊されたコンポーネントのコードを実行すると、バグが発生する可能性があります。何らかの理由で実際にそれをしたくないのであれば:p
私がそれに遭遇した何かは、チュートリアルとドキュメントの最初の読みからは明らかではありませんでしたが、マルチキャストのアイデアでした。
デフォルトでは、複数のサブスクリプションがObservableで複数の実行をトリガーすることに注意してください。単一のHTTP呼び出しObservableへの複数のサブスクリプションは、.share()
(マルチキャストを有効にする)場合を除き、複数の同一のHTTP呼び出しをトリガーします。
promiseは、一度に1つの事柄に対処し、そのデータをアンラップし、例外を処理し、async / awaitなどのすばらしいものを言語でサポートし、それ以外の場合は非常に重要です。
Observableにはたくさんの魅力がありますが、使用しているパワーを理解する必要があります。理解していないと誤用される可能性があります。
約束する:
非同期イベントハンドラー-Promiseオブジェクトは、非同期操作の最終的な完了(または失敗)とその結果の値を表します。
構文: new Promise(executor);
例えば:
var promise_eg = new Promise(function(resolve, reject) {
setTimeout(function() {
resolve('foo');
}, 300);
});
promise_eg.then(function(value) {
console.log(value);
// expected output: "foo"
});
console.log(promise_eg);
Promiseについて: 1つのパイプラインがあるため、呼び出されたときに1回だけ値を返します。その一方向ハンドラなので、一度呼び出されるとキャンセルできない場合があります。when()とthen()で使用できる便利な構文
観察可能なもの:
オブザーバブルは、時間の経過に伴う複数の値のレイジーコレクションです。それは非同期操作のための本当に素晴らしいアプローチです。これは、クロスプラットフォームのサポートを備えたrxjsで行うことができ、angular / reactなどで使用できます。
そのストリームライナーのような行動。マルチパイプラインにすることができます。したがって、一度定義すると、サブスクライブして多くの場所で結果を返すことができます。
構文: import * as Rx from "@reactivex/rxjs";
初期化する:
Rx.Observable.fromEvent(button, "click"),
Rx.Subject()
等
購読するには: RxLogger.getInstance();
例えば:
import { range } from 'rxjs';
import { map, filter } from 'rxjs/operators';
range(1, 200).pipe(
filter(x => x % 2 === 1),
map(x => x + x)
).subscribe(x => console.log(x));
マルチパイプラインをサポートしているため、異なる場所で結果をサブスクライブできるため、 約束よりも多くの可能性があります。
使用法:次の
ような可能性がありますmap, filter, pipe, map, concatMap etc
オブザーバブルはしばしば約束と比較されます。主な違いは次のとおりです。
オブザーバブルは宣言型です。計算はサブスクリプションまで開始されません。プロミスは作成と同時に実行されます。これにより、オブザーバブルは、結果が必要なときにいつでも実行できるレシピを定義するのに役立ちます。
Observableは多くの値を提供します。約束はそれを提供します。これにより、observableは時間の経過とともに複数の値を取得するのに役立ちます。
Observableはチェーンとサブスクリプションを区別します。Promiseには.then()句しかありません。これにより、オブザーバブルは、作業を実行させることなく、システムの他の部分で使用される複雑な変換レシピを作成するのに役立ちます。
Observables subscribe()はエラー処理を担当します。約束は子どもの約束に誤りを押しやります。これにより、observableは集中型で予測可能なエラー処理に役立ちます。
これは、ANGULAR.IOのドキュメントで最も単純な違いです。残りの答えはほとんどの人が自分の場所で正しいと答えています
このトピックにはすでにたくさんの回答があるので、冗長なものは追加しません。
しかし、Observable / Angularの学習を始めたばかりで、どれをPromiseと比較するのか疑問に思っている人には、すべてをObservableに保ち、プロジェクト内のすべての既存のPromiseを Observableに変換することをお勧めします。
単にAngularフレームワーク自体とそのコミュニティがすべてObservableを使用しているからです。したがって、フレームワークサービスまたはサードパーティのモジュールを統合し、すべてをチェーン化することは有益です。
私はすべての反対投票に感謝しますが、AngularプロジェクトでPromises over Observablesを使用するのに役立つ可能性があるいくつかのシナリオをリストするために誰かが適切なコメントをしない限り、私は上記の意見を主張します。
もちろん、すべてのケースで100%正しいという意見はありませんが、少なくともAngularフレームワークで実装された通常の商用プロジェクトの98%の時間では、Observableが正しい方法だと思います。
単純な趣味のプロジェクトの開始点で気に入らなくても、Angularで操作するほぼすべてのコンポーネントにすぐに気付き、AngularフレンドリーなサードパーティフレームワークのほとんどがObservablesを使用しているため、彼らと通信するために、あなたの約束を観察可能なものに常に変換することになりました。
これらのコンポーネントには、HttpClient、フォームビルダー、Angularマテリアルモジュール/ダイアログ、Ngrxストア/エフェクト、ngx-bootstrapが含まれますが、これらに限定されません。
実際、私が過去2年間に扱ったAngularエコシステムからの唯一の約束はAPP_INITIALIZER
です。