我认为可观察对象是主体的包装。而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>;

行为主体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

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

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

观察

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

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

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

主题

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

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

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

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

ReplaySubject

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

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

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

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

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

BehaviorSubject

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

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

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

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

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

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

一个非常非常重要的区别。因为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                          ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

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会确保使用该服务的组件接收到最后一次更新的数据，即使自该组件订阅该数据以来没有新的更新。