Please enable JavaScript.

Coggle requires JavaScript to display documents.

rxjs (2) Observables a defined stream of events (methods (pipe,…

- - - - next = does a console.log of what is returned from the stream
      - error = does a console.log if an error occurs in the stream
      - complete = writes done to the console when execution is finished
- - - - Convert
      - Connectable Observable
        
        Replay — ensure that all observers see the same sequence of emitted items, even if they subscribe after the Observable has begun emitting
        
        RefCount — make a Connectable Observable behave like an ordinary Observable
        
        Publish — convert an ordinary Observable into a connectable Observable
        
        Connect — instruct a connectable Observable to begin emitting items to its subscribers
      - Backpressure
        
        backpressure operators — strategies for coping with Observables that produce items more rapidly than their observers consume them
      - Mathematical and Aggregate
        
        Sum — calculate the sum of numbers emitted by an Observable and emit this sum
        
        Reduce — apply a function to each item emitted by an Observable, sequentially, and emit the final value
        
        Min — determine, and emit, the minimum-valued item emitted by an Observable
        
        Max — determine, and emit, the maximum-valued item emitted by an Observable
        
        Count — count the number of items emitted by the source Observable and emit only this value
        
        Concat — emit the emissions from two or more Observables without interleaving them
        
        Average — calculates the average of numbers emitted by an Observable and emits this average
      - Conditional and Boolean
        
        TakeWhile — discard items emitted by an Observable after a specified condition becomes false
        
        TakeUntil — discard items emitted by an Observable after a second Observable emits an item or terminates
        
        SkipWhile — discard items emitted by an Observable until a specified condition becomes false
        
        SkipUntil — discard items emitted by an Observable until a second Observable emits an item
        
        SequenceEqual — determine whether two Observables emit the same sequence of items
        
        DefaultIfEmpty — emit items from the source Observable, or a default item if the source Observable emits nothing
        
        Contains — determine whether an Observable emits a particular item or not
        
        Amb — given two or more source Observables, emit all of the items from only the first of these Observables to emit an item
        
        All — determine whether all items emitted by an Observable meet some criteria
      - Utility
        
        Using — create a disposable resource that has the same lifespan as the Observable
        
        Timestamp — attach a timestamp to each item emitted by an Observable
        
        Timeout — mirror the source Observable, but issue an error notification if a particular period of time elapses without any emitted items
        
        TimeInterval — convert an Observable that emits items into one that emits indications of the amount of time elapsed between those emissions
        
        SubscribeOn — specify the scheduler an Observable should use when it is subscribed to
        
        Subscribe — operate upon the emissions and notifications from an Observable
        
        Serialize — force an Observable to make serialized calls and to be well-behaved
        
        ObserveOn — specify the scheduler on which an observer will observe this Observable
        
        Materialize/Dematerialize — represent both the items emitted and the notifications sent as emitted items, or reverse this process
        
        Do — register an action to take upon a variety of Observable lifecycle events
        
        Delay — shift the emissions from an Observable forward in time by a particular amount
      - Error Handling
        
        Catch — recover from an onError notification by continuing the sequence without error
        
        Retry — if a source Observable sends an onError notification, resubscribe to it in the hopes that it will complete without error
      - Combining
        
        Zip — combine the emissions of multiple Observables together via a specified function and emit single items for each combination based on the results of this function
        
        Switch — convert an Observable that emits Observables into a single Observable that emits the items emitted by the most-recently-emitted of those Observables
        
        StartWith — emit a specified sequence of items before beginning to emit the items from the source Observable
        
        Merge — combine multiple Observables into one by merging their emissions
        
        Join — combine items emitted by two Observables whenever an item from one Observable is emitted during a time window defined according to an item emitted by the other Observable
        
        CombineLatest — when an item is emitted by either of two Observables, combine the latest item emitted by each Observable via a specified function and emit items based on the results of this function
        
        And/Then/When — combine sets of items emitted by two or more Observables by means of Pattern and Plan intermediaries
      - Filtering
        
        TakeLast — emit only the last n items emitted by an Observable
        
        Take — emit only the first n items emitted by an Observable
        
        SkipLast — suppress the last n items emitted by an Observable
        
        Skip — suppress the first n items emitted by an Observable
        
        Sample — emit the most recent item emitted by an Observable within periodic time intervals
        
        Last — emit only the last item emitted by an Observable
        
        IgnoreElements — do not emit any items from an Observable but mirror its termination notification
        
        First — emit only the first item, or the first item that meets a condition, from an Observable
        
        Filter — emit only those items from an Observable that pass a predicate test
        
        ElementAt — emit only item n emitted by an Observable
        
        Distinct — suppress duplicate items emitted by an Observable
        
        Debounce — only emit an item from an Observable if a particular timespan has passed without it emitting another item
      - Transforming
        
        Window — periodically subdivide items from an Observable into Observable windows and emit these windows rather than emitting the items one at a time
        
        Scan — apply a function to each item emitted by an Observable, sequentially, and emit each successive value
        
        Map — transform the items emitted by an Observable by applying a function to each item
        
        GroupBy — divide an Observable into a set of Observables that each emit a different group of items from the original Observable, organized by key
        
        FlatMap — transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable
        
        Buffer — periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a time
      - Creating
        
        ajax Create an observable for an Ajax request with either a request object with url, headers, etc or a string for a URL.
        
        Timer — create an Observable that emits a single item after a given delay
        
        Start — create an Observable that emits the return value of a function
        
        Repeat — create an Observable that emits a particular item or sequence of items repeatedly
        
        Range — create an Observable that emits a range of sequential integers
        
        Just — convert an object or a set of objects into an Observable that emits that or those objects
        
        Interval — create an Observable that emits a sequence of integers spaced by a particular time interval
        
        From — convert some other object or data structure into an Observable
        
        Empty/Never/Throw — create Observables that have very precise and limited behavior
        
        Defer — do not create the Observable until the observer subscribes, and create a fresh Observable for each observer
        
        Create — create an Observable from scratch by calling observer methods programmatically
    - - Creation from,fromEvent, of
        
        Combination combineLatest, concat, merge, startWith , withLatestFrom, zip
        
        Filtering debounceTime, distinctUntilChanged, filter, take, takeUntil
        
        Transformation bufferTime, concatMap, map, mergeMap, scan, switchMap
        
        Utility tap
        
        Multicasting share
        
        Error catchError,retry