Renvoyer un observable vide

La fonction more()est censée renvoyer un à Observablepartir d'une requête get

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();
          }
       );
    }
}

Dans ce cas, je ne peux faire une requête que si hasMore()c'est vrai, sinon j'obtiens une erreur sur la subscribe()fonction subscribe is not defined, comment puis-je retourner une observable vide?

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

Mettre à jour

Dans RXJS 6

import { EMPTY } from 'rxjs'

return EMPTY; 

Pour le typographie, vous pouvez spécifier le paramètre générique de votre observable vide comme ceci:

import 'rxjs/add/observable/empty' 

Observable.empty<Response>();

Avec la nouvelle syntaxe de RxJS 5.5+, cela devient comme suit:

// 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({});

Juste une chose à garder à l'esprit, empty()complète l'observable, donc il ne se déclenchera pas nextdans votre flux, mais se terminera seulement. Donc si vous avez, par exemple,tap ils pourraient ne pas se déclencher comme vous le souhaitez (voir un exemple ci-dessous).

Alors que of({})crée un Observableet émet ensuite avec une valeur de {}, puis il complète leObservable .

Par exemple:

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 (sans package de compatibilité installé)

Il y a maintenant une EMPTYconstante et une emptyfonction.

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

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

Observable.empty() n'existe plus.

Dans mon cas avec Angular2 et rxjs, cela fonctionnait avec:

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

Oui, il y a un opérateur vide

Rx.Observable.empty();

Pour dactylographié, vous pouvez utiliser from:

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

Plusieurs façons de créer un observable vide:

Ils diffèrent seulement sur la façon dont vous allez utiliser davantage (quels événements il émettra après: next, completeou do nothing) , par exemple:

• Observable.never() - n'émet aucun événement et ne se termine jamais.
• Observable.empty()- émet uniquement complete.
• Observable.of({})- émet à la fois nextet complete(littéral d'objet vide passé comme exemple).

Utilisez-le sur vos besoins exacts)

Vous pouvez renvoyer Observable.of (empty_variable), par exemple

Observable.of('');

// or
Observable.of({});

// etc

Ou tu peux ignoreElements()aussi essayer

RxJS 6

vous pouvez également utiliser une fonction comme ci-dessous:

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

après l'importation:

import {from} from 'rxjs';

Je suis venu ici avec une question similaire, ce qui précède n'a pas fonctionné pour moi dans:, "rxjs": "^6.0.0"afin de générer un observable qui n'émet aucune donnée que je devais faire:

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

Essaye ça

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();