Creates a new Observable

const obs$ = new Observable((observer) => {
  for (let i = 0; i < 10; ++i) {
    observer.next(i);
  }

  observer.complete();
});

const obs$ = Observable.create((observer) => {
  for (let i = 0; i < 10; ++i) {
    observer.next(i);
  }

  observer.complete();
});

observable$.subscribe({
  next(value) {
    console.log('logs if next', value);
  },
  error() {
    console.log('logs if error');
  },
  complete() {
    console.log('logs if complete');
  }
});

observable$.subscribe(
 (value) => console.log('logs if next', value),
 () => console.log('logs if error'),
 () => console.log('logs if complete')
);

Make a cancellable XHR request

Will create an observable that will listen for an event on a DOM element

Utilizes the makeHot method so that the event does not get reattached on every subscription

Turns a promise into an observable that emits the value of the promise and then completes

Creates an interval that will count on every interval tick

Takes any number of arguments and outputs them in order in an Observable stream

Output a range of numbers to an Observable stream

Takes an average of everything coming into the event stream until it completes

combines multiple observables at the same time. it will only call the observer's next function when all observables have emitted at least one value

Concatenate any number of observables together

Counts the number of values coming into the stream on complete

Debounces values that will be sent down the stream. Will only output values if there has not been any new values in the past time interval passed

Will delay output from the observable until a specific time interval has passed

Will run some callback before passing the current value to the subscription

doStuff(obs$, (value) => console.log(value))
 .subscribe((sameValue) => console.log('Will log the same value: ', sameValue))l

Will filter out values that you do not want to subscribe to

Will take the first value from the observable and then complete This is an alias for take(obs$, 1, callback)

Same as map(obs$, mapCallback) but will take the value of the callback and turn it from an observable to a value

Will map each value to a new value using the callback

Will result in the maximum value passed to the observer then will complete

Will merge any number of observables into one observable stream

Will result in the minimum value passed to the observer then will complete

Sort of the same way that Array.reduce works, it will concatenate all of the values passing through an Observable event stream with a given scanCallback

Sums all the values of an observable upon completion

The value from the mapCallback is an observable and if another value comes through the previous observable is cancelled
This is useful for things like typeaheads where you dont want a request for every keypress

Takes a number of values that satisfy the filterCallback then completes

Takes values from the source$ until the takeSource$ emits one value

Reverse of fromPromise
Converts an Observable to a promise, takes the first value and then completes

Makes an observable "hot" -- very useful for things like DOM event listeners so that the events do not get bound numerous amounts of times