Rxjs

auditTime: Emite el último valor emitido en un intervalo de tiempo fijo, después de un intervalo de silencio

const source = interval(1000);

source.pipe(auditTime(2000)).subscribe((value) => {
  console.log(value);
});

combineLatest: Emite valor en cualquier observable, emitiéndolos en un arreglo combinados

const source1$ = timer(1000, 2000);
const source2$ = timer(2000, 1000);

combineLatest(source1$, source2$).subscribe(([value1, value2]) => {
  console.log(value1, value2);
});
// Output: 0 0, 1 0, 1 1, 2 1, 3 1, ...

concat: Espera la solicitud anterior se complete antes de comenzar

// Ejemplo con concat
const source1 = of('A', 'B', 'C');
const source2 = of('D', 'E', 'F');
const resultConcat = concat(source1, source2);
resultConcat.subscribe(value => console.log(value));
// Salida: A, B, C, D, E, F

concatMap: Espera la solicitud anterior se complete antes de comenzar y puedes mapear la resp

const source = of(1, 2, 3);

const example = source.pipe(
  concatMap(value => of(value * 2))
);

example.subscribe(console.log); // Output: 2, 4, 6

debounceTime: Emite después del tiempo determinado

const click$ = fromEvent( document, 'click' );

click$.pipe(
	debounceTime(3000) // 3000ms = 3s
).subscribe( console.log);

distinct: Emite valores unicos

const numeros$ = of<number | string>(12,3,4,5,67,2,8,8,634,62345,23,1,11,1,12,2,'1')

numeros$.pipe(
    distinct() // === También especifica el tipado osea '1' != 1
).subscribe(console.log)

interface Personaje {
    nombre:string;
}

const personajes:Personaje[] = [
    {
        nombre: 'Zero'
    },
    {
        nombre: 'Z'
    },
    {
        nombre: 'Zero'
    },
]

from(personajes).pipe( 
    distinct(p => p.nombre) // Estara al pendiente de p.nombre
) // No repitio el nombre de Zero
.subscribe(console.log);

distinctUntilChanged: Emite solo valores distintos consecutivos, ignorando los repetidos

// Si el valor anterior no es diferente no lo emite
of(1, 1, 2, 2, 3, 1, 2, 3).pipe(
  distinctUntilChanged()
).subscribe(result => console.log(result));
// Output: 1, 2, 3, 1, 2, 3

endWith: Emite un valor al final de la secuencia de valores del Observable

const source = of(1, 2, 3);

source.pipe(endWith(4)).subscribe((value) => {
  console.log(value);
});

filter: Filtra los valores emitidos según una condición especificada

of(1, 2, 3, 4, 5).pipe(
  filter(value => value % 2 === 0)
).subscribe(result => console.log(result));
// Output: 2, 4

first: Emite el primer valor que cumple con la condición especificada

import { of } from 'rxjs';
import { first } from 'rxjs/operators';

const observable = of(1, 2, 3);

observable.pipe(first((value) => value > 1)).subscribe((value) => {
  console.log(value);
});

forkJoin: Combina múltiples observables y emite un arreglo con sus últimos valores emitidos

// forkJoin emite solo una vez que todos los observables han completado.
// combineLatest emite cada vez que se emite un valor

const observable1$ = of('Hello');
const observable2$ = of('World');
const observable3$ = of('!');

forkJoin([observable1$, observable2$, observable3$]).subscribe(result => {
  console.log(result);
});
// Output: ['Hello', 'World', '!']

from: Convierte una estructura iterable en un Observable

const array = [1, 2, 3];
const observable = from(array);

observable.subscribe((value) => {
  console.log(value);
});

map: Transforma cada valor emitido en un nuevo valor

of(1, 2, 3).pipe(
  map(value => value * 2)
).subscribe(result => console.log(result));
// Output: 2, 4, 6

mapTo: Transforma cada valor emitido en un valor constante

const observable = of(1, 2, 3);

observable.pipe(mapTo('Hola')).subscribe((value) => {
  console.log(value);
});

mergeMap: Combina múltiples observables en un solo observable secuencialmente

of('Hello', 'World').pipe(
  mergeMap(value => of(value + ' RxJS!'))
).subscribe(result => console.log(result));
// Output: Hello RxJS!, World RxJS!

retry : Reintenta la suscripción a un observable cuando se produce un error

let count = 0;

of('Hello').pipe(
  map(() => {
    if (count < 2) {
      count++;
      throw new Error('Error occurred');
    }
    return 'Success';
  }),
  retry(2)
).subscribe(result => console.log(result));
// Output: Success

sample: Emite el último valor emitido por el Observable de muestreo

import { interval, fromEvent } from 'rxjs';
import { sample } from 'rxjs/operators';

const source = interval(1000);
const click = fromEvent(document, 'click');

source.pipe(sample(click)).subscribe((value) => {
  console.log(value);
});

sampleTime: Emite el último valor emitido dentro de un intervalo de tiempo fijo

const source = interval(1000);

source.pipe(sampleTime(2000)).subscribe((value) => {
  console.log(value);
});

skip: Omite los primeros valores especificados y emite los siguientes

import { of } from 'rxjs';
import { skip } from 'rxjs/operators';

const observable = of(1, 2, 3, 4, 5);

observable.pipe(skip(2)).subscribe((value) => {
  console.log(value);
});

startWith: Emite un valor inicial antes de comenzar a emitir los valores del Observable

const source = of(1, 2, 3);

source.pipe(startWith(0)).subscribe((value) => {
  console.log(value);
});

Subscription: Permite cancelar subscripciones manualmente y acciones adicionales

const subscription: Subscription = interval(1000).subscribe((num: number) => {
  console.log(num);
});

// Cancelar la suscripción después de 5 segundos
setTimeout(() => {
  subscription.unsubscribe();
  console.log('Suscripción cancelada');
}, 5000);

switchMap: Mapea cada valor emitido a un Observable y cambia al último Observable activo

const source = of(1, 2, 3);

source.pipe(switchMap((value) => interval(value * 1000))).subscribe((value) => {
  console.log(value);
});

take: Numero de veces que va emitir el observable

import { of } from 'rxjs';
import { take } from 'rxjs/operators';

const observable = of(1, 2, 3);

observable.pipe(take(2)).subscribe((value) => {
  console.log(value);
});

takeUntil: Completa la emisión hasta que se cumple una condición específica

// Creamos un observable que emite valores cada segundo
const source = interval(1000);

// Creamos un observable que se completará después de 5 segundos
const timer$ = timer(5000);

// Utilizamos el operador takeUntil para completar el flujo de datos de source cuando timer$ emite
const example = source.pipe(takeUntil(timer$));

// Suscribimos y mostramos los valores emitidos hasta que timer$ complete
example.subscribe(value => console.log(value));

// Salida esperada:
// 0
// 1
// 2
// 3
// 4

takeWhile: Emite valores mientras se cumpla una condición, luego completa

import { of } from 'rxjs';
import { takeWhile } from 'rxjs/operators';

const observable = of(1, 2, 3, 4, 5);

observable.pipe(takeWhile((value) => value <= 3)).subscribe((value) => {
  console.log(value);
});

tap: Realiza una acción sin modificar los valores del Observable

const observable = of(1, 2, 3);
observable.pipe(tap((value) => console.log(value))).subscribe();

throttleTime: Emite el primer valor del intervalo de tiempo especificado y luego ignora los siguientes valores

const source = interval(1000);

source.pipe(throttleTime(2000)).subscribe((value) => {
  console.log(value);
});