Interview Questions and Answers

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'));