Jaké operátory pro práci s proudy znáte?

Operátory pro práci s datovými proudy, obzvláště relevantní v kontextu asynchronního programování a reaktivních knihoven (například RxJS), lze rozdělit do několika kategorií.

Operátory tvorby (Creation Operators): Používají se k vytvoření nového datového proudu.

• of(): Vytváří proud, který vydává pevně stanovenou sadu hodnot.

  // Z RxJS
  import { of } from 'rxjs';
  
  const source = of(1, 2, 3); // Proud vydávající 1, 2, 3
  

• from(): Převádí různé zdroje dat (Promise, Iterable, ArrayLike) na proud.

  // Z RxJS
  import { from } from 'rxjs';
  
  const source = from([10, 20, 30]); // Proud z pole
  

• interval(): Vytváří proud, který vydává sekvenční čísla v daném časovém intervalu.

  // Z RxJS
  import { interval } from 'rxjs';
  
  const source = interval(1000); // Proud vydávající čísla každou sekundu
  

• timer(): Vytváří proud, který vydá jednu hodnotu po stanoveném čase, případně s následnými hodnotami v intervalu.
• fromEvent(): Vytváří proud z DOM událostí nebo EventEmitteru.

Transformační operátory (Transformation Operators): Mění hodnoty, které proud vydává.

• map(): Převádí každou hodnotu, kterou proud vydává, pomocí zadané funkce.

  // Z RxJS
  import { of } from 'rxjs';
  import { map } from 'rxjs/operators';
  
  const source = of(1, 2, 3);
  const result = source.pipe(map(x => x * 2)); // Proud s hodnotami 2, 4, 6
  

• pluck(): Vytahuje vlastnost z každého objektu vydávaného proudem.
• scan(): Aplikuje akumulátorovou funkci na každou hodnotu a vydává mezivýsledky.
• mergeMap() / flatMap(): Projektuje každou hodnotu původního proudu do nového proudu (vnitřního Observable) a slučuje je.

  // Z 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'))); // Hodnoty '1a', '1b', '2a', '2b'
  

• switchMap(): Podobné mergeMap, ale při vydání nového hodnoty z hlavního proudu zruší předchozí vnitřní proud.
• concatMap(): Podobné mergeMap, ale zaručuje sekvenční provádění vnitřních proudů.

Filtrační operátory (Filtering Operators): Vyberou hodnoty, které mají projít.

• filter(): Propustí pouze hodnoty, které splňují podmínku.

  // Z 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)); // Hodnoty 2, 4
  

• take(): Propustí pouze prvních N hodnot.
• takeUntil(): Propustí hodnoty, dokud jiný proud nevydá hodnotu.
• skip(): Přeskočí prvních N hodnot.
• debounceTime(): Vydá hodnotu až poté, co proud přestal vydávat hodnoty po stanovenou dobu.
• distinctUntilChanged(): Vydá hodnotu pouze pokud se liší od předchozí.

Kombinační operátory (Combination Operators): Spojují více proudů do jednoho.

• combineLatest(): Spojuje poslední hodnoty z více proudů a vydává je při každé změně.
• zip(): Páruje hodnoty z více proudů podle indexu.
• merge(): Spojuje hodnoty z více proudů, vydává je jak přicházejí.
• concat(): Sekvenčně spojuje proudy.

Operátory pro zpracování chyb (Error Handling Operators): Určují chování při chybách.

• catchError(): Zachytí chybu a umožní pokračovat nebo nahradit proud jiným.

  // Z RxJS
  import { throwError } from 'rxjs';
  import { catchError, of } from 'rxjs/operators';
  
  const source = throwError(() => new Error('Něco se pokazilo'));
  const result = source.pipe(catchError(err => of('Chyba zachycena'))); // Proud s hodnotou 'Chyba zachycena'
  

• retry(): Pokusí se znovu přihlásit k proudu Nkrát při chybě.

Operátory ukončení (Completion Operators): Řídí chování při ukončení proudu.

• finalize(): Vykoná zadanou akci při ukončení (úspěšném nebo s chybou) nebo zrušení předplatného.
• tap(): Umožňuje provádět vedlejší efekty (například logování) bez změny hodnot.

Toto je jen stručný, ale důležitý seznam operátorů, se kterými se často pracuje ve frontendu, zvláště při použití reaktivního přístupu.