Let say I have a component in Angular 2 that needs to load 2 different things from the server before the page is displayed. I'd like all of those things to fire off and call one event handler when they come back telling the page isLoaded = true. Let's say I have a service class that looks like this.
export class MyService {
getStronglyTypedData1(): Observable<StrongData1[]>{
return this.http.get('http://...').map((response:Response) => <StrongData1[]>response.json());
}
getStronglyTypedData2(): Observable<StrongData2[]>{
return this.http.get('http://...').map((response:Response) => <StrongData2[]>response.json());
}
}
Then I have a component that uses that service class like this.
export class MyComponent implements OnInit {
isLoaded = false;
stronglyTypedData1: StrongData1[];
stronglyTypedData2: StrongData2[];
constructor(private myService:MyService){ }
ngOnInit(){
var requests [
this.myService.getStronglyTypedData1(),
this.myService.getStronglyTypedData2()
];
Observable.forkJoin(requests).subscribe(
results => {
this.stronglyTypedData1 = results[0];
this.stronglyTypedData2 = results[1];
this.isLoaded = true;
});
}
}
The TypeScript compiler is complaining that it cant convert type object to type StrongData1[]. If I change StrongData1 and StrongData2 to "any", everything works fine. I'd rather not do that though because I'm losing the benefit of TypeScript's strong typings.
How do I cast the results from forkJoin to their respective types?
Returns. Accepts an Array of ObservableInput or a dictionary Object of ObservableInput and returns an Observable that emits either an array of values in the exact same order as the passed array, or a dictionary of values in the same shape as the passed dictionary.
ForkJoin. This operator is best used when you have a group of observables and only care about the final emitted value of each. It means that forkJoin allows us to group multiple observables and execute them in parallel, then return only one observable.
The RxJS forkJoin() operator is a join operator that accepts an Array of ObservableInput or a dictionary Object of ObservableInput and returns an Observableand then waits for the Observables to complete and then combine last values they emitted.
The forkJoin will subscribe to the passed observables, by making the HTTP GET requests. If any input observable errors at some point, forkJoin will find the error as well and all other observables will be immediately unsubscribed.
for me it always works when i add the requests directly to the Observable.forkJoin and then use es6 destructing for the result array.
so your code could look like this
Observable
.forkJoin(this.myService.getStronglyTypedData1(), this.myService.getStronglyTypedData2())
.subscribe(
([typeData1, typeData2]) => {
this.stronglyTypedData1 = typeData1;
this.stronglyTypedData2 = typeData2;
this.isLoaded = true;
}
);
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With