Tere kĂ”igile. Siin on Omelnitski Sergei. Hiljuti viisin lĂ€bi voogedastuse reaktiivprogrammeerimise kohta, kus rÀÀkisin asĂŒnkroonsusest JavaScriptis. TĂ€na tahaksin selle materjali kokku vĂ”tta.

Kuid enne, kui alustame pÔhiteemat, peame tegema sissejuhatuse. Niisiis, alustame mÀÀratlemisest: mis on virn ja jÀrjekord?
Virn on kogum, mille elemendid saavad pÔhinedes "viimane sisse, first out" LIFO
JÀrjekord on kogum, mille elemendid saavad pÔhinedes "esimene sisse, esimene vÀlja" FIFO
Selge, jÀtkame.

JavaScript on ĂŒhetine programmeerimiskeel. See tĂ€hendab, et seal on ainult ĂŒks teostusniit ja ĂŒks virn, kuhu funktsioonid pandakse tĂ€itmiseks jĂ€rjekorda. Seega saab JavaScript korraga teostada ainult ĂŒhte operatsiooni, teised operatsioonid peavad oma jĂ€rjekorda ootama virnas, kuni neid kutsutakse.
Kutsumisvirn on andmestruktuur, mis lihtsustatult öeldes salvestab teavet selle kohta, kus me programmis asume. Kui me liigume funktsiooni, paneme selle kirje virna ĂŒlempoolsesse ossa. Kui me funktsioonist tagasi tuleme, tĂ”mbame virnast kĂ”ige ĂŒlemise elemendi ja jĂ”uame sinna, kust seda funktsiooni kutsuti. See on kĂ”ik, mida virn suudab. NĂŒĂŒd on vĂ€ga huvitav kĂŒsimus. Kuidas siis töötab asĂŒnkroonsus JavaScriptis?

Tegelikult on peale virna brauserites olemas ka eriline jĂ€rjekord, kus töötab nn WebAPI. Funktsioonid sellest jĂ€rjekorrast tĂ€idetakse jĂ€rjestikku ainult pĂ€rast seda, kui virn on tĂ€ielikult tĂŒhjaks tehtud. Alles pĂ€rast seda paigutatakse need jĂ€rjekorrast virna tĂ€itmiseks. Kui virnas on vĂ€hemalt ĂŒks element, siis nad ei saa virna siseneda. Just seetĂ”ttu on funktsioonide kutsumine ajavahemiku jĂ€rgi tihti ajaliselt ebatĂ€pne, kuna funktsioon ei saa pÀÀseda jĂ€rjekorrast virna, kuni see on tĂ€is.
Vaatame jĂ€rgmine nĂ€ide ja tegeleme selle samm-sammult "teostamisega". Samuti uurime, mis sĂŒsteemis sellega toimub.
console.log('Hi);
setTimeout(function cb1() {
console.log('cb1');
}, 5000);
console.log('Bye');
1) Seni ei toimu midagi. Brauseri konsool on puhas, kutsumisvirn on tĂŒhi.

2) Siis lisatakse kĂ€sk console.log(âHiâ) kutsumisvirna.

3) Ja see tÀidetakse

4) SeejĂ€rel eemaldatakse console.log(âHiâ) kutsumissteigist.

5) NĂŒĂŒd liikume kĂ€su setTimeout(function cb1() {⊠}) juurde. See lisatakse kutsumissteigi.

6) KÀsk setTimeout(function cb1() {⊠}) tÀidetakse. Brauser loob taimeri, mis on osa Web API-st. See hakkab ajaloos tagasi lugema.

7) KÀsk setTimeout(function cb1() {⊠}) lÔpetab töö ja eemaldatakse kutsumissteigist.

8) KĂ€sk console.log(âByeâ) lisatakse kutsumissteigi.

9) KĂ€sk console.log(âByeâ) tĂ€idetakse.

10) KĂ€sk console.log(âByeâ) eemaldatakse kutsumissteigist.

11) PÀrast vÀhemalt 5000 ms möödumist, taimer lÔpetab töö ja paneb kolmanda argumendi cb1 tagumise jÀrjekorda.

12) Ărituste tsĂŒkkel vĂ”tab funktsiooni cb1 tagumisest jĂ€rjekorrast ja paneb selle kutsumissteigi.

13) Funktsioon cb1 tĂ€idetakse ja lisab console.log(âcb1â) kutsumissteigi.

14) KĂ€sk console.log(âcb1â) tĂ€idetakse.

15) KĂ€sk console.log(âcb1â) eemaldatakse kutsumissteigist.

16) Funktsioon cb1 eemaldatakse kutsumissteigist.
Vaadakem nĂ€idet dĂŒnaamikas:

Noh, oleme uurinud, kuidas JavaScriptis asĂŒnkroonsus töötab. NĂŒĂŒd rÀÀgime lĂŒhidalt asĂŒnkroonse koodi arengust.
AsĂŒnkroonse koodi areng.
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);
})
})
})
})
})
});AsĂŒnkroonne programmeerimine, nagu me seda JavaScripts tunneme, saab teostada ainult funktsioonidega. Need vĂ”ivad olla edastatud nagu iga teine muutuja teistele funktsioonidele. Nii sĂŒndisid tagasikutsed. Ja see on lahe, lĂ”bus ja energiline, kuni see muutub kurvaks, igavaks ja masendavaks. Miks? Lihtsalt:
- Koodi keerukuse suurenemisega muutub projekt kiiresti arusaamatuks mitmekordselt sisestatud plokkideks â "callback hell".
- Vea kÀsitlemine vÔib kergesti ununeda.
- VĂ€ljendeid ei saa tagastada return-iga.
Promises'i tulekuga paranes olukord veidi.
new Promise(function(resolve, reject) {
setTimeout(() => resolve(1), 2000);
}).then((result) => {
alert(result);
return result + 2;
}).then((result) => {
throw new Error('FAIL HERE');
alert(result);
return result + 2;
}).then((result) => {
alert(result);
return result + 2;
}).catch((e) => {
console.log('error: ', e);
});- Tekkis lubade ahel, mis parandas koodi loetavust.
- Ilmus eraldi viga pĂŒĂŒdmise meetod.
- Ilmnes paralleelse tÀitmise vÔimalus Promise.all abil
- Sisemise asĂŒnkroonsuse saame lahendada async/await abil
Kuid lubadusel on oma piirangud. NĂ€iteks lubadust ei saa tĂŒhistada ilma eriliste pingutusteta, ja mis veelgi olulisem - see töötab ĂŒhe vÀÀrtusega.
Noh, oleme sujuvalt jĂ”udnud reaktiivse programmeerimise juurde. Kas olete vĂ€sinud? Ănneks on vĂ”imalik minna tee keetmiseks, mĂ”elda ja naasta lugema edasi. Aga mina jĂ€tkan.

Reaktiivne programmeerimineâ programmiskeem, mis keskendub andmevoogudele ja muutuste levitamisele. Vaatame lĂ€hemalt, mis on andmevoog.
// ĐĐŸĐ»ŃŃĐ°Đ”ĐŒ ŃŃŃĐ»ĐșŃ ĐœĐ° ŃĐ»Đ”ĐŒĐ”ĐœŃ
const input = ducument.querySelector('input');
const eventsArray = [];
// ĐŃŃĐžĐŒ ĐșĐ°Đ¶ĐŽĐŸĐ” ŃĐŸĐ±ŃŃОД ĐČ ĐŒĐ°ŃŃĐžĐČ eventsArray
input.addEventListener('keyup',
event => eventsArray.push(event)
);Kujutame ette, et meil on sisestusvĂ€li. Loome massiivi ja salvestame iga input'i keyup sĂŒndmuse meie massiivi. Samuti tahan mĂ€rkida, et meie massiiv on jĂ€rjestatud ajaliselt, st hilisemate sĂŒndmuste indeks on suurem kui varasemate indeks. Selline massiiv esindab lihtsustatud andmevoogu, kuid see pole veel voog. Et seda massiivi saaks julgesti nimetada vooguks, peab see suutma mingil viisil teavitada tellijaid, et sinna on tulnud uusi andmeid. Seega jĂ”udsime andmevoo mÀÀratlemiseni.
Andmevoog
const { interval1 } = Rx;
const { take } = RxOperators;
interval(1000).pipe(
take(4)
)
Voogâ on ajaliselt jĂ€rjestatud andmemassiiv, mis vĂ”ib teavitada andmete muudatustest. Kujutage nĂŒĂŒd ette, kui mugav on kirjutada koodi, kus ĂŒhe tegevuse jaoks tuleb kutsuda mitu sĂŒndmust erinevates koodilĂ”ikudes. Me lihtsalt tellime voogu ja see teavitab meid automaatselt, kui muudatused toimuvad. Ja seda suudab RxJs teek.

RxJS â on teek asĂŒnkroonsete ja sĂŒndmustel pĂ”hinevate programmide jaoks, kasutades jĂ€lgitavaid jĂ€rjestusi. Teek pakub pĂ”hityĂŒpi Observable, mitu abistavat tĂŒĂŒpi (Observer, Schedulers, Subjects) ja sĂŒndmuste töötlemise operaatorid nagu kogumite puhul (map, filter, reduce, every ja sarnased JavaScripti massiivist).
Vaatame pÔhikontseptsioone, mis selles teegis on.
Observable, Observer, Producer
Observable on esimene pÔhiklass, millega me tutvume. See klass sisaldab RxJs rakenduse pÔhijÔudu. See on seotud jÀlgitava vooguga, millele saab registreeruda meetodi subscribe kaudu.
Observable'is on rakendatud abimehhanism vĂ€rskenduste loomiseks, nii öeldakse Observer. KĂ”iki Observer'i vÀÀrtusi,tootjat nimetatakse Producer. See vĂ”ib olla massiiv, iteratsioon, web soket, mingi sĂŒndmus jne. Seega vĂ”ib öelda, et observable on vahendaja Producer'i ja Observer'i vahel.
Observable töötleb kolme tĂŒĂŒpi ĂŒritusi Observer'ile:
- next â uued andmed
- error â viga, kui jada lĂ”ppes erandi tĂ”ttu. see sĂŒndmus eeldab ka jada lĂ”petamist.
- complete â signaal jada lĂ”petamiseks. See tĂ€hendab, et uusi andmeid enam ei tule.
Vaadakem demo:

Alustame vÀÀrtuste 1, 2, 3 töötlemisest, ja pÀrast 1 sekundit saame 4 ning lÔpetame meie voolu.
MÔtisklen
Ja siis mĂ”istsin, et rÀÀkimine oli huvitavam kui sellest kirjutamine. đ
Subscription
Kui me registreerume voogule, loome uue klassi subscription, mis vĂ”imaldab meil tĂŒhistada tellimuse meetodi unsubscribekaudu. Samuti saame tellimusi rĂŒhmitada meetodi kaudu add. Ja on mĂ”istetav, et saame vooge eraldada meetodi abil eemalda. Meetodid add ja remove vĂ”tavad sisse teise tellimuse. Tahaksin mĂ€rkida, et kui me tĂŒhistame tellimuse, siis tĂŒhistame me ka kĂ”ik alamtellimused just nagu oleksime neile kĂ€skinud meetodit unsubscribe. JĂ€tkame.
Vood tĂŒĂŒbid
| HOT | COLD |
|---|---|
| Producer luuakse observable'ist vÀljaspool | Producer luuakse observable'i sees |
| Andmed edastatakse observable'i loomise hetkel | Andmed edastatakse tellimise hetkel |
| Tuleb lisaloogika tĂŒhistamiseks | Voo lĂ”petab iseennast |
| Kasutab ĂŒhte-korra-mitmele seondumist | Kasutab ĂŒhe-korra-ĂŒhele seondumist |
| KĂ”ik tellimused omavad ĂŒhte vÀÀrtust | Tellimused on sĂ”ltumatud |
| Andmed vÔivad kaduda, kui tellimust ei ole | TaaskÀideldakse kÔiki voolu vÀÀrtusi uus tellimus |
Kui tuua analoogia, siis kujutaksin kuuma voolu nagu filmi kinos. Millal sa kohale jĂ”udsid, sellest hetkest alates hakad vaatama. KĂŒlma voolu vĂ”iksin vĂ”rrelda tehnilise toe kĂ”nega. Iga helistaja kuulab vastusautomaatide salvestust algusest lĂ”puni, kuid saad telefonikĂ”ne katkestada meetodiga unsubscribe.
Tahaksin mĂ€rkida, et eksisteerivad ka nn soojad vood (seda mÀÀratlust kohtasin ÀÀrmiselt harva ja ainult vĂ€lisriikide kogukondades) â see on voog, mis transformeerub kĂŒlmast voost kuumaks. KĂŒsitav on, kus seda kasutada)) Toon nĂ€ite praktikast.
Töötan angulaariga. See kasutab aktiivselt rxjs-i. Serverist andmete saamiseks ootan kĂŒlma voogu ja kasutan seda ĆĄabloonis koos asyncPipe'iga. Kui kasutan seda pipa mitu korda, siis naastes kĂŒlma voolu mÀÀratlemise juurde, taotleb iga pipa andmeid serverist, mis on pehmelt öeldes kummaline. Kui aga muudan kĂŒlma voogu soojaks, siis toimub pĂ€ring ĂŒks kord.
Ăldiselt on voogude tĂŒĂŒpide mĂ”istmine algajatele piisavalt keeruline, kuid oluline.
Operaatorid
return this.http.get(`${environment.apiUrl}/${this.apiUrl}/trade_companies`)
.pipe(
tap(({ data }: TradeCompanyList) => this.companies$$.next(cloneDeep(data))),
map(({ data }: TradeCompanyList) => data)
);Operaatorid pakuvad meile laiendatud vĂ”imalusi voogudega töötamiseks. Need aitavad kontrollida Observable'is toimuvaid sĂŒndmusi. KĂ€sitleme mĂ”nda kĂ”ige populaarsemat, kuid operaatoritega saab lĂ€hemalt tutvuda kasuliku info lingil.
Operaatorid â of
Alustame abistava operaatori of'iga. See loob Observable'i lihtsast vÀÀrtusest.

Operaatorid â filter

Filteroperaator filter, nagu nimi ĂŒtleb, filtreerib voolu signaali. Kui operaator tagastab tĂ”e, siis lastakse see edasi.
Operaatorid â take

take â VĂ”tab vastu emitatsioonide arvu, pĂ€rast mida lĂ”petab voo.
Operaatorid â debounceTime

debounceTime â viskab kĂ”rvale emitatsioonid, mis satuvad mÀÀratud aja vahemikku vĂ€ljundite vahel â pĂ€rast ajavahemiku möödumist emititakse viimane vÀÀrtus.
const { Observable } = Rx;
const { debounceTime, take } = RxOperators;
Observable.create((observer) => {
let i = 1;
observer.next(i++);
// Emitime vÀÀrtuse iga 1000 ms jÀrel
setInterval(() => {
observer.next(i++)
}, 1000);
// Emitime vÀÀrtuse iga 1500 ms jÀrel
setInterval(() => {
observer.next(i++)
}, 1500);
}).pipe(
debounceTime(700), // Ootame 700 ms vÀÀrtuse enne töötlemist
take(3)
); 
Operaatorid â takeWhile

Emitib vÀÀrtusi, kuni takeWhile ei tagasta false, pÀrast mida loobub voost.
const { Observable } = Rx;
const { debounceTime, takeWhile } = RxOperators;
Observable.create((observer) => {
let i = 1;
observer.next(i++);
// Emit value every 1000ms
setInterval(() => {
observer.next(i++)
}, 1000);
}).pipe(
takeWhile(producer => producer < 5)
); 
Operators â combineLatest
Kombineeritud operaator combineLatest sarnaneb promise.all-iga. See ĂŒhendab mitmed vood ĂŒhte. PĂ€rast seda, kui iga voog on teinud vĂ€hemalt ĂŒhe emit'i, saame viimasest vÀÀrtused igaĂŒhe kohta massiivina. Edasi, pĂ€rast mida tahes ĂŒhte emit'i ĂŒhendatud voogudest, annab see uusi vÀÀrtusi.

const { combineLatest, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Emit value every 1000ms
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
});
const observer_2 = Observable.create((observer) => {
let i = 1;
// Emit value every 750ms
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
});
combineLatest(observer_1, observer_2).pipe(take(5));
Operators â zip
Zip ootab vÀÀrtust igast voost ja moodustab massiivi nende vÀÀrtuste pĂ”hjal. Kui vÀÀrtus ei tule ĂŒheltki voost, siis gruppi ei moodustata.

const { zip, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Emit value every 1000ms
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
});
const observer_2 = Observable.create((observer) => {
let i = 1;
// Emit value every 750
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
});
const observer_3 = Observable.create((observer) => {
let i = 1;
// Emit value every 500
setInterval(() => {
observer.next('c: ' + i++);
}, 500);
});
zip(observer_1, observer_2, observer_3).pipe(take(5));
Operators â forkJoin
forkJoin ĂŒhendab ka vood, kuid emit'ib vÀÀrtuse ainult siis, kui kĂ”ik vood on lĂ”petatud (complete).

const { forkJoin, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Emit value every 1000ms
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
}).pipe(take(3));
const observer_2 = Observable.create((observer) => {
let i = 1;
// Emit value every 750
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
}).pipe(take(5));
const observer_3 = Observable.create((observer) => {
let i = 1;
// Emit value every 500
setInterval(() => {
observer.next('c: ' + i++);
}, 500);
}).pipe(take(4));
forkJoin(observer_1, observer_2, observer_3);
Operators â map
Muutmisoperaator map muudab emit'i vÀÀrtuse uueks.

const { Observable } = Rx;
const { take, map } = RxOperators;
Observable.create((observer) => {
let i = 1;
// Emit value every 1000ms
setInterval(() => {
observer.next(i++);
}, 1000);
}).pipe(
map(x => x * 10),
take(3)
);

Operators â share, tap
Operator tap vÔimaldab teha kergelt kÔrvalisi efekte, s.t. teisi tegevusi, mis ei mÔjuta jÀrjestust.
Abiooperator share suudab kĂŒlma voolu muuta kuumaks.

Oleme operaatoritega lÔpetanud. Liigume subjektide juurde.
MÔtisklen
Ja siis lĂ€ksin ma teed jooma. Need nĂ€ited vĂ€sitasid mind đ
Subjektide perekond
Subjektide perekond on ilmekas nĂ€ide kuumadest voogudest. Need klassid on teatud hĂŒbriid, mis toimivad samal ajal nii observable kui observerina. Kuna subjekt on kuum voog, tuleb sellelt maha registreerida. Peamised meetodid on:
- next â andmete edastamine voogu
- error â voogu lĂ”petamine ja viga
- complete â voogu lĂ”petamine
- subscribe â voogu registreerimine
- unsubscribe â voogust maha registreerimine
- asObservable â muudame vaatlejaks
- toPromise â muudab lubaduseks
Erakordselt on 4-5 tĂŒĂŒpi subjekte.
MÔtisklen
Streamil rÀÀkisin 4, aga selgus, et nad on ĂŒhe veel lisanud. Nagu öeldakse, elad ja Ă”pid.
Lihtne Subject new Subject()â kĂ”ige lihtsam tĂŒĂŒp subjekte. Loob ilma parameetriteta. Edastab vÀÀrtusi, mis saabuvad vaid pĂ€rast registreerimist.
BehaviorSubject new BehaviorSubject(defaultData<T>) â minu arvates kĂ”ige levinum tĂŒĂŒp subjekte. VĂ”tab sisendiks vaikevÀÀrtuse. Hoidub alati viimase edastuse andmetest, mille ta edastab registreerimise ajal. Sellel klassil on samuti kasulik meetod value, mis tagastab voolu praeguse vÀÀrtuse.
ReplaySubject new ReplaySubject(bufferSize?: number, windowTime?: number) â VĂ”tab sisendiks valikuliselt esmase argumendina vÀÀrtuste puhvri suuruse, mille ta enda sisse salvestab, ja teise argumentina aja, mille jooksul on meil muudatused vajalikud.
AsyncSubject new AsyncSubject() â registreerimisel ei toimu midagi, ja vÀÀrtus naastes ainult siis, kui voog on lĂ”petatud. Tagastatakse ainult voolu viimane vÀÀrtus.
WebSocketSubject new WebSocketSubject(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>) â Dokumentatsioon selle kohta ei rÀÀgi ja nĂ€en seda esmakordselt. Kes teab, mida see teeb, kirjutage, tĂ€iendame.
Ohh. Noh, oleme nĂŒĂŒd lĂ€binud kĂ”ik, mida tahtsin tĂ€na jagada. Loodan, et see teave oli kasulik. Iseseisvalt saab kirjanduse nimekirjaga tutvuda kasulike info sektsioonist.
Kasulik teave
- â link streamile
- â Kuidas JS töötab: ĂŒlevaade mootori, kĂ€itamise mehhanismide, vĂ€ljakutsumise virna kohta
- â Kuidas töötab JS: sĂŒndmuste tsĂŒkkel, asĂŒnkroonsus ja viis viisi koodi parendamiseks async / await abil
- â Kuidas töötab Event Loop JavaScriptis
- â AsĂŒnkroonse JavaScripti evolutsioon
- â Mis on RxJS ja miks on sellest kasulik teada
- â Praktiline rakendamine RxJS
- â RxJS Observablesi Ă”petus â loomine ja tellimine observablest
- â RXJS: kuumad ja kĂŒlmad observablid
- â Klassid, funktsioonid observablite loomiseks. Operiatorid.
- â RxJS operaatorid nĂ€ite kaudu
- â API loetelu
- â Subjectide ja ajakava tĂŒĂŒbid RxJS-is
Allikas: habr.com
