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

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

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

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

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

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

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

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

firstNameChanges.value;

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

我在例子中没有看到的一件事是，当你通过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}}

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

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