Random 2

Question 1

There are several ways of getting the latest value from a Subject or Observable in a “Rx-y” way

Answer 1

1. Using BehaviorSubject: But actually subscribing to it. When you first subscribe to BehaviorSubject it will synchronously send the previous value it received or was initialized with.
2. Using a ReplaySubject(N): This will cache N values and replay them to new subscribers.
3. A.withLatestFrom(B): Use this operator to get the most recent value from observable Bwhen observable A emits. Will give you both values in an array [a, b].
4. A.combineLatest(B): Use this operator to get the most recent values from A and B every time either A or B emits. Will give you both values in an array.
5. shareReplay(): Makes an Observable multicast through a ReplaySubject, but allows you to retry the observable on error. (Basically it gives you that promise-y caching behavior).
6. publishReplay(), publishBehavior(), multicast(subject: BehaviorSubject | ReplaySubject), etc: Other operators that leverage BehaviorSubject and ReplaySubject. Different flavors of the same thing, they basically multicast the source observable by funneling all notifications through a subject. You need to call connect() to subscribe to the source with the subject.

Question 2

Operators that originate new Observables

Answer 2

• 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
• Empty/Never/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

Question 3

create ReplaySubject that buffers the 3 last values but with a window time of 500ms

Answer 3

var subject = new Rx.ReplaySubject(3, 500);

Question 4

Transforming Observables

Operators that transform items that are emitted by an Observable

Answer 4

• 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

Question 5

Filtering Observables

Operators that selectively emit items from a source Observable.

Answer 5

• 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

Question 6

Combining Observables

Operators that work with multiple source Observables to create a single Observable

Answer 6

• And/Then/When — combine sets of items emitted by two or more Observables by means of Patternand Plan intermediaries
• 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

Question 7

Error Handling Operators

Operators that help to recover from error notifications from an Observable

Answer 7

• Catch — recover from an onError notification by continuing the sequence without error
• Retry — if a source Observable sends an onError notification, resubscribe to it in the hopes that it will complete without error

Question 8

Observable Utility Operators

A toolbox of useful Operators for working with Observables

Answer 8

• 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
• Materialize/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

Question 9

Conditional and Boolean Operators

Operators that evaluate one or more Observables or items emitted by Observables

Answer 9

• All — determine whether all items emitted by an Observable meet some criteria
• Amb — given two or more source Observables, emit all of the items from only the first of these Observables to emit an item
• Contains — determine whether an Observable emits a particular item or not
• DefaultIfEmpty — emit items from the source Observable, or a default item if the source Observable emits nothing
• SequenceEqual — determine whether two Observables emit the same sequence of items
• SkipUntil — discard items emitted by an Observable until a second Observable emits an item
• SkipWhile — discard items emitted by an Observable until a specified condition becomes false
• TakeUntil — discard items emitted by an Observable after a second Observable emits an item or terminates
• TakeWhile — discard items emitted by an Observable after a specified condition becomes false

Question 10

• backpressure operators — strategies for coping with Observables that produce items more rapidly than their observers consume them

Answer 10

Buffer, Sample, Debounce, or Window.

Question 11

Connectable Observable Operators

Specialty Observables that have more precisely-controlled subscription dynamics

Answer 11

• Connect — instruct a connectable Observable to begin emitting items to its subscribers
• Publish — convert an ordinary Observable into a connectable Observable
• RefCount — make a Connectable Observable behave like an ordinary Observable
• Replay — ensure that all observers see the same sequence of emitted items, even if they subscribe after the Observable has begun emitting items

Question 12

Operators to Convert Observables

• To — convert an Observable into another object or data structure

Answer 12

…

Question 13

Default font size.

Answer 13

This is default font but with some bold words.

No line break above.

• Two bulleted items
• Second bulleted item

Answer 14

Observer

What is an Observer? An Observer is a consumer of values delivered by an Observable. Observers are simply a set of callbacks, one for each type of notification delivered by the Observable: next, error, and complete.

Observer

What is an Observer? An Observer is a consumer of values delivered by an Observable. Observers are simply a set of callbacks, one for each type of notification delivered by the Observable: next, error, and complete.

Question 15

What is an Observer

Answer 15

Observer

What is an Observer? An Observer is a consumer of values delivered by an Observable. Observers are simply a set of callbacks, one for each type of notification delivered by the Observable: next, error, and complete.

Question 16

The following is an example of a typical Observer object:

Answer 16

var observer = {

` next: x => console.log(‘Observer got a next value: ‘ + x),`

` error: err => console.error(‘Observer got an error: ‘ + err),`

` complete: () => console.log(‘Observer got a complete notification’),`

};

Question 17

More sample code, without code tag.

Answer 17

var observer = {
next: x => console.log(‘Observer got a next value: ‘ + x),
error: err => console.error(‘Observer got an error: ‘ + err),
complete: () => console.log(‘Observer got a complete notification’),
};

Question 18

When subscribing to an Observable, you may also just provide the callbacks as arguments, without being attached to an Observer object, for instance like this:

Answer 18

observable.subscribe(x => console.log(‘Observer got a next value: ‘ + x));

Question 19

Question 20

null (scheduler type)

Answer 20

By not passing any scheduler, notifications are delivered synchronously and recursively. Use this for constant-time operations or tail recursive operations.

Question 21

Rx.Scheduler.queue

Answer 21

Schedules on a queue in the current event frame (trampoline scheduler). Use this for iteration operations.

Question 22

Rx.Scheduler.asap

Answer 22

Schedules on the micro task queue, which uses the fastest transport mechanism available, either Node.js’ process.nextTick() or Web Worker MessageChannel or setTimeout or others. Use this for asynchronous conversions.

Question 23

Rx.Scheduler.async

Answer 23

Schedules work with setInterval. Use this for time-based operations.