111 lines
4.9 KiB
JavaScript
111 lines
4.9 KiB
JavaScript
/** PURE_IMPORTS_START .._util_isScheduler,._of,._from,.._operators_concatAll PURE_IMPORTS_END */
|
|
import { isScheduler } from '../util/isScheduler';
|
|
import { of } from './of';
|
|
import { from } from './from';
|
|
import { concatAll } from '../operators/concatAll';
|
|
/* tslint:enable:max-line-length */
|
|
/**
|
|
* Creates an output Observable which sequentially emits all values from given
|
|
* Observable and then moves on to the next.
|
|
*
|
|
* <span class="informal">Concatenates multiple Observables together by
|
|
* sequentially emitting their values, one Observable after the other.</span>
|
|
*
|
|
* <img src="./img/concat.png" width="100%">
|
|
*
|
|
* `concat` joins multiple Observables together, by subscribing to them one at a time and
|
|
* merging their results into the output Observable. You can pass either an array of
|
|
* Observables, or put them directly as arguments. Passing an empty array will result
|
|
* in Observable that completes immediately.
|
|
*
|
|
* `concat` will subscribe to first input Observable and emit all its values, without
|
|
* changing or affecting them in any way. When that Observable completes, it will
|
|
* subscribe to then next Observable passed and, again, emit its values. This will be
|
|
* repeated, until the operator runs out of Observables. When last input Observable completes,
|
|
* `concat` will complete as well. At any given moment only one Observable passed to operator
|
|
* emits values. If you would like to emit values from passed Observables concurrently, check out
|
|
* {@link merge} instead, especially with optional `concurrent` parameter. As a matter of fact,
|
|
* `concat` is an equivalent of `merge` operator with `concurrent` parameter set to `1`.
|
|
*
|
|
* Note that if some input Observable never completes, `concat` will also never complete
|
|
* and Observables following the one that did not complete will never be subscribed. On the other
|
|
* hand, if some Observable simply completes immediately after it is subscribed, it will be
|
|
* invisible for `concat`, which will just move on to the next Observable.
|
|
*
|
|
* If any Observable in chain errors, instead of passing control to the next Observable,
|
|
* `concat` will error immediately as well. Observables that would be subscribed after
|
|
* the one that emitted error, never will.
|
|
*
|
|
* If you pass to `concat` the same Observable many times, its stream of values
|
|
* will be "replayed" on every subscription, which means you can repeat given Observable
|
|
* as many times as you like. If passing the same Observable to `concat` 1000 times becomes tedious,
|
|
* you can always use {@link repeat}.
|
|
*
|
|
* @example <caption>Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10</caption>
|
|
* var timer = Rx.Observable.interval(1000).take(4);
|
|
* var sequence = Rx.Observable.range(1, 10);
|
|
* var result = Rx.Observable.concat(timer, sequence);
|
|
* result.subscribe(x => console.log(x));
|
|
*
|
|
* // results in:
|
|
* // 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10
|
|
*
|
|
*
|
|
* @example <caption>Concatenate an array of 3 Observables</caption>
|
|
* var timer1 = Rx.Observable.interval(1000).take(10);
|
|
* var timer2 = Rx.Observable.interval(2000).take(6);
|
|
* var timer3 = Rx.Observable.interval(500).take(10);
|
|
* var result = Rx.Observable.concat([timer1, timer2, timer3]); // note that array is passed
|
|
* result.subscribe(x => console.log(x));
|
|
*
|
|
* // results in the following:
|
|
* // (Prints to console sequentially)
|
|
* // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9
|
|
* // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5
|
|
* // -500ms-> 0 -500ms-> 1 -500ms-> ... 9
|
|
*
|
|
*
|
|
* @example <caption>Concatenate the same Observable to repeat it</caption>
|
|
* const timer = Rx.Observable.interval(1000).take(2);
|
|
*
|
|
* Rx.Observable.concat(timer, timer) // concating the same Observable!
|
|
* .subscribe(
|
|
* value => console.log(value),
|
|
* err => {},
|
|
* () => console.log('...and it is done!')
|
|
* );
|
|
*
|
|
* // Logs:
|
|
* // 0 after 1s
|
|
* // 1 after 2s
|
|
* // 0 after 3s
|
|
* // 1 after 4s
|
|
* // "...and it is done!" also after 4s
|
|
*
|
|
* @see {@link concatAll}
|
|
* @see {@link concatMap}
|
|
* @see {@link concatMapTo}
|
|
*
|
|
* @param {ObservableInput} input1 An input Observable to concatenate with others.
|
|
* @param {ObservableInput} input2 An input Observable to concatenate with others.
|
|
* More than one input Observables may be given as argument.
|
|
* @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each
|
|
* Observable subscription on.
|
|
* @return {Observable} All values of each passed Observable merged into a
|
|
* single Observable, in order, in serial fashion.
|
|
* @static true
|
|
* @name concat
|
|
* @owner Observable
|
|
*/
|
|
export function concat() {
|
|
var observables = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
observables[_i - 0] = arguments[_i];
|
|
}
|
|
if (observables.length === 1 || (observables.length === 2 && isScheduler(observables[1]))) {
|
|
return from(observables[0]);
|
|
}
|
|
return concatAll()(of.apply(void 0, observables));
|
|
}
|
|
//# sourceMappingURL=concat.js.map
|