rxjs5

tl;dr: Basically I want to marry Angular's ngOnDestroy with the Rxjs takeUntil() operator. -- is that possible? I have an Angular component that opens several Rxjs subscriptions. These need to be closed when the component is destroyed. A simple solution for this would be: class myComponent { private subscriptionA; private subscriptionB; private subscriptionC; constructor( private serviceA: ServiceA, private serviceB: ServiceB, private serviceC: ServiceC) {} ngOnInit() { this.subscriptionA = this.serviceA.subscribe(...); this.subscriptionB = this.serviceB.subscribe(...); this.subscriptionC =

I wonder, if there is any difference in performance between using .take(1) and .unsubscribe when unsubscribe is used right after the subscription: var observable = Rx.Observable.interval(100); First: var subscription = observable.subscribe(function(value) { console.log(value); }).unsubscribe(); Second: var subscription = observable.take(1).subscribe(function(value) { console.log(value); }); Any ideas of it makes any different regard the performance? Each serves a different purpose so it's hard to compare them. In general if you take this source: const source = range(1,3); ... and consume it

After release of Angular 2 RC.5 there was introduced router resolve. Here demonstrated example with Promise, how to do the same if I make request to server with Observable? search.service.ts ... searchFields(id: number) { return this.http.get(`http://url.to.api/${id}`).map(res => res.json()); } ... search-resolve.service.ts import { Injectable } from '@angular/core'; import { Router, Resolve, ActivatedRouteSnapshot } from '@angular/router'; import { Observable } from 'rxjs/Observable'; import { SearchService } from '../shared'; @Injectable() export class SearchResolveService implements Resolve

I am wondering what is the use of asObservable : As per docs: An observable sequence that hides the identity of the source sequence. But why would you need to hide the sequence? When you don't want to leak the "observer-side" of a Subject out of your API. (Basically to prevent leaky abstraction). var myAPI = { getData: () => { var subject = new Subject(); var source = new SomeWeirdDataSource(); source.onMessage = (data) => subject.next({ type: 'message', data }); source.onOtherMessage = (data) => subject.next({ type: 'othermessage', data }); return subject.asObservable(); } }; Now when someone