Milyen operátorokat ismersz a folyamatok kezeléséhez…

A adatfolyamokkal való munkához, különösen az aszinkron programozás és a reaktív könyvtárak (például RxJS) kontextusában releváns operátorokat több kategóriába lehet sorolni.

Létrehozó operátorok (Creation Operators): Új adatfolyam létrehozására szolgálnak.

of(): Egy olyan folyamot hoz létre, amely rögzített értékek halmazát bocsátja ki.

// RxJS-ből
import { of } from 'rxjs';

const source = of(1, 2, 3); // Olyan folyam, amely kiadja az 1, 2, 3 értékeket

from(): Különböző adatforrásokat (Promise, Iterable, ArrayLike) alakít át folyamokká.

// RxJS-ből
import { from } from 'rxjs';

const source = from([10, 20, 30]); // Tömbből származó folyam

interval(): Olyan folyamot hoz létre, amely egymást követő számokat ad ki adott időközönként.

// RxJS-ből
import { interval } from 'rxjs';

const source = interval(1000); // Olyan folyam, amely másodpercenként ad ki számokat

timer(): Egy értéket ad ki egy adott idő után, opcionálisan későbbi értékekkel intervallumon keresztül.
fromEvent(): DOM eseményekből vagy EventEmitterből hoz létre folyamot.

Átalakító operátorok (Transformation Operators): Megváltoztatják a folyam által kibocsátott értékeket.

map(): Minden kibocsátott értéken alkalmaz egy függvényt.

// RxJS-ből
import { of } from 'rxjs';
import { map } from 'rxjs/operators';

const source = of(1, 2, 3);
const result = source.pipe(map(x => x * 2)); // 2, 4, 6 értékű folyam

pluck(): Kiválaszt egy tulajdonságot minden kibocsátott objektumból.
scan(): Akkumulátor függvényt alkalmaz minden értéken, és közbenső eredményeket ad ki.

mergeMap() / flatMap(): Minden eredeti értéket egy új folyamra vetít, és egyesíti azokat.

// RxJS-ből
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'))); // '1a', '1b', '2a', '2b' értékekkel

switchMap(): Hasonló a mergeMap-hez, de az előző belső folyamot leállítja, amikor új érték érkezik.
concatMap(): Hasonló a mergeMap-hez, de garantálja, hogy a belső folyamok egymás után, sorrendben futnak.

Szűrő operátorok (Filtering Operators): Kiválasztott értékeket engednek át.

filter(): Csak azokat az értékeket engedi át, amelyek megfelelnek egy feltételnek.

// RxJS-ből
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)); // 2, 4 értékekkel

take(): Csak az első N értéket engedi át.
takeUntil(): Addig enged át értékeket, amíg egy másik folyam nem ad ki értéket.
skip(): Az első N értéket kihagyja.
debounceTime(): Csak akkor ad ki értéket, ha a folyam egy ideig nem ad ki új értéket.
distinctUntilChanged(): Csak akkor ad ki értéket, ha az eltér az előzőtől.

Összevonó operátorok (Combination Operators): Több folyamot egyesítenek.

combineLatest(): Minden folyam legutolsó értékét összegyűjti, és minden változáskor kibocsát.
zip(): Egymás mellé rendezi a több folyam értékeit.
merge(): Egymás mellett futtatja a folyamokat.
concat(): Sorba fűzi a folyamokat.

Hiba kezelés operátorok (Error Handling Operators): Hibák esetén viselkedést határoznak meg.

catchError(): Hibát fog el, és lehetőséget ad a folyam folytatására.

// RxJS-ből
import { throwError } from 'rxjs';
import { catchError, of } from 'rxjs/operators';

const source = throwError(() => new Error('Valami baj történt'));
const result = source.pipe(catchError(err => of('Hiba elkapva'))); // 'Hiba elkapva' értékkel

retry(): Megpróbálja újra feliratkozni a folyamra N alkalommal.

Befejező operátorok (Completion Operators): A folyam befejeződését kezelik.

finalize(): Minden esetben végrehajt egy műveletet a befejezéskor.
tap(): Oldalhatásokat végez anélkül, hogy megváltoztatná az értékeket.

Ez csak egy rövid, de fontos lista azokról az operátorokról, amelyekkel gyakran dolgoznak a Frontend fejlesztésben, különösen a reaktív megközelítés alkalmazásakor.

Milyen operátorokat ismersz a folyamatok kezeléséhez?