javascript - from - Devuelve un observable vacío

rxjs angular

Question

Se supone que la función more() devuelve un Observable desde una solicitud 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 verdadero, de lo contrario, obtengo un error en la función subscribe() 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; 

Answer 1

RxJS6 (sin paquete de compatibilidad instalado)

Ahora hay una constante EMPTY y una función empty .

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

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

Observable.empty() ya no existe.

Answer 2

Con la nueva sintaxis, por ejemplo, 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á a next en su transmisión, ¡solo se completa! Entonces, si tiene tap por ejemplo, es posible que no se activen como lo desea (consulte el ejemplo a continuación).

mientras que of({}) crea un observable y emite a continuación con un valor de {} y luego completa el observable.

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

Answer 3

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

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

Answer 4

O también puede intentar ignoreElements()

Answer 5

Para el mecanografiado, puede especificar el parámetro genérico de su observable vacío de esta manera:

import ''rxjs/add/observable/empty'' 

Observable.empty<Response>();

Answer 6

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

Answer 7

Puede devolver Observable.of (empty_variable), por ejemplo

Observable.of('''');

// or
Observable.of({});

// etc

Answer 8

Sí, hay un operador Empty

Rx.Observable.empty();

Para el mecanografiado, puede usar from :

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

Answer 9

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

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

Answer 10

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'';

Answer 11

Varias formas de crear un Observable vacío:

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

• Observable.never() : no emite eventos y nunca termina.
• Observable.empty() : emite solo complete .
• Observable.of({}) : emite tanto el next como el complete (literal de objeto vacío pasado como ejemplo).

Úselo en sus necesidades exactas)