throwError

function stable

throwError(errorOrErrorFactory: any, scheduler?: SchedulerLike): Observable<never>

Parameters

errorOrErrorFactory

Type: any.

scheduler

Optional. Default is undefined.

Type: SchedulerLike.

Returns

Observable<never>

Overloads

throwError(errorFactory: () => any): Observable<never>

Creates an observable that will create an error instance and push it to the consumer as an error immediately upon subscription.

Parameters

errorFactory

A factory function that will create the error instance that is pushed.

Returns

Observable<never>

Just errors and does nothing else

throw marble diagram

This creation function is useful for creating an observable that will create an error and error every time it is subscribed to. Generally, inside of most operators when you might want to return an errored observable, this is unnecessary. In most cases, such as in the inner return of concatMap, mergeMap, defer, and many others, you can simply throw the error, and RxJS will pick that up and notify the consumer of the error.

Example

Create a simple observable that will create a new error with a timestamp and log it and the message every time you subscribe to it.

import { throwError } from 'rxjs';

let errorCount = 0;

const errorWithTimestamp$ = throwError(() => {
   const error: any = new Error(`This is error number ${++errorCount}`);
   error.timestamp = Date.now();
   return error;
});

errorWithTimesptamp$.subscribe({
   error: err => console.log(err.timestamp, err.message)
});

errorWithTimesptamp$.subscribe({
   error: err => console.log(err.timestamp, err.message)
});

// Logs the timestamp and a new error message each subscription;

Unnecessary usage

Using throwError inside of an operator or creation function with a callback, is usually not necessary:

import { throwError, timer, of } from 'rxjs';
import { concatMap } from 'rxjs/operators';

const delays$ = of(1000, 2000, Infinity, 3000);

delays$.pipe(
   concatMap(ms => {
     if (ms < 10000) {
       return timer(ms);
     } else {
       // This is probably overkill.
       return throwError(() => new Error(`Invalid time ${ms}`));
     }
   })
)
.subscribe({
   next: console.log,
   error: console.error
});

You can just throw the error instead:

import { throwError, timer, of } from 'rxjs';
import { concatMap } from 'rxjs/operators';

const delays$ = of(1000, 2000, Infinity, 3000);

delays$.pipe(
   concatMap(ms => {
     if (ms < 10000) {
       return timer(ms);
     } else {
       // Cleaner and easier to read for most folks.
       throw new Error(`Invalid time ${ms}`);
     }
   })
)
.subscribe({
   next: console.log,
   error: console.error
});

throwError(error: any): Observable<never>

Returns an observable that will error with the specified error immediately upon subscription.

Deprecation Notes

Support for passing an error value will be removed in v8. Instead, pass a factory function to throwError(() => new Error('test')). This is because it will create the error at the moment it should be created and capture a more appropriate stack trace. If for some reason you need to create the error ahead of time, you can still do that: const err = new Error('test'); throwError(() => err);.

Parameters

error

The error instance to emit

Returns

Observable<never>

throwError(errorOrErrorFactory: any, scheduler: SchedulerLike): Observable<never>

Notifies the consumer of an error using a given scheduler by scheduling it at delay 0 upon subscription.

Deprecation Notes

The scheduler parameter will be removed in v8. Use throwError in combination with observeOn: throwError(() => new Error('test')).pipe(observeOn(scheduler));. Details: https://rxjs.dev/deprecations/scheduler-argument

Parameters

errorOrErrorFactory

An error instance or error factory

scheduler

A scheduler to use to schedule the error notification

Returns

Observable<never>

© 2015–2021 Google, Inc., Netflix, Inc., Microsoft Corp. and contributors.
Code licensed under an Apache-2.0 License. Documentation licensed under CC BY 4.0.
https://rxjs.dev/api/index/function/throwError