Come fare la sequenza della catena in rxjs

Question

Vorrei a qualcosa di simile:

this._myService.doSomething().subscribe(result => { 
    doSomething() 
}); 
.then(() => dosthelse()) 
.then(() => dosanotherthing()) 

Così Vorrei catena .then come nella promessa. Come lo farei in Rxjs?

this._myService.getLoginScreen().subscribe(result => { 
     window.location.href = MyService.LOGIN_URL; 
     /// I would like to wait for the site to load and alert something from  the url, when I do it here it alerts the old one 
    }); 
    .then (alert(anotherService.partOfTheUrl()) 


getLoginScreen() { 
    return this.http.get(myService.LOGIN_URL) 
.flatMap(result => this.changeBrowserUrl()) 
.subscribe(result => //i want to do sth when the page is loaded//); 
} 

changeBrowserUrl(): Observable<any> { 
return Observable.create(observer => { 
window.location.href = myService.LOGIN_URL; 
observer.next(); 
}); 
} 

Answer 1

Possiamo usare il metodo toPromise, che permette di convertire una sequenza Observable a una promessa.

Answer 2

L'equivalente di then per gli osservabili è flatMap. È possibile vedere alcuni esempi di utilizzo qui:

• RxJS Promise Composition (passing data)
• Why we need to use flatMap?
• RxJS sequence equvalent to promise.then()?

Per esempio, si potrebbe fare qualcosa di simile:

this._myService.doSomething() 
    .flatMap(function(x){return functionReturningObservableOrPromise(x)}) 
    .flatMap(...ad infinitum) 
    .subscribe(...final processing) 

Prestare attenzione alla i tipi di ciò che restituiscono le tue funzioni, come a catena osservabili con flatMap dovrai restituire una promessa o un osservabile.

Answer 3

Se dosthelse o dosanotherthing restituisce un valore non elaborato, l'operatore da utilizzare è map. Se è osservabile, l'operatore è flatMap (o equivalente).

Se si vuole fare qualcosa in modo imperativo. Voglio dire al di fuori della catena di elaborazione asincrona, si potrebbe sfruttare l'operatore do.

Supponendo che dosthelse restituisce un osservabile e dosanotherthing un oggetto grezzo, il codice sarebbe:

this._myService.doSomething() 
    .do(result => { 
    doSomething(); 
    }) 
    .flatMap(() => dosthelse()) 
    .map(() => dosanotherthing()); 

Si noti che se si torna al ritorno del metodo Subcribe, esso corrisponderà a un oggetto di sottoscrizione e non un osservabile. Un oggetto di abbonamento è principalmente per poter annullare l'osservabile e non può prendere parte alla catena di elaborazione asincrona.

In realtà, la maggior parte delle volte, ti iscrivi alla fine della catena.

Quindi mi sento di refactoring del codice in questo modo:

this._myService.getLoginScreen().subscribe(result => { 
    window.location.href = MyService.LOGIN_URL; 
    /// I would like to wait for the site to load and alert something from  the url, when I do it here it alerts the old one 
    alert(anotherService.partOfTheUrl() 
}); 

getLoginScreen() { 
    return this.http.get(myService.LOGIN_URL) 
    .flatMap(result => this.changeBrowserUrl()) 
    .do(result => //i want to do sth when the page is loaded//); 
} 

changeBrowserUrl(): Observable<any> { 
    return Observable.create(observer => { 
    window.location.href = myService.LOGIN_URL; 
    observer.next(); 
    }); 
}