Kādus operatorus jūs zināt darbam ar plūsmām…

Datu plūsmas ar operētāji, kas īpaši aktuāli asinhronās programmēšanas un reakcīvo bibliotēku (piemēram, RxJS) kontekstā, var tikt iedalīti vairākās kategorijās:

Izveides operatori (Creation Operators): tiek izmantoti jauna plūsmas izveidei:

of(): izveido plūsmu, kas emitē noteiktu vērtību kopumu:

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

const source = of(1, 2, 3); // Plūsma, kas emitē 1, 2, 3

from(): pārvērš dažādus avotus (Promise, Iterable, ArrayLike) plūsmā:

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

const source = from([10, 20, 30]); // Masīva plūsma

interval(): izveido plūsmu, kas emitē secīgas skaitļus noteiktā laika intervālā:

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

const source = interval(1000); // Plūsma, kas emitē skaitļus katru sekundi

timer(): izveido plūsmu, kas emitē vienu vērtību pēc noteikta laika, iespējams, arī sekvences vērtības intervālos:
fromEvent(): izveido plūsmu no DOM notikumiem vai EventEmitter:

Transformācijas operatori (Transformation Operators): maina plūsmā emitētās vērtības:

map(): pārveido katru vērtību, izmantojot norādīto funkciju:

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

const source = of(1, 2, 3);
const result = source.pipe(map(x => x * 2)); // Plūsma, kas emitē 2, 4, 6

pluck(): izvelk īpašību no katra objekta plūsmā:
scan(): izmanto akumulācijas funkciju un emitē starpposma rezultātus:

mergeMap() / flatMap(): katru vērtību pārvērš par jaunu plūsmu un apvieno tās:

// No 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'))); // Plūsma, kas emitē '1a', '1b', '2a', '2b'

switchMap(): jauna vērtība emitējot, iepriekšējais plūsma tiek pārtraukta:
concatMap(): veic plūsmas secīgi:

Filtra operatori (Filtering Operators): atlasa vērtības:

filter(): ļauj tikai tām vērtībām, kas atbilst nosacījumam:

// No 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)); // Emitē 2, 4

take(): ļauj tikai pirmajām N vērtībām:
takeUntil(): emitē kamēr cita plūsma emitē vērtību:
skip(): izlaida pirmajās N vērtības:
debounceTime(): emitē tikai pēc tam, kad plūsma ir pārtraukusi mainīties noteiktā laikā:
distinctUntilChanged(): emitē tikai tad, ja vērtība atšķiras no iepriekšējās:

Kombinācijas operatori (Combination Operators): apvieno vairākas plūsmas:

combineLatest(): apvieno pēdējās vērtības no visām plūsmām:
zip(): apvieno vērtības pēc indeksa:
merge(): apvieno plūsmas, emitējot vērtības pēc to rašanās laika:
concat(): veic plūsmas secīgi:

Kļūdu apstrādes operatori (Error Handling Operators): pārvalda kļūdas:

catchError(): noķer kļūdu un var turpināt vai aizstāt ar citu plūsmu:

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

const source = throwError(() => new Error('Kaut kas nogāja greizi'));
const result = source.pipe(catchError(err => of('Kļūda noķerta'))); // Plūsma, kas emitē 'Kļūda noķerta'

retry(): mēģina atkārtoti pieslēgties plūsmai N reižu kļūdas gadījumā:

Pabeigšanas operatori (Completion Operators): nosaka, ko darīt, kad plūsma beidzas:

finalize(): veic norādīto darbību pabeigšanas vai atcelšanas laikā:
tap(): ļauj veikt blakus efektus (piemēram, reģistrāciju):

Šis operatoru saraksts nav pilnīgs, bet tas ir pietiekami svarīgs un bieži lietots Frontend izstrādē, īpaši izmantojot reakcīvo pieeju.

Kādus operatorus jūs zināt darbam ar plūsmām?