AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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?

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

1) Seni ei toimu midagi. Brauseri konsool on puhas, kutsumisvirn on tĂŒhi.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

3) Ja see tÀidetakse

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

7) KĂ€sk setTimeout(function cb1() {
 }) lĂ”petab töö ja eemaldatakse kutsumissteigist.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

16) Funktsioon cb1 eemaldatakse kutsumissteigist.

Vaadakem nĂ€idet dĂŒnaamikas:

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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:

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

HOTCOLD
Producer luuakse observable'ist vÀljaspoolProducer luuakse observable'i sees
Andmed edastatakse observable'i loomise hetkelAndmed edastatakse tellimise hetkel
Tuleb lisaloogika tĂŒhistamiseksVoo lĂ”petab iseennast
Kasutab ĂŒhte-korra-mitmele seondumistKasutab ĂŒhe-korra-ĂŒhele seondumist
KĂ”ik tellimused omavad ĂŒhte vÀÀrtustTellimused on sĂ”ltumatud
Andmed vÔivad kaduda, kui tellimust ei oleTaaskÀ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.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

Operaatorid — filter

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

Operaatorid — take

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

Operaatorid — debounceTime

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

Operaatorid — takeWhile

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

Operators — forkJoin

forkJoin ĂŒhendab ka vood, kuid emit'ib vÀÀrtuse ainult siis, kui kĂ”ik vood on lĂ”petatud (complete).

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

Operators — map

Muutmisoperaator map muudab emit'i vÀÀrtuse uueks.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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.

AsĂŒnkroonne programmeerimine JavaScriptis. (Tagasiside, Lubadus, RxJs)

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

Allikas: habr.com

Osta usaldusvÀÀrne veebimajutus DDoS-kaitsega veebisaitidele, VPS VDS serverid đŸ”„ Osta usaldusvÀÀrne veebimajutus DDoS-kaitsega veebisaitidele, VPS VDS serverid - ProHoster