TypeScript operators.concatAll函數代碼示例

 constructorZone2.run(() => {
   const highOrder = observable1.pipe(map((v: any) => {
     expect(Zone.current.name).toEqual(constructorZone2.name);
     return of(v + 1);
   }));
   concatObservable = highOrder.pipe(concatAll());
 });

 it('should handle an Observable as the only value', () => {
   const source = of<Observable<string>>(
     of<string>('a', 'b', 'c', rxTestScheduler),
     rxTestScheduler
   );
   const result = source.pipe(concatAll());
   expectObservable(result).toBe('(abc|)');
 });

 concatMap((check: CanActivate) => {
   return from([
            fireChildActivationStart(check.route.parent, forwardEvent),
            fireActivationStart(check.route, forwardEvent),
            runCanActivateChild(futureSnapshot, check.path, moduleInjector),
            runCanActivate(futureSnapshot, check.route, moduleInjector)
          ])
       .pipe(concatAll(), first(result => {
               return result !== true;
             }, true as boolean | UrlTree));
 }),

 concatAll1() {
   // emit a value every 2 seconds
   const source = interval(2000);
   const example = source.pipe(
     // for demonstration, add 10 to and return as observable
     map(val => of(val + 10)),
     // merge values from inner observable
     concatAll()
   );
   // output: 'Example with Basic Observable 10', 'Example with Basic Observable 11'...
   const subscribe = example.subscribe(val =>
     console.log('Example with Basic Observable:', val)
   );
 }

  concatAll2() {
    // create and resolve basic promise
    const samplePromise = val => new Promise(resolve => resolve(val));
    // emit a value every 2 seconds
    const source = interval(2000);

    const example = source.pipe(
      map(val => samplePromise(val)),
      // merge values from resolved promise
      concatAll()
    );
    // output: 'Example with Promise 0', 'Example with Promise 1'...
    const subscribe = example.subscribe(val =>
      console.log('Example with Promise:', val)
    );
  }

    mergeMap((timing) => {
      log.warn("Buffer: Running garbage collector");
      const buffered = bufferingQueue.getBuffered();
      let cleanedupRanges =
        selectGCedRanges(timing.currentTime, buffered, GC_GAP_CALM);

      // more aggressive GC if we could not find any range to clean
      if (cleanedupRanges.length === 0) {
        cleanedupRanges =
          selectGCedRanges(timing.currentTime, buffered, GC_GAP_BEEFY);
      }

      log.debug("Buffer: GC cleaning", cleanedupRanges);
      return observableFrom(
        cleanedupRanges.map(({ start, end }) => bufferingQueue.removeBuffer(start, end))
      ).pipe(concatAll());
    })

  concatAll3() {
    const obs1 = interval(1000).pipe(take(5));
    const obs2 = interval(500).pipe(take(2));
    const obs3 = interval(2000).pipe(take(1));
    // emit three observables
    const source = of(obs1, obs2, obs3);
    // subscribe to each inner observable in order when previous completes
    const example = source.pipe(concatAll());
    /*
      output: 0,1,2,3,4,0,1,0
      How it works...
      Subscribes to each inner observable and emit values, when complete subscribe to next
      obs1: 0,1,2,3,4 (complete)
      obs2: 0,1 (complete)
      obs3: 0 (complete)
    */

    const subscribe = example.subscribe(val => console.log(val));
  }

export function waitForMap<A, B>(
    obj: {[k: string]: A}, fn: (k: string, a: A) => Observable<B>): Observable<{[k: string]: B}> {
  if (Object.keys(obj).length === 0) {
    return of ({});
  }

  const waitHead: Observable<B>[] = [];
  const waitTail: Observable<B>[] = [];
  const res: {[k: string]: B} = {};

  forEach(obj, (a: A, k: string) => {
    const mapped = fn(k, a).pipe(map((r: B) => res[k] = r));
    if (k === PRIMARY_OUTLET) {
      waitHead.push(mapped);
    } else {
      waitTail.push(mapped);
    }
  });

  // Closure compiler has problem with using spread operator here. So just using Array.concat.
  return of .apply(null, waitHead.concat(waitTail)).pipe(concatAll(), lastValue(), map(() => res));
}

//.........這裏部分代碼省略.........
 * @param {QueuedSourceBuffer} qSourceBuffer
 * @param {Number} position - The current position
 * @param {Number} maxBufferBehind
 * @param {Number} maxBufferAhead
 * @returns {Observable}
 */
function clearBuffer(
  qSourceBuffer : QueuedSourceBuffer<unknown>,
  position : number,
  maxBufferBehind : number,
  maxBufferAhead : number
) : Observable<never> {
  if (!isFinite(maxBufferBehind) && !isFinite(maxBufferAhead)) {
    return EMPTY;
  }

  const cleanedupRanges : Array<{
    start : number;
    end: number;
  }> = [];
  const { innerRange, outerRanges } = getInnerAndOuterTimeRanges(
    qSourceBuffer.getBuffered(),
    position
  );

  const collectBufferBehind = () => {
    if (!isFinite(maxBufferBehind)) {
      return ;
    }

    // begin from the oldest
    for (let i = 0; i < outerRanges.length; i++) {
      const outerRange = outerRanges[i];
      if (position - maxBufferBehind >= outerRange.end) {
        cleanedupRanges.push(outerRange);
      }
      else if (
        position >= outerRange.end &&
        position - maxBufferBehind > outerRange.start &&
        position - maxBufferBehind < outerRange.end
      ) {
        cleanedupRanges.push({
          start: outerRange.start,
          end: position - maxBufferBehind,
        });
      }
    }
    if (innerRange) {
      if (position - maxBufferBehind > innerRange.start) {
        cleanedupRanges.push({
          start: innerRange.start,
          end: position - maxBufferBehind,
        });
      }
    }
  };

  const collectBufferAhead = () => {
    if (!isFinite(maxBufferAhead)) {
      return ;
    }

    // begin from the oldest
    for (let i = 0; i < outerRanges.length; i++) {
      const outerRange = outerRanges[i];
      if (position + maxBufferAhead <= outerRange.start) {
        cleanedupRanges.push(outerRange);
      }
      else if (
        position <= outerRange.start &&
        position + maxBufferAhead < outerRange.end &&
        position + maxBufferAhead > outerRange.start
      ) {
        cleanedupRanges.push({
          start: position + maxBufferAhead,
          end: outerRange.end,
        });
      }
    }
    if (innerRange) {
      if (position + maxBufferAhead < innerRange.end) {
        cleanedupRanges.push({
          start: position + maxBufferAhead,
          end: innerRange.end,
        });
      }
    }
  };

  collectBufferBehind();
  collectBufferAhead();
  const clean$ = observableFrom(
    cleanedupRanges.map((range) => {
      log.debug("GC: cleaning range from SourceBuffer", range);
      return qSourceBuffer.removeBuffer(range.start, range.end);
    })
  ).pipe(concatAll(), ignoreElements());

  return clean$;
}