Kombinieren von RxJS-Operatoren in einen neuen Operator unter Verwendung von TypScript

Question

Ich finde häufig, dass ich Observablen die gleiche Sequenz von Operatoren hinzufüge, z.

observable$ 
    .do(x => console.log('some text', x)) 
    .publishReplay() 
    .refCount(); 

ich nach einer Möglichkeit, diesen 3-Betreiber in einem kleinen wiederverwendbaren Operator (z .cache('some text')), dass ich kann Kette auf jede beobachtbare zu kombinieren. Wie kann ich dies in Typescript definieren, so dass ich rxjs/Observable und diesen Operator importieren kann, wie ich es mit rxjs-Operatoren mache?

Answer 1

den Operator implementieren Sie beschrieben haben, erstellen Sie eine cache.ts-Datei mit folgendem Inhalt:

import { Observable } from "rxjs/Observable"; 
import "rxjs/add/operator/do"; 
import "rxjs/add/operator/publishReplay"; 

// Compose the operator: 

function cache<T>(this: Observable<T>, text: string): Observable<T> { 
    return this 
    .do(x => console.log(text, x)) 
    .publishReplay() 
    .refCount(); 
} 

// Add the operator to the Observable prototype: 

Observable.prototype.cache = cache; 

// Extend the TypeScript interface for Observable to include the operator: 

declare module "rxjs/Observable" { 
    interface Observable<T> { 
    cache: typeof cache; 
    } 
} 

Und verbrauchen sie dies wie:

import { Observable } from "rxjs/Observable"; 
import "rxjs/add/observable/of"; 
import "./cache"; 

let cached = Observable.of(1).cache("some text"); 
cached.subscribe(x => console.log(x)); 

Answer 2

Antwort über die cartant funktioniert gut und beantwortet die Frage, die gestellt wurde (Wie kann ich das in Typescript definieren, so dass ich rxjs/Observable und diesen Operator wie ich mit rxjs Operatoren importieren konnte?)

Ich entdeckte vor kurzem die let Operator, wenn Sie nicht brauchen, tatsächlich die Funktion als Operator implementiert haben, noch lassen Sie Ihren Code vertrocknen.

Ich begann mit der Implementierung eines eckigen 2-Dienstes zur Schnittstelle mit meinem Rails-Backend und wusste, dass die meisten meiner API-Aufrufe sehr ähnlich aussehen würden, also wollte ich versuchen, so viel wie möglich in eine Funktion zu bringen.

Fast alle Anrufe in die folgenden tun:

1. Wiederholungs auf einem Fehler (meine Funktion muss weiter unten noch mehr Arbeit an dieser Front)
2. die HTTP-Antwort in eine Typoskript Karte Klasse lokal definiert (via json-typescript-mapper)
3. Griff Fehler

Hier ist ein Beispiel für meine Verwendung des let Operator meiner hTTP-Antworten durch eine gemeinsame Funktion (Hand leResponse) über den rxjs-Operator.

handleResponse<T>({klass, retries=0} :{klass:any,retries?:number }) : (source: Observable<Response>) => Observable<T> { 
    return (source: Observable<Response>) : Observable<T> => { 
     return source.retry(retries) 
      .map((res) => this.processResponse(klass,res)) 
      .catch((res) => this.handleError(res)); 
    } 
    } 

    processResponse(klass, response: Response) { 
    return deserialize(klass, response.json()); 
    } 

    handleError(res: Response) { 
    const error = new RailsBackendError(res.status, res.statusText); 
    return Observable.throw(error); 
    } 

    getUserList({page=1,perPage=30,retry=0}: { page?:number, perPage?:number, retry?:number }={}) : Observable<UserList> { 
    const requestURL = `/api/v1/users/?${this.apiTokenQueryString}&page=${page}&per_page=${perPage}`; 
    return this.http.get(requestURL).let(this.handleResponse<UserList>({klass: UserList})); 
    }