原文：http://reactivex.io/rxjs/manu…

Observable

可观察量是一种能惰性推送的鸠合，他可以包括多个值。下面的表格对比了推送和拉取2种体式格局：

举例来说，以下Observable 在被定阅以后会马上推送(同步)值1,2,3，而值4将会在1秒以后被推送到定阅者，以后这个流进入完成状况:

var obserable = Rx.Observable.create(function(observer){   //注重参数的定名
 observer.next(1);
 observer.next(2);
 observer.next(3);
 
 setTimeout(function(){
     observer.next(4);
     observer.complete();
 },1000);
 
});

为了挪用以上的Observable并输出个中的值，须要定阅这个流:

console.log('just before subscribe');
observable.subscribe({
 next:x => console.log('got value:',x),
 error:err => console.log('something wrong occurred: ' + err),
 complete:() => console.log('done')
});
console.log('just after subscribe');

实行以后会输出:

just before subscribe
got value 1
got value 2
got value 3
just after subscribe
got value 4
done

pull vs push 拉取 vs 推送

拉取和推送是数据生产者和数据运用者之间举行数据交换的2种情势。

什么是拉取？

在拉取体系中，数据运用者决议什么时刻从数据生产者那边吸收数据。数据生产者本身并不知道数据什么时刻会被通报给运用者。

每个js函数都是一个拉取体系。函数是一个数据生产者，经由过程在别处被挪用，他返回的单一值将会被投入盘算。

ES2015又引入了新的拉取体系，generator和迭代器(function*)。挪用iterator.next()来消耗从迭代器(数据生产者)中拉取到的数据。

什么是推送？

在推送体系中，数据生产者决议什么时刻把数据推送给运用者，运用者本身并不知道什么时刻可以吸收到数据。

Promise是现今js中最罕见的一种推送体系。和函数差别，Promise(数据生产者)准确的掌握机遇，将数据“推送”给业已注册的回调函数(数据运用者)。

RxJS引入了Observables，一个新的JS推送体系。

一个Observable是一个包括多个值的“数据生产者”，它会将数据推送给Observer(数据运用者)。

A Function is a lazily evaluated computation that synchronously returns a single value on invocation.
A generator is a lazily evaluated computation that synchronously returns zero to (potentially) infinite values on iteration.
A Promise is a computation that may (or may not) eventually return a single value.
An Observable is a lazily evaluated computation that can synchronously or asynchronously return zero to (potentially) infinite values from the time it’s invoked onwards.

• Function是一种惰性盘算体式格局，当他被挪用时会同步的返回一个值。

• generator是一种惰性盘算体式格局，会在迭代中同步的返回0到无穷个（能够的话）返回值。

• Promise运用一种处置惩罚要领，终究能够会（或能够不会）返回一个值。

• Observable是一种惰性处置惩罚要领，当被挪用的时刻，可以同步也可以异步的返回0到无穷个（能够的话）返回值。

明白Observable

有别于盛行的说法，Observable既不像多个EventEmitter，也不像一种能返回多个值的Promise。

在一些场所，比方播送音讯时，Observer看起来很像EventEmitter，在RxJS中，被称为Subject。而在大多数状况下，Observable并不像EventEmitter。

Observables 像一群没有参数的函数，形成了多个值的鸠合。

斟酌以下状况：

function foo() {
  console.log('Hello');
  return 42;
}

var x = foo.call(); // same as foo()
console.log(x);
var y = foo.call(); // same as foo()
console.log(y);

输出是:

"Hello"
42
"Hello"
42

用Observables重写上面的行动是：

var foo = Rx.Observable.create(function(observer){
    console.log('Hello');
    observer.next(42);
});

foo.subscribe(function(x){
    console.log(x);
});

foo.subscribe(function(y){
    console.log(y);
});

上面2种状况实际上是因为函数和Observable都是一种惰性的盘算。假如你不挪用函数，那末console.log('Hello')就不会被实行，也不会有输出。一样的，只用当“挪用”（经由过程subscribe定阅）Observable，才会有输出。

另外，挪用和定阅都是伶仃运转的。2个函数分别被挪用会发生2个结果，2个Observable定阅者会发生2个自力的结果。
不像EventEmitter会派发它的状况而且不管是不是有定阅者都邑实行那样，Observable不会派发状况而且是惰性的。

定阅observable，类似于挪用一个函数

有些声响声称Observable是异步的，这是不对的。假如你运用一个函数来输出日记，像如许:

console.log('before');
console.log(foo.call());
console.log('after');

输出是:

"before"
"Hello"
42
"after"

一样的行动，运用Observable：

console.log('before');
foo.subscribe(function(x){
    console.log('Hello');
    return x;
});
console.log('after');

输出是一样的:

"before"
"Hello"
42
"after"

以上证明了定阅foo以后，结果和函数一样，都是同步的。

无论是同步体式格局照样异步体式格局，obsverable都可以择其一来通报返回值。

Observable和函数之间有什么区别？Observables可以跟着时间线返回多个值，函数却不能，因而你可以如许:

function foo() {
  console.log('Hello');
  return 42;
  return 100; // dead code. will never happen
}

函数返回单一的值，Observables却可以如许：

var foo = Rx.Observable.create(function(observer){
    console.log('hello');
    observer.next(42);
    observer.next(100);
    observer.next(200);
});

console.log('before');
foo.subscribe(function(x){
    console.log(x);
});
console.log('after');

同步式的输出:

"before"
"Hello"
42
100
200
"after"

也可以运用异步式的输出:

var foo = Rx.Observable.create(function(observer){
    console.log('Hello');
    observer.next(42);
    observer.next(100);
    observer.next(200);
    
    setTimeout(function(){
        observer.next(300);
    },1000);
});

console.log('before');
foo.subscribe(function(x){
    console.log(x);
});
console.log('after');

输出为:

"before"
"Hello"
42
100
200
"after"
300

结论:

• func.call()意味着“同步的返回一个值”。

• observable.subscribe()意义是“返回恣意数目的值，同步式、异步式二择其一。”