Código:
const main$ = of(true); const int$ = interval(2000); const notifier$ = new Subject(); main$.pipe( switchMap(() => int$.pipe( tap(() => { // some logic for when to trigger notifier notifier$.next(1); // after some intervals }), takeUntil(notifier$), )), tap(() => {// never reach here}) ).subscribe(() => { // never reach here }); En el código anterior, takeUntil detiene el interval cuando el notifier$ emite pero no llama a subscribe() nunca y nunca llega a los operadores, por ejemplo. tap() (ver código) después de takeUntil . ¿Porqué es eso? ¿Me estoy perdiendo de algo?
el operador takeUntil emite los valores emitidos por un Observable fuente que sería su Observable main$ hasta que un Observable notificador emita un valor como lo está haciendo el Sujeto notifier$ . Por lo tanto, después de que notifier$ emita un valor en la next llamada dentro de la primera iteración de su intervalo, takeUntil evita que el Observable subyacente se propague más, lo que significa que nunca se alcanzará al operador tap .
Si estuviera utilizando una implementación diferente para su notifier$ como el timer , podría observar que se llamará al operador de tap hasta que transcurra el temporizador y, por lo tanto, active el takeUntil .
const main$ = of(true); const int$ = interval(2000); const notifier$ = timer(10000); main$.pipe( switchMap(() => int$.pipe( tap(() => { // some logic for when to trigger notifier }), takeUntil(notifier$), )), tap((result) => { console.log(result) }) ).subscribe((result) => { // will be reached four times. }); }