RxJs: Is Observable stateful? - rxjs

Question

I'm asking this because I tried below code:
//RxJs v5.5.2; NodeJs v7.10.1
var Rx = require('rxjs/Rx');
var observable = Rx.Observable.of(1,2,3);
var sub = observable.subscribe(console.log);
var sub1 = observable.subscribe(console.log);
It outputs 1 2 3 1 2 3 (new line omitted).
However, as RxJs's document says, Observable is a stream, so why does the second subscription got all the values? My understanding is, after the first subscribe, the observable has already been completed and as a stream, it should never produce a value it has already emitted.
Do I misunderstood anything?

Answer 1

From the article referenced above, Hot vs Cold Observables
Observables are just functions!
Observables are functions that tie an observer to a producer. That’s it. They don’t necessarily set up the producer, they just set up an observer to listen to the producer, and generally return a teardown mechanism to remove that listener. The act of subscription is the act of “calling” the observable like a function, and passing it an observer.
So, the observable is just a pipe between a producer and observer, and the producer can (often) have the state 'baked in'.
Trying to prove that there's a producer somewhere in your example Rx.Observable.of(1,2,3) is a bit difficult.
The source for Observable.of is
export const of = ArrayObservable.of;
and ArrayObservable.of
static of<T>(...array: Array<T | IScheduler>): Observable<T> {
so the spread operator is the producer in this case, and array is the state which is passed in to the Observable.
I can't find source for the spread operator, but this ref es6-equivalents-in-es5#spread-operator gives the the following es5 equivalent
var _toArray = function (arr) {
return Array.isArray(arr) ? arr : [].slice.call(arr);
};
function add(a, b) {
return a + b;
}
var nums = [5, 4];
console.log(add.apply(null, _toArray(nums)));
Assuming _toArray() above is a fair approximation of spread, we can argue that spread is essentially a producer function.
So, does Rx.Observable.of(1,2,3) have state? We could argue yes, since the statement encloses the state, but in the equivalent
const nums = [1,2,3]
const src = Rx.Observable.of(...nums)
we can see that the state is actually external to the observable.
What about hot?
A hot observable has a producer that's not reproducing it's values on demand, e.g events.
So when the producer is hot, the observable does not 'remember' state prior to the setting up of the pipeline (i.e when subscription occurs), so again the producer has the state not the observable.
console.clear()
const eventEmitter = new EventEmitter();
var source = Rx.Observable.fromEvent(eventEmitter, 'data')
eventEmitter.emit('data', 1);
eventEmitter.emit('data', 2);
source.subscribe(x => console.log('subscription', x))
eventEmitter.emit('data', 3);
eventEmitter.emit('data', 4);
<script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/5.5.2/Rx.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/EventEmitter/5.2.4/EventEmitter.js"></script>