TypeScript operators.skipUntil函數代碼示例

 skipUntil1() {
   // emit every 1s
   const source = interval(1000);
   // skip emitted values from source until inner observable emits (6s)
   const example = source.pipe(skipUntil(timer(6000)));
   // output: 5...6...7...8........
   const subscribe = example.subscribe(val => console.log(val));
 }

  it('should emit elements after a synchronous notifier emits', () => {
    const values: string[] = [];

    of('a', 'b').pipe(skipUntil(of('x'))).subscribe(
      value => values.push(value),
      err => { throw err; },
      () => expect(values).to.deep.equal(['a', 'b'])
    );
  });

  it('should unsubscribe the notifier after its first nexted value', () => {
    const source =   hot('-^-o---o---o---o---o---o---|');
    const notifier = hot('-^--------n--n--n--n--n--n-|');
    const nSubs =         '^        !';
    const expected =     '-^---------o---o---o---o---|';
    const result = source.pipe(skipUntil(notifier));

    expectObservable(result).toBe(expected);
    expectSubscriptions(notifier.subscriptions).toBe(nSubs);
  });

  asDiagram('skipUntil')('should skip values until another observable notifies', () => {
    const e1 =     hot('--a--b--c--d--e----|');
    const e1subs =     '^                  !';
    const skip =   hot('---------x------|   ');
    const skipSubs =   '^        !          ';
    const expected =  ('-----------d--e----|');

    expectObservable(e1.pipe(skipUntil(skip))).toBe(expected);
    expectSubscriptions(e1.subscriptions).toBe(e1subs);
    expectSubscriptions(skip.subscriptions).toBe(skipSubs);
  });

    store.getState().get("quittingState") === QUITTING_STATE_NOT_STARTED
  ) {
    e.preventDefault();
    store.dispatch(setQuittingState(QUITTING_STATE_QUITTING));

    // Trigger each windows' closeNotebookEpic. If and when all windows are closed,
    // the window-all-closed event will fire and we will complete the quit action.
    windows.forEach(win => win.close());
  }
});

const windowAllClosed = new Observable(observer => {
  app.on("window-all-closed", (event: Event) => observer.next(event));
});

windowAllClosed.pipe(skipUntil(appAndKernelSpecsReady)).subscribe(() => {
  // On macOS:
  // - If user manually closed the last window, we want to keep the app and
  //   menu bar active.
  // - If the window was closed programmatically as part of a quit, and not
  //   canceled during notebook shutdown, then we proceed w/ the quit.
  // All other platforms:
  // - Quit when last window closed.
  if (
    process.platform !== "darwin" ||
    store.getState().get("quittingState") === QUITTING_STATE_QUITTING
  ) {
    app.quit();
  }
});

it('should infer correctly', () => {
  const o = of('foo', 'bar', 'baz').pipe(skipUntil(of(4, 'RxJS', 7))); // $ExpectType Observable<string>
});

export function skipUntil<T>(this: Observable<T>, notifier: Observable<any>): Observable<T> {
  return higherOrder(notifier)(this) as Observable<T>;
}

 observable1 = constructorZone1.run(() => {
   return interval(10).pipe(skipUntil(interval(25)));
 });