Name Product: RxJS Operators
Download Size: 251 MB
COST: $27= Yours Free
Sale Page: _http://reactivex.io/documentation/operators.html
Each language-specific implementation of ReactiveX implements a set of operators. Although there is much overlap between implementations, there are also some operators that are only implemented in certain implementations. Also, each implementation tends to name its operators to resemble those of similar methods that are already familiar from other contexts in that language.
Most operators operate on an Observable and return an Observable. This allows you to apply these operators one after the other, in a chain. Each operator in the chain modifies the Observable that results from the operation of the previous operator.
There are other patterns, like the Builder Pattern, in which a variety of methods of a particular class operate on an item of that same class by modifying that object through the operation of the method. These patterns also allow you to chain the methods in a similar way. But while in the Builder Pattern, the order in which the methods appear in the chain does not usually matter, with the Observable operators order matters.
A chain of Observable operators do not operate independently on the original Observable that originates the chain, but they operate in turn, each one operating on the Observable generated by the operator immediately previous in the chain.
The Operators of ReactiveX
This page first lists what could be considered the “core” operators in ReactiveX, and links to pages that have more in-depth information on how these operators work and how particular language-specific ReactiveX versions have implemented these operators.
Next is a “decision tree” that may help you choose the operator that is most appropriate to your use case.
Finally, there is an alphabetical list of most of the operators available in the many language-specific implementations of ReactiveX. These link to the page that documents the core operator that most closely resembles the language-specific operator (so, for instance, the Rx.NET “SelectMany” operator links to the documentation of the FlatMap ReactiveX operator, of which “SelectMany” is the Rx.NET implementation).
If you want to implement your own operator, see
Operators By Category
Operators that originate new Observables.
Create— create an Observable from scratch by calling observer methods programmatically
Defer— do not create the Observable until the observer subscribes, and create a fresh Observable for each observer
Throw— create Observables that have very precise and limited behavior
From— convert some other object or data structure into an Observable
Interval— create an Observable that emits a sequence of integers spaced by a particular time interval
Just— convert an object or a set of objects into an Observable that emits that or those objects
Range— create an Observable that emits a range of sequential integers
Repeat— create an Observable that emits a particular item or sequence of items repeatedly
Start— create an Observable that emits the return value of a function
Timer— create an Observable that emits a single item after a given delay
Operators that transform items that are emitted by an Observable.
Buffer— periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a time
FlatMap— transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable
GroupBy— divide an Observable into a set of Observables that each emit a different group of items from the original Observable, organized by key
Map— transform the items emitted by an Observable by applying a function to each item
Scan— apply a function to each item emitted by an Observable, sequentially, and emit each successive value
Window— periodically subdivide items from an Observable into Observable windows and emit these windows rather than emitting the items one at a time
Operators that selectively emit items from a source Observable.
Debounce— only emit an item from an Observable if a particular timespan has passed without it emitting another item
Distinct— suppress duplicate items emitted by an Observable
ElementAt— emit only item n emitted by an Observable
Filter— emit only those items from an Observable that pass a predicate test
First— emit only the first item, or the first item that meets a condition, from an Observable
IgnoreElements— do not emit any items from an Observable but mirror its termination notification
Last— emit only the last item emitted by an Observable
Sample— emit the most recent item emitted by an Observable within periodic time intervals
Skip— suppress the first n items emitted by an Observable
SkipLast— suppress the last n items emitted by an Observable
Take— emit only the first n items emitted by an Observable
TakeLast— emit only the last n items emitted by an Observable
Operators that work with multiple source Observables to create a single Observable
When— combine sets of items emitted by two or more Observables by means of
CombineLatest— when an item is emitted by either of two Observables, combine the latest item emitted by each Observable via a specified function and emit items based on the results of this function
Join— combine items emitted by two Observables whenever an item from one Observable is emitted during a time window defined according to an item emitted by the other Observable
Merge— combine multiple Observables into one by merging their emissions
StartWith— emit a specified sequence of items before beginning to emit the items from the source Observable
Switch— convert an Observable that emits Observables into a single Observable that emits the items emitted by the most-recently-emitted of those Observables
Zip— combine the emissions of multiple Observables together via a specified function and emit single items for each combination based on the results of this function
Error Handling Operators
Operators that help to recover from error notifications from an Observable
Catch— recover from an
onErrornotification by continuing the sequence without error
Retry— if a source Observable sends an
onErrornotification, resubscribe to it in the hopes that it will complete without error
Observable Utility Operators
A toolbox of useful Operators for working with Observables
Delay— shift the emissions from an Observable forward in time by a particular amount
Do— register an action to take upon a variety of Observable lifecycle events
Dematerialize— represent both the items emitted and the notifications sent as emitted items, or reverse this process
ObserveOn— specify the scheduler on which an observer will observe this Observable
Serialize— force an Observable to make serialized calls and to be well-behaved
Subscribe— operate upon the emissions and notifications from an Observable
SubscribeOn— specify the scheduler an Observable should use when it is subscribed to
TimeInterval— convert an Observable that emits items into one that emits indications of the amount of time elapsed between those emissions
Timeout— mirror the source Observable, but issue an error notification if a particular period of time elapses without any emitted items
Timestamp— attach a timestamp to each item emitted by an Observable
Using— create a disposable resource that has the same lifespan as the Observable
Leave a comment
You must be logged into post a comment.