TypeScript rxjs.Subject類代碼示例

describe('TaskManagerService', () => {
  let taskManagerService: TaskManagerService;
  let called: boolean;

  const summaryDataSource = new Subject();
  const fakeService = {
    summaryData$: summaryDataSource.asObservable()
  };

  const summary = {
    executing_tasks: [],
    health_status: 'HEALTH_OK',
    mgr_id: 'x',
    rbd_mirroring: { errors: 0, warnings: 0 },
    rbd_pools: [],
    have_mon_connection: true,
    finished_tasks: [{ name: 'foo', metadata: {} }],
    filesystems: [{ id: 1, name: 'cephfs_a' }]
  };

  configureTestBed(
    {
      providers: [TaskManagerService, { provide: SummaryService, useValue: fakeService }]
    },
    true
  );

  beforeEach(() => {
    taskManagerService = TestBed.get(TaskManagerService);
    called = false;
    taskManagerService.subscribe('foo', {}, () => (called = true));
  });

  it('should be created', () => {
    expect(taskManagerService).toBeTruthy();
  });

  it(
    'should subscribe and be notified when task is finished',
    fakeAsync(() => {
      expect(taskManagerService.subscriptions.length).toBe(1);
      summaryDataSource.next(summary);
      tick();
      expect(called).toEqual(true);
      expect(taskManagerService.subscriptions).toEqual([]);
    })
  );

  it(
    'should subscribe and process executing taks',
    fakeAsync(() => {
      const original_subscriptions = _.cloneDeep(taskManagerService.subscriptions);
      _.assign(summary, {
        executing_tasks: [{ name: 'foo', metadata: {} }],
        finished_tasks: []
      });
      summaryDataSource.next(summary);
      tick();
      expect(taskManagerService.subscriptions).toEqual(original_subscriptions);
    })
  );
});

	getEventObservableForType(eventType: EventType): Observable<Event> {
		return this.eventSubject.asObservable()
			.pipe(filter(event => event.eventType === eventType));
	}

    .map(val => parseInt(val, 10))
    .filter(num => !isNaN(num))
    .reduce((previous: number, current: number) => previous + current);

console.log(result);

const result$ = from(source).pipe(
    map(val => parseInt(val, 10)),
    filter(num => !isNaN(num)),
    reduce((previous: number, current: number) => previous + current));

result$.subscribe(res => console.log(res));


/*** Subjects **/
const subject = new RxJS.Subject();

subject.subscribe({
    next: (v) => console.log('observerA: ', v)
});
subject.subscribe({
    next: (v) => console.log('observerB: ', v)
});

subject.next(1);
subject.next(2);


const subjectAsObserver = new RxJS.Subject();

subjectAsObserver.subscribe(v1 => console.log('ObserverA: ', v1));

import { Subject, ConnectableObservable } from "rxjs";
import { tap, share, publish } from "rxjs/operators";

// A Subject is a Multicast / Hot Observable...
// But beware of the .pipe()! it will make it unicast / cold again!

let idx = 0;
const s$ = new Subject<number>();
// the pipe() operator make the subject Cold
const o$ = s$.pipe(
    tap(() => console.log("tap: " + ++idx)),
    // publish() // <- use the publish() operator to make it hot!
) // as ConnectableObservable<number>;

s$.next(1);
s$.next(2);

// o$.connect();

o$.subscribe(data => console.log("subscriber 1: " + data));
o$.subscribe(data => console.log("subscriber 2: " + data));

s$.next(3);
s$.next(4);

// Output: (without publish())
//
// tap: 1          (the side effect is executed for each message for each subscriber)
// subscriber 1: 3
// tap: 2
// subscriber 2: 3

 setImageIndex(app: PreviewDataApp, index: number) {
     if (app) {
         appImage.setImageIndex(app.images, this.appImages, index);
         this.previewDataChanged.next();
     }
 }

 clearPreviewData() {
     this.previewData = undefined;
     this.clearImageCache(true);
     this.previewVariables.numberOfListItems = 0;
     this.previewDataChanged.next();
 }

 /**
  * On destroy
  */
 ngOnDestroy(): void
 {
     // Unsubscribe from all subscriptions
     this._unsubscribeAll.next();
     this._unsubscribeAll.complete();
 }

 imageLoader.onload = () => {
     image.loadStatus = 'done';
     this.previewDataChanged.next();
 };

 subscribe( onNext: StreamCallback ): Subscription  {
     return this.stream.subscribe( onNext );
 }

	// ---
	// PUBLIC METHODS.
	// ---

	// I push the given event onto the message bus.
	public emit( event: any ) : void {

		this.eventStream.next( event );

	}