Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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?

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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');

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

1) Dok se ništa ne dešava. Konzola pregledača je prazna, stek poziva je prazan.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

3) I ona se izvršava.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

16) Funkcija cb1 se uklanja iz steka poziva.

Pogledajmo primer u dinamici:

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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)
)

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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:

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

HOTCOLD
Producer se kreira van observable-aProducer se kreira unutar observable-a
Podaci se prenose u trenutku kreiranja observable-aPodaci se saopštavaju u trenutku pretplate
Potrebna je dodatna logika za odjavuTok se završava samostalno
Koristi vezu jedan-prema-mnogimaKoristi vezu jedan-prema-jednom
Sve pretplate imaju jedinstvenu vrednostPretplate su nezavisne
Podaci se mogu izgubiti ako nema pretplatePonovno 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.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

Operatori — filter

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Operatori — take

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Operatori — debounceTime

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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)
);  

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

Operatori — takeWhile

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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)
);  

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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));

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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));

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

Operateri — forkJoin

forkJoin također spaja tokove, ali emitira vrijednost samo kada su svi tokovi završeni (complete).

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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);

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

Operateri — map

Transformacijski operator map pretvara emitovanu vrijednost u novu.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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)
);

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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.

Asinhrono programiranje u JavaScriptu. ( Callback, Promise, RxJs )

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

Izvor: habr.com

Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere 🔥 Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere | ProHoster