RxJS

exhaustMap starts an inner observable only when none is active and discards source values that arrive meanwhile, without buffering them. A login button then sends one request however often it is clicked, and a poll never overlaps a slow previous request.

auditTime starts a window on a value and emits the latest value when it ends; sampleTime emits the latest value on a fixed clock; default throttleTime emits a window's first value. auditTime usually suits a scroll tracker's latest position.

throttleTime defaults to { leading: true, trailing: false }: it emits each window's first value and drops the rest, so a scroll ending mid-window loses its final position. { leading: true, trailing: true }, passed third, also emits each window's latest value.

bufferTime emits the collected array every time span, bufferCount after N values, and buffer each time its notifier emits. On completion the partial buffer is emitted; on error it is discarded. bufferTime and buffer emit empty arrays when nothing arrived.

With zero delay, RxJS queueScheduler runs the task synchronously (queuing nested tasks until the current one ends), asapScheduler runs it as a microtask after the current code, and asyncScheduler runs it on a timer, after pending microtasks.

RxJS subscribeOn schedules the moment the source is subscribed, so a synchronous source still emits in one burst later. observeOn reschedules every next, error and complete notification on the scheduler, so it changes when values reach downstream observers.

Create one RxJS Subscription, add() each child subscription or teardown function to it, and call unsubscribe() once. add() returns void in RxJS 7, runs a teardown immediately if the parent is already closed, and closed children drop out automatically.

ReplaySubject(bufferSize, windowTime) keeps at most bufferSize values that are younger than windowTime milliseconds and replays them in order to each new subscriber before live values; both limits default to infinity.

of, from over arrays or iterables, range and EMPTY deliver all values and completion before subscribe() returns; from(promise), interval and timer deliver later. Synchronous delivery breaks code that uses the subscription variable in its callback or that assumes asynchrony.

Use retry({ count, delay }) where delay is a function of (error, retryCount) returning timer(base * 2 ** (retryCount - 1)); count caps retries, and resetOnSuccess restarts the count after the source emits again.

In RxJS marble tests, hot() and cold() fixtures log every subscription. Pass fixture.subscriptions to expectSubscriptions(...).toBe(...) with subscription marbles, where ^ marks subscribe and ! unsubscribe; an array covers several subscriptions, proving the stale inner ended when the next began.

combineLatest stays silent until every source has emitted once, so one of the three never emitted, completed empty or errored; trace each source with tap, then seed or default the culprit or fix its producer.

takeUntil completes only when its notifier emits a value; a notifier that completes without emitting is ignored. It also misfires when the notifier errors, emits synchronously at subscribe time, or when a flattening operator after it keeps an inner stream alive.

concatMap runs one save at a time and buffers the rest in an unbounded queue, so a slow server grows the backlog, memory and latency. mergeMap(save, n) runs up to n saves at once, draining faster but losing ordered completion.

debounceTime holds the latest edit until its quiet period ends; unsubscribing first discards it. Completing the source instead makes debounceTime emit the held value immediately, so end the stream upstream rather than unsubscribing.

A custom operator is a function from a source Observable to a new one. Compose existing operators with the standalone pipe(); only when that cannot work, return a new Observable that forwards next, error and complete and unsubscribes the source in teardown.

shareReplay's refCount defaults to false, so when the subscriber count drops to zero its inner ReplaySubject stays subscribed to the source; for a never-completing source use shareReplay({ bufferSize, refCount: true }) or share with explicit reset options.

Each shared its name with a static creation function, which clashed once all operators moved into the 'rxjs' entry point; they were renamed mergeWith, concatWith, zipWith, raceWith and combineLatestWith, and the old names are deprecated.

They flatten an observable that already emits observables, using the same strategies as the Map operators: run concurrently, queue, switch to the newest, or ignore while busy. map(project) followed by mergeAll() behaves like mergeMap(project); concatAll() is mergeAll(1).

pairwise emits [previous, current] tuples, so it needs two values before its first emission. Putting startWith(x) before it supplies a synthetic first value, so the first real value produces [x, first] immediately.

timeout errors with a TimeoutError when a value is late: each limits every gap, first the wait for the first value, and with switches to a replacement instead; put timeout before retry so each attempt gets its own timer.

RxJS TestScheduler.run removes the frame limit, so an endless source such as interval keeps virtual time flushing forever; add an unsubscription marble. Promises and direct timers are not virtualised, so their values never arrive; test those parts asynchronously or stub them.

RxJS 7 treats the error as unhandled: the subscription closes and runs its teardown, and the error is rethrown asynchronously in a setTimeout, or passed to config.onUnhandledError. A try/catch around subscribe() has already exited, so it never sees it.

debounce() gets a duration observable per value from its selector and emits the value when that observable first emits. Since RxJS 7 completing does not end the duration, so EMPTY holds the value until a newer one or source completion.

Use interval(0, animationFrameScheduler) or animationFrames() to emit once per frame, compute remaining time from a clock, and end with takeWhile. A positive delay makes animationFrameScheduler fall back to a timer, so interval(16, ...) is not frame-aligned.

RxJS 7 reduced multicasting to connectable, connect, share and shareReplay; use connectable() when you must attach every subscriber before the source starts, because share() starts it on the first subscription.