Hi uile. Sergei Omelnitsky saor an asgaidh. Chan eil cho fada air ais, chùm mi sruth air prògramadh reactive, far an do bhruidhinn mi mu dheidhinn asynchrony ann an JavaScript. An-diugh bu mhath leam geàrr-chunntas a dhèanamh air an stuth seo.
Ach mus tòisich sinn air a 'phrìomh stuth, feumaidh sinn ro-ràdh a dhèanamh. Mar sin tòisichidh sinn le mìneachaidhean: dè a th’ ann an stac agus ciudha?
Stac na chruinneachadh anns a bheil na h-eileamaidean air an toirt air ais air bunait LIFO “mu dheireadh a-steach, an toiseach a-mach”.
Ciudha Is e cruinneachadh a th’ ann a gheibhear eileamaidean a rèir a’ phrionnsapail (“an toiseach a-steach, an toiseach a-mach” FIFO
Ceart gu leòr, leanaidh sinn oirnn.
Is e cànan prògramadh aon-snàthainn a th’ ann an JavaScript. Tha seo a’ ciallachadh nach eil ann ach aon snàithlean cur gu bàs agus aon stac far a bheil gnìomhan air an ciudha airson an cur gu bàs. Mar sin, chan urrainn dha JavaScript ach aon obair a dhèanamh aig an aon àm, agus feithidh gnìomhachdan eile an tionndadh air a’ chruach gus an tèid an gairm.
gairm stac na structar dàta a tha, gu sìmplidh, a’ clàradh fiosrachadh mun àite sa phrògram far a bheil sinn. Ma leumas sinn a-steach gu gnìomh, bidh sinn a 'putadh a-steach gu mullach a' chruach. Nuair a thilleas sinn bho ghnìomh, bidh sinn a’ popadh an eileamaid as àirde far a’ chruach agus a’ tighinn gu crìch far an do ghairm sinn an gnìomh. Sin a h-uile rud as urrainn don stac a dhèanamh. Agus a-nis ceist gu math inntinneach. Ciamar a tha asyncronaidh ag obair ann an JavasScript?
Gu dearbh, a bharrachd air a’ chruach, tha ciudha sònraichte aig brobhsairean airson a bhith ag obair leis an t-ainm WebAPI. Thèid na gnìomhan bhon ciudha seo a chuir gu bàs ann an òrdugh dìreach às deidh don chruach a bhith air a ghlanadh gu tur. Is ann dìreach às deidh sin a thèid an cur bhon chiudha air a’ chruach airson a chur gu bàs. Ma tha co-dhiù aon eileamaid air a’ chruaich an-dràsta, chan urrainn dhaibh faighinn air a’ chruaich. Dìreach air sgàth seo, bidh gairm ghnìomhan le ùine a-mach gu tric mearachdach ann an ùine, leis nach urrainn don ghnìomh faighinn bhon ciudha chun chruach fhad ‘s a tha e làn.
Bheir sinn sùil air an eisimpleir a leanas agus rachamaid troimhe ceum air cheum. Bheir sinn sùil cuideachd air na thachras san t-siostam.
console.log('Hi);
setTimeout(function cb1() {
console.log('cb1');
}, 5000);
console.log('Bye');
1) Gu ruige seo chan eil dad a’ tachairt. Tha consol a’ bhrobhsair glan, tha an stac gairm falamh.
2) An uairsin thèid an àithne console.log ('Hi') a chur ris a 'chruach gairm.
3) Agus tha e air a choileanadh
4) An uairsin tha console.log ('Hi') air a thoirt air falbh bhon stac gairm.
5) A-nis gluaisidh sinn air adhart chun an àithne setTimeout (gnìomh cb1 () {… }). Tha e air a chur ris an stac call.
6) Tha an àithne setTimeout (gnìomh cb1 () {… }) air a chuir gu bàs. Bidh am brabhsair a’ cruthachadh timer a tha na phàirt den Web API. Bidh e a 'dèanamh cunntadh sìos.
7) Tha an àithne setTimeout (gnìomh cb1 () {… }) air crìoch a chuir air an obair aige agus thèid a thoirt air falbh bhon stac gairm.
8) Tha an àithne console.log ('Bye') air a chur ris a 'chruach ghairm.
9) Tha an àithne console.log ('Bye') air a chur gu bàs.
10) Tha an àithne console.log ('Bye') air a thoirt air falbh bhon stac gairm.
11) Às deidh co-dhiù 5000ms a dhol seachad, thig an timer gu crìch agus cuiridh e an ath-ghairm cb1 a-steach don ciudha gairm air ais.
12) Bidh lùb an tachartais a’ toirt gnìomh cb1 bhon ciudha gairm air ais agus ga phutadh air a’ chruach ghairm.
13) Tha gnìomh cb1 air a chuir gu bàs agus a’ cur console.log (‘cb1’) ris a’ chruach ghairm.
14) Tha an àithne console.log ('cb1') air a chur gu bàs.
15) Tha an àithne console.log ('cb1') air a thoirt air falbh bhon stac gairm.
16) Tha gnìomh cb1 air a thoirt air falbh bhon stac gairm.
Bheir sinn sùil air eisimpleir ann an dinamics:
Uill, thug sinn sùil air mar a tha asynchrony air a chuir an gnìomh ann an JavaScript. A-nis bruidhnidh sinn gu h-aithghearr mu mean-fhàs còd asyncronach.
Leasachadh còd asyncronach.
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);
})
})
})
})
})
});Chan urrainnear prògramadh asyncronach mar as aithne dhuinn ann an JavaScript a dhèanamh ach le gnìomhan. Faodar an toirt seachad mar chaochladair sam bith eile gu gnìomhan eile. Seo mar a rugadh callbacks. Agus tha e fionnar, spòrsail agus làidir, gus an tionndaidh e gu bròn, melancholy agus bròn. Carson? Tha, tha e sìmplidh:
- Mar a bhios iom-fhillteachd a ’chòd a’ fàs, bidh am pròiseact gu sgiobalta a ’tionndadh gu bhith na ioma-bloc neadachaidh doilleir -“ callback hell ”.
- Faodar dearmad a dhèanamh air làimhseachadh mhearachdan gu furasta.
- Chan urrainn dhut abairtean a thilleadh le tilleadh.
Le teachd Promise, tha an suidheachadh air fàs beagan nas fheàrr.
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);
});- Nochd slabhraidhean gealltanas, a leasaich leughadh a’ chòd
- Bha dòigh eadar-dhealaichte ann airson mearachdan a lorg
- Cur gu bàs co-shìnte le Promise.all air a chur ris
- Is urrainn dhuinn asyncronadh neadachaidh fhuasgladh le async / feitheamh
Ach tha crìochan aig a’ ghealladh. Mar eisimpleir, chan urrainnear gealladh, gun dannsa le tambourine, a chuir dheth, agus as cudromaiche, bidh e ag obair le aon luach.
Uill, an seo tha sinn gu rèidh a’ tighinn faisg air prògramadh reactive. Sgìthichte? Uill, is e an rud math, faodaidh tu a dhol a ghrùdadh faoileagan, cnuasachadh eanchainn agus tilleadh airson barrachd a leughadh. Agus leanaidh mi air adhart.
Prògramadh ath-ghnìomhach - paradigm prògramadh le fòcas air sruthan dàta agus iomadachadh atharrachaidhean. Bheir sinn sùil nas mionaidiche air dè a th’ ann an sruth dàta.
// Получаем ссылку на элемент
const input = ducument.querySelector('input');
const eventsArray = [];
// Пушим каждое событие в массив eventsArray
input.addEventListener('keyup',
event => eventsArray.push(event)
);Smaoinich gu bheil raon cuir a-steach againn. Bidh sinn a’ cruthachadh sreath, agus airson gach keyup den tachartas cuir a-steach, stòraidh sinn an tachartas nar raon. Aig an aon àm, bu mhath leam a thoirt fa-near gu bheil ar raon air a rèiteachadh a rèir ùine, i.e. tha an clàr-amais de thachartasan nas fhaide air adhart nas àirde na clàr-amais thachartasan nas tràithe. Tha an leithid de raon na mhodail sruthadh dàta nas sìmplidhe, ach chan eil e fhathast na shruth. Gus an tèid an t-sreath seo a ghairm gu sàbhailte mar shruth, feumaidh e a bhith comasach air innse do luchd-aontachaidh gu bheil dàta ùr air ruighinn ann. Mar sin tha sinn a 'tighinn chun a' mhìneachadh air sruth.
Sruth dàta
const { interval1 } = Rx;
const { take } = RxOperators;
interval(1000).pipe(
take(4)
)
Sruth 'S e sreath de dhàta a th' ann an òrdugh a rèir ùine a dh'fhaodas nochdadh gu bheil an dàta air atharrachadh. A-nis smaoinich air cho goireasach sa bhios e còd a sgrìobhadh anns am feum thu grunn thachartasan a bhrosnachadh ann an diofar phàirtean den chòd airson aon ghnìomh. Bidh sinn dìreach a’ fo-sgrìobhadh don t-sruth agus innsidh e dhuinn nuair a thachras atharrachaidhean. Agus faodaidh leabharlann RxJs seo a dhèanamh.
RxJS na leabharlann airson a bhith ag obair le prògraman asyncronach agus stèidhichte air tachartas a’ cleachdadh sreathan faicsinneach. Tha an leabharlann a 'toirt seachad a' phrìomh sheòrsa Amharc, grunn sheòrsaichean cuideachaidh (Luchd-amhairc, Luchd-clàraidh, Cuspairean) agus gnìomhaichean airson a bhith ag obair le tachartasan mar le cruinneachaidhean (map, criathraich, lughdaich, gach agus feadhainn coltach ris bho JavaScript Array).
Tuigidh sinn bun-bheachdan an leabharlainn seo.
Faicsinneach, Fear-amhairc, Riochdaire
Is e faicsinneach a’ chiad sheòrsa bunaiteach air am bi sinn a’ coimhead. Anns a’ chlas seo tha am prìomh phàirt de bhuileachadh RxJs. Tha e co-cheangailte ri sruth faicsinneach, a dh'fhaodar a chleachdadh le bhith a' cleachdadh an dòigh fo-sgrìobhaidh.
Bidh Observable a’ cur an gnìomh uidheamachd taice airson ùrachaidhean a chruthachadh, ris an canar Observer. Canar tùs luachan airson Neach-amhairc Riochdaire. Faodaidh e a bhith na raon, neach-aithris, socaid lìn, tachartas de sheòrsa air choreigin, msaa. Mar sin faodaidh sinn a ràdh gu bheil observable na stiùiriche eadar Riochdaire agus Neach-amhairc.
Bidh faicsinneach a’ làimhseachadh trì seòrsaichean de thachartasan Observer:
- an ath rud - dàta ùr
- mearachd - mearachd ma thig an t-sreath gu crìch air sgàth eisgeachd. tha an tachartas seo cuideachd a’ ciallachadh deireadh an t-sreath.
- coileanta - comharra mu dheireadh an t-sreath. Tha seo a’ ciallachadh nach bi barrachd dàta ùr ann
Chì sinn demo:
Aig an toiseach bidh sinn a 'giullachd luachan 1, 2, 3, agus an dèidh 1 sec. gheibh sinn 4 agus cuiridh sinn crìoch air an t-snàthainn againn.
A 'smaoineachadh a-mach àrd
Agus an uairsin thuig mi gu robh e nas inntinniche innse na sgrìobhadh mu dheidhinn. 😀
fo-sgrìobhaidh
Nuair a bhios sinn a’ fo-sgrìobhadh do shruth, bidh sinn a’ cruthachadh clas ùr subscription, a bheir dhuinn an roghainn dì-chlàradh leis a’ mhodh dì-fho-sgrìobhadh. Faodaidh sinn cuideachd fo-sgrìobhaidhean a chur còmhla a’ cleachdadh an dòigh ris. Uill, tha e loidsigeach gun urrainn dhuinn snàithleanan a chuir còmhla a’ cleachdadh a thoirt air falbh. Bidh na dòighean cuir ris is thoir air falbh a’ gabhail ri ballrachd eile mar chur-a-steach. Bu mhath leam a thoirt fa-near, nuair a bhios sinn a’ dì-chlàradh, gun cuir sinn crìoch air an fho-sgrìobhadh bho gach ballrachd cloinne mar gum biodh iad cuideachd ag ainmeachadh an dòigh dì-chlàraidh. Siuthad.
Seòrsan sruthan
| Air adhart | FUAR |
|---|---|
| Tha an riochdaire air a chruthachadh taobh a-muigh an amharc | Tha an riochdaire air a chruthachadh taobh a-staigh faicsinneach |
| Thèid dàta a thoirt seachad aig an àm a thèid an sealladh a chruthachadh | Tha dàta air a thoirt seachad aig àm an fho-sgrìobhaidh. |
| Feum air barrachd loidsig airson dì-chlàradh | Bidh snàithlean a 'crìochnachadh leis fhèin |
| A 'cleachdadh dàimh aon-ri-iomadh | A’ cleachdadh dàimh aon-ri-aon |
| Tha an aon luach aig gach ballrachd | Tha fo-sgrìobhaidhean neo-eisimeileach |
| Faodar dàta a chall mura h-eil ballrachd ann | Ag ath-fhoillseachadh a h-uile luach srutha airson ballrachd ùr |
Gus samhlachadh a thoirt seachad, bhithinn a’ smaoineachadh air sruth teth mar fhilm ann an taigh-dhealbh. Dè an àm anns an tàinig thu, bhon mhionaid sin thòisich thu a’ coimhead. Dheanadh mi coimeas eadar sruthan fuar agus gairm anns na. taic. Bidh neach-fios sam bith ag èisteachd ris an inneal freagairt a’ clàradh bho thoiseach gu deireadh, ach faodaidh tu crochadh suas le dì-chlàradh.
Bu mhath leam a thoirt fa-near gu bheil sruthan blàth ris an canar cuideachd (tha mi air coinneachadh ri leithid de mhìneachadh gu math ainneamh agus dìreach ann an coimhearsnachdan cèin) - is e sruth a tha seo a tha ag atharrachadh bho shruth fuar gu sruth teth. Tha a 'cheist ag èirigh - càite an cleachdar)) Bheir mi eisimpleir bho chleachdadh.
Tha mi ag obair le Angular. Bidh e gu gnìomhach a’ cleachdadh rxjs. Gus dàta fhaighinn chun an fhrithealaiche, tha mi an dùil ri sruth fuar agus cleachdaidh mi an t-sruth seo san teamplaid a’ cleachdadh asyncPipe. Ma chleachdas mi am pìob seo grunn thursan, an uairsin, a 'tilleadh chun a' mhìneachadh air sruth fuar, iarraidh gach pìob dàta bhon fhrithealaiche, rud a tha neònach a ràdh an ìre as lugha. Agus ma thionndaidheas mi sruth fuar gu fear blàth, bidh an t-iarrtas a 'tachairt aon uair.
San fharsaingeachd, tha tuigse air an t-seòrsa sruthan gu math duilich do luchd-tòiseachaidh, ach cudromach.
Oibrichean
return this.http.get(`${environment.apiUrl}/${this.apiUrl}/trade_companies`)
.pipe(
tap(({ data }: TradeCompanyList) => this.companies$$.next(cloneDeep(data))),
map(({ data }: TradeCompanyList) => data)
);Bheir luchd-obrachaidh cothrom dhuinn a bhith ag obair le sruthan. Bidh iad a’ cuideachadh le smachd a chumail air na tachartasan a tha a’ sruthadh anns an Observable. Beachdaichidh sinn air cuid den fheadhainn as mòr-chòrdte, agus gheibhear tuilleadh fiosrachaidh mu na gnìomhaichean aig na ceanglaichean ann am fiosrachadh feumail.
Luchd-obrachaidh-de
Feuch an tòisich sinn leis a’ ghnìomhaiche cuideachaidh aig. Bidh e a’ cruthachadh amharc stèidhichte air luach sìmplidh.
Luchd-obrachaidh - sìoltachan
Bidh an gnìomhaiche sìoltachain, mar a tha an t-ainm a’ moladh, a’ sìoladh comharra an t-srutha. Ma thilleas an gnìomhaiche fìor, leumaidh e nas fhaide.
Luchd-obrachaidh - a 'gabhail
gabhail - A 'gabhail luach an àireamh de sgaoilidhean, an dèidh sin an t-sruth a' tighinn gu crìch.
Luchd-obrachaidh - debounceTime
debounceTime - tilg air falbh luachan sgaoilte a tha taobh a-staigh na h-ùine ainmichte eadar dàta toraidh - às deidh don ùine a dhol seachad, cuiridh e a-mach an luach mu dheireadh.
const { Observable } = Rx;
const { debounceTime, take } = RxOperators;
Observable.create((observer) => {
let i = 1;
observer.next(i++);
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next(i++)
}, 1000);
// Испускаем значение раз в 1500мс
setInterval(() => {
observer.next(i++)
}, 1500);
}).pipe(
debounceTime(700), // Ожидаем 700мс значения прежде чем обработать
take(3)
);
Operators-takeWhile
Cuir a-mach luachan gus an till TakeWhile returns false, an uairsin dì-chlàradh bhon t-snàthainn.
const { Observable } = Rx;
const { debounceTime, takeWhile } = RxOperators;
Observable.create((observer) => {
let i = 1;
observer.next(i++);
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next(i++)
}, 1000);
}).pipe(
takeWhile( producer => producer < 5 )
);
Luchd-obrachaidh - cothlamadh as ùire
Tha an gnìomhaiche aonaichte combineLatest rudeigin coltach ri promise.all. Bidh e a’ cothlamadh grunn shruthan ann an aon. Às deidh gach snàithlean co-dhiù aon sgaoileadh a dhèanamh, gheibh sinn na luachan as ùire bho gach fear mar raon. Nas fhaide, às deidh sgaoileadh sam bith bho na sruthan còmhla, bheir e luachan ùra.
const { combineLatest, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
});
const observer_2 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 750мс
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
});
combineLatest(observer_1, observer_2).pipe(take(5));
Gnìomhaichean-zip
Zip - a 'feitheamh airson luach bho gach sruth agus a' cruthachadh sreath stèidhichte air na luachan sin. Mura h-eil an luach a 'tighinn bho snàithlean sam bith, cha tèid a' bhuidheann a chruthachadh.
const { zip, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
});
const observer_2 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 750
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
});
const observer_3 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 500
setInterval(() => {
observer.next('c: ' + i++);
}, 500);
});
zip(observer_1, observer_2, observer_3).pipe(take(5));
Luchd-obrachaidh - forkJoin
Bidh forkJoin cuideachd a’ tighinn còmhla ri snàithleanan, ach cha bhith e a’ sgaoileadh luach ach nuair a bhios na snàithleanan uile deiseil.
const { forkJoin, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
}).pipe(take(3));
const observer_2 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 750
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
}).pipe(take(5));
const observer_3 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 500
setInterval(() => {
observer.next('c: ' + i++);
}, 500);
}).pipe(take(4));
forkJoin(observer_1, observer_2, observer_3);
Luchd-obrachaidh - mapa
Bidh an gnìomhaiche cruth-atharrachaidh mapa ag atharrachadh an luach sgaoilidhean gu luach ùr.
const { Observable } = Rx;
const { take, map } = RxOperators;
Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next(i++);
}, 1000);
}).pipe(
map(x => x * 10),
take(3)
);
Luchd-obrachaidh - roinn, tap
Leigidh an gnìomhaiche tap leat frith-bhuaidhean a dhèanamh, is e sin, gnìomhan sam bith nach toir buaidh air an t-sreath.
Faodaidh an gnìomhaiche goireas cuibhreann sruth fuar a thionndadh gu sruth teth.
Tha gnìomhaichean air an dèanamh. Gluaisidh sinn air adhart gu Cuspair.
A 'smaoineachadh a-mach àrd
Agus an uairsin chaidh mi a dh'òl tì. Tha mi sgìth de na h-eisimpleirean seo 😀
Teaghlach cuspair
Tha an teaghlach cuspair na phrìomh eisimpleir de snàithleanan teth. Tha na clasaichean sin nan seòrsa de hybrid a bhios ag amharc agus a’ coimhead aig an aon àm. Leis gur e sruth teth a th’ anns a’ chuspair, feumaidh gun fho-sgrìobhadh dheth. Ma tha sinn a 'bruidhinn mu na prìomh dhòighean, is iad seo:
- an ath rud - a' dol seachad air dàta ùr dhan t-sruth
- mearachd - mearachd agus crìochnachadh snàithlean
- coileanta - deireadh an t-snàthainn
- fo-sgrìobhadh - fo-sgrìobhadh gu sruth
- dì-chlàradh - dì-chlàradh bhon t-snàthainn
- asObservable - atharraich gu neach-amhairc
- toPromise - ag atharrachadh gu gealladh
Roinn 4 5 seòrsa de chuspairean.
A 'smaoineachadh a-mach àrd
Thuirt mi 4 air an t-sruth, ach thionndaidh e a-mach gun do chuir iad fear eile ris. Mar a tha an abairt ag ràdh, bi beò agus ionnsaich.
Cuspair sìmplidh new Subject()- an seòrsa cuspairean as sìmplidh. Air a chruthachadh às aonais crìochan. A 'dol seachad air na luachan a thàinig a-mhàin an dèidh an fho-sgrìobhaidh.
Giùlan Cuspair new BehaviorSubject( defaultData<T> ) - nam bheachd-sa an seòrsa cuspair-s as cumanta. Gabhaidh an cuir a-steach an luach bunaiteach. Bidh an-còmhnaidh a’ sàbhaladh dàta na cùise mu dheireadh, a thèid a chraoladh nuair a bhios tu a’ fo-sgrìobhadh. Tha modh luach feumail aig a’ chlas seo cuideachd a thilleas luach làithreach an t-sruth.
Cuspair ath-chluich new ReplaySubject(bufferSize?: number, windowTime?: number) - Roghainneil, faodaidh e a bhith mar a’ chiad argamaid meud bufair luachan a bhios e a’ stòradh ann fhèin, agus an dàrna turas nuair a dh’ fheumas sinn atharrachaidhean.
cuspair asyncronach new AsyncSubject() - chan eil dad a’ tachairt nuair a bhios tu a ’fo-sgrìobhadh, agus cha tèid an luach a thilleadh ach nuair a bhios e deiseil. Cha tèid ach an luach mu dheireadh den t-sruth a thilleadh.
Cuspair lìn Socket new WebSocketSubject(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>) - Tha na sgrìobhainnean sàmhach mu dheidhinn agus tha mi fhìn ga fhaicinn airson a’ chiad uair. Cò aig tha fios dè a nì e, sgrìobh, cuiridh sinn ris.
Phew. Uill, tha sinn air beachdachadh air a h-uile dad a bha mi airson innse an-diugh. An dòchas gun robh am fiosrachadh seo cuideachail. Faodaidh tu an liosta de litreachas a leughadh leat fhèin anns an taba Fiosrachadh Feumail.
fiosrachadh feumail
- - ceangal sruth
- - Mar a tha JS ag obair: sealladh farsaing air an einnsean, uidheamachdan ùine ruith, stac gairm
- - Mar a tha JS ag obair: lùb an tachartais, asyncronach, agus còig dòighean air do chòd adhartachadh le async / feitheamh
- - Mar a tha an Event Loop ag obair ann an JavaSript
- - mean-fhàs JavaScript asyncronach
- - Dè a th’ ann an RxJS agus carson a tha e feumail fios a bhith agad mu dheidhinn
- - Cur an gnìomh practaigeach RxJS
- - Oideachadh RxJS Observables - A’ cruthachadh & a’ fo-sgrìobhadh do nithean a chithear
- - RXJS: Toraidhean teth is fuar
- - Clasaichean, gnìomhan airson cruthachadh faicsinneach. Oibrichean.
- Luchd-obrachaidh RxJS Mar eisimpleir
- Liosta API
- — Diofar chuspairean agus Chlàr ann an RxJS
Source: www.habr.com