| 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(...observables) { |
| if (observables.length === 1 || (observables.length === 2 && isScheduler(observables[1]))) { |
| return from(observables[0]); |
| } |
| return concatAll()(of(...observables)); |
| } |
| //# sourceMappingURL=concat.js.map |