🥇 JavaScript मध्ये अॅसिंक्रोनस प्रोग्रामिंग (कॉलबॅक, प्रॉमिस, RxJs)

सर्वांना नमस्कार. सेर्गेई ओमेलनित्स्की संपर्कात आहे. काही काळापूर्वी मी प्रतिक्रियाशील प्रोग्रामिंगवर एक प्रवाह होस्ट केला होता, जिथे मी JavaScript मध्ये असिंक्रोनीबद्दल बोललो होतो. आज मी या सामग्रीवर नोट्स घेऊ इच्छितो.

परंतु आम्ही मुख्य सामग्री सुरू करण्यापूर्वी, आम्हाला एक परिचयात्मक नोंद करणे आवश्यक आहे. चला व्याख्यांसह प्रारंभ करूया: स्टॅक आणि रांग म्हणजे काय?

स्टॅक हा एक संग्रह आहे ज्याचे घटक अंतिम-इन, प्रथम-आऊट LIFO आधारावर प्राप्त केले जातात

रांग हा एक संग्रह आहे ज्याचे घटक प्रथम-इन, प्रथम-आऊट FIFO आधारावर प्राप्त केले जातात

ठीक आहे, चला सुरू ठेवूया.

JavaScript ही एकल-थ्रेडेड प्रोग्रामिंग भाषा आहे. याचा अर्थ असा की एक्झिक्युशनचा एकच थ्रेड आणि एक स्टॅक आहे ज्यावर फंक्शन्स एक्झिक्यूशनसाठी रांगेत आहेत. त्यामुळे, JavaScript एका वेळी फक्त एकच ऑपरेशन करू शकते, तर इतर ऑपरेशन्स स्टॅकवर कॉल होईपर्यंत त्यांच्या वळणाची वाट पाहतील.

कॉल स्टॅक ही एक डेटा संरचना आहे जी, सोप्या भाषेत सांगायचे तर, आपण जिथे आहोत त्या प्रोग्राममधील ठिकाणाची माहिती रेकॉर्ड करते. जर आपण फंक्शनमध्ये प्रवेश केला तर आपण त्याची एंट्री स्टॅकच्या शीर्षस्थानी ढकलतो. जेव्हा आपण फंक्शनमधून परत येतो, तेव्हा आपण स्टॅकमधून सर्वात वरचा घटक पॉप करतो आणि जिथे आपण फंक्शन म्हटले होते तिथे परत येतो. हे सर्व स्टॅक करू शकते. आणि आता एक अत्यंत मनोरंजक प्रश्न. मग JavaScript मध्ये असिंक्रोनी कसे कार्य करते?

खरं तर, स्टॅक व्यतिरिक्त, तथाकथित WebAPI सह कार्य करण्यासाठी ब्राउझरची एक विशेष रांग आहे. स्टॅक पूर्णपणे साफ केल्यानंतरच या रांगेतील कार्ये क्रमाने चालविली जातील. यानंतरच त्यांना रांगेतून अंमलबजावणीसाठी स्टॅकवर ढकलले जाते. या क्षणी स्टॅकवर किमान एक घटक असल्यास, ते स्टॅकमध्ये जोडले जाऊ शकत नाहीत. हे नेमके कारण आहे की कालबाह्यतेनुसार फंक्शन कॉल करणे अनेकदा वेळेत अचूक नसते, कारण फंक्शन पूर्ण भरलेले असताना रांगेतून स्टॅकपर्यंत जाऊ शकत नाही.

चला खालील उदाहरण पाहू आणि त्याच्या चरण-दर-चरण अंमलबजावणीसह प्रारंभ करूया. प्रणालीमध्ये काय होते ते देखील पाहूया.

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

१) अजून काही घडत नाहीये. ब्राउझर कन्सोल स्पष्ट आहे, कॉल स्टॅक रिक्त आहे.

2) नंतर console.log('Hi') कमांड कॉल स्टॅकमध्ये जोडली जाते.

3) आणि ते पूर्ण होते

4) नंतर console.log('हाय') कॉल स्टॅकमधून काढून टाकले जाते.

५) आता setTimeout(function cb5() {… }) कमांडवर जा. ते कॉल स्टॅकमध्ये जोडले जाते.

6) setTimeout(function cb1() {… }) कमांड कार्यान्वित होते. ब्राउझर एक टायमर तयार करतो जो वेब API चा भाग आहे. तो काउंटडाउन करेल.

7) setTimeout(function cb1() {... }) कमांडने त्याचे कार्य पूर्ण केले आहे आणि कॉल स्टॅकमधून काढून टाकले आहे.

8) console.log('बाय') ही कमांड कॉल स्टॅकमध्ये जोडली जाते.

9) console.log('Bye') कमांड कार्यान्वित होते.

10) console.log('Bye') कमांड कॉल स्टॅकमधून काढून टाकली आहे.

11) किमान 5000 ms निघून गेल्यावर, टाइमर बंद होतो आणि कॉलबॅक रांगेत कॉलबॅक cb1 ठेवतो.

१२) इव्हेंट लूप कॉलबॅक रांगेतून फंक्शन cb12 घेते आणि कॉल स्टॅकवर ठेवते.

13) फंक्शन cb1 कार्यान्वित केले जाते आणि कॉल स्टॅकमध्ये console.log('cb1') जोडते.

14) console.log('cb1') कमांड कार्यान्वित झाली आहे.

15) console.log('cb1') कमांड कॉल स्टॅकमधून काढून टाकली आहे.

16) फंक्शन cb1 कॉल स्टॅकमधून काढून टाकले आहे.

चला डायनॅमिक्समधील उदाहरण पाहू:

बरं, आम्ही JavaScript मध्ये असिंक्रोनी कशी लागू केली जाते ते पाहिले. आता एसिंक्रोनस कोडच्या उत्क्रांतीबद्दल थोडक्यात बोलूया.

असिंक्रोनस कोडची उत्क्रांती.

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

असिंक्रोनस प्रोग्रॅमिंग हे जावास्क्रिप्टमध्‍ये आपल्याला माहीत आहे ते फंक्‍शनद्वारेच लागू केले जाऊ शकते. ते इतर कोणत्याही व्हेरिएबलप्रमाणे इतर फंक्शन्समध्ये पास केले जाऊ शकतात. अशा प्रकारे कॉलबॅकचा जन्म झाला. आणि ते शांत, मजेदार आणि खेळकर आहे, जोपर्यंत ते दुःख, खिन्नता आणि दुःखात बदलत नाही. का? हे सोपं आहे:

कोडची जटिलता जसजशी वाढत जाते, तसतसे प्रकल्प अस्पष्ट, वारंवार नेस्टेड ब्लॉक्समध्ये बदलतो - "कॉलबॅक नरक".
त्रुटी हाताळणे चुकणे सोपे असू शकते.
आपण रिटर्नसह अभिव्यक्ती परत करू शकत नाही.

प्रॉमिसच्या आगमनाने परिस्थिती थोडी चांगली झाली.

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 वापरून समांतर अंमलबजावणीची शक्यता जोडली
आम्ही 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 लायब्ररी हे करू शकते.

RxJS निरीक्षण करण्यायोग्य क्रम वापरून असिंक्रोनस आणि इव्हेंट-आधारित प्रोग्रामसह कार्य करण्यासाठी एक लायब्ररी आहे. लायब्ररी मूलभूत प्रकार प्रदान करते अवलोकन करण्यायोग्य, अनेक सहायक प्रकार (निरीक्षक, शेड्युलर, विषय) आणि संकलनाप्रमाणे इव्हेंटसह कार्य करण्यासाठी ऑपरेटर (नकाशा, फिल्टर, कमी, प्रत्येक आणि JavaScript अॅरे मधील तत्सम).

या ग्रंथालयाच्या मूलभूत संकल्पना समजून घेऊ.

निरीक्षण करण्यायोग्य, निरीक्षक, निर्माता

निरीक्षण करण्यायोग्य हा पहिला मूलभूत प्रकार आहे ज्याकडे आपण पाहू. या वर्गामध्ये RxJs अंमलबजावणीचा मुख्य भाग आहे. हे निरीक्षण करण्यायोग्य प्रवाहाशी संबंधित आहे, ज्याची सदस्यता पद्धत वापरून सदस्यता घेतली जाऊ शकते.

निरीक्षण करण्यायोग्य अद्यतने तयार करण्यासाठी एक सहाय्यक यंत्रणा लागू करते, तथाकथित निरीक्षक. निरीक्षकासाठी मूल्यांचा स्त्रोत म्हणतात उत्पादक. हे अॅरे, इटरेटर, वेब सॉकेट, काही प्रकारचे इव्हेंट इत्यादी असू शकते. म्हणून आपण असे म्हणू शकतो की निर्माते आणि निरीक्षक यांच्यातील प्रेक्षणीय वाहक आहे.

निरीक्षण करण्यायोग्य तीन प्रकारचे निरीक्षक इव्हेंट हाताळते:

पुढील - नवीन डेटा
त्रुटी – अपवादामुळे क्रम समाप्त झाल्यास त्रुटी. ही घटना क्रम पूर्ण करणे देखील सूचित करते.
पूर्ण — क्रम पूर्ण झाल्याबद्दलचे संकेत. याचा अर्थ असा की आणखी नवीन डेटा मिळणार नाही.

चला डेमो पाहू:

सुरुवातीला आपण 1, 2, 3 आणि 1 सेकंदानंतर मूल्यांवर प्रक्रिया करू. आम्हाला 4 मिळेल आणि आमचा प्रवाह संपुष्टात येईल.

मोठ्याने विचार करणे

आणि मग माझ्या लक्षात आले की त्याबद्दल लिहिण्यापेक्षा ते सांगणे अधिक मनोरंजक आहे. 😀

सदस्यता

जेव्हा आम्ही एखाद्या प्रवाहाची सदस्यता घेतो तेव्हा आम्ही एक नवीन वर्ग तयार करतो सदस्यताजे आम्हाला पद्धत वापरून सदस्यता रद्द करण्याची क्षमता देते सदस्यता रद्द करा. आम्ही पद्धत वापरून सदस्यत्व गट देखील करू शकतो जोडा. बरं, हे तर्कसंगत आहे की आपण वापरून थ्रेड्सचे गट रद्द करू शकतो दूर. जोडा आणि काढून टाकण्याच्या पद्धती इनपुट म्हणून दुसरी सदस्यता स्वीकारतात. मी हे लक्षात घेऊ इच्छितो की जेव्हा आम्ही सदस्यत्व रद्द करतो, तेव्हा आम्ही सर्व मुलांचे सदस्यत्व रद्द करतो जणू त्यांनी सदस्यत्व रद्द करण्याची पद्धत म्हटले आहे. पुढे जा.

प्रवाहांचे प्रकार

गरम
शीतल

निर्माता निरीक्षण करण्यायोग्य बाहेर तयार केला जातो
निर्माता निरीक्षण करण्यायोग्य आत तयार केला जातो

निरीक्षण करण्यायोग्य तयार केल्यावर डेटा हस्तांतरित केला जातो
सबस्क्रिप्शनच्या वेळी डेटा प्रदान केला जातो

सदस्यत्व रद्द करण्यासाठी अतिरिक्त तर्काची आवश्यकता आहे
धागा स्वतःच संपतो

एक-ते-अनेक संबंध वापरते
वन टू वन रिलेशनशिप वापरते

सर्व सदस्यतांचा एकच अर्थ आहे
सदस्यता स्वतंत्र आहेत

तुमच्याकडे सदस्यत्व नसल्यास डेटा गमावला जाऊ शकतो
नवीन सदस्यत्वासाठी सर्व प्रवाह मूल्ये पुन्हा जारी करते

एक साधर्म्य द्यायचे तर, मी थिएटरमधील चित्रपट म्हणून गरम प्रवाहाचा विचार करेन. तुम्ही कोणत्या वेळी पोहोचलात, त्या क्षणापासून तुम्ही पाहण्यास सुरुवात केली. मी शीत प्रवाहाची तुलना तंत्रज्ञानातील कॉलशी करेन. समर्थन कोणताही कॉलर सुरुवातीपासून शेवटपर्यंत व्हॉइसमेल रेकॉर्डिंग ऐकतो, परंतु तुम्ही सदस्यत्व रद्द करून हँग अप करू शकता.

मी हे लक्षात घेऊ इच्छितो की तथाकथित उबदार प्रवाह देखील आहेत (मला ही व्याख्या अत्यंत क्वचितच आणि केवळ परदेशी समुदायांमध्येच आली आहे) - हा एक प्रवाह आहे जो थंड प्रवाहापासून गरम प्रवाहात बदलतो. प्रश्न उद्भवतो - कुठे वापरायचे)) मी सरावातून एक उदाहरण देईन.

मी अँगुलर सोबत काम करत आहे. तो सक्रियपणे 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)
    );

ऑपरेटर आम्हाला प्रवाहांसह कार्य करण्याची क्षमता वाढवण्याची क्षमता प्रदान करतात. ते निरीक्षण करण्यायोग्य घटनांवर नियंत्रण ठेवण्यास मदत करतात. आम्ही काही सर्वात लोकप्रिय पाहू, आणि ऑपरेटरबद्दल अधिक तपशील उपयुक्त माहितीमधील दुवे वापरून आढळू शकतात.

ऑपरेटर - च्या

च्या सहाय्यक ऑपरेटरसह प्रारंभ करूया. हे एका साध्या मूल्यावर आधारित निरीक्षण करण्यायोग्य तयार करते.

ऑपरेटर - फिल्टर

फिल्टर ऑपरेटर, नावाप्रमाणेच, प्रवाह सिग्नल फिल्टर करतो. ऑपरेटर खरे परत आल्यास, तो पुढे वगळतो.

ऑपरेटर - घ्या

take — उत्सर्जकांच्या संख्येचे मूल्य घेते, ज्यानंतर धागा संपतो.

ऑपरेटर - 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 )
);

ऑपरेटर - नवीनतम एकत्र करा

combineLatest ऑपरेटर काहीसे promise.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)
);

ऑपरेटर - शेअर करा, टॅप करा

टॅप ऑपरेटर आपल्याला साइड इफेक्ट्स करण्याची परवानगी देतो, म्हणजे, कोणत्याही क्रिया ज्या अनुक्रमांवर परिणाम करत नाहीत.

शेअर युटिलिटी ऑपरेटर थंड प्रवाहाला गरम मध्ये बदलू शकतो.

आम्ही ऑपरेटर्ससह पूर्ण केले. चला विषयाकडे जाऊया.

मोठ्याने विचार करणे

आणि मग चहा प्यायला गेलो. मी या उदाहरणांनी कंटाळलो आहे 😀

विषय कुटुंब

विषय कुटुंब हे गरम प्रवाहाचे प्रमुख उदाहरण आहे. हे वर्ग एक प्रकारचे संकरित आहेत जे एकाच वेळी निरीक्षण आणि निरीक्षक म्हणून कार्य करतात. विषय हा चर्चेचा धागा असल्याने त्याचे सदस्यत्व रद्द करणे आवश्यक आहे. जर आपण मुख्य पद्धतींबद्दल बोललो तर या आहेत:

पुढील - प्रवाहात नवीन डेटाचे हस्तांतरण
त्रुटी - त्रुटी आणि थ्रेड समाप्ती
पूर्ण - थ्रेड पूर्ण करणे
सदस्यता घ्या - प्रवाहाची सदस्यता घ्या
सदस्यता रद्द करा - प्रवाहातून सदस्यता रद्द करा
asObservable - निरीक्षकात रूपांतरित करा
to Promise - वचनात रूपांतरित होते

विषयांचे ४५ प्रकार आहेत.

मोठ्याने विचार करणे

प्रवाहावर 4 लोक बोलत होते, परंतु असे दिसून आले की त्यांनी आणखी एकाची भर घातली. जसे ते म्हणतात, जगा आणि शिका.

साधा विषय new Subject()- विषयांचा सर्वात सोपा प्रकार. पॅरामीटर्सशिवाय तयार केले. सदस्यता घेतल्यानंतरच प्राप्त झालेली मूल्ये प्रसारित करते.

वर्तन विषय new BehaviorSubject( defaultData<T> ) - माझ्या मते, विषयाचा सर्वात सामान्य प्रकार. इनपुट डीफॉल्ट मूल्य घेते. शेवटच्या अंकाचा डेटा नेहमी जतन करतो, जो सदस्यत्व घेत असताना प्रसारित केला जातो. या वर्गामध्ये एक उपयुक्त मूल्य पद्धत देखील आहे, जी प्रवाहाचे वर्तमान मूल्य परत करते.

रीप्ले विषय new ReplaySubject(bufferSize?: number, windowTime?: number) - इनपुट वैकल्पिकरित्या प्रथम युक्तिवाद म्हणून मूल्यांच्या बफरचा आकार घेऊ शकतो जो तो स्वतःमध्ये संग्रहित करेल आणि दुसरी वेळ ज्या दरम्यान आपल्याला बदलांची आवश्यकता आहे.

AsyncSubject new AsyncSubject() — सदस्यत्व घेताना काहीही होत नाही आणि मूल्य पूर्ण झाल्यावरच परत केले जाईल. प्रवाहाचे फक्त शेवटचे मूल्य परत केले जाईल.

वेबसॉकेट विषय new WebSocketSubject(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>) - दस्तऐवजीकरण त्याच्याबद्दल शांत आहे आणि मी त्याला प्रथमच पाहत आहे. तो काय करतो हे कोणाला माहीत असल्यास, कृपया लिहा आणि आम्ही ते जोडू.

ओफ. बरं, आज मी तुम्हाला सांगू इच्छित असलेल्या सर्व गोष्टी आम्ही कव्हर केल्या आहेत. मला आशा आहे की ही माहिती उपयुक्त होती. उपयुक्त माहिती टॅबमध्ये तुम्ही स्वतः संदर्भांची यादी वाचू शकता.

उपयुक्त माहिती

स्त्रोत: www.habr.com

JavaScript मध्ये असिंक्रोनस प्रोग्रामिंग (कॉलबॅक, प्रॉमिस, RxJs)

असिंक्रोनस कोडची उत्क्रांती.

डेटा प्रवाह

निरीक्षण करण्यायोग्य, निरीक्षक, निर्माता

सदस्यता

प्रवाहांचे प्रकार

ऑपरेटर

विषय कुटुंब

उपयुक्त माहिती

एक टिप्पणी जोडा Отменить ответ