Aké operátory pre prácu s tokmi poznáte?

Operátory pre práce s tokmi dát, obzvlášť aktuálne v kontexte asynchrónneho programovania a reaktívnych knižníc (napríklad RxJS), možno rozdeliť do niekoľkých kategórií.

Operátory tvorby (Creation Operators): Používajú sa na vytvorenie nového dátového toku.

• of(): Vytvára tok, ktorý vydáva pevne stanovenú sadu hodnôt.

  // Z RxJS
  import { of } from 'rxjs';
  
  const source = of(1, 2, 3); // Tok, ktorý vydáva 1, 2, 3
  

• from(): Premení rôzne zdroje dát (Promise, Iterable, ArrayLike) na tok.

  // Z RxJS
  import { from } from 'rxjs';
  
  const source = from([10, 20, 30]); // Tok z poľa
  

• interval(): Vytvára tok, ktorý vydáva sekvenčné čísla v danom časovom intervale.

  // Z RxJS
  import { interval } from 'rxjs';
  
  const source = interval(1000); // Tok, ktorý vydáva čísla každú sekundu
  

• timer(): Vytvára tok, ktorý vydá jednu hodnotu po stanovenom čase, s možnosťou ďalších hodnôt v intervale.
• fromEvent(): Vytvára tok z DOM udalostí alebo EventEmitteru.

Transformačné operátory (Transformation Operators): Menia hodnoty, ktoré tok vydáva.

• map(): Prevod každej hodnoty, ktorú tok vydáva, pomocou zadané funkcie.

  // 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)); // Tok s hodnotami 2, 4, 6
  

• pluck(): Vyberá vlastnosť z každého objektu, ktorý tok vydáva.
• scan(): Aplikuje akumulátorovú funkciu na každú hodnotu a vydáva medzivýsledky.
• mergeMap() / flatMap(): Projektuje každú hodnotu pôvodného toku do nového toku (Inner Observable) a ich spája.

  // 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 pri vydaní novej hodnoty z hlavného toku, zruší predchádzajúci vnútorný tok.
• concatMap(): Podobné mergeMap, ale garantuje, že vnútorné toky budú vykonané sekvenčne podľa ich vytvorenia.

Filtračné operátory (Filtering Operators): Vyberajú hodnoty, ktoré majú prejsť.

• filter(): Propustí iba tie hodnoty, ktoré spĺňajú podmienku.

  // 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í iba prvých N hodnôt.
• takeUntil(): Propustí hodnoty, kým iný tok nevydá hodnotu.
• skip(): Preskočí prvých N hodnôt.
• debounceTime(): Vydá hodnotu až po tom, čo tok prestane vydávať hodnoty počas stanoveného času.
• distinctUntilChanged(): Vydá hodnotu iba ak sa líši od predchádzajúcej.

Kombinačné operátory (Combination Operators): Spájajú viac tokov do jedného.

• combineLatest(): Spojí posledné hodnoty z viacerých tokov a vydáva ich pri každej zmene.
• zip(): Páruje hodnoty z viacerých tokov podľa indexu.
• merge(): Spája viac tokov, vydáva ich hodnoty ako prichádzajú.
• concat(): Sekvenčne spája toky.

Operátory pre spracovanie chýb (Error Handling Operators): Určujú správanie pri chybách.

• catchError(): Zachytí chybu a umožní pokračovať alebo nahradiť tok iným.

  // Z RxJS
  import { throwError } from 'rxjs';
  import { catchError, of } from 'rxjs/operators';
  
  const source = throwError(() => new Error('Niečo sa pokazilo'));
  const result = source.pipe(catchError(err => of('Chyba zachytená'))); // Tok s hodnotou 'Chyba zachytená'
  

• retry(): Pokúsi sa znovu prihlásiť k toku N-krát pri chybe.

Operátory ukončenia (Completion Operators): Určujú správanie pri ukončení toku.

• finalize(): Vykoná zadanú akciu pri ukončení (úspešnom alebo s chybou) alebo zrušení odberu.
• tap(): Umožňuje vykonávať vedľajšie efekty (napríklad logovanie) bez zmeny hodnôt.

Toto je len stručný, ale dôležitý zoznam operátorov, s ktorými sa často pracuje vo frontendovom vývoji, najmä pri použití reaktívneho prístupu.