Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Observable<T>

An Observable produces an asynchronous stream of values once iterated over or subscribed on. Observable methods operate on the asynchronous stream of values as they come by returning a new observable. Using this it's possible to create an asynchronous operator chain.

eg.

 const myObservable = Observable.for(0, 100, 10).map(i => i += 5);

 myObservable.subscribe({next: console.log});

 for await(const i of myObservable) {
     console.log(i);
 }

Type parameters

  • T

Hierarchy

  • Observable

Implements

  • AsyncIterable<T>

Index

Constructors

constructor

  • new Observable(ai: AsyncIterable<T>, unsubscribe: function): Observable

Properties

__@asyncIterator

__@asyncIterator: function

Type declaration

    • (): AsyncIterator<T>
    • Returns AsyncIterator<T>

Private unsubscribe

unsubscribe: function

Type declaration

    • (): void
    • Returns void

Methods

assign

checkValid

count

  • count(predicate?: undefined | function): Observable<number>

do

filter

flatMap

forEach

map

max

  • max listens on this input observable and yields the element with the maximum value when the input is completed. When the input type is not a number, a custom comparer has to be passed to compare the values.

    Type parameters

    • T: number

    Parameters

    Returns Observable<T>

min

reduce

  • Type parameters

    • K

    Parameters

    • fn: function
        • (acc: K, curr: T): K
        • Parameters

          • acc: K
          • curr: T

          Returns K

    • seed: K

    Returns Observable<K>

subscribe

toArray

  • toArray(): Promise<T[]>

where

Static callback

  • callback<T, K>(val: T, fn: function): Observable<K>
  • Type parameters

    • T

    • K

    Parameters

    • val: T
    • fn: function
        • (val: T, callback: function): any
        • Parameters

          • val: T
          • callback: function
              • (err: any, v: K): any
              • Parameters

                • err: any
                • v: K

                Returns any

          Returns any

    Returns Observable<K>

Static create

Static fibonacci

  • fibonacci(iterations?: undefined | number): Observable<number>

Static interval

  • interval(ms: number, max: number): Observable<number>

Static listen

Static of

  • of<T>(...values: (T | Promise<T>)[]): Observable<T>

Static random

  • random(min?: number, max?: number, count?: number): Observable<number>
  • Parameters

    • Default value min: number = 0
    • Default value max: number = 1
    • Default value count: number = Infinity

    Returns Observable<number>

Static range

  • range(from: number, to: number, step?: number): Observable<number>

Static unsubscribable

Generated using TypeDoc