Observable
Related Doc:
package Rx
Propagates the observable sequence or Promise that reacts first.
Propagates the observable sequence or Promise that reacts first. "amb" stands for ambiguous.
(Array|arguments): Observable sources or Promises competing to react first either as an array or arguments.
An observable sequence that surfaces any of the given sequences, whichever reacted first.
Uses selector to determine which source in sources to use.
Uses selector to determine which source in sources to use. There is an alias 'switchCase' for browsers < IE9.
(Function): The function which extracts the value for to test in a case statement.
(Object): A object which has keys which correspond to the case statement labels.
[elseSource|scheduler] (Observable | Scheduler): The observable sequence that will be run if the sources are not matched. If this is not provided, it defaults to Rx.Observable.empty with the specified scheduler.
An observable sequence which is determined by a case statement.
Rx.Observable.case(selector, sources, [elseSource|scheduler])
Continues an observable sequence that is terminated by an exception with the next observable sequence.
Continues an observable sequence that is terminated by an exception with the next observable sequence.
(Array | arguments): Observable sequences to catch exceptions for.
An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.
Rx.Observable.catch(...args)
Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully.
Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully.
(Array | arguments): Observable sequences or Promises to concatenate.
(Observable): An observable sequence that contains the elements of each given sequence, in sequential order.
Rx.Observable.concat(...args)
Creates an observable sequence from a specified subscribe method implementation.
Creates an observable sequence from a specified subscribe method implementation. This is an alias for the
createWithDisposable method
(Function): Implementation of the resulting observable sequence's subscribe method, optionally returning a function that will be wrapped in a disposable object. This could also be a disposable object.
(Observable): The observable sequence with the specified implementation for the subscribe method.
Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.
Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.
(Function): Observable factory function to invoke for each observer that subscribes to the resulting sequence.
(Observable): An observable sequence whose observers trigger an invocation of the given observable factory function.
Rx.Observable.defer(observableFactory)
Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message.
Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message.
[scheduler=Rx.Scheduler.immediate] (Scheduler): Scheduler to send the termination call on.
(Observable): An observable sequence with no elements.
Rx.Observable.empty([scheduler])
Concatenates the observable sequences or Promises obtained by running the specified result selector for each element in source.
Concatenates the observable sequences or Promises obtained by running the specified result selector for each element in source. There is an alias for this method called forIn for browsers < IE9
(Array): An array of values to turn into an observable sequence.
(Function): A function to apply to each item in the sources array to turn it into an observable sequence. The resultSelector is called with the following information:
(Any): Object to use as this when executing resultSelector.
(Observable): An observable sequence from the concatenated observable sequences or Promises.
Rx.Observable.for(sources, resultSelector, [thisArg])
Runs all observable sequences in parallel and collect their last elements.
Runs all observable sequences in parallel and collect their last elements.
(Arguments | Array): An array or arguments of Observable sequences or Promises to collect the last elements for.
(Observable): An observable sequence with an array collecting the last elements of all the input sequences or the result of the result selector if specified.
Rx.Observable.forkJoin(...args, [resultSelector])
Runs all observable sequences in parallel and collect their last elements.
Runs all observable sequences in parallel and collect their last elements.
(Arguments | Array): An array or arguments of Observable sequences or Promises to collect the last elements for.
(Function): The result selector from all the values produced. If not specified, forkJoin will return the results as an array.
(Observable): An observable sequence with an array collecting the last elements of all the input sequences or the result of the result selector if specified.
Rx.Observable.forkJoin(...args, [resultSelector])
This method creates a new Observable sequence from an array-like or iterable object.
This method creates a new Observable sequence from an array-like or iterable object.
(Array | Arguments | Iterable): An array-like or iterable object to convert to an Observable sequence.
(Function): Map function to call on every element of the array.
(Any): The context to use calling the mapFn if provided.
[scheduler=Rx.Scheduler.currentThread] (Scheduler): Scheduler to run the enumeration of the input sequence on.
(Observable): The observable sequence whose elements are pulled from the given iterable sequence.
Rx.Observable.from(iterable, [mapFn], [thisArg], [scheduler])
Converts a callback function to an observable sequence.
Converts a callback function to an observable sequence.
(Function): Function with a callback as the last parameter to convert to an Observable sequence.
(Any): The context for the func parameter to be executed. If not specified, defaults to undefined.
(Function): A selector which takes the arguments from the callback to produce a single item to yield on next.
(Function): A function, when executed with the required parameters minus the callback, produces an Observable sequence with a single value of the arguments to the callback as an array if no selector given, else the object created by the selector function.
Rx.Observable.fromCallback(func, [context], [selector])
Creates an observable sequence by adding an event listener to the matching DOMElement, jQuery element, Zepto Element, Angular element, Ember.js element or EventEmitter.
Creates an observable sequence by adding an event listener to the matching DOMElement, jQuery element, Zepto Element, Angular element, Ember.js element or EventEmitter.
Note that this uses the library approaches for jQuery, Zepto, Backbone.Marionette, AngularJS and Ember.js and falls back to native binding if not present. If you are using AMD you may need to include these libraries as dependencies of RxJs in your requirejs configuration file. RxJs will attempt to detect their presence when deciding which library to use.
(Any): The DOMElement, NodeList, jQuery element, Zepto Element, Angular element, Ember.js element or EventEmitter to attach a listener. For Backbone.Marionette this would be the application or an EventAggregator object.
(String): The event name to attach the observable sequence.
(Function): A selector which takes the arguments from the event emitter so that you can return a single object.
(Object): An object of event listener options.
(Observable): An observable sequence of events from the specified element and the specified event.
Rx.Observable.fromEvent(element, eventName, [selector], [options])
Creates an observable sequence by using the addHandler and removeHandler functions to add and remove the handlers, with an optional selector function to project the event arguments.
Creates an observable sequence by using the addHandler and removeHandler functions to add and remove the handlers, with an optional selector function to project the event arguments.
(Function): The DOMElement, NodeList or EventEmitter to attach a listener.
(Function): The optional function to remove a handler from an emitter.
(Function): A selector which takes the arguments from the event handler to produce a single item to yield on next.
(Observable): An observable sequence of events from the specified element and the specified event.
Rx.Observable.fromEventPattern(addHandler, [removeHandler], [selector])
Converts a Node.js callback style function to an observable sequence.
Converts a Node.js callback style function to an observable sequence. This must be in function (err, ...) format.
(Function): Function with a callback as the last parameter to convert to an Observable sequence.
(Any): The context for the func parameter to be executed. If not specified, defaults to undefined.
(Function): A selector which takes the arguments from callback sans the error to produce a single item to yield on next.
(Function): A function which when applied, returns an observable sequence with the callback arguments as an array if no selector given, else the object created by the selector function on success, or an error if the first parameter is not falsy.
Rx.Observable.fromNodeCallback(func, [context], [selector])
Converts a Promises/A+ spec compliant Promise and/or ES2015 compliant Promise or a factory function which returns said Promise to an Observable sequence.
Converts a Promises/A+ spec compliant Promise and/or ES2015 compliant Promise or a factory function which returns said Promise to an Observable sequence.
(Promise|Function): Promises/A+ spec compliant Promise to an Observable sequence or a function which returns a Promise.
(Observable): An Observable sequence which wraps the existing promise success and failure.
Generates an observable sequence in a manner similar to a for loop, using an optional scheduler to enumerate the values.
Generates an observable sequence in a manner similar to a for loop, using an optional scheduler to enumerate the values.
(Any): Initial state.
(Function): Condition to terminate generation (upon returning false).
(Function): Iteration step function.
(Function): Selector function for results produced in the sequence.
[scheduler=Rx.Scheduler.currentThread] (Scheduler): Scheduler on which to run the generator loop. If not provided, defaults to Scheduler.currentThread.
(Observable): The generated sequence.
Rx.Observable.generate(initialState, condition, iterate, resultSelector, [scheduler])
Generates an observable sequence by iterating a state from an initial state until the condition fails.
Generates an observable sequence by iterating a state from an initial state until the condition fails.
(Any): Initial state.
(Function): Condition to terminate generation (upon returning false).
(Function): Iteration step function.
(Function): Selector function for results produced in the sequence.
(Function): Time selector function to control the speed of values being produced each iteration, returning Date values.
[scheduler=Rx.Scheduler.timeout] (Scheduler): Scheduler on which to run the generator loop. If not provided, defaults to Scheduler.timeout.
(Observable): The generated sequence.
Rx.Observable.generateWithAbsoluteTime(initialState, condition, iterate, resultSelector, timeSelector, [scheduler])
Generates an observable sequence by iterating a state from an initial state until the condition fails.
Generates an observable sequence by iterating a state from an initial state until the condition fails.
(Any): Initial state.
(Function): Condition to terminate generation (upon returning false).
(Function): Iteration step function.
(Function): Selector function for results produced in the sequence.
(Function): Time selector function to control the speed of values being produced each iteration, returning integer values denoting milliseconds.
[scheduler=Rx.Scheduler.timeout] (Scheduler): Scheduler on which to run the generator loop. If not provided, defaults to Scheduler.timeout.
(Observable): The generated sequence.
Determines whether an observable collection contains values.
Determines whether an observable collection contains values. There is an alias for this method called ifThen for browsers < IE9
(Function): The condition which determines if the thenSource or elseSource will be run.
(Observable): thenSource The observable sequence that will be run if the condition function returns true.
(Observable|Scheduler): The observable sequence that will be run if the condition function returns false. If this is not provided, it defaults to Rx.Observabe.Empty with the specified scheduler.
(Observable): The generated sequence.
Rx.Observable.if(condition, thenSource, [elseSource])
Returns an observable sequence that produces a value after each period.
Returns an observable sequence that produces a value after each period.
(Number): Period for producing the values in the resulting sequence (specified as an integer denoting milliseconds).
Scheduler=Rx.Scheduler.timeout): Scheduler to run the timer on. If not specified, Rx.Scheduler.timeout is used.
(Observable): An observable sequence that produces a value after each period. Each value produced will default to a Number denoting its order in the timeline. (e.g. 0, 1, 2...)
Rx.Observable.interval(period, [scheduler])
Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages.
Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages.
There is an alias called returnValue for browsers < IE9 and a regular alias called just.
(Any): Single element in the resulting observable sequence.
[scheduler=Rx.Scheduler.immediate] (Scheduler): Scheduler to send the single element on. If not specified, defaults to Scheduler.immediate.
(Observable): An observable sequence with the single element.
Rx.Observable.just(value, [scheduler])
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/return.md
Merges all the observable sequences and Promises into a single observable sequence.
Merges all the observable sequences and Promises into a single observable sequence.
(Array|arguments): Observable sequences to merge into a single sequence.
(Observable): An observable sequence that produces a value after each period.
Rx.Observable.merge([scheduler], ...args)
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/merge.md
Merges all the observable sequences and Promises into a single observable sequence.
Merges all the observable sequences and Promises into a single observable sequence.
(Scheduler=Rx.Scheduler.immediate): Scheduler to run the timer on. If not specified, Rx.Scheduler.immediate is used.
(Array|arguments): Observable sequences to merge into a single sequence.
(Observable): An observable sequence that produces a value after each period.
Rx.Observable.merge([scheduler], ...args)
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/merge.md
Flattens an Observable that emits Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
Flattens an Observable that emits Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
This behaves like Observable.prototype.mergeAll except that if any of the merged Observables notify of an error via the Observer's onError, mergeDelayError will refrain from propagating that error notification until all of the merged Observables have finished emitting items.
(Array|arguments): Arguments or an array of Observable sequences to merge.
(Observable): An Observable that emits all of the items emitted by the Observables emitted by the Observable
Rx.Observable.mergeDelayError(...args)
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/mergedelayerror.md
Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g.
Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins).
(Observable): An observable sequence whose observers will never get called.
Rx.Observable.never()
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/never.md
Converts arguments to an observable sequence.
Converts arguments to an observable sequence.
(Arguments): A list of arguments to turn into an Observable sequence.
(Observable): The observable sequence whose elements are pulled from the given arguments.
Rx.Observable.of(...args)
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/of.md
Converts arguments to an observable sequence.
Converts arguments to an observable sequence.
(Arguments): A list of arguments to turn into an Observable sequence.
(Observable): The observable sequence whose elements are pulled from the given arguments.
Rx.Observable.of(...args)
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/of.md
Converts arguments to an observable sequence, using an optional scheduler to enumerate the arguments.
Converts arguments to an observable sequence, using an optional scheduler to enumerate the arguments.
(Arguments): A list of arguments to turn into an Observable sequence.
(Observable): The observable sequence whose elements are pulled from the given arguments.
Rx.Observable.ofWithScheduler([scheduler], ...args)
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/ofwithscheduler.md
Converts arguments to an observable sequence, using an optional scheduler to enumerate the arguments.
Converts arguments to an observable sequence, using an optional scheduler to enumerate the arguments.
(Scheduler): An optional scheduler used to enumerate the arguments.
(Arguments): A list of arguments to turn into an Observable sequence.
(Observable): The observable sequence whose elements are pulled from the given arguments.
Rx.Observable.ofWithScheduler([scheduler], ...args)
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/ofwithscheduler.md
Continues an observable sequence that is terminated normally or by an exception with the next observable sequence or Promise.
Continues an observable sequence that is terminated normally or by an exception with the next observable sequence or Promise.
(Array|arguments): Observable sequences to concatenate.
(Observable): An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.
Rx.Observable.onErrorResumeNext(...args)
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/onerrorresumenext.md
Convert an object into an observable sequence of [key, value] pairs using an optional Scheduler to enumerate the object.
Convert an object into an observable sequence of [key, value] pairs using an optional Scheduler to enumerate the object.
(Object): The object to inspect and turn into an Observable sequence.
(Scheduler): Scheduler to run the enumeration of the input sequence on. If not specified, defaults to Rx.Scheduler.currentThread
(Observable): An observable sequence of [key, value] pairs from the object.
Rx.Observable.pairs(obj, [scheduler])
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/pairs.md
Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages.
Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages.
(Number): The value of the first integer in the sequence.
(Number): The number of sequential integers to generate.
[scheduler=Rx.Scheduler.currentThread] (Scheduler): Scheduler to run the generator loop on. If not specified, defaults to Scheduler.currentThread.
(Observable): An observable sequence that contains a range of sequential integral numbers.
Rx.Observable.range(start, count, [scheduler])
Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages.
Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages.
(Any): Element to repeat.
[repeatCount=-1] (Number):Number of times to repeat the element. If not specified, repeats indefinitely.
[scheduler=Rx.Scheduler.immediate] (Scheduler): Scheduler to run the producer loop on. If not specified, defaults to Scheduler.immediate.
(Observable): An observable sequence that repeats the given element the specified number of times.
Rx.Observable.repeat(value, [repeatCount], [scheduler])
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/repeat.md
Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages.
Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages.
There is an alias called returnValue for browsers < IE9 and a regular alias called just.
(Any): Single element in the resulting observable sequence.
[scheduler=Rx.Scheduler.immediate] (Scheduler): Scheduler to send the single element on. If not specified, defaults to Scheduler.immediate.
(Observable): An observable sequence with the single element.
Rx.Observable.return(value, [scheduler])
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/return.md
Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single onError message.
Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single onError message.
the given exception
[scheduler=Rx.Scheduler.immediate] (Scheduler): Scheduler to send the exceptional termination call on. If not specified, defaults to the immediate scheduler.
(Observable): The observable sequence that terminates exceptionally with the specified exception object.
Rx.Observable.throw(exception, [scheduler])
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/throw.md
Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single onError message.
Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single onError message.
the given exception
[scheduler=Rx.Scheduler.immediate] (Scheduler): Scheduler to send the exceptional termination call on. If not specified, defaults to the immediate scheduler.
(Observable): The observable sequence that terminates exceptionally with the specified exception object.
Rx.Observable.throwError(exception, [scheduler])
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/throw.md
Returns an observable sequence that produces a value after dueTime has elapsed and then after each period.
Returns an observable sequence that produces a value after dueTime has elapsed and then after each period. Note for rx.lite.js, only relative time is supported.
(Date|Number): Absolute (specified as a Date object) or relative time (specified as an integer denoting milliseconds) at which to produce the first value.
[period|scheduler=Rx.Scheduler.timeout] (Number|Scheduler): Period to produce subsequent values (specified as an integer denoting milliseconds), or the scheduler to run the timer on. If not specified, the resulting timer is not recurring.
[scheduler=Rx.Scheduler.timeout] (Scheduler): Scheduler to run the timer on. If not specified, the timeout scheduler is used.
(Observable): An observable sequence that produces a value after due time has elapsed and then each period.
Rx.Observable.timer(dueTime, [period], [scheduler])
Converts the function into an asynchronous function.
Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.
(Function): Function to convert to an asynchronous function.
(Any): The context for the func parameter to be executed. If not specified, defaults to undefined.
[scheduler=Rx.Scheduler.timeout] (Scheduler): Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
(Function): Asynchronous function.
Rx.Observable.toAsync(func, [context], [scheduler])
Merges the specified observable sequences or Promises into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.
Merges the specified observable sequences or Promises into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.
(Arguments | Array): Arguments or an array of observable sequences.
(Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function.
Rx.Observable.prototype.zip(...args, [resultSelector])
Merges the specified observable sequences or Promises into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.
Merges the specified observable sequences or Promises into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.
(Arguments | Array): Arguments or an array of observable sequences.
(Function): A function which takes the inputs at the specified index and combines them together. If omitted, a list with the elements of the observable sequences at corresponding indexes will be yielded.
(Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function.
Rx.Observable.prototype.zip(...args, [resultSelector])
Converts an array to an observable sequence, using an optional scheduler to enumerate the array.
Converts an array to an observable sequence, using an optional scheduler to enumerate the array.
(Array): An array to convert to an Observable sequence.
[scheduler=Rx.Scheduler.currentThread] (Scheduler): Scheduler to run the enumeration of the input sequence on.
(Observable): The observable sequence whose elements are pulled from the given enumerable sequence.
(Since version 4.0) Use Rx.Observable.from instead
Rx.Observable.fromArray(array, [scheduler])
Determines whether an observable collection contains values.
Determines whether an observable collection contains values. There is an alias for this method called ifThen for browsers < IE9
(Function): The condition which determines if the thenSource or elseSource will be run.
(Observable): thenSource The observable sequence that will be run if the condition function returns true.
(Observable|Scheduler): The observable sequence that will be run if the condition function returns false. If this is not provided, it defaults to Rx.Observabe.Empty with the specified scheduler.
(Observable): The generated sequence.
(Since version 4.0) Use Rx.Observable.if instead
Rx.Observable.ifThen(condition, thenSource, [elseSource])
Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single onError message.
Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single onError message.
the given exception
[scheduler=Rx.Scheduler.immediate] (Scheduler): Scheduler to send the exceptional termination call on. If not specified, defaults to the immediate scheduler.
(Observable): The observable sequence that terminates exceptionally with the specified exception object.
(Since version 4.0) Use RX.Observable.throwError instead
Rx.Observable.throwException(exception, [scheduler])
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/throw.md