جاوا اسڪرپٽ ۾ هم وقت سازي پروگرامنگ (ڪال بيڪ، وعدو، RxJs)

هيلو سڀ. سرجي Omelnitsky رابطي ۾ آهي. گهڻو وقت اڳ مون ري ايڪٽو پروگرامنگ تي هڪ اسٽريم جي ميزباني ڪئي هئي، جتي مون جاوا اسڪرپٽ ۾ اسنڪروني بابت ڳالهايو هو. اڄ مان هن مواد تي نوٽس وٺڻ چاهيان ٿو.

پر ان کان اڳ جو اسان بنيادي مواد شروع ڪريون، اسان کي هڪ تعارفي نوٽ ٺاهڻو پوندو. سو اچو ته وصفن سان شروع ڪريون: اسٽيڪ ۽ قطار ڇا آهي؟

اسٽيڪ ھڪڙو مجموعو آھي جنھن جا عناصر حاصل ڪيا ويا آھن آخري-ان، پھريون-آئوٽ LIFO بنياد تي

قطار ھڪڙو مجموعو آھي جنھن جا عنصر حاصل ڪيا ويندا آھن ھڪڙي فرسٽ ان، فرسٽ آئوٽ FIFO بنياد تي

ٺيڪ آهي، اچو ته جاري رکون.

JavaScript هڪ واحد موضوع واري پروگرامنگ ٻولي آهي. هن جو مطلب اهو آهي ته عملدرآمد جو صرف هڪ سلسلو آهي ۽ هڪ اسٽيڪ آهي جنهن تي ڪارڪردگي لاء قطار ۾ آهن. تنهن ڪري، جاوا اسڪرپٽ هڪ وقت ۾ صرف هڪ آپريشن ڪري سگهي ٿو، جڏهن ته ٻيا عمل ان جي اسٽيڪ تي موڙ جو انتظار ڪندا جيستائين انهن کي سڏيو وڃي.

ڪال اسٽيڪ هڪ ڊيٽا جو ڍانچو آهي، جيڪو آسانيءَ سان بيان ڪري ٿو، پروگرام ۾ ان هنڌ بابت معلومات رڪارڊ ڪري ٿو جتي اسان آهيون. جيڪڏهن اسان هڪ فنڪشن ۾ داخل ڪريون ٿا، اسان ان جي داخلا کي اسٽيڪ جي چوٽي تي ڌڪيندا آهيون. جڏهن اسان هڪ فنڪشن مان واپس وڃون ٿا، اسان اسٽيڪ مان مٿين عنصر کي پاپ ڪريون ٿا ۽ واپس ختم ڪريون ٿا جتي اسان فنڪشن سڏيو آهي. اهو سڀ ڪجهه آهي جيڪو اسٽيڪ ڪري سگهي ٿو. ۽ هاڻي هڪ انتهائي دلچسپ سوال. پوء ڪيئن Asynchrony جاوا اسڪرپٽ ۾ ڪم ڪندو آهي؟

حقيقت ۾، اسٽيڪ جي اضافي ۾، برائوزرن کي نام نهاد WebAPI سان ڪم ڪرڻ لاء هڪ خاص قطار آهي. هن قطار ۾ ڪم مڪمل طور تي صاف ٿيڻ کان پوء ئي ترتيب سان عمل ڪيو ويندو. ان کان پوءِ ئي انهن کي قطار مان دٻايو وڃي ٿو اسٽيڪ تي عمل لاءِ. جيڪڏهن هن وقت اسٽيڪ تي گهٽ ۾ گهٽ هڪ عنصر آهي، پوء اهي اسٽيڪ ۾ شامل نه ٿي سگهن. اهو خاص طور تي اهو ئي سبب آهي ته وقت ختم ٿيڻ سان ڪالنگ افعال اڪثر وقت ۾ درست نه هوندا آهن، ڇاڪاڻ ته فنڪشن قطار کان اسٽيڪ تائين نه ٿو پهچي سگهي جڏهن اهو مڪمل آهي.

اچو ته ھيٺ ڏنل مثال تي نظر رکون ۽ ان جي قدم قدم تي عمل ڪرڻ سان شروع ڪريو. اچو ته اهو پڻ ڏسو ته سسٽم ۾ ڇا ٿئي ٿو.

console.log('Hi');
setTimeout(function cb1() {
    console.log('cb1');
}, 5000);
console.log('Bye');

1) اڃا تائين ڪجھ به نه ٿي رهيو آهي. برائوزر ڪنسول صاف آھي، ڪال اسٽيڪ خالي آھي.

2) پوءِ console.log('Hi') حڪم ڪال اسٽيڪ ۾ شامل ڪيو ويو آهي.

3) ۽ اهو پورو ٿيو

4) پوءِ console.log('Hi') ڪال اسٽيڪ مان هٽايو ويو آهي.

5) ھاڻي ڪمانڊ ڏانھن وڃو setTimeout(function cb1() {… }). اهو ڪال اسٽيڪ ۾ شامل ڪيو ويو آهي.

6) setTimeout (function cb1() {… }) حڪم جاري ڪيو ويو آهي. برائوزر هڪ ٽائمر ٺاهي ٿو جيڪو ويب API جو حصو آهي. اهو هڪ ڳڻپ انجام ڏيندو.

7) setTimeout(function cb1() {... }) ڪمانڊ پنهنجو ڪم مڪمل ڪيو آهي ۽ ڪال اسٽيڪ مان هٽايو ويو آهي.

8) ڪمانڊ console.log('Bye') ڪال اسٽيڪ ۾ شامل ڪيو ويو آهي.

9) console.log('Bye') حڪم جاري ڪيو ويو آهي.

10) حڪم console.log('Bye') ڪال اسٽيڪ مان هٽايو ويو آهي.

11) گھٽ ۾ گھٽ 5000 ms گذرڻ کان پوءِ، ٽائمر ختم ٿئي ٿو ۽ ڪال بڪ سي بي 1 کي ڪال بڪ قطار ۾ رکي ٿو.

12) ايونٽ لوپ ڪال بڪ قطار مان فنڪشن cb1 وٺي ٿو ۽ ان کي ڪال اسٽيڪ تي رکي ٿو.

13) فنڪشن cb1 تي عمل ڪيو ويو آهي ۽ ڪال اسٽيڪ ۾ console.log('cb1') شامل ڪري ٿو.

14) console.log('cb1') حڪم جاري ڪيو ويو آهي.

15) حڪم console.log('cb1') ڪال اسٽيڪ مان هٽايو ويو آهي.

16) فنڪشن cb1 ڪال اسٽيڪ مان هٽايو ويو آهي.

اچو ته متحرڪ ۾ هڪ مثال ڏسو:

خير، اسان ڏٺو ته ڪيئن asynchrony جاوا اسڪرپٽ ۾ لاڳو ٿئي ٿي. ھاڻي اچو ته مختصر طور تي غير مطابقت واري ڪوڊ جي ارتقا جي باري ۾ ڳالهايون.

هم وقت سازي ڪوڊ جي ارتقا.

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

Asynchronous programming جيئن اسان ڄاڻون ٿا ان کي جاوا اسڪرپٽ ۾ صرف ڪم ڪري سگهجي ٿو. انهن کي ڪنهن ٻئي variable وانگر ٻين ڪمن ڏانهن منتقل ڪري سگهجي ٿو. اهڙيءَ طرح ڪال بیکس پيدا ٿيا. ۽ اهو ٿڌو، مزيدار ۽ چنچل آهي، جيستائين اهو اداس، مايوسي ۽ اداس ۾ تبديل نه ٿئي. ڇو؟ اهو سادو آهي:

• جيئن ته ڪوڊ جي پيچيدگي وڌي ٿي، پروجيڪٽ جلدي غير واضح، بار بار نيسٽ ٿيل بلاڪ ۾ بدلجي ٿو - "ڪال بيڪ دوزخ".
• نقص سنڀالڻ آسان ٿي سگھي ٿو ياد ڪرڻ.
• توهان واپسي سان اظهار واپس نه ٿا ڪري سگهو.

وعدي جي اچڻ سان صورتحال ڪجهه بهتر ٿي وئي.

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

• واعدو زنجير ظاهر ٿيو، جنهن ۾ ڪوڊ پڙهڻ جي صلاحيت بهتر ٿي
• غلطين کي پڪڙڻ لاء هڪ الڳ طريقو ظاهر ٿيو آهي
• Promise.all استعمال ڪندي متوازي عمل جي امڪان کي شامل ڪيو
• اسان حل ڪري سگهون ٿا nested asynchrony async/await استعمال ڪندي

پر واعدو انهن جون حدون آهن. مثال طور، هڪ واعدو رد نه ٿو ڪري سگهجي بغير دان سان ناچ ڪرڻ، ۽ ڇا سڀ کان اهم آهي اهو هڪ قدر سان ڪم ڪري ٿو.

خير، اسان آساني سان رد عمل واري پروگرامنگ سان رابطو ڪيو آهي. ٿڪل؟ خير، خوشقسمتيءَ سان، توهان وڃي سگهو ٿا چانهه ٺاهڻ لاءِ، ان بابت سوچيو ۽ وڌيڪ پڙهڻ لاءِ واپس اچو. ۽ مان جاري ڪندس.

رد عمل پروگرامنگ ڊيٽا جي وهڪري ۽ تبديلي جي پروپيگيشن تي مرکوز هڪ پروگرامنگ پيراڊم آهي. اچو ته هڪ ويجهي نظر رکون ته ڊيٽا جو وهڪرو ڇا آهي.

// Получаем ссылку на элемент
const input = ducument.querySelector('input');

const eventsArray = [];

// Пушим каждое событие в массив eventsArray
input.addEventListener('keyup',
    event => eventsArray.push(event)
);

اچو ته تصور ڪريون ته اسان وٽ هڪ ان پٽ فيلڊ آهي. اسان هڪ صف ٺاهي رهيا آهيون ۽ ان پٽ ايونٽ جي هر ڪيپ اپ لاءِ اسان ايونٽ کي پنهنجي صف ۾ محفوظ ڪنداسين. ساڳئي وقت، مان اهو نوٽ ڪرڻ چاهيان ٿو ته اسان جي صف وقت جي ترتيب سان ترتيب ڏنل آهي، يعني. پوئين واقعن جي انڊيڪس اڳين واقعن جي انڊيڪس کان وڌيڪ آھي. اهڙي صف هڪ ڊيٽا جي وهڪري جو هڪ سادي نموني آهي، پر اهو اڃا تائين هڪ وهڪرو ناهي. انهي صف لاءِ محفوظ طور تي هڪ وهڪرو سڏيو وڃي ٿو، اهو لازمي آهي ته ڪنهن نه ڪنهن طرح سبسڪرائبرن کي خبر ڏئي سگهي ٿو ته ان ۾ نئون ڊيٽا اچي چڪو آهي. اهڙيءَ طرح اسان وهڪري جي تعريف ڏانهن اچون ٿا.

ڊيٽا وهڪرو

const { interval } = Rx;
const { take } = RxOperators;

interval(1000).pipe(
    take(4)
)

وهواه وقت جي ترتيب سان ترتيب ڏنل ڊيٽا جو هڪ صف آهي جيڪو ظاهر ڪري ٿو ته ڊيٽا تبديل ٿي وئي آهي. هاڻي تصور ڪريو ته اهو ڪوڊ لکڻ ڪيترو آسان آهي جنهن ۾ هڪ عمل ڪوڊ جي مختلف حصن ۾ ڪيترن ئي واقعن کي ڪال ڪرڻ جي ضرورت آهي. اسان صرف اسٽريم جي رڪنيت حاصل ڪندا آهيون ۽ اهو اسان کي اطلاع ڏيندو جڏهن تبديليون ٿينديون. ۽ RxJs لائبريري اهو ڪري سگهي ٿي.

آرڪس ايس ايس ھڪ لئبرري آھي جيڪو ڪم ڪرڻ لاءِ غير مطابقت پذير ۽ واقعن تي ٻڌل پروگرامن سان ڪم ڪري سگھي ٿو. لائبريري هڪ بنيادي قسم مهيا ڪري ٿي مشاهدو، ڪيترائي معاون قسم (مبصر ، مقرر ، مضمون(نقشو، فلٽر، گھٽ، هر ۽ جاوا اسڪرپٽ آري مان ساڳيا).

اچو ته هن لائبريري جي بنيادي مفهومن کي سمجهون.

مشاهدو ڪندڙ ، مشاهدو ڪندڙ ، پيش ڪندڙ

Observable پهريون بنيادي قسم آهي جنهن کي اسين ڏسنداسين. ھن ڪلاس ۾ RxJs جي عمل درآمد جو بنيادي حصو آھي. اهو هڪ مشاهدو وهڪرو سان لاڳاپيل آهي، جيڪو رڪنيت حاصل ڪرڻ جو طريقو استعمال ڪندي رڪنيت حاصل ڪري سگهجي ٿو.

مشاهدو اپ ڊيٽ ٺاهڻ لاء هڪ مددگار ميڪانيزم لاڳو ڪري ٿو، جنهن کي سڏيو ويندو آهي نظرثاني ڪندڙ. مبصر لاء قدر جو ذريعو سڏيو ويندو آهي پالڻ وارو. اهو ٿي سگهي ٿو هڪ صف، آئٽرٽر، ويب ساکٽ، ڪجهه قسم جو واقعو، وغيره. تنهن ڪري اسان اهو چئي سگهون ٿا ته مشاهدو پيدا ڪندڙ ۽ مبصر جي وچ ۾ هڪ موصل آهي.

مشاهدو ڪندڙ مبصر واقعن جي ٽن قسمن کي سنڀاليندو آهي:

• اڳيون - نئين ڊيٽا
• غلطي - هڪ غلطي جيڪڏهن تسلسل هڪ استثنا جي ڪري ختم ٿي وئي. اهو واقعو پڻ تسلسل جي مڪمل ٿيڻ جو مطلب آهي.
• مڪمل - تسلسل جي مڪمل ٿيڻ بابت سگنل. هن جو مطلب آهي ته ڪو به وڌيڪ نئين ڊيٽا نه ٿيندو.

اچو ته ڊيمو ڏسو:

شروعات ۾ اسان قدر 1، 2، 3، ۽ 1 سيڪنڊ کان پوء پروسيس ڪنداسين. اسان 4 حاصل ڪنداسين ۽ اسان جو وهڪرو ختم ڪنداسين.

وڏي آواز سان سوچڻ

۽ پوءِ مون محسوس ڪيو ته اهو ٻڌائڻ ان بابت لکڻ کان وڌيڪ دلچسپ آهي. 😀

رڪنيت

جڏهن اسان هڪ وهڪرو جي رڪنيت حاصل ڪندا آهيون ته اسان هڪ نئون ڪلاس ٺاهيندا آهيون سبسڪرپشنجيڪو اسان کي طريقو استعمال ڪندي رڪنيت ختم ڪرڻ جي صلاحيت ڏئي ٿو بندوبست ڪريو. اسان طريقو استعمال ڪندي گروپ رڪنيت پڻ ڪري سگھون ٿا شامل. خير، اهو منطقي آهي ته اسان استعمال ڪندي موضوعن کي غير گروپ ڪري سگهون ٿا مٽائڻ. شامل ڪرڻ ۽ ختم ڪرڻ جا طريقا ٻئي رڪنيت کي ان پٽ طور قبول ڪندا آھن. مان نوٽ ڪرڻ چاهيان ٿو ته جڏهن اسان رڪنيت ختم ڪريون ٿا، اسان سڀني ٻارن جي سبسڪرپشن مان رڪنيت ختم ڪريون ٿا ڄڻ ته انهن رڪنيت ختم ڪرڻ جو طريقو سڏيو آهي. اڳتي وڃو.

وهڪري جا قسم

گرم
ڀڌ

پيدا ڪندڙ ٻاهر observable پيدا ڪيو آهي
پروڊيوسر مشاهدو اندر ٺهيل آهي

ڊيٽا کي منتقل ڪيو ويندو آهي جڏهن مشاهدو پيدا ٿئي ٿي
ڊيٽا سبسڪرپشن جي وقت تي مهيا ڪئي وئي آهي

رڪنيت ختم ڪرڻ لاءِ اضافي منطق جي ضرورت آهي
موضوع پاڻ ئي ختم ٿي ويندو

استعمال ڪري ٿو هڪ کان گھڻا تعلق
هڪ کان هڪ تعلق استعمال ڪري ٿو

سڀني رڪنن جو ساڳيو مطلب آهي
رڪنيتون آزاد آهن

ڊيٽا گم ٿي سگهي ٿي جيڪڏهن توهان وٽ رڪنيت نه آهي
نئين سبسڪرپشن لاءِ سڀني اسٽريم ويلز کي ٻيهر جاري ڪري ٿو

هڪ قياس ڏيڻ لاء، مان هڪ گرم وهڪرو کي ٿيٽر ۾ فلم وانگر سمجهان ٿو. توهان ڪهڙي وقت پهتا آهيو، ان وقت کان توهان ڏسڻ شروع ڪيو. مان هڪ سرد وهڪري کي ٽيڪن ۾ ڪال سان موازنہ ڪندس. حمايت. ڪو به ڪال ڪندڙ وائس ميل رڪارڊنگ کي شروع کان آخر تائين ٻڌندو آهي، پر توهان رڪنيت ختم ڪرڻ کي استعمال ڪندي بند ڪري سگهو ٿا.

مان اهو نوٽ ڪرڻ چاهيان ٿو ته گرم وهڪري پڻ آهن (مون کي هن تعريف ۾ تمام گهٽ ۽ صرف غير ملڪي برادرين ۾ آيو آهي) - اهو هڪ وهڪرو آهي جيڪو ٿڌي وهڪري کان گرم ۾ تبديل ٿئي ٿو. سوال پيدا ٿئي ٿو - ڪٿي استعمال ڪرڻ)) مان مشق مان هڪ مثال ڏيندس.

مان Angular سان ڪم ڪري رهيو آهيان. هو فعال طور تي استعمال ڪري ٿو rxjs. سرور ڏانهن ڊيٽا حاصل ڪرڻ لاءِ، مان هڪ ٿڌي سلسلي جي توقع ڪريان ٿو ۽ asyncPipe استعمال ڪندي ٽيمپليٽ ۾ هن سلسلي کي استعمال ڪريان ٿو. جيڪڏهن آئون هن پائپ کي ڪيترائي ڀيرا استعمال ڪريان ٿو، پوء، ٿڌو وهڪرو جي تعريف ڏانهن موٽڻ، هر پائپ سرور کان ڊيٽا جي درخواست ڪندو، جيڪو گهٽ ۾ گهٽ چوڻ لاء عجيب آهي. ۽ جيڪڏهن مان ٿڌي وهڪري کي گرم ۾ تبديل ڪريان، ته پوءِ درخواست هڪ ڀيرو ٿيندي.

عام طور تي، وهڪري جي قسم کي سمجهڻ شروع ڪندڙن لاءِ ڪافي ڏکيو آهي، پر اهم.

آپريٽر

return this.http.get(`${environment.apiUrl}/${this.apiUrl}/trade_companies`)
    .pipe(
        tap(({ data }: TradeCompanyList) => this.companies$$.next(cloneDeep(data))),
        map(({ data }: TradeCompanyList) => data)
    );

آپريٽرز اسان کي مهيا ڪن ٿا اسان جي صلاحيت کي وڌائڻ لاء اسان جي اسٽريم سان ڪم ڪرڻ جي صلاحيت. اهي مشاهدو ۾ واقع ٿيندڙ واقعن کي ڪنٽرول ڪرڻ ۾ مدد ڪن ٿيون. اسان ڪجھه مقبول ترين تي نظر ڪنداسين، ۽ آپريٽرز بابت وڌيڪ تفصيل مفيد معلومات ۾ لنڪ استعمال ڪندي ڳولهي سگهجن ٿا.

آپريٽرز - جو

اچو ته معاون آپريٽر سان شروع ڪريون. اهو هڪ سادي قدر جي بنياد تي هڪ مشاهدو پيدا ڪري ٿو.

آپريٽر - فلٽر

فلٽر آپريٽر، جيئن نالو ڏيکاري ٿو، وهڪرو سگنل کي فلٽر ڪري ٿو. جيڪڏهن آپريٽر صحيح موٽائي ٿو، اهو اڳتي وڌندو.

آپريٽر - وٺي

وٺو - emitters جي تعداد جي قيمت وٺندو آهي، جنهن کان پوء موضوع ختم ٿئي ٿو.

آپريٽرز - debounceTime

debounceTime - خارج ٿيل قدرن کي رد ڪري ٿو جيڪي آئوٽ پُٽ جي وچ ۾ مخصوص وقت جي وقفي ۾ اچن ٿا - وقت جي وقفي کان پوءِ ، آخري قدر خارج ڪري ٿو.

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

آپريٽر- takeWhile

قيمتن کي خارج ڪري ٿو جيستائين takeWhile غلط موٽائي، ان کان پوء ان سلسلي مان رڪنيت ختم ڪري.

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

آپريٽرز - combinine Latest

combineLatest آپريٽر ڪجهه حد تائين وعدو.all سان ملندڙ جلندڙ آهي. اهو ڪيترن ئي موضوعن کي هڪ ۾ گڏ ڪري ٿو. هر ٿريڊ کان پوءِ گهٽ ۾ گهٽ هڪ اخراج ٿئي ٿو، اسان هر هڪ کان جديد قدر حاصل ڪريون ٿا هڪ صف جي صورت ۾. وڌيڪ، ضم ٿيل اسٽريمز مان ڪنهن به اخراج کان پوء، اهو نئون قدر ڏيندو.

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

آپريٽر- زپ

زپ - هر سلسلي مان هڪ قدر جو انتظار ڪري ٿو ۽ انهن قدرن جي بنياد تي هڪ صف ٺاهي ٿو. جيڪڏهن قيمت ڪنهن به سلسلي مان نه ايندي ته پوء گروپ نه ٺهندو.

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

آپريٽرز - forkJoin

forkJoin پڻ ٿريڊن ۾ شامل ٿئي ٿو، پر اهو صرف هڪ قدر خارج ڪري ٿو جڏهن سڀ ٿريڊ مڪمل ٿين ٿا.

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

آپريٽر- نقشو

نقشي جي ٽرانسفارميشن آپريٽر ايمٽر ويل کي نئين ۾ تبديل ڪري ٿو.

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

آپريٽر - حصيداري ڪريو، ٽيپ ڪريو

ٽيپ آپريٽر توهان کي ضمني اثرات ڪرڻ جي اجازت ڏئي ٿو، اهو آهي، ڪو به عمل جيڪو تسلسل تي اثر انداز نٿو ڪري.

شيئر يوٽيلٽي آپريٽر ٿڌي وهڪري کي گرم ۾ تبديل ڪري سگهي ٿو.

اسان آپريٽرز سان ڪيو آهي. اچو ته موضوع ڏانهن وڃو.

وڏي آواز سان سوچڻ

۽ پوءِ مان چانهه پيئڻ ويس. مان ٿڪجي پيو آهيان انهن مثالن مان 😀

مضمون خاندان

موضوع خاندان گرم وهڪري جو هڪ اهم مثال آهي. اهي طبقا هڪ قسم جي هائبرڊ آهن جيڪي هڪ ئي وقت ۾ مشاهدو ۽ مبصر طور ڪم ڪن ٿا. جيئن ته موضوع هڪ گرم موضوع آهي، ان جي رڪنيت ختم ڪرڻ ضروري آهي. جيڪڏهن اسان بنيادي طريقن بابت ڳالهايون ٿا، ته اهي آهن:

• اڳيون - وهڪرو ڏانهن نئين ڊيٽا جي منتقلي
• غلطي - غلطي ۽ موضوع ختم ٿيڻ
• مڪمل- سلسلي جي مڪمل ٿيڻ
• رڪنيت حاصل ڪرڻ - رڪنيت حاصل ڪرڻ لاء
• رڪنيت ختم ڪرڻ- رڪنيت ختم ڪرڻ
• as Observable - مبصر ۾ تبديل
• وعدو ڪرڻ- واعدو ۾ بدلجي ٿو

مضمونن جا 4 قسم آهن.

وڏي آواز سان سوچڻ

وهڪري تي 4 ماڻهو ڳالهائي رهيا هئا، پر اهو ظاهر ٿيو ته انهن هڪ وڌيڪ شامل ڪيو. جيئن اهي چون ٿا، جيو ۽ سکيو.

سادي مضمون new Subject()- مضمونن جو آسان ترين قسم. پيٽرول کان سواء ٺهيل. صرف سبسڪرپشن کان پوء وصول ڪيل قدر منتقل ڪري ٿو.

رويي جو مضمون new BehaviorSubject( defaultData<T> ) - منهنجي خيال ۾، موضوع جو سڀ کان عام قسم. ان پٽ ڊفالٽ قدر وٺندو آهي. هميشه آخري مسئلي جي ڊيٽا کي محفوظ ڪري ٿو، جيڪو رڪنيت حاصل ڪرڻ وقت منتقل ڪيو ويندو آهي. ھن ڪلاس ۾ ھڪڙو مفيد قدر طريقو آھي، جيڪو وهڪرو جي موجوده قيمت کي واپس ڪري ٿو.

Replay Subject new ReplaySubject(bufferSize?: number, windowTime?: number) - ان پٽ اختياري طور وٺي سگھي ٿو پھرين دليل جي طور تي قدرن جي بفر جي سائيز جو اھو پاڻ ۾ ذخيرو ڪندو، ۽ ٻيو وقت جنھن دوران اسان کي تبديلين جي ضرورت آھي.

AsyncSubject new AsyncSubject() - رڪنيت حاصل ڪرڻ وقت ڪجھ به نه ٿيندو، ۽ قيمت صرف مڪمل ٿيڻ تي واپس ڪئي ويندي. صرف وهڪرو جو آخري قدر واپس ڪيو ويندو.

WebSocketSubject new WebSocketSubject(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>) - دستاويز هن جي باري ۾ خاموش آهي ۽ مان هن کي پهريون ڀيرو ڏسي رهيو آهيان. جيڪڏهن ڪو ڄاڻي ٿو ته هو ڇا ڪري ٿو، مهرباني ڪري لکندا ۽ اسان ان کي شامل ڪنداسين.

ڦوهه. خير، اسان هر شي کي ڍڪي ڇڏيو آهي جيڪو اڄ توهان کي ٻڌائڻ چاهيان ٿو. مون کي اميد آهي ته هي معلومات مفيد هئي. توھان پڙھي سگھوٿا حوالن جي لسٽ پاڻ کي مفيد معلومات واري ٽئب ۾.

مددگار معلومات

• وهڪرو ڏانهن لنڪ
• JS ڪيئن ڪم ڪري ٿو: انجڻ جو جائزو، رن ٽائم ميڪانيزم، ڪال اسٽيڪ
• ڪيئن JS ڪم ڪري ٿو: ايونٽ لوپ، Asynchrony، ۽ async/await سان توهان جي ڪوڊ کي بهتر ڪرڻ جا پنج طريقا
• ڪيئن ايونٽ لوپ جاوا اسڪرپٽ ۾ ڪم ڪري ٿو
• Asynchronous JavaScript جو ارتقا
• RxJS ڇا آهي ۽ ان بابت ڄاڻڻ ڇو مفيد آهي؟
  
• RxJS جي عملي درخواست
• RxJS Observables Tutorial — تخليق ڪرڻ ۽ سبسڪرائب ڪرڻ جا Observables
• RXJS: گرم ۽ ٿڌو مشاهدو
• ڪلاس، مشاهدو ٺاهڻ لاءِ افعال. آپريٽرز.
• RxJS آپريٽرز مثال طور
• API لسٽ
• RxJS ۾ مضمون ۽ شيڊول جا مختلف قسم

جو ذريعو: www.habr.com