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

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

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                          ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

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

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

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

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

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

firstNameChanges.value;

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