Geben Sie ein leeres Observable zurück

Die Funktion more()soll eine Observablevon einer get-Anfrage zurückgeben

export class Collection{

    public more = (): Observable<Response> => {
       if (this.hasMore()) {

         return this.fetch();
       }
       else{
         // return empty observable
       }
    }

    private fetch = (): Observable<Response> => {
       return this.http.get('some-url').map(
          (res) => {
              return res.json();
          }
       );
    }
}

In diesem Fall kann ich eine Anfrage nur dann stellen, wenn sie hasMore()wahr ist. Andernfalls wird ein subscribe()Funktionsfehler angezeigt subscribe is not defined. Wie kann ich eine leere Observable zurückgeben?

this.collection.more().subscribe(
   (res) =>{
       console.log(res);
   },
   (err) =>{
       console.log(err);
   }
)

Aktualisieren

In RXJS 6

import { EMPTY } from 'rxjs'

return EMPTY; 

Für Typoskript können Sie generische Parameter Ihres leeren Observable wie folgt angeben:

import 'rxjs/add/observable/empty' 

Observable.empty<Response>();

Mit der neuen Syntax von RxJS 5.5+ wird dies wie folgt:

// RxJS 6
import { empty, of } from "rxjs";

// rxjs 5.5+ (<6)
import { empty } from "rxjs/observable/empty";
import { of } from "rxjs/observable/of";

empty();
of({});

Nur eine Sache, die Sie beachten sollten, empty()vervollständigt das Observable, sodass es nicht nextin Ihrem Stream ausgelöst wird , sondern nur abgeschlossen wird. Wenn Sie zum Beispiel haben tap, werden sie möglicherweise nicht wie gewünscht ausgelöst (siehe ein Beispiel unten).

Während of({})erstellt ein Observableund emittiert als nächstes mit einem Wert von {}und vervollständigt dann das Observable.

Z.B:

empty().pipe(
    tap(() => console.warn("i will not reach here, as i am complete"))
).subscribe();

of({}).pipe(
    tap(() => console.warn("i will reach here and complete"))
).subscribe();

RxJS6 (ohne Kompatibilitätspaket installiert)

Es gibt jetzt eine EMPTYKonstante und eine emptyFunktion.

  import { Observable, empty, of } from 'rxjs';

  var delay = empty().pipe(delay(1000));     
  var delay2 = EMPTY.pipe(delay(1000));

Observable.empty() existiert nicht mehr.

In meinem Fall mit Angular2 und rxjs funktionierte es mit:

import {EmptyObservable} from 'rxjs/observable/EmptyObservable';
...
return new EmptyObservable();
...

Ja, es gibt einen leeren Operator

Rx.Observable.empty();

Für Typoskript können Sie Folgendes verwenden from:

Rx.Observable<Response>.from([])

Verschiedene Möglichkeiten, um ein leeres Observable zu erstellen:

Sie unterscheiden sich nur, wie Sie es wollen weiter verwenden (welche Ereignisse es nach emittieren: next, completeoder do nothing) , zB:

• Observable.never() - gibt keine Ereignisse aus und endet nie.
• Observable.empty()- emittiert nur complete.
• Observable.of({})- gibt beide aus nextund complete(leeres Objektliteral als Beispiel übergeben).

Verwenden Sie es für Ihre genauen Bedürfnisse)

Sie können beispielsweise Observable.of (empty_variable) zurückgeben

Observable.of('');

// or
Observable.of({});

// etc

Oder Sie können versuchen , ignoreElements()als auch

RxJS 6

Sie können auch von der Funktion wie unten verwenden:

return from<string>([""]);

nach dem Import:

import {from} from 'rxjs';

Kam hier mit einer ähnlichen Frage, funktionierte das oben genannte für mich nicht in: "rxjs": "^6.0.0"um ein Observable zu generieren, das keine Daten ausgibt, die ich tun musste:

import {Observable,empty} from 'rxjs';
class ActivatedRouteStub {
  params: Observable<any> = empty();
}

Versuche dies

export class Collection{
public more (): Observable<Response> {
   if (this.hasMore()) {
     return this.fetch();
   }
   else{
     return this.returnEmpty(); 
   }            
  }
public returnEmpty(): any {
    let subscription = source.subscribe(
      function (x) {
       console.log('Next: %s', x);
    },
    function (err) {
       console.log('Error: %s', err);
    },
    function () {
       console.log('Completed');
    });
    }
  }
let source = Observable.empty();