A flowable can be in pull/paused ("consuming") mode or push/flowing mode, like a stream.
The mode is initially decided by which subscribe() method is called first:
If Observable.subscribe() is called first, the mode is flowing
If Flowable.consume.subscribe() is called first, the mode is consuming
A subscriber via Observable.subscribe() always receives all data, but it
may be delayed by any subscribed consumers (like 'data' events).
A flowable is always multicast, and hot if there is at least one subscriber.
the function that is called when the Observable is
initially subscribed to. This function is given a Subscriber, to which new values
can be nexted, or an error method can be called to raise an error, or
complete can be called to notify of a successful completion.
Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
APIs that expect promises, like async/await. You cannot unsubscribe from this.
WARNING: Only use this with observables you know will complete. If the source
observable does not complete, you will end up with a promise that is hung up, and
potentially all of the state of an async function hanging out in memory. To avoid
this situation, look into adding something like {@link timeout}, {@link take},
{@link takeWhile}, or {@link takeUntil} amongst others.
a handler for each value emitted by the observable
(value: T): void
Parameters
value: T
Returns void
Returns Promise<void>
a promise that either resolves on observable completion or
rejects with the handled error
deprecated
Passing a Promise constructor will no longer be available
in upcoming versions of RxJS. This is because it adds weight to the library, for very
little benefit. If you need this functionality, it is recommended that you either
polyfill Promise, or you create an adapter to convert the returned native promise
to whatever promise implementation you wanted. Will be removed in v8.
Parameters
next: (value: T) => void
a handler for each value emitted by the observable
(value: T): void
Parameters
value: T
Returns void
promiseCtor: PromiseConstructorLike
a constructor function used to instantiate the Promise
Returns Promise<void>
a promise that either resolves on observable completion or
rejects with the handled error
lift
lift<R>(operator?: Operator<T, R>): Observable<R>
Creates a new Observable, with this Observable instance as the source, and the passed
operator defined as the new observable's operator.
method
lift
deprecated
Internal implementation detail, do not use directly. Will be made internal in v8.
If you have implemented an operator using lift, it is recommended that you create an
operator by simply returning new Observable() directly. See "Creating new operators from
scratch" section here: https://rxjs.dev/guide/operators
Type parameters
R
Parameters
Optional operator: Operator<T, R>
the operator defining the operation to take on the observable
Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments
A flowable can be in pull/paused ("consuming") mode or push/flowing mode, like a stream. The mode is initially decided by which
subscribe()method is called first:Observable.subscribe()is called first, the mode is flowingFlowable.consume.subscribe()is called first, the mode is consumingA subscriber via
Observable.subscribe()always receives all data, but it may be delayed by any subscribed consumers (like 'data' events).A flowable is always multicast, and hot if there is at least one subscriber.
https://nodejs.org/api/stream.html#two-reading-modes