Practical observable usage

Here are some examples of domains in which observables are particularly useful.

Type-ahead suggestions

Observables can simplify the implementation of type-ahead suggestions. Typically, a type-ahead has to do a series of separate tasks:

  • Listen for data from an input
  • Trim the value (remove whitespace) and make sure it's a minimum length
  • Debounce (so as not to send off API requests for every keystroke, but instead wait for a break in keystrokes)
  • Don't send a request if the value stays the same (rapidly hit a character, then backspace, for instance)
  • Cancel ongoing AJAX requests if their results will be invalidated by the updated results

Writing this in full JavaScript can be quite involved. With observables, you can use a simple series of RxJS operators:

import { fromEvent, Observable } from 'rxjs';
import { ajax } from 'rxjs/ajax';
import { debounceTime, distinctUntilChanged, filter, map, switchMap } from 'rxjs/operators';

const searchBox = document.getElementById('search-box') as HTMLInputElement;

const typeahead = fromEvent(searchBox, 'input').pipe(
  map(e => (e.target as HTMLInputElement).value),
  filter(text => text.length > 2),
  switchMap(searchTerm => ajax(`/api/endpoint?search=${searchTerm}`))

typeahead.subscribe(data => {
  // Handle the data from the API

Exponential backoff

Exponential backoff is a technique in which you retry an API after failure, making the time in between retries longer after each consecutive failure, with a maximum number of retries after which the request is considered to have failed. This can be quite complex to implement with promises and other methods of tracking AJAX calls. With observables, it is very easy:

import { of, pipe, range, throwError, timer, zip } from 'rxjs';
import { ajax } from 'rxjs/ajax';
import { map, mergeMap, retryWhen } from 'rxjs/operators';

export function backoff(maxTries: number, delay: number) {
  return pipe(
    retryWhen(attempts =>
      zip(range(1, maxTries + 1), attempts).pipe(
        mergeMap(([i, err]) => (i > maxTries) ? throwError(err) : of(i)),
        map(i => i * i),
        mergeMap(v => timer(v * delay)),

  .pipe(backoff(3, 250))
  .subscribe(function handleData(data) { /* ... */ });
Last reviewed on Mon Feb 28 2022

© 2010–2022 Google, Inc.
Licensed under the Creative Commons Attribution License 4.0.