Zdravo svima. Ovde je Omel'nitskiy Sergey. Nedavno sam vodio prenos uživo o reaktivnom programiranju, gde sam govorio o asinhronosti u JavaScriptu. Danas bih želeo da sažmem ovaj materijal.

Ali pre nego što počnemo sa glavnim sadržajem, moramo napraviti uvod. Dakle, hajde da počnemo sa definicijama: šta je stek i šta je red?
Stek je kolekcija čiji se elementi dobijaju po principu „poslednji došao, prvi otišao“ LIFO.
Red je kolekcija čiji se elementi dobijaju po principu („prvi došao, prvi otišao“) FIFO.
U redu, nastavljamo.

JavaScript je jednonitni programski jezik. To znači da ima samo jedan tok izvršenja i jedan stek, u koji se funkcije stavljaju u red za izvršenje. Shodno tome, u jednom trenutku JavaScript može izvršiti samo jednu operaciju, dok ostale operacije čekaju svoj red u steku dok ih ne pozovu.
Stek poziva je struktura podataka koja, pojednostavljeno, beleži informacije o mestu u programu gde se nalazimo. Kada ulazimo u funkciju, stavljamo zabeleženi podatak o njoj na vrh steka. Kada se vraćamo iz funkcije, uzimamo najgornji element iz steka i vraćamo se na mesto odakle smo pozvali tu funkciju. To je sve što stek zna raditi. A sada jedno veoma zanimljivo pitanje. Kako to onda funkcioniše asinhronost u JavaScriptu?

U stvarnosti, pored steka, u pregledačima postoji posebna red za rad sa takozvanim WebAPI-jem. Funkcije iz ovog reda će se izvršavati po redu tek nakon što se stek potpuno očisti. Tek tada se premeštaju iz reda u stek za izvršenje. Ako se u steku trenutno nalazi makar jedan element, ne mogu se prebaciti u stek. Upravo zbog toga pozivi funkcija sa vremenskim odlaganjem često nisu tačni, jer funkcija ne može ući iz reda u stek dok je on pun.
Razmotrićemo sledeći primer i baviti se njegovim korak-po-korak „izvršavanjem“. Takođe ćemo pogledati šta se tada dešava u sistemu.
console.log('Hi);
setTimeout(function cb1() {
console.log('cb1');
}, 5000);
console.log('Bye');
1) Dok se ništa ne dešava. Konzola pregledača je prazna, stek poziva je prazan.

2) Zatim se komanda console.log('Hi') dodaje u stek poziva.

3) I ona se izvršava.

4) Potom se console.log('Hi') uklanja iz steka poziva.

5) Sada prelazimo na komandu setTimeout(function cb1() {… }). Ona se dodaje u stek poziva.

6) Komanda setTimeout(function cb1() {… }) se izvršava. Pregledač kreira tajmer koji je deo Web API-a. On će izvršiti odbrojavanje.

7) Komanda setTimeout(function cb1() {… }) je završila rad i uklanja se iz steka poziva.

8) Komanda console.log(‘Bye’) se dodaje u stek poziva.

9) Komanda console.log(‘Bye’) se izvršava.

10) Komanda console.log(‘Bye’) se uklanja iz steka poziva.

11) Nakon što prođe barem 5000 ms, tajmer završava rad i stavlja kolbek cb1 u red kolbeka.

12) Ciklus događaja uzima funkciju cb1 iz reda kolbeka i stavlja je u stek poziva.

13) Funkcija cb1 se izvršava i dodaje console.log(‘cb1’) u stek poziva.

14) Komanda console.log(‘cb1’) se izvršava.

15) Komanda console.log(‘cb1’) se uklanja iz steka poziva.

16) Funkcija cb1 se uklanja iz steka poziva.
Pogledajmo primer u dinamici:

Pa, sada smo razmotrili kako je asinhronost realizovana u JavaScript-u. Sada da kratko razgovaramo o evoluciji asinhronog koda.
Evolucija asinhronog koda.
a(function (resultsFromA) {
b(resultsFromA, function (resultsFromB) {
c(resultsFromB, function (resultsFromC) {
d(resultsFromC, function (resultsFromD) {
e(resultsFromD, function (resultsFromE) {
f(resultsFromE, function (resultsFromF) {
console.log(resultsFromF);
})
})
})
})
})
});Asinhrono programiranje kakvo poznajemo u JavaScript-u može se realizovati samo funkcijama. One mogu biti prosleđene kao bilo koja druga promenljiva drugim funkcijama. Tako su nastali kolbekovi. I to je sjajno, zabavno i veselo, dok se ne pretvori u tugu i jad. Zašto? Zato što:
- Kako složenost koda raste, projekat se brzo pretvara u teško razumljive višestruko ugnježdene blokove — 'callback hell'.
- Obrada grešaka se lako može izostaviti.
- Nije moguće vraćati izraze sa return.
Sa pojavom Promise-a situacija je postala malo bolja.
new Promise(function(resolve, reject) {
setTimeout(() => resolve(1), 2000);
}).then((result) => {
alert(result);
return result + 2;
}).then((result) => {
throw new Error('FAILED HERE');
alert(result);
return result + 2;
}).then((result) => {
alert(result);
return result + 2;
}).catch((e) => {
console.log('error: ', e);
});- Pojavile su se lančane promese, što je poboljšalo čitljivost koda.
- Pojavio se poseban metod za hvatanje grešaka.
- Pojavila se mogućnost paralelnog izvršavanja pomoću Promise.all.
- Ugnijevanje asinkronosti možemo riješiti pomoću async/await
Ali obećanje ima svoja ograničenja. Na primjer, obećanje se ne može prekinuti bez dodatnog truda, a što je najvažnije — radi sa jednom vrijednošću.
I tako smo polako došli do reaktivnog programiranja. Umorni ste? Pa dobro, možete otići skuhati čaj, razmisliti i vratiti se da nastavite čitati. A ja ću nastaviti.

Reaktivno programiranje— paradigme programiranja usmjerene na tokove podataka i širenje promjena. Pogledajmo detaljnije što je to tok podataka.
// Получаем ссылку на элемент
const input = ducument.querySelector('input');
const eventsArray = [];
// Пушим каждое событие в массив eventsArray
input.addEventListener('keyup',
event => eventsArray.push(event)
);Zamislimo da imamo odjeljak za unos. Kreiramo niz, a na svaki keyup događaj unosa, sačuvat ćemo događaj u našem nizu. Pri tome treba naglasiti da je naš niz sortiran prema vremenu — tj. indeks novijih događaja je veći od indeksa starijih. Takav niz predstavlja pojednostavljeni model toka podataka, ali to još nije tok. Da bi se ovaj niz mogao smatrati tokom, mora na neki način obavijestiti pretplatnike da su novi podaci stigli. Tako smo došli do definicije toka.
Tok podataka
const { interval1 } = Rx;
const { take } = RxOperators;
interval(1000).pipe(
take(4)
)
Tok— to je niz podataka sortiranih prema vremenu, koji može obavijestiti kada su se podaci promijenili. A sada zamislite koliko praktično postaje pisati kod u kojem će jedno djelovanje zahtijevati pozivanje nekoliko događaja na različitim mjestima u kodu. Samo se pretplatimo na tok i on će nam sam javiti kada se dogode promjene. I to je ono što biblioteka RxJs može.

RxJS — to je biblioteka za rad sa asinkronim i događajima temeljenim programima koristeći promatranje sekvenci. Biblioteka nudi osnovni tip Observable, nekoliko pomoćnih tipova (Observer, Schedulers, Subjects) i operatore rada sa događajima kao kolekcijama (map, filter, reduce, every i slični iz JavaScript niza).
Pogledajmo osnovne pojmove ove biblioteke.
Observable, Observer, Producer
Observable — prvi osnovni tip kojeg ćemo istražiti. Ova klasa sadrži osnovni dio implementacije RxJs. Ona je povezana s promatranim tokom, na koji se može pretplatiti pomoću metode subscribe.
U Observable je implementiran pomoćni mehanizam za kreiranje ažuriranja, tako zvani Observer. Izvor vrednosti za Observer naziva se Producer. To može biti niz, iteracija, web socket, neki događaj itd. Tako da se može reći da je observable posrednik između Producer i Observer.
Observable obrađuje tri vrste događaja Observer:
- next – nove podatke
- error – grešku, ako sekvenca završi zbog izuzetka. Ovo događanje takođe implicira završetak sekvence.
- complete — signal o završetku sekvence. To znači da više neće biti novih podataka.
Pogledajmo demo:

Na početku ćemo obraditi vrednosti 1, 2, 3, a nakon 1 sekunde dobićemo 4 i završiti naš tok.
Misli naglas
I tada sam shvatio da je pričati zanimljivije nego pisati o tome. 😀
Subscription
Kada se pretplatimo na tok, kreiramo novu klasu subscription, koja nam omogućava da otkažemo pretplatu putem metode unsubscribe. Takođe možemo grupisati pretplate putem metode add. Takođe, logistično je da možemo razgrupisati tokove putem ukloni. Metode add i remove primaju drugu pretplatu kao argument. Voleo bih da napomenem da kada se odjavimo, odjavljujemo se od svih pod-pretplata kao da smo za njih pozvali metodu unsubscribe. Idemo dalje.
Vrste tokova
| HOT | COLD |
|---|---|
| Producer se kreira van observable-a | Producer se kreira unutar observable-a |
| Podaci se prenose u trenutku kreiranja observable-a | Podaci se saopštavaju u trenutku pretplate |
| Potrebna je dodatna logika za odjavu | Tok se završava samostalno |
| Koristi vezu jedan-prema-mnogima | Koristi vezu jedan-prema-jednom |
| Sve pretplate imaju jedinstvenu vrednost | Pretplate su nezavisne |
| Podaci se mogu izgubiti ako nema pretplate | Ponovno izbacuje sve vrednosti toka za novu pretplatu |
Ako bismo povukli analogiju, predstavio bih vrući tok kao film u bioskopu. U kojoj god trenutku si došao, odatle si počeo gledanje. Hladni tok bih uporedio sa telefonskim pozivom u tehničku podršku. Svako ko pozove sluša snimak automatskog odgovarača od početka do kraja, ali možeš prekinuti poziv putem unsubscribe.
Želeo bih da napomenem da postoje i takozvani topli tokovi (ovu definiciju sam retko viđao i samo u stranim zajednicama) — to je tok koji se transformiše iz hladnog u vruć. Postavlja se pitanje — gde ga koristiti?)) Dajući primer iz prakse.
Radim sa Angular-om. On aktivno koristi RxJS. Za dobijanje podataka sa servera očekujem hladni tok i taj tok koristim u šablonu putem asyncPipe-a. Ako koristim ovu cev više puta, vraćajući se na definiciju hladnog toka, svaka cev će zatražiti podatke sa servera, što je blago rečeno čudno. A ako transformišem hladni tok u topli, zahtev će biti poslat samo jednom.
Uopšte, razumevanje vrsta tokova je prilično teško za početnike, ali je važno.
Operatori
return this.http.get(`${environment.apiUrl}/${this.apiUrl}/trade_companies`)
.pipe(
tap(({ data }: TradeCompanyList) => this.companies$$.next(cloneDeep(data))),
map(({ data }: TradeCompanyList) => data)
);Operatori nam proširuju mogućnosti rada sa tokovima. Pomažu da kontrolišemo događaje koji se dešavaju u Observable-u. Razmotrićemo nekoliko najpopularnijih, a detaljno o operatorima možete pročitati u vezama u korisnim informacijama.
Operatori — of
Počnimo s pomoćnim operatorom of. On kreira Observable na osnovu jednostavne vrednosti.

Operatori — filter

Operator filtriranja filter, kako se može razumeti iz naziva, filtrira signal toka. Ako operator vrati istinu, propušta dalje.
Operatori — take

take — Prima vrednost količine emitovanih, nakon čega završava tok.
Operatori — debounceTime

debounceTime — odbacuje emitovane vrednosti koje ulaze u određeni vremenski interval između izlaznih podataka — nakon isteka vremenskog intervuala emituje poslednju vrednost.
const { Observable } = Rx;
const { debounceTime, take } = RxOperators;
Observable.create((observer) => {
let i = 1;
observer.next(i++);
// Emitujemo vrednost jednom u 1000ms
setInterval(() => {
observer.next(i++)
}, 1000);
// Emitujemo vrednost jednom u 1500ms
setInterval(() => {
observer.next(i++)
}, 1500);
}).pipe(
debounceTime(700), // Čekamo 700ms pre obrade vrednosti
take(3)
); 
Operatori — takeWhile

Emituje vrednosti dok takeWhile ne vrati false, nakon čega se odjavljuje od toka.
const { Observable } = Rx;
const { debounceTime, takeWhile } = RxOperators;
Observable.create((observer) => {
let i = 1;
observer.next(i++);
// Ispušta vrijednost svake 1000ms
setInterval(() => {
observer.next(i++)
}, 1000);
}).pipe(
takeWhile(producer => producer < 5)
); 
Operateri — combineLatest
Kombinovani operator combineLatest je slično kao promise.all. Spaja više tokova u jedan. Nakon što svaki tok emitira barem jednom, dobijamo posljednje vrijednosti od svakog u obliku niza. Nadalje, nakon bilo kojeg emitovanja iz spojeni tokova će vraćati nove vrijednosti.

const { combineLatest, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Ispušta vrijednost svake 1000ms
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
});
const observer_2 = Observable.create((observer) => {
let i = 1;
// Ispušta vrijednost svake 750ms
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
});
combineLatest(observer_1, observer_2).pipe(take(5));
Operateri — zip
Zip čeka vrijednost iz svakog toka i formira niz na osnovu tih vrijednosti. Ako ne dođe vrijednost iz bilo kojeg toka, grupa neće biti formirana.

const { zip, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Ispušta vrijednost svake 1000ms
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
});
const observer_2 = Observable.create((observer) => {
let i = 1;
// Ispušta vrijednost svake 750ms
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
});
const observer_3 = Observable.create((observer) => {
let i = 1;
// Ispušta vrijednost svake 500ms
setInterval(() => {
observer.next('c: ' + i++);
}, 500);
});
zip(observer_1, observer_2, observer_3).pipe(take(5));
Operateri — forkJoin
forkJoin također spaja tokove, ali emitira vrijednost samo kada su svi tokovi završeni (complete).

const { forkJoin, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Ispušta vrijednost svake 1000ms
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
}).pipe(take(3));
const observer_2 = Observable.create((observer) => {
let i = 1;
// Ispušta vrijednost svake 750ms
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
}).pipe(take(5));
const observer_3 = Observable.create((observer) => {
let i = 1;
// Ispušta vrijednost svake 500ms
setInterval(() => {
observer.next('c: ' + i++);
}, 500);
}).pipe(take(4));
forkJoin(observer_1, observer_2, observer_3);
Operateri — map
Transformacijski operator map pretvara emitovanu vrijednost u novu.

const { Observable } = Rx;
const { take, map } = RxOperators;
Observable.create((observer) => {
let i = 1;
// Ispušta vrijednost svake 1000ms
setInterval(() => {
observer.next(i++);
}, 1000);
}).pipe(
map(x => x * 10),
take(3)
);

Operateri – share, tap
Operator tap omogućava da se izvrše side efekti, tj. radnje koje ne utiču na redosled.
Utility operator share može pretvoriti hladan tok u topao.

Završili smo sa operatorima. Pređimo na Subject.
Misli naglas
I onda sam otišao da pijem čaj. Ovi primeri su me umorili 😀
Porodica subject-a
Porodica subject-a je sjajan primer toplih tokova. Ove klase su neka vrsta hibrida, koje istovremeno funkcionišu i kao observable i kao observer. Pošto je subject topao tok, potrebno je od njega otkazati pretplatu. Osnovne metode su:
- next – prenosi nove podatke u tok
- error – greška i završetak toka
- complete – završetak toka
- subscribe – pretplati se na tok
- unsubscribe – otkaži pretplatu na tok
- asObservable – transformišemo u posmatrača
- toPromise – transformiše u promise
Prepoznajemo 4–5 vrsta subject-a.
Misli naglas
Na stream-u sam rekao 4, a ispostavlja se da su dodali još jedan. Kao što kažu, vek živi, vek uči.
Običan Subject new Subject()– najjednostavnija vrsta subject-a. Stvara se bez parametara. Prenosi vrednosti koje su stigle samo nakon pretplate.
BehaviorSubject new BehaviorSubject(defaultData) – po mom mišljenju, najrasprostranjenija vrsta subject-a. Prihvatama početnu vrednost. Uvek čuva podatke poslednjeg emitovanja, koje šalje prilikom pretplate. Ova klasa takođe ima koristan metod value, koji vraća trenutnu vrednost toka.
ReplaySubject new ReplaySubject(bufferSize?: number, windowTime?: number) – može opcionalno da primi kao prvi argument veličinu bafera vrednosti koje će čuvati, a kao drugi vreme tokom kojeg su nam potrebne promene.
AsyncSubject new AsyncSubject() – prilikom pretplate se ništa ne dešava, i vrednost će biti vraćena samo pri complete. Vraćaće se samo poslednja vrednost toka.
WebSocketSubject new WebSocketSubject(urlConfigOrSource: string | WebSocketSubjectConfig | Observable, destination?: Observer) – o njemu dokumentacija ćuti i prvi put ga vidim. Ako neko zna šta radi, pišite da dopunimo.
Uf. Tako, razmotrili smo sve što sam želeo da podelim danas. Nadam se da su informacije bile korisne. Samostalno se možete upoznati sa listom literature na kartici korisne informacije.
Korisne informacije
- – link na stream
- – Kako funkcioniše JS: pregled engine-a, mehanizama izvršavanja, steka poziva
- — Kako funkcioniše JS: petlje događaja, asinhronost i pet načina za poboljšanje koda koristeći async / await
- — Kako funkcioniše Event Loop u JavaScriptu
- — Evolucija asinhronog JavaScripta
- — Šta je RxJS i zašto je korisno znati o njemu
- — Praktična primena RxJS-a
- — RxJS Observables Tutorial — Kreiranje & Pretplata na Observables
- — RXJS: Vrući i Hladni Observables
- — Klase, funkcije za kreiranje Observable. Operatori.
- — RxJS Operatori po Primeru
- — API Lista
- — Vrste Subject-a i raspored u RxJS-u
Izvor: habr.com
