欢迎指错与讨论 : ）
当前RxJS版本：5.0.0-beta.10。更详细的内容尽在RxJS官网http://reactivex.io/rxjs/manual/overview.html。文章比较长，可以通过快捷键 command+f 或者 ctrl+f 搜索主要内容。
- 前言
RxJS在ng2、redux-observable或者前端数据层中扮演一个重要角色，因此笔者想学好RxJS，提前做好准备。本文95%非原创，而是笔者对RxJS官网基础篇的翻译，如有错漏请指出。本文主要内容：简介和六大概念（Observable、Observer、Subscription、Subject、Operators、Scheduler）。
具体Api请本博客的另外几篇中文api翻译文章：
transform（转换）、filter （过滤）、combination/multicasting （组合、广播）、ErrorHanding/Condition/Mathematical（错误处理、情况处理、数学方法）
- 安装
import {Observable} from 'rxjs/Observable' // 1. 按需打包，减轻bundle.js大小
import 'rxjs/add/observable/merge'; // 2. 按需导入函数，如merge
- 一些概念
- Observable( 可被观察的 ) : 是一个包含来自未来、可以被使用的值( value )或事件( event )的集合
- Observe( 观察者 )：是一个知道如何监听、处理来自Obervable的值的函数集合
- Subscription( 订阅 )：代表着Observable的执行动作，我们可以使用它来停止Obervable继续执行
- Operators( 操作 )：一系列可以操作集合的pure function，像是过滤( filter )、转换( map )等等
- Subject( )：相当于一个事件发射器，是唯一能够向多个Observer广播值( value )的唯一手段
- Schedulers( 调度 )：是一个中央调度员，帮助我们控制并发，协调计算( setTimeout、requestAnimationFrame等 )
- Observable( 被观察者 )
通常而言，Observable都会延迟产生值 ，比如当我们subscribe一个observable的时候它才会向我们发送这些值 let observable = Rx.Observable.range(1,3)
- pull( 拉取 ) 每个函数都是一个数据的生产者，每个调用函数的那个'人'，都会希望从这个函数中能够获得(pull) 唯一的返回值
- push( 推送 ) 在数据生产者中( 如函数 )，会在特定时候把数据推送至消费者，消费者在获得数据之前啥也不会做
- Observable与函数、promsise的对比：函数是当调用才同步计算，并最终只返回一个值的；promise是会或者不会返回一个值；Observable是当调用才同步或者异步地计算，并可能产生0到无穷多个值的。Observable就像一个没有参数的函数，并不断生成一些值供我们使用，因此它也像是一个事件发射机( EventEmitters )。在Observable中subscribe就像call一个函数，你订阅它，它才会被'启动'。同一个Observable对于不同的subscribe，是不会共享结果的( 通常情况下这样子的，但可以通过调用api来共享 )。
- Observable四大核心：创建 、订阅 、 执行 、销毁 。
订阅( subscribe )。当对一个Observable调用多个subscribe函数并创建多个observe时，observe之间不会共享任何东西，因为在Observable.create内部是对observe列表调用各自的回调的 Observable.create(function subscribe(observe){...})
执行( Executing )。Next函数能够将数据传递给Observer，同时在执行期间，能在Observable内部调用多个Next( )函数。同时建议在Observabl内部使用try/catch语法。
销毁Observe
var observable = Rx.Observable.from([10, 20, 30]);
var subscription = observable.subscribe(x => console.log(x));
// Later:
subscription.unsubscribe();
销毁Observable
var observable = Rx.Observable.create(function subscribe(observer) {
var intervalID = setInterval(() => {
...
}, 1000);
return function unsubscribe() {
clearInterval(intervalID);
};
});
- Observer( 观察者 )
什么是观察者？观察者其实是数据的消费者，把来自Observble的数据拿过来使用。同时，Observer的本质是一系列的回调函数，是来自于Observable传递数据后的回调函数。我们可以直接通过subscribe函数创建观察者
observable.subscribe(
x => console.log('Observer got a next value: ' + x),
err => console.error('Observer got an error: ' + err),
() => console.log('Observer got a complete notification')
);
- Subscription( 订阅 )
什么是Subscription？它其实是代表着Observable的'执行'的对象，我们可以通过它的 unsubscribe 方法销毁Observable的执行。同时我们能使用 add 方法，一次销毁多个
var subscription = observable1.subscribe(x => console.log('first: ' + x));
var childSubscription = observable2.subscribe(x => console.log('second: ' + x));
subscription.add(childSubscription);
setTimeout(() => {
subscription.unsubscribe();
}, 1000);
- Subject( )
什么是Subject？它是在Rx中一种比较特殊的Observable( 同时它也是Observer )，它能够让值( value )同时向多个Observer传播( 广播 )。而一般的Observable都是' 单播 '形式，即：每一个订阅了同一个Observable的observer，实际上是拥有不同的、独立的Observable的执行( 原文：each subscribed Observer owns an independent execution of the Observable )，而Subject是多播的。
// Observable对比Subject
let source = Rx.Observable.create((observer)=>{
observer.next('1');
observer.next('2');
});
source.subscribe((x)=>{console.log(x);});
source.subscribe((x)=>{console.log(x);});
// 输出 1 2 1 2
let subject = new Rx.Subject();
subject.subscribe((x)=>{console.log(`${x}`);});
subject.subscribe((x)=>{console.log(`${x}`);});
subject.next(1);
subject.next(2);
// 输出 1 1 2 2
// Subject可以在'多播'情景下对Observable进行优化
// 明显看到在subject下，Observable只执行了一次
var source = Rx.Observable.create((observer)=>{
console.log(`source was called`);
observer.next(1);observer.next(2);observer.next(3);
});
source.subscribe({next: (v) => console.log('observerA: ' + v)});
source.subscribe({next: (v) => console.log('observerB: ' + v)});
// 输出为 'source was called' observerA: 1 observerA: 2
// 'source was called' observerB: 1 observerB: 2
var source = Rx.Observable.create((o)=>{
console.log(`source was called`);
o.next(1);o.next(2);
});
var subject = new Rx.Subject();
var multicasted = source.multicast(subject);
// 原理是`subject.subscribe({...})`:返回的multicasted是一个connectableObservable
multicasted.subscribe({next: (v) => console.log('observerA: ' + v)});
multicasted.subscribe({next: (v) => console.log('observerB: ' + v)});
// 原理是 `source.subscribe(subject)`:
multicasted.connect();
// 输出 ‘source was called’ observerA: 1 observerB: 1
// observerA: 2 observerB: 2
可以单个取消订阅状态 observer.subscribe( ) ，也可以直接销毁Subject subscriptionConnect.unsubscribe( )
- refCount( ) 该api能监听当前connectableObservable的'连接状态'，当有大于0个subscribe挂在它上面它会自动执行 connect ，无subscribtion的时候会自动执行 unsubscribe( )
var refCounted = source.multicast(subject).refCount();
- BehaviorSubject（） 它能储存上一次从Observable发过来的值，每当有新的observer的时，会把改值立即发送给它
var subject = new Rx.BehaviorSubject(0)// 初始值
- ReplaySubject( 重现 ) 是BehaviorSubject的加强版，它能储存从Observable发送过来的一系列值，当有新的observer连接时，会把这些值发送给它。
var subject = new Rx.ReplaySubject(3); // 缓存空间为3
- AsyncSubject（异步）仅将从Observable发送过来的最后一个值发送给Observe
var subject = new Rx.AsyncSubject();
- Operators
什么是Operators？Operators是Rx中最有用的一系列函数，它们建立在Observable之上，并能优雅地以同步代码的写法，将不同的异步流代码链式组合到一起。同时，Operator都是pure的，因为这些函数不会直接修改传入进来的Observable，而是经过修饰之后返回一个新Observable。
在链式操作中，下一个operator会根据上一个operator修改后的Observable继续工作。
- 具体请本博客的另外几篇中文api翻译文章：
transform（请点击）、filter （请点击）、combination/multicasting （请点击）、ErrorHanding/Condition/Mathematical（请点击）
- Scheduler
Scheduler有咩用？Scheduler能控制一个订阅的开始、数据的传递。它由三部分组成：
- scheduler是一种数据结构，它知道如何基于优先级或者其他标准对任务队列进行储存
- scheduler是一个执行环境，它指何时何地地执行任务
- scheduler有一个' 时钟 '的概念，它能让我们自己定义，当Observable向Observer时会处于什么环境下( context )
// observeOn( RX.Scheduler.async )
var observable = Rx.Observable.create(function (observer) {
observer.next(1);observer.next(2);
})
.observeOn(Rx.Scheduler.async);
console.log('just before subscribe');
observable.subscribe({next: x => console.log('got value ' + x)});
console.log('just after subscribe');
// 输出
// just before subscribe just after subscribe
// got value 1 got value 2
- Scheduler类型
- Scheduler.queue 基于当前的事件框架在一个队列上工作，当我们需要遍历操作时可以使用它
- Scheduler.asap
- Scheduler.async 在内部，Schedules会使用setInterval，当我们需要以时间为基线时就使用它
- 基础
- 创建流: Observable.create、of、from、fromEvent( target,eventType )、fromPromise、bindCallback( 把callback写法转换为链式写法 )
let exists = Rx.Observable.bindCallback(fs.exists);
exists('file.txt').subscribe( exist=>console.log(`exist? : ${exist} `) )
- 事件流: filter、delay( 延时 )、throttleTime( 时间间隔 )、debounceTime( 事件暂停x毫秒后 )、take( 执行x次后停止 )、takeUtil( 取消订阅 )
let inputStream = Rx.Observable.fromEvent(document.querySelector('input'), 'keyup')
let stopStream = Rx.Observable.fromEvent(document.querySelector('button'), 'click')
inputStream.throttleTime(200) // 每隔200毫秒才释放一次
.takeUtil(stopStream) // 当触发时，停止订阅
.subscribe(($event)=> {console.log(`${$event.target.value}`)}) // 事件对象
- 转换流、过滤流：map、distinct( 过滤重复 )、distince( 过滤连续重复 )
// 输入hello world
input.pluck('target', 'value').distinctUntilChanged()
.subscribe(value => console.log(value)); // "helo wrd"
input.pluck('target', 'value').distinct()
.subscribe(value => console.log(value)); // "helo world"
- 创建一个应用
- RxJS的工具函数都是pure、无状态的一类函数。但我们的应用中往往需要记录大量的state，那在Rx如何记录状态呢？类似于redux，rx中的scan函数能够使用reduce函数，将流的结果合并。我们需要做的仅仅是保存这个状态( state )值
// 基础模式
var button = document.querySelector('button');
Rx.Observable.fromEvent(button, 'click')
// 内部的reduce函数能够积累(此处是相加，若是对象可以是Object.assign),并相应变化
.scan(count => count + 1, 0)
// Set the count on an element each time it changes
.subscribe(count => document.querySelector('#count').innerHTML = count);
- 一个更好的模式
var button = document.querySelector('button');
Rx.Observable.fromEvent(button, 'click')
// 返回了一个, 类似redux中 经过switch(action.type)的reducer 与函数
.map(() => state => Object.assign({}, state, {count: state.count + 1}))
// 直接把函数作用于初始化state，scan同时能保存这个更新后的state
.scan((state, changeFn) => changeFn(state), {count: 0})
.subscribe(state => document.querySelector('#count').innerHTML = state.count);
- 对于某一个组件还可以
var state = Rx.Observable.merge(
increase,
decrease,
input
).scan((state, changeFn) => changeFn(state), {
count: 0,
inputValue: ''
});