Observable对象表示一个基于推的集合。

观察者和可观察接口为基于推送的通知提供了一种通用机制，也称为观察者设计模式。Observable对象表示发送通知的对象(提供者);Observer对象表示接收它们的类(观察者)。

Subject类继承了Observable和Observer，也就是说它既是一个观察者又是一个可观察对象。您可以使用主题订阅所有观察者，然后将主题订阅到后端数据源

var subject = new Rx.Subject();

var subscription = subject.subscribe(
    function (x) { console.log('onNext: ' + x); },
    function (e) { console.log('onError: ' + e.message); },
    function () { console.log('onCompleted'); });

subject.onNext(1);
// => onNext: 1

subject.onNext(2);
// => onNext: 2

subject.onCompleted();
// => onCompleted

subscription.dispose();

更多信息https://github.com/Reactive-Extensions/RxJS/blob/master/doc/gettingstarted/subjects.md

BehaviorSubject是一种类型的主题，主题是一种特殊类型的可观察对象，所以你可以像其他可观察对象一样订阅消息。行为主体的独特之处在于:

它需要一个初始值，因为它必须总是在订阅时返回一个值，即使它没有接收到next() 在订阅时，它返回主题的最后一个值。常规可观察对象只有在接收到onnext时才会触发 在任何时候，您都可以使用getValue()方法在不可观察的代码中检索主题的最后一个值。

与可观察对象相比，主体的独特特征是:

它是一个观察者，除了是一个可观察对象，所以你也可以发送值到一个主题，除了订阅它。

此外，你可以使用行为主体上的asObservable()方法从行为主体获取一个可观察对象。

Observable是一个泛型，而BehaviorSubject在技术上是Observable的子类型，因为BehaviorSubject是一个具有特定品质的可观察对象。

以行为主体为例:

// Behavior Subject

// a is an initial value. if there is a subscription 
// after this, it would get "a" value immediately
let bSubject = new BehaviorSubject("a"); 

bSubject.next("b");

bSubject.subscribe(value => {
  console.log("Subscription got", value); // Subscription got b, 
                                          // ^ This would not happen 
                                          // for a generic observable 
                                          // or generic subject by default
});

bSubject.next("c"); // Subscription got c
bSubject.next("d"); // Subscription got d

例2:常规主语:

// Regular Subject

let subject = new Subject(); 

subject.next("b");

subject.subscribe(value => {
  console.log("Subscription got", value); // Subscription won't get 
                                          // anything at this point
});

subject.next("c"); // Subscription got c
subject.next("d"); // Subscription got d

可以使用Subject . asobservable()从Subject和BehaviorSubject创建一个可观察对象。

唯一的区别是你不能使用next()方法将值发送到可观察对象。

在Angular服务中，我会为数据服务使用BehaviorSubject，因为Angular服务通常会在组件之前进行初始化，而behavior subject会确保使用该服务的组件接收到最后一次更新的数据，即使自该组件订阅该数据以来没有新的更新。

观察:每个观察者的结果不同

一个非常非常重要的区别。因为Observable只是一个函数，它没有任何状态，所以对于每个新的Observer，它都会一次又一次地执行可观察对象的创建代码。结果是:

为每个观察者运行代码 ． 如果它是一个HTTP调用，它会被每个观察者调用

这会导致主要的错误和低效率

BehaviorSubject(或Subject)存储观察者细节，只运行一次代码，并将结果提供给所有观察者。

Ex:

JSBin： http://jsbin.com/qowulet/edit?js,console

// --- Observable --- let randomNumGenerator1 = Rx.Observable.create(observer => { observer.next(Math.random()); }); let observer1 = randomNumGenerator1 .subscribe(num => console.log('observer 1: '+ num)); let observer2 = randomNumGenerator1 .subscribe(num => console.log('observer 2: '+ num)); // ------ BehaviorSubject/ Subject let randomNumGenerator2 = new Rx.BehaviorSubject(0); randomNumGenerator2.next(Math.random()); let observer1Subject = randomNumGenerator2 .subscribe(num=> console.log('observer subject 1: '+ num)); let observer2Subject = randomNumGenerator2 .subscribe(num=> console.log('observer subject 2: '+ num)); <script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/5.5.3/Rx.min.js"></script>

输出:

"observer 1: 0.7184075243594013"
"observer 2: 0.41271850211336103"
"observer subject 1: 0.8034263165479893"
"observer subject 2: 0.8034263165479893"

观察如何使用Observable。create为每个观察者创建了不同的输出，但BehaviorSubject为所有观察者提供了相同的输出。这很重要。

总结了其他差异。

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃         Observable                  ┃     BehaviorSubject/Subject         ┃      
┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ 
┃ Is just a function, no state        ┃ Has state. Stores data in memory    ┃
┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
┃ Code run for each observer          ┃ Same code run                       ┃
┃                                     ┃ only once for all observers         ┃
┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
┃ Creates only Observable             ┃Can create and also listen Observable┃
┃ ( data producer alone )             ┃ ( data producer and consumer )      ┃
┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
┃ Usage: Simple Observable with only  ┃ Usage:                              ┃
┃ one Obeserver.                      ┃ * Store data and modify frequently  ┃
┃                                     ┃ * Multiple observers listen to data ┃
┃                                     ┃ * Proxy between Observable  and     ┃
┃                                     ┃   Observer                          ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

我在例子中没有看到的一件事是，当你通过asObservable将BehaviorSubject转换为Observable时，它继承了订阅时返回最后一个值的行为。

这是很棘手的一点，因为库通常会将字段作为可观察对象公开(例如，在Angular2中ActivatedRoute中的参数)，但可能会在幕后使用Subject或BehaviorSubject。他们使用什么会影响订阅行为。

请看这里http://jsbin.com/ziquxapubo/edit?html,js,console

let A = new Rx.Subject();
let B = new Rx.BehaviorSubject(0);

A.next(1);
B.next(1);

A.asObservable().subscribe(n => console.log('A', n));
B.asObservable().subscribe(n => console.log('B', n));

A.next(2);
B.next(2);

可观察对象只允许你订阅，而主题允许你同时发布和订阅。

因此，主题允许您的服务同时用作发布者和订阅者。

到目前为止，我不太擅长Observable，所以我只分享一个Subject的例子。

让我们用一个Angular CLI的例子来更好地理解。执行如下命令:

npm install -g @angular/cli

ng new angular2-subject

cd angular2-subject

ng serve

将app.component.html的内容替换为:

<div *ngIf="message">
  {{message}}
</div>

<app-home>
</app-home>

执行命令ng g c components/home生成home组件。将home.component.html的内容替换为:

<input type="text" placeholder="Enter message" #message>
<button type="button" (click)="setMessage(message)" >Send message</button>

#message是这里的局部变量。添加属性消息:string; 到app.component.ts的类。

执行命令ng g s service/message。这将在src\app\service\message.service.ts上生成一个服务。向应用程序提供此服务。

将Subject导入MessageService。也要添加一个主题。最终的代码应该是这样的:

import { Injectable } from '@angular/core';
import { Subject } from 'rxjs/Subject';

@Injectable()
export class MessageService {

  public message = new Subject<string>();

  setMessage(value: string) {
    this.message.next(value); //it is publishing this value to all the subscribers that have already subscribed to this message
  }
}

现在，将这个服务注入到home.component.ts中，并将它的一个实例传递给构造函数。对app.component.ts也这样做。使用这个服务实例将#message的值传递给服务函数setMessage:

import { Component } from '@angular/core';
import { MessageService } from '../../service/message.service';

@Component({
  selector: 'app-home',
  templateUrl: './home.component.html',
  styleUrls: ['./home.component.css']
})
export class HomeComponent {

  constructor(public messageService:MessageService) { }

  setMessage(event) {
    console.log(event.value);
    this.messageService.setMessage(event.value);
  }
}

在app.component.ts中，向Subject订阅和取消订阅(以防止内存泄漏):

import { Component, OnDestroy } from '@angular/core';
import { MessageService } from './service/message.service';
import { Subscription } from 'rxjs/Subscription';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html'
})
export class AppComponent {

  message: string;
  subscription: Subscription;

  constructor(public messageService: MessageService) { }

  ngOnInit() {
    this.subscription = this.messageService.message.subscribe(
      (message) => {
        this.message = message;
      }
    );
  }

  ngOnDestroy() {
    this.subscription.unsubscribe();
  }
}

就是这样。

现在，在home.component.html的#message中输入的任何值都将被打印到app.component.html中的{{message}}

可观察对象和主体都是可观察对象，这意味着观察者可以跟踪它们。它们都有一些独特的特点。有三种类型的科目，每一种也有独特的特点。

您可以在stackblitz上找到实际示例。 (您需要检查控制台以查看实际输出)

观察

它们是冷的:当它们至少有一个观察者时，代码就会被执行。

创建数据副本:Observable为每个观察者创建数据副本。

单向:观察者不能给观察对象赋值(源/主)。

主题

它们很热:即使没有观察者，代码也会被执行，值也会被传播。

共享数据:在所有观察者之间共享相同的数据。

双向:观察者可以给观察对象赋值(源/主)。

如果你正在使用subject，那么你会错过所有在创建观察者之前传播的值。这就是重放主题

ReplaySubject

它们很热:即使没有观察者，代码也会被执行，值也会被传播。

共享数据:在所有观察者之间共享相同的数据。

双向:观察者可以给观察对象赋值(源/主)。+

重播消息流:无论您何时订阅重播主题，您都将收到所有的广播消息。

在Subject和ReplaySubject中，不能将初始值设置为observable。这就是行为主体…

BehaviorSubject

它们很热:即使没有观察者，代码也会被执行，值也会被传播。

共享数据:在所有观察者之间共享相同的数据。

双向:观察者可以给观察对象赋值(源/主)。+

重播消息流:无论您何时订阅重播主题，您都将收到所有的广播消息。

你可以设置初始值:你可以用默认值初始化可观察对象。

app.component.ts

behaviourService.setName("behaviour");

behaviour.service.ts

private name = new BehaviorSubject("");
getName = this.name.asObservable();

constructor() {}

setName(data) {
    this.name.next(data);
}

custom.component.ts

behaviourService.subscribe(response=>{
    console.log(response);    //output: behaviour
});

行为主体vs可观察对象:RxJS有观察者和可观察对象，RxJS提供了多个用于数据流的类，其中一个是行为主体。

可观察对象:可观察对象是多个值随时间变化的惰性集合。

BehaviorSubject:一个需要初始值并将其当前值发送给新订阅者的Subject。

 // RxJS v6+
import { BehaviorSubject } from 'rxjs';

const subject = new BehaviorSubject(123);

//two new subscribers will get initial value => output: 123, 123
subject.subscribe(console.log);
subject.subscribe(console.log);

//two subscribers will get new value => output: 456, 456
subject.next(456);

//new subscriber will get latest value (456) => output: 456
subject.subscribe(console.log);

//all three subscribers will get new value => output: 789, 789, 789
subject.next(789);

// output: 123, 123, 456, 456, 456, 789, 789, 789

把Observables想象成一个管道，里面有流动的水，有时水流动，有时不流动。在某些情况下，你可能真的需要一个一直有水的管道，你可以通过创建一个特殊的管道来做到这一点，不管它有多小，让我们把这个特殊的管道称为行为主题，如果你恰好是你所在社区的供水供应商，你可以安心地睡在晚上，因为你新安装的管道只是工作。

在技术术语中:你可能会遇到一个可观察对象总是有价值的情况，也许你想要捕获输入文本的值，然后你可以创建一个BehaviorSubject的实例来确保这种行为，让我们说:

const firstNameChanges = new BehaviorSubject("<empty>");

// pass value changes.
firstNameChanges.next("Jon");
firstNameChanges.next("Arya");

然后，您可以使用“value”对随时间变化的更改进行抽样。

firstNameChanges.value;

这在你以后组合可观察对象时很方便，通过查看你的流的类型为BehaviorSubject，你可以确保流至少会触发或发出至少一次信号。

BehaviorSubject

BehaviorSubject构建在与我们的ReplaySubject相同的功能之上，比如，hot，并重放先前的值。

BehaviorSubject又增加了一个功能，您可以给BehaviorSubject一个初始值。让我们继续，看看这段代码

import { ReplaySubject } from 'rxjs';

const behaviorSubject = new BehaviorSubject(
  'hello initial value from BehaviorSubject'
);

behaviorSubject.subscribe(v => console.log(v));

behaviorSubject.next('hello again from BehaviorSubject');

观察

首先，我们来看看创建常规Observable的最小API。有几种方法可以创建Observable。创建Observable的方法是实例化类。其他操作符可以简化这个步骤，但我们希望将实例化步骤与不同的Observable类型进行比较

import { Observable } from 'rxjs';

const observable = new Observable(observer => {
  setTimeout(() => observer.next('hello from Observable!'), 1000);
});

observable.subscribe(v => console.log(v));

可观测的 是通用的，

可观察对象是多个值随时间变化的惰性集合。

只是一个函数，没有状态

为每个观察者运行代码

BehaviorSubject: 一个需要初始值并将其当前值发送给新订阅者的主题。

在技术上是Observable的子类型，因为BehaviorSubject是一个具有特定品质的可观察对象。

有状态。在内存中存储数据

相同的代码只对所有观察者运行一次

行为主体的独特特征如下:

它需要一个初始值，因为它必须总是在订阅时返回一个值，即使它没有接收到next()

在订阅时，它返回主题的最后一个值。常规可观察对象只有在接收到onnext时才会触发

在任何时候，您都可以使用getValue()方法在不可观察的代码中检索主题的最后一个值。

在rxjs中，Subject本质上是一个观察者和可观察对象。观察者是我们放入值的对象，可观察对象是我们可以观察值的对象。

Subject is Hot by default. Observables by default are cold. That means they are not going to emit any values until someone subscribes to it. The instant we create a subject, we can emit a value from it and that value will be emitted even if nobody is subscribed to it yet. Subject is multicast by default. Observable by default are unicast and that means that for every different observer that we have, we have to subscibe to an observable, if that observable emits a value that value is going to flow through all the different operators inside of our pipe once for each subscriber. Multicast means all of other operators will run one time for every value, regardless of the number of observers we have. GOTCHA= thE SUBJECT is multicast but if you chain on a pipe statement to it, that is going to return a new observable that is cold and unicast.

行为主体与主体相同，但也有初始的“种子”值。新订阅用户立即获得最新的值。如果有人订阅了行为主体，它会立即接收到最近的值。所以行为主体总有一些价值可以分给订阅者。

关于行为主体最有用的事情是当我们开始发出网络请求时。想象一下，我们将一些管道连接到一个行为主题上，在一个管道函数或管道操作符中，我们最终发出一个网络请求并获取一些数据。你最终可能会想让其他东西订阅那个可观察对象，并立即获得已经获取的数据。使用行为主体，我们可以很容易地实现这种行为。

我认为可观察对象是主体的包装。而Observable仅用于订阅数据更改。Subject还可以用于将数据更改通知订阅者(使用next()方法)。下面是一个小的可观察的模式实现，它可能有助于您理解这个概念。打印稿操场

你也可以像这样将一个主题更改为一个可观察对象:

 page = new BehaviorSubject<String|null>(null);
 actualPage:Observable<string> = new Observable()

this.page.next("hardware")
this.actualPage = this.page as Observable<any>;