Interview Questions and Answers

RxJS is a library for reactive programming using Observables, making it easier to compose asynchronous or callback-based code.

Example:

const observable = new Observable(observer => { observer.next('Hello'); });

Observables are data streams that emit a sequence of values over time. They can be subscribed to, and observers can react to emitted values.

Example:

const observable = new Observable(observer => { observer.next('First'); observer.next('Second'); });

An Observer is an interface that defines methods to handle the next, error, and complete events emitted by an Observable.

Example:

const observer = { next: value => console.log(value), error: err => console.error(err), complete: () => console.log('Completed') };

'pluck' is used to extract a specified property from each emitted object in an Observable stream.

Example:

const pluckedObservable = sourceObservable.pipe(pluck('name'));

'distinctUntilChanged' filters out consecutive duplicate values emitted by an Observable, only allowing distinct values to be emitted.

Example:

const distinctObservable = observable.pipe(distinctUntilChanged());

'interval' creates an Observable that emits sequential numbers at a specified interval, creating a timer-like behavior.

Example:

const intervalObservable = interval(1000);

'take' is used to emit only the first n values emitted by an Observable and then complete.

Example:

const takenObservable = observable.pipe(take(3));

Operators are functions that can be applied to Observables to manipulate, transform, and filter the emitted values.

Example:

const modifiedObservable = observable.pipe(map(value => value.toUpperCase()));

The 'map' operator transforms each value emitted by an Observable by applying a provided function to it.

Example:

const modifiedObservable = observable.pipe(map(value => value * 2));

'map' is used to transform values emitted by an Observable, while 'mergeMap' is used to project each value to an Observable and flatten the resulting Observables into one.

Example:

const modifiedObservable = observable.pipe(mergeMap(value => of(value, value * 2)));

The 'filter' operator is used to selectively emit values from an Observable based on a provided predicate function.

Example:

const filteredObservable = observable.pipe(filter(value => value > 5));

'rxjs/operators' is a module in RxJS that provides a collection of operators. These operators are used for transforming, filtering, and combining Observables to perform various operations.

Example:

import { map, filter } from 'rxjs/operators'; const modifiedObservable = observable.pipe(map(value => value * 2), filter(value => value > 5));

'switchMap' is used to transform each value emitted by an Observable into a new Observable and switch to emitting values from the latest Observable, ignoring previous ones.

Example:

const switchedObservable = observable.pipe(switchMap(value => of(value, value * 2)));

Subjects are both Observers and Observables. They can multicast values to multiple Observers, making them useful for scenarios where multiple subscribers need to receive the same values.

Example:

const subject = new Subject(); subject.next('First value'); subject.subscribe(value => console.log(value));

'concatMap' concatenates the emissions of mapped Observables in the order they were emitted, while 'mergeMap' merges them as soon as they arrive, possibly interleaving values.

Example:

const concatenatedObservable = observable.pipe(concatMap(value => of(value, value * 2)));

Errors in Observables can be handled using the 'catchError' operator, which allows you to catch and handle errors within the Observable stream.

Example:

const errorHandledObservable = observable.pipe(catchError(err => of('Error handled:', err)));

'zip' is used to combine multiple Observables by emitting values in a strict sequence, combining corresponding values from each Observable.

Example:

const zippedObservable = zip(observable1, observable2, (value1, value2) => value1 + value2);

'bufferTime' is used to collect values emitted by an Observable over a specified time period into arrays and emit these arrays at regular intervals.

Example:

const bufferedObservable = observable.pipe(bufferTime(1000));

'throttleTime' emits a value from the source Observable, then ignores subsequent values for a specified duration, ensuring a minimum time between emissions.

Example:

const throttledObservable = inputObservable.pipe(throttleTime(300));

'combineLatest' combines the latest values from multiple Observables into an array or using a provided function, emitting a new value whenever any of the combined Observables emit.

Example:

const combinedObservable = combineLatest(observable1, observable2, (value1, value2) => value1 + value2);

'defer' is used to create an Observable only when a subscriber subscribes, ensuring that each subscriber gets a fresh Observable instance.

Example:

const deferredObservable = defer(() => of('Deferred value'));

Multicasting is the process of broadcasting a single source Observable to multiple subscribers, preventing redundant work for shared operations.

Example:

const subject = new Subject(); observable.subscribe(subject);

'Cold' Observables start producing values only when a subscription is made, while 'Hot' Observables produce values even before any subscriptions.

Example:

Cold: const coldObservable = new Observable(...); Hot: const hotObservable = new Subject();

The 'debounceTime' operator is used to emit a value from an Observable only after a specified amount of time has passed without any new values being emitted.

Example:

const debouncedObservable = inputObservable.pipe(debounceTime(300));

Schedulers are used to control the execution context and timing of Observable operations, allowing you to control when and where certain code is executed.

Example:

const scheduledObservable = observable.pipe(delay(1000, asyncScheduler));

'finalize' is used to perform a specified action when an Observable completes, whether it completes normally or due to an error.

Example:

const finalizedObservable = observable.pipe(finalize(() => console.log('Observable completed')));

ReplaySubjects are similar to Subjects but can 'replay' a specified number of previously emitted values to new subscribers, ensuring they receive a specific history of values.

Example:

const replaySubject = new ReplaySubject(2); replaySubject.next('First value'); replaySubject.next('Second value'); replaySubject.subscribe(value => console.log(value));

BehaviorSubjects always emit the latest value to new subscribers, while ReplaySubjects can replay a specified number of previous values to new subscribers.

Example:

const behaviorSubject = new BehaviorSubject('Initial value'); behaviorSubject.next('Updated value'); behaviorSubject.subscribe(value => console.log(value));

'debounce' is used to discard values emitted by an Observable that follow each other too quickly, allowing only the last value within a specified time window to be emitted.

Example:

const debouncedObservable = inputObservable.pipe(debounce(() => timer(300)));