Devuelve un observable vacío

Se more()supone que la función devuelve una Observablesolicitud 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();
          }
       );
    }
}

En este caso, solo puedo hacer una solicitud si hasMore()es verdadera, de lo contrario, obtengo un error en la subscribe()función subscribe is not defined, ¿cómo puedo devolver un observable vacío?

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

Actualizar

En RXJS 6

import { EMPTY } from 'rxjs'

return EMPTY; 

Para el mecanografiado puede especificar el parámetro genérico de su observable vacío como este:

import 'rxjs/add/observable/empty' 

Observable.empty<Response>();

Con la nueva sintaxis de RxJS 5.5+, esto se convierte en lo siguiente:

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

Solo una cosa a tener en cuenta, empty()completa lo observable, por lo que no se activará nexten su transmisión, sino que solo se completará. Entonces, si tiene, por ejemplo, tapes posible que no se activen como desee (vea un ejemplo a continuación).

Mientras que of({})crea un Observabley emite a continuación con un valor de {}y luego completa elObservable .

P.ej:

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 (sin paquete de compatibilidad instalado)

Ahora hay una EMPTYconstante y una emptyfunción.

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

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

Observable.empty() ya no existe

En mi caso con Angular2 y rxjs, funcionó con:

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

Sí, hay un operador vacío

Rx.Observable.empty();

Para el mecanografiado, puede usar from:

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

Varias formas de crear un Observable vacío:

Simplemente difieren en cómo lo va a usar más (qué eventos emitirá después de next, completeo do nothing) por ejemplo:

• Observable.never() - No emite eventos y nunca termina.
• Observable.empty()- solo emite complete.
• Observable.of({})- emite ambos nexty complete(objeto literal literal pasado como ejemplo).

Úselo en sus necesidades exactas)

Puede devolver Observable.of (empty_variable), por ejemplo

Observable.of('');

// or
Observable.of({});

// etc

O puedes intentarlo ignoreElements()también

RxJS 6

puede usar también desde la función como a continuación:

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

después de la importación:

import {from} from 'rxjs';

Vine aquí con una pregunta similar, lo anterior no funcionó para mí: "rxjs": "^6.0.0"para generar un observable que no emita ningún dato que deba hacer:

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

Prueba esto

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