Que operadores para trabalhar com fluxos conhece…

Os operadores para trabalhar com fluxos de dados, especialmente relevantes no contexto de programação assíncrona e bibliotecas reactivas (como RxJS), podem ser divididos em várias categorias.

Operadores de criação (Creation Operators): Utilizados para criar um novo fluxo de dados.

of(): Cria um fluxo que emite um conjunto fixo de valores.

// Do RxJS
import { of } from 'rxjs';

const source = of(1, 2, 3); // Fluxo que emite 1, 2, 3

from(): Converte várias fontes de dados (Promise, Iterable, ArrayLike) em um fluxo.

// Do RxJS
import { from } from 'rxjs';

const source = from([10, 20, 30]); // Fluxo a partir de um array

interval(): Cria um fluxo que emite números sequenciais em intervalos de tempo definidos.

// Do RxJS
import { interval } from 'rxjs';

const source = interval(1000); // Fluxo que emite números a cada segundo

timer(): Cria um fluxo que emite um valor após um tempo definido, opcionalmente com valores subsequentes em intervalos.
fromEvent(): Cria um fluxo a partir de eventos DOM ou EventEmitter.

Operadores de transformação (Transformation Operators): Modificam os valores emitidos pelo fluxo.

map(): Transforma cada valor emitido aplicando uma função.

// Do RxJS
import { of } from 'rxjs';
import { map } from 'rxjs/operators';

const source = of(1, 2, 3);
const result = source.pipe(map(x => x * 2)); // Fluxo com valores 2, 4, 6

pluck(): Extrai uma propriedade de cada objeto emitido.
scan(): Aplica uma função de acumulação a cada valor do fluxo e emite os resultados intermediários.

mergeMap() / flatMap(): Projeta cada valor do fluxo original em um novo fluxo (Observable interno) e os combina em um único fluxo de saída. Permite realizar operações assíncronas para cada valor.

// Do RxJS
import { of } from 'rxjs';
import { mergeMap } from 'rxjs/operators';

const source = of(1, 2);
const result = source.pipe(mergeMap(val => of(val + 'a', val + 'b'))); // Fluxo com valores '1a', '1b', '2a', '2b'

switchMap(): Semelhante a mergeMap, mas ao emitir um novo valor, cancela a assinatura ao fluxo interno anterior. Útil para autocompletar ou solicitações com cancelamento.
concatMap(): Semelhante a mergeMap, mas garante que os fluxos internos sejam executados em sequência.

Operadores de filtragem (Filtering Operators): Permitem passar seletivamente valores emitidos.

filter(): Apenas passa valores que satisfazem uma condição.

// Do RxJS
import { of } from 'rxjs';
import { filter } from 'rxjs/operators';

const source = of(1, 2, 3, 4);
const result = source.pipe(filter(x => x % 2 === 0)); // Fluxo com valores 2, 4

take(): Apenas pega os primeiros N valores.
takeUntil(): Pega valores até que outro fluxo emita.
skip(): Ignora os N primeiros valores.
debounceTime(): Emite um valor apenas após o fluxo ficar inativo por um tempo definido. Útil para evitar ações muito frequentes.
distinctUntilChanged(): Emite um valor apenas se for diferente do anterior.

Operadores de combinação (Combination Operators): Combinam vários fluxos em um.

combineLatest(): Combina os últimos valores de vários fluxos, emitindo um array com esses últimos valores toda vez que um deles muda.
zip(): Combina valores de vários fluxos em um array por índice.
merge(): Mescla vários fluxos, emitindo seus valores assim que chegam.
concat(): Executa vários fluxos em sequência.

Operadores de tratamento de erros (Error Handling Operators): Definem o comportamento em caso de erro.

catchError(): Captura um erro e permite continuar ou substituir o fluxo.

// Do RxJS
import { throwError } from 'rxjs';
import { catchError, of } from 'rxjs/operators';

const source = throwError(() => new Error('Algo deu errado'));
const result = source.pipe(catchError(err => of('Erro capturado'))); // Fluxo com valor 'Erro capturado'

retry(): Tenta novamente a assinatura N vezes em caso de erro.

Operadores de término (Completion Operators): Definem ações ao terminar o fluxo.

finalize(): Executa uma ação ao finalizar ou cancelar.
tap(): Permite efeitos colaterais sem modificar os valores.

Esta não é uma lista exaustiva, mas cobre os operadores mais importantes frequentemente utilizados em desenvolvimento frontend, especialmente com programação reativa.

Que operadores para trabalhar com fluxos conhece?