摘要：原文可觀察量是一種能惰性推送的集合，他可以包含多個(gè)值。是一種惰性計(jì)算方式，會(huì)在迭代中同步的返回到無限個(gè)可能的話返回值。使用一種處理方法，最終可能會(huì)或可能不會(huì)返回一個(gè)值。無論是同步方式還是異步方式，都可以擇其一來傳遞返回值。

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

可觀察量是一種能惰性推送的集合，他可以包含多個(gè)值。下面的表格對(duì)比了推送和拉取2種方式：

舉例來說，下列Observable 在被訂閱之后會(huì)立即推送(同步)值1,2,3，而值4將會(huì)在1秒之后被推送到訂閱者，之后這個(gè)流進(jìn)入完成狀態(tài):

var obserable = Rx.Observable.create(function(observer){   //注意參數(shù)的命名
 observer.next(1);
 observer.next(2);
 observer.next(3);
 
 setTimeout(function(){
     observer.next(4);
     observer.complete();
 },1000);
 
});

為了調(diào)用以上的Observable并輸出其中的值，需要訂閱這個(gè)流:

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

執(zhí)行之后會(huì)輸出:

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

拉取和推送是數(shù)據(jù)生產(chǎn)者和數(shù)據(jù)使用者之間進(jìn)行數(shù)據(jù)交換的2種形式。

在拉取系統(tǒng)中，數(shù)據(jù)使用者決定何時(shí)從數(shù)據(jù)生產(chǎn)者那里接收數(shù)據(jù)。數(shù)據(jù)生產(chǎn)者自身并不知道數(shù)據(jù)何時(shí)會(huì)被傳遞給使用者。

每一個(gè)js函數(shù)都是一個(gè)拉取系統(tǒng)。函數(shù)是一個(gè)數(shù)據(jù)生產(chǎn)者，通過在別處被調(diào)用，他返回的單一值將會(huì)被投入計(jì)算。

ES2015又引入了新的拉取系統(tǒng)，generator和迭代器(function*)。調(diào)用iterator.next()來消費(fèi)從迭代器(數(shù)據(jù)生產(chǎn)者)中拉取到的數(shù)據(jù)。

在推送系統(tǒng)中，數(shù)據(jù)生產(chǎn)者決定何時(shí)把數(shù)據(jù)推送給使用者，使用者自己并不知道何時(shí)能夠接收到數(shù)據(jù)。

Promise是當(dāng)今js中最常見的一種推送系統(tǒng)。和函數(shù)不同，Promise(數(shù)據(jù)生產(chǎn)者)精確的控制時(shí)機(jī)，將數(shù)據(jù)“推送”給業(yè)已注冊(cè)的回調(diào)函數(shù)(數(shù)據(jù)使用者)。

RxJS引入了Observables，一個(gè)新的JS推送系統(tǒng)。

一個(gè)Observable是一個(gè)包含多個(gè)值的“數(shù)據(jù)生產(chǎn)者”，它會(huì)將數(shù)據(jù)推送給Observer(數(shù)據(jù)使用者)。

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是一種惰性計(jì)算方式，當(dāng)他被調(diào)用時(shí)會(huì)同步的返回一個(gè)值。

generator是一種惰性計(jì)算方式，會(huì)在迭代中同步的返回0到無限個(gè)（可能的話）返回值。

Promise使用一種處理方法，最終可能會(huì)（或可能不會(huì)）返回一個(gè)值。

Observable是一種惰性處理方法，當(dāng)被調(diào)用的時(shí)候，可以同步也可以異步的返回0到無限個(gè)（可能的話）返回值。

有別于流行的說法，Observable既不像多個(gè)EventEmitter，也不像一種能返回多個(gè)值的Promise。

在一些場(chǎng)合，比如廣播消息時(shí)，Observer看起來很像EventEmitter，在RxJS中，被稱為Subject。而在大多數(shù)情況下，Observable并不像EventEmitter。

Observables 像一群沒有參數(shù)的函數(shù)，形成了多個(gè)值的集合。

考慮以下情況：

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種情況其實(shí)是由于函數(shù)和Observable都是一種惰性的計(jì)算。如果你不調(diào)用函數(shù)，那么console.log("Hello")就不會(huì)被執(zhí)行，也不會(huì)有輸出。同樣的，只用當(dāng)“調(diào)用”（通過subscribe訂閱）Observable，才會(huì)有輸出。

此外，調(diào)用和訂閱都是孤立運(yùn)行的。2個(gè)函數(shù)分別被調(diào)用會(huì)產(chǎn)生2個(gè)效果，2個(gè)Observable訂閱者會(huì)產(chǎn)生2個(gè)獨(dú)立的效果。
不像EventEmitter會(huì)派發(fā)它的狀態(tài)并且不論是否有訂閱者都會(huì)執(zhí)行那樣，Observable不會(huì)派發(fā)狀態(tài)而且是惰性的。

訂閱observable，類似于調(diào)用一個(gè)函數(shù)

有些聲音宣稱Observable是異步的，這是不對(duì)的。如果你使用一個(gè)函數(shù)來輸出日志，像這樣:

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之后，效果和函數(shù)一樣，都是同步的。

無論是同步方式還是異步方式，obsverable都可以擇其一來傳遞返回值。

Observable和函數(shù)之間有什么區(qū)別？Observables可以隨著時(shí)間線返回多個(gè)值，函數(shù)卻不能，因此你可以這樣:

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

函數(shù)返回單一的值，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

結(jié)論:

func.call()意味著“同步的返回一個(gè)值”。

observable.subscribe()意思是“返回任意數(shù)量的值，同步式、異步式二擇其一?！?/p>