javascript - descargar - Observable finalmente en Suscribirse

void(0) javascript href

Question

De acuerdo con este artículo , las funciones onComplete y onError de la subscribe son mutuamente excluyentes.

onError onComplete eventos onError o onComplete se activarán en mi subscribe .
Tengo un bloque lógico que debe ejecutarse si recibo un error o si termino mi flujo de información con éxito.

Busqué algo como finally en Python , pero todo lo que encontré es finally que debe adjuntarse al observable que creo.

Pero quiero hacer esa lógica solo cuando me suscribo, y después de que la transmisión haya finalizado, ya sea con éxito o con un error.

¿Algunas ideas?

Answer 1

Ahora estoy usando RxJS 5.5.7 en una aplicación angular y el uso del operador de finalize tiene un comportamiento extraño para mi caso de uso, ya que se dispara antes de las devoluciones de llamada de éxito o error.

Ejemplo simple:

// Simulate an AJAX callback...
of(null)
  .pipe(
    delay(2000),
    finalize(() => {
      // Do some work after complete...
      console.log(''Finalize method executed before "Data available" (or error thrown)'');
    })
  )
  .subscribe(
      response => {
        console.log(''Data available.'');
      },
      err => {
        console.error(err);
      }
  );

He tenido que usar el add medhod en la suscripción para lograr lo que quiero. Básicamente, una devolución de llamada finally después de que se realicen las devoluciones de llamada de éxito o error. Como un try..catch..finally block o Promise.finally .

Ejemplo simple:

// Simulate an AJAX callback...
of(null)
  .pipe(
    delay(2000)
  )
  .subscribe(
      response => {
        console.log(''Data available.'');
      },
      err => {
        console.error(err);
      }
  );
  .add(() => {
    // Do some work after complete...
    console.log(''At this point the success or error callbacks has been completed.'');
  });

Answer 2

La variante actual "pipable" de este operador se llama finalize() (desde RxJS 6). El operador "parche" anterior y ahora en desuso fue llamado finally() (hasta RxJS 5.5).

Creo que el operador finalize() es realmente correcto. Tu dices:

hacer esa lógica solo cuando me suscribo, y después de que la transmisión ha finalizado

lo cual no es un problema, creo. Puede tener una sola source y usar finalize() antes de suscribirse si lo desea. De esta manera, no es obligatorio que use siempre finalize() :

let source = new Observable(observer => {
  observer.next(1);
  observer.error(''error message'');
  observer.next(3);
  observer.complete();
}).pipe(
  publish(),
);

source.pipe(
  finalize(() => console.log(''Finally callback'')),
).subscribe(
  value => console.log(''#1 Next:'', value),
  error => console.log(''#1 Error:'', error),
  () => console.log(''#1 Complete'')
);

source.subscribe(
  value => console.log(''#2 Next:'', value),
  error => console.log(''#2 Error:'', error),
  () => console.log(''#2 Complete'')
);

source.connect();

Esto imprime a la consola:

#1 Next: 1
#2 Next: 1
#1 Error: error message
Finally callback
#2 Error: error message

Enero de 2019: actualizado para RxJS 6

Answer 3

Lo único que funcionó para mí es esto

fetchData()
  .subscribe(
    (data) => {
       //Called when success
     },
    (error) => {
       //Called when error
    }
  ).add(() => {
       //Called when operation is complete (both success and error)
  });