The problem is that we convert observable into different type… with .subscribe – while we should not (it does not return observable) public makeRequest = (): Observable<any> => { return this.myObservable().subscribe( … // this is wrong, we cannot return .subscribe // because it consumes observable and returns ISusbcriber ); } When we have an observable… … Read more
it should be: getProjectByName(name: String) { return this.projects .map(projects => projects.filter(proj => proj.name === name)); } you misunderstood about filter operator. The operator using to filter data return from stream. Your stream return array of object, so you need filter array to get you needed value. The solution above will return an array after filtered, … Read more
As mentioned in comments, you are looking for the flatMap operator. You can find more details in previous answers : How to do the chain sequence in rxjs Why do we need to use flatMap? Your example would read as : this.returnsObservable1(…) .flatMap(success => this.returnsObservable2(…)) .flatMap(success => this.returnsObservable3(…)) .subscribe(success => {(…)});
The error There are multiple modules with names that only differ in casing. is indicating the wrong import is being targeted with how you are trying to use Observable. The import should be with a capital “O” like: import { Observable } from ‘rxjs/Observable’; This will import the individual Observable operator, which be used in … Read more
I think that your problem is located here: getRisks(): Observable<RiskListSummary[]> { return this.http.get(this.serviceUrl) .map(this.extractData()) <== passing result of function .catch(this.handleError()); <== passing result of function } You could use just passing function reference: getRisks(): Observable<RiskListSummary[]> { return this.http.get(this.serviceUrl) .map(this.extractData) .catch(this.handleError); } but this way you will lose this. Or you could use bind method to … Read more
shareReplay() is basically publishReplay().refCount() Definitely not. Both shareReplay and publishReplay (+ calling connect on it) will make the observable behind it hot. But the very important difference between them is: shareReplay: won’t stop emitting until it’s completed, no matter if there are no subscriptions anymore or not. publishReplay: will stop after the last subscriber unsubscribes … Read more
The method in TypeScript (or JavaScript for that matter) is called of. Learn rxjs has a nice tutorial as well If you are using rxjs6 you get everything from rxjs import { Observable, of } from ‘rxjs’; public getPlants(): Observable<Plant[]> { const mocked: Plant[] = [ { id: 1, image: ‘hello.png’ } ]; // returns … Read more
Actually, it was as easy as pairing pairwise() with startWith() operators: subject .startWith(null) // emitting first empty value to fill-in the buffer .pairwise() .subscribe([previousValue, currentValue] => { if (null === previousValue) { console.log(‘Probably first emission…’); } }) ;
I’m going to describe the difference between them in terms of their Time versions as that’s how I understand them best. Both auditTime and debounceTime will initially start a timer when an event comes in. Both will wait the given amount of time before they emit an event. The difference is that debounceTime resets the … Read more
I think there’s one key misunderstanding: You either have someone who wants “success and finally”, or “success and error” but none wants the 3 of them. This isn’t entirely true. Each Observable can send zero or more next notifications and one error or complete notification but never both. For example when making a successful HTTP … Read more