概述：

Promise和Observables都帮助我们处理异步操作。当这些异步操作完成时，它们可以调用某些回调。Promise只能处理一个事件，Observables用于一段时间内的事件流承诺一旦待定，就不能取消可以使用运算符转换可观测数据发射

您可以始终使用可观察对象来处理异步行为，因为可观察对象具有承诺提供的所有功能（+额外功能）。然而，有时不需要Observables提供的额外功能。然后，导入一个库以供其使用将是额外的开销。

何时使用Promise：

当您有一个要处理结果的异步操作时，请使用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将从挂起状态变为resolved或reject状态。当promise状态被解析时，将调用then（）方法。当promise状态被拒绝时，将调用catch（）方法。

何时使用Observables：

当一段时间内存在需要处理的数据流时，使用Observables。流是一系列随时间而可用的数据元素。流的示例有：

用户事件，例如单击或键控事件。用户随时间生成事件（数据）。Websockets，在客户端与服务器建立WebSocket连接后，它会随时间推移推送数据。

在Observable中，指定了下一个事件发生的时间、错误发生的时间或Observable完成的时间。然后，我们可以订阅这个可观察的，它激活了它，在这个订阅中，我们可以传递3个回调（不必总是传递所有回调）。成功时执行一次回调，错误时回调，完成时回调。例如：

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被订阅时，它将调用传入订阅的相应回调。

Promise和Observables都为我们提供了抽象，帮助我们处理应用程序的异步性质。Günter和@Relu清楚地指出了它们之间的区别。

由于一段代码相当于一千个单词，所以让我们通过下面的示例来更容易地理解它们。

感谢@Christoph Burgdorf的精彩文章

---

Angular使用Rx.js Observables而不是承诺来处理HTTP。

假设您正在构建一个搜索函数，该函数应在您键入时立即显示结果。这听起来很熟悉，但这项任务带来了很多挑战。

我们不希望每次用户按下键时都会触及服务器端点。它应该会向他们发出大量HTTP请求。基本上，我们只想在用户停止打字后点击它，而不是每次按键。对于后续请求，不要使用相同的查询参数到达搜索端点。处理无序响应。当我们同时处理多个请求时，我们必须考虑这些请求以意外顺序返回的情况。想象一下，我们首先键入计算机，停止，一个请求发出，我们键入汽车，停止，请求发出。现在我们有两个请求正在执行中。不幸的是，携带计算机结果的请求在携带汽车结果的请求之后返回。

演示将仅由两个文件组成：app.ts和wikipedia-service.ts。然而，在现实世界场景中，我们很可能将事情进一步拆分。

---

下面是一个基于Promise的实现，它不处理任何描述的边缘情况。

维基百科服务.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]);
  }
}

我们正在注入Jsonp服务，以针对给定搜索词的Wikipedia API发出GET请求。注意，我们调用toPromise是为了从一个可观察的<Response>转换为Promise<Response>。最终以Promise＜Array＜string＞作为搜索方法的返回类型。

应用程序

// 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，并通过搜索方法向模板公开其功能。该模板简单地绑定到keyup并调用search（term.value）。

我们打开WikipediaService的搜索方法返回的Promise的结果，并将其作为一个简单的字符串数组公开给模板，这样我们就可以让*ngFor循环通过它，并为我们建立一个列表。

参见Plunker上基于Promise的实现示例

---

观察者真正闪耀的地方

让我们将代码更改为不在每次击键时敲击端点，而是仅在用户停止键入400ms时发送请求

要揭示这些超级功能，我们首先需要获得一个Observable＜string＞，它包含用户键入的搜索项。我们可以利用Angular的formControl指令，而不是手动绑定到keyup事件。要使用此指令，我们首先需要将ReactiveFormsModule导入到应用程序模块中。

应用程序

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"/>

在我们的组件中，我们从@angular/form创建一个FormControl实例，并将其作为组件名称项下的字段公开。

在幕后，术语会自动将Observable<string>公开为我们可以订阅的属性valueChanges。现在我们有了Observable<string>，克服用户输入就像在Observable上调用debounceTime（400）一样简单。这将返回一个新的Observable＜string＞，它只会在400ms内没有新值时发出一个新值。

export class App {
  items: Array<string>;
  term = new FormControl();
  constructor(private wikipediaService: WikipediaService) {
    this.term.valueChanges
              .debounceTime(400)        // wait for 400 ms pause in events
              .distinctUntilChanged()   // ignore if next search term is same as previous
              .subscribe(term => this.wikipediaService.search(term).then(items => this.items = items));
  }
}

如果我们的应用程序已经显示了搜索结果，那么再次发出搜索项请求将是浪费资源。为了实现所需的行为，我们所要做的就是在调用debounceTime（400）之后立即调用distinctUntilChanged运算符

参见Plunker上的Observable实现示例

关于处理无序响应，请查看全文http://blog.thoughtram.io/angular/2016/01/06/taking-advantage-of-observables-in-angular2.html

就我在Angular中使用HTTP而言，我同意在正常的用例中，使用Observable over Promise没有太大的区别。在实践中，没有一个优点是真正相关的。我希望将来能看到一些高级用例：）

---

了解更多信息https://angular-2-training-book.rangle.io/handout/observables/https://angular.io/tutorial/toh-pt6#observables

关于这个话题已经有很多答案了，所以我不会再赘述。

但是对于刚开始学习Observable/Aangular并想知道与Promise相比使用哪一个的人来说，我建议您将所有内容都保持Observable，并将项目中所有现有的Promise转换为Observable。

因为Angular框架本身及其社区都在使用Observable。因此，当您集成框架服务或第三方模块并将所有内容链接在一起时，这将是有益的。

---

当然，没有任何意见在所有情况下都是100%正确的，但至少我认为98%的时间是在Angular框架中实现的常规商业项目，Observable是正确的选择。

即使你在开始你的简单爱好项目时不喜欢它，你很快就会意识到你在Angular中与之交互的几乎所有组件，而且大多数Angular友好的第三方框架都使用Observables，然后你会不断地将Promise转换为Observable，以便与它们进行通信。

这些组件包括但不限于：HttpClient、表单生成器、Angular材质模块/对话框、Ngrx存储/效果和ngx引导。

事实上，我在过去两年中处理的Angular生态系统中唯一的Promise是APP_INITIALIZER。

我看到很多人认为Observable是“可取消的”，但将Promise设为“可取消”并不重要

函数cancelablePromise（主体）{让决心，拒绝；const promise=新的promise（（res，rej）=>{分辨率=res；拒绝=rej；正文（解析，拒绝）})promise.resolve=决议；promise.reject=拒绝；退货承诺}//示例1：过早拒绝承诺const p1=可取消承诺（（resolve，reject）=>{setTimeout（（）=>解析（“10”，100））})p1.then（value=>alert（value））.catch（err=>console.error（err））p1.拒绝（新错误（'denid'））//控制台中出现错误//示例：过早地解决承诺const p2=可取消承诺（（resolve，reject）=>{setTimeout（（）=>解析（'blop'），100）})p2.then（value=>alert（value））.catch（err=>console.error（err））p2.resolve（200）//预期警报为200

假设你想去海滩。你必须根据天气做出决定。您有三种方法：

你往外面看，看到雨点，所以你改变了主意。这是一个同步操作。你停止了你正在做的事情，去外面看看，得到了结果，然后回到你正在做什么。你请你旁边的哥哥检查一下今天的天气状况。当他在检查天气时，你仍然在做你正在做的事情。这是一个异步操作。你把一项任务交给了你的兄弟，等待承诺得到解决。在这种情况下，您将得到一个响应，在得到响应后，您将不再得到任何更新。这一次，你打开收音机，收听全天候播报天气状况的天气频道。在这种情况下，响应是持续的，而不是得到一个响应。此响应类似于订阅可观察的。可观测的是“天气”，订阅的是“让你不断更新的无线电信号”。只要你的收音机开着，你就会得到所有可用的更新。在你关掉收音机之前，你不会错过任何信息。当你关闭收音机时，意味着“你已取消订阅”。

在第一次阅读教程和文档时，我遇到了一个不明显的问题，那就是多播的想法。

确保您知道默认情况下，多个订阅将触发Observable中的多个执行。对单个HTTP调用的多个订阅Observable将触发多个相同的HTTP调用，除非您.share（）（启用多播）。

一个承诺迫使你一次处理一件事，解开它的数据，处理异常，对async/await等很酷的事情有语言支持，否则就很简单了。

Observable有很多钟和哨子，但你需要了解你正在使用的力量，否则它可能被滥用。