Welke operators voor het werken met streams kent u…

Operatoren voor het werken met datastromen, vooral relevant in de context van asynchrone programmeren en reactieve bibliotheken (zoals RxJS), kunnen worden onderverdeeld in verschillende categorieën.

Creatie-operators (Creation Operators): Worden gebruikt om een nieuwe datastroom te creëren.

of(): Creëert een stroom die een vaste set waarden uitzendt.

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

const source = of(1, 2, 3); // Stroom die 1, 2, 3 uitzendt

from(): Zet verschillende gegevensbronnen om in een stroom (Promise, Iterable, ArrayLike).

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

const source = from([10, 20, 30]); // Stroom van een array

interval(): Creëert een stroom die opeenvolgende nummers uitzendt na een bepaalde tijd.

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

const source = interval(1000); // Stroom die elke seconde nummers uitzendt

timer(): Creëert een stroom die na een bepaalde tijd één waarde uitzendt, optioneel met vervolgwaarden op intervallen.
fromEvent(): Creëert een stroom van DOM-evenementen of EventEmitter.

Transformatie-operators (Transformation Operators): Veranderen de waarden die door de stroom worden uitgezonden.

map(): Transformeert elke waarde door een functie toe te passen.

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

const source = of(1, 2, 3);
const result = source.pipe(map(x => x * 2)); // Stroom met waarden 2, 4, 6

pluck(): Haalt een eigenschap uit elk object dat door de stroom wordt uitgezonden.
scan(): Voert een accumulatiefunctie uit op elke waarde en zendt tussentijdse resultaten uit.

mergeMap() / flatMap(): Projecteert elke waarde naar een nieuwe stroom en combineert ze. Geschikt voor asynchrone operaties.

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

switchMap(): Vergelijkbaar met mergeMap, maar annuleert de vorige interne stroom bij nieuwe emissies.
concatMap(): Zorgt dat interne stromen sequentieel worden uitgevoerd.

Filter-operators (Filtering Operators): Laten waarden door die aan een voorwaarde voldoen.

filter(): Laat alleen waarden door die voldoen aan een conditie.

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

take(): Neemt alleen de eerste N waarden.
takeUntil(): Neemt door totdat een andere stroom een waarde uitzendt.
skip(): Slaat de eerste N waarden over.
debounceTime(): Zendt een waarde uit na een periode van geen emissies.
distinctUntilChanged(): Zendt alleen waarden uit die verschillen van de vorige.

Combinatie-operators (Combination Operators): Combineert meerdere stromen.

combineLatest(): Emiteert de laatste waarden van alle stromen bij elke verandering.
zip(): Combineert waarden op basis van index.
merge(): Combineert stromen en emit ze in de volgorde van binnenkomst.
concat(): Voert stromen sequentieel uit.

Foutafhandelings-operators (Error Handling Operators): Beheren fouten.

catchError(): Vangt fouten op en kan de stroom voortzetten of vervangen.

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

const source = throwError(() => new Error('Iets ging mis'));
const result = source.pipe(catchError(err => of('Fout opgevangen'))); // Stroom met waarde 'Fout opgevangen'

retry(): Probeert opnieuw te abonneren bij fouten, N keer.

Eind-operators (Completion Operators): Bepalen gedrag bij voltooiing.

finalize(): Voert een actie uit bij voltooiing of annulering.
tap(): Voert neveneffecten uit zonder de waarden te veranderen.

Dit is geen volledige lijst, maar een belangrijke selectie operators die vaak in frontend-ontwikkeling worden gebruikt, vooral bij het gebruik van een reactieve aanpak.

Welke operators voor het werken met streams kent u?