🤟🏻 👩🏾‍🤝‍👩🏼 👨‍👧‍👧 अतुल्यकालिक जावास्क्रिप्ट प्रोग्रामिंग (कॉलबैक, वादा, RxJs) 🌳 🧘🏾 🚲

सभी को नमस्कार। स्पर्श में ओमेल्नित्स्की सर्गेई। ऐसा नहीं है कि बहुत पहले मैंने एक प्रतिक्रियाशील प्रोग्रामिंग स्ट्रीम का नेतृत्व किया था जहाँ मैंने जावास्क्रिप्ट में एसिंक्रोनस के बारे में बात की थी। आज मैं इस सामग्री को रेखांकित करना चाहूंगा।

लेकिन इससे पहले कि हम मुख्य सामग्री शुरू करें, हमें एक परिचयात्मक करने की आवश्यकता है। तो, चलो परिभाषाओं के साथ शुरू करते हैं: स्टैक और कतार क्या है?

स्टैक एक संग्रह है, जिसके तत्व "आखिरी में, पहले बाहर" लिफो के सिद्धांत पर प्राप्त होते हैं

एक कतार एक संग्रह है जिसके तत्व सिद्धांत के अनुसार प्राप्त होते हैं ("पहले आओ, पहले बाहर आओ" फीफो

ठीक है, चलो जारी रखें।

जावास्क्रिप्ट एक एकल-थ्रेडेड प्रोग्रामिंग भाषा है। इसका मतलब यह है कि इसमें निष्पादन का केवल एक धागा है और एक स्टैक जिसमें कार्य निष्पादन के लिए पंक्तिबद्ध हैं। इसलिए, एक समय में, जावास्क्रिप्ट केवल एक ही ऑपरेशन कर सकती है, जबकि अन्य ऑपरेशन तब तक स्टैक पर अपनी बारी का इंतजार करेंगे जब तक कि उन्हें बुलाया न जाए।

कॉल स्टैक एक डेटा संरचना है, जो सरल शब्दों में, उस कार्यक्रम के स्थान के बारे में जानकारी दर्ज करती है, जहाँ हम हैं। यदि हम किसी फ़ंक्शन में जाते हैं, तो हम स्टैक के शीर्ष पर इसके बारे में एक रिकॉर्ड डालते हैं। जब हम फ़ंक्शन से लौटते हैं, तो हम स्टैक से सबसे ऊपरी तत्व को खींचते हैं और खुद को पाते हैं कि हमने इस फ़ंक्शन को कहां से बुलाया है। यह सब स्टैक कर सकता है। और अब एक बेहद दिलचस्प सवाल। तब कैसे जावास्क्रिप्ट में काम करता है अतुल्यकालिक?

वास्तव में, स्टैक के अलावा, तथाकथित वेबएपीआई के साथ काम करने के लिए ब्राउज़रों की एक विशेष कतार है। स्टैक पूरी तरह से साफ होने के बाद ही इस कतार से कार्य निष्पादित किए जाएंगे। उसके बाद ही उन्हें कतार से धकेल दिया जाता है और निष्पादन के लिए ढेर पर रखा जाता है। यदि स्टैक पर वर्तमान में कम से कम एक तत्व है, तो वे स्टैक पर नहीं मिल सकते हैं। यह ठीक इस वजह से है कि टाइमआउट द्वारा कॉलिंग फ़ंक्शन अक्सर समय में सटीक नहीं होता है, क्योंकि फ़ंक्शन पूर्ण होने के दौरान स्टैक पर कतार से नहीं मिल सकता है।

निम्नलिखित उदाहरण पर विचार करें और इसके चरण-दर-चरण "निष्पादन" करें। यह भी देखें कि सिस्टम में क्या होता है।

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

1) अभी तक, कुछ भी नहीं हो रहा है। ब्राउज़र कंसोल साफ है, कॉल स्टैक खाली है।

2) फिर कॉल स्टैक में कंसोल.लॉग ('हाय') कमांड जोड़ा जाता है।

3) और इसे निष्पादित किया जाता है

4) इसके बाद कॉल स्टैक से कंसोल.लॉग ('हाय') हटा दिया जाता है।

5) अब setTimeout कमांड (फंक्शन cb1 () {...}) पर जाएं। इसे कॉल स्टैक में जोड़ा जाता है।

6) सेटटाइमआउट (फंक्शन cb1 () {...}) कमांड निष्पादित होता है। ब्राउज़र एक टाइमर बनाता है जो वेब एपीआई का हिस्सा है। वह उलटी गिनती करेगा।

7) सेटटाइमआउट कमांड (फ़ंक्शन cb1 () {...}) ने अपना काम पूरा कर लिया है और कॉल स्टैक से निकाल दिया गया है।

8) कॉल स्टैक में कंसोल.लॉग ('बाय') कमांड जोड़ा गया है।

9) कंसोल.लॉग ('बाय') कमांड को निष्पादित किया जाता है।

10) कॉल स्टैक से कंसोल.लॉग ('बाय') कमांड हटा दी जाती है।

11) कम से कम 5000 एमएस पास होने के बाद, टाइमर बाहर निकलता है और कॉलबैक कतार में cb1 कॉलबैक डालता है।

12) ईवेंट लूप कॉलबैक कतार से cb1 फ़ंक्शन लेता है और कॉल स्टैक पर रखता है।

13) cb1 फ़ंक्शन निष्पादित होता है और कॉल स्टैक पर कंसोल.लॉग ('cb1') जोड़ता है।

14) कंसोल.लॉग ('cb1') कमांड निष्पादित होता है।

15) कॉल स्टैक से कंसोल.लॉग कमांड ('cb1') को हटा दिया जाता है।

16) कॉल स्टैक से cb1 फ़ंक्शन को हटा दिया जाता है।

डायनेमिक्स में एक उदाहरण देखें:

खैर, यहां हमने जांच की है कि जावास्क्रिप्ट में एसिंक्रोनस कैसे लागू किया जाता है। अब अतुल्यकालिक कोड के विकास के बारे में संक्षेप में बात करते हैं।

अतुल्यकालिक कोड का विकास।

 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 / प्रतीक्षा के साथ हल कर सकते हैं

लेकिन प्रॉमिस की अपनी सीमाएँ हैं। उदाहरण के लिए, एक वादा, एक टैमूराइन के साथ नृत्य के बिना, पूर्ववत नहीं किया जा सकता है, और सबसे महत्वपूर्ण बात, यह एक मूल्य के साथ काम करता है।

खैर, हम सुचारू रूप से प्रतिक्रियाशील प्रोग्रामिंग के पास पहुंचे। क्या आप थके हुए हैं? ठीक है, अच्छी बात यह है कि आप कुछ गुल बना सकते हैं, सोच सकते हैं और आगे पढ़ने के लिए वापस लौट सकते हैं। और मैं जारी रखूंगा।

प्रतिक्रियाशील प्रोग्रामिंग मूल बातें

रिएक्टिव प्रोग्रामिंग एक प्रोग्रामिंग प्रतिमान है जो डेटा प्रवाह और परिवर्तन के प्रसार पर केंद्रित है। आइए एक डेटा स्ट्रीम क्या है, इस पर करीब से नज़र डालते हैं।

 //     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 अतुल्यकालिक और घटना-आधारित कार्यक्रमों के साथ अवलोकन योग्य दृश्यों का उपयोग करके काम करने के लिए एक पुस्तकालय है। लाइब्रेरी मुख्य प्रकार के ऑब्जर्वेबल , कई सहायक प्रकारों ( ऑब्जर्वर, शेड्यूलर्स, सब्जेक्ट्स ) और घटनाओं के साथ काम करने वाले ऑपरेटरों ( मैप, फिल्टर, कम, हर तरह और जावास्क्रिप्ट ऐरे से पसंद) प्रदान करती है।

आइए इस लाइब्रेरी की मूल अवधारणाओं को देखें।

अवलोकनीय, ऑब्जर्वर, निर्माता

अवलोकनीय पहला बुनियादी प्रकार है जिसे हम देखेंगे। इस वर्ग में आरएक्सजे कार्यान्वयन के थोक शामिल हैं। यह एक अवलोकन योग्य धारा से जुड़ा है, जिसे आप सदस्यता विधि का उपयोग करके सदस्यता ले सकते हैं।

वेधशाला अद्यतन बनाने के लिए एक सहायक तंत्र को लागू करती है, तथाकथित प्रेक्षक । ऑब्जर्वर के मूल्यों के स्रोत को निर्माता कहा जाता है। यह एक सरणी, एक पुनरावृत्त, एक वेब सॉकेट, किसी प्रकार की घटना आदि हो सकता है। तो हम कह सकते हैं कि अवलोकनीय निर्माता और पर्यवेक्षक के बीच एक कंडक्टर है।

वेधशाला तीन प्रकार की प्रेक्षक घटनाओं को संभालती है:

अगला - नया डेटा
त्रुटि - एक त्रुटि यदि अनुक्रम अपवाद के कारण समाप्त हो गया। इस घटना में अनुक्रम का पूरा होना भी शामिल है।
अनुक्रम के पूरा होने के बारे में पूरा संकेत। इसका मतलब है कि कोई नया डेटा नहीं होगा।

आइए देखें डेमो:

शुरुआत में हम 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) );

ऑपरेटर हमें धाराओं के साथ काम करने की क्षमता प्रदान करते हैं। वे ऑब्जर्वेबल में होने वाली घटनाओं को नियंत्रित करने में मदद करते हैं। हम सबसे लोकप्रिय लोगों में से एक जोड़े पर विचार करेंगे, और ऑपरेटरों को उपयोगी जानकारी के लिंक का उपयोग करके अधिक विस्तार से पाया जा सकता है।

संचालक - का

हम सहायक ऑपरेटर के साथ शुरू करते हैं। यह एक साधारण मूल्य के आधार पर एक ऑब्जर्वेबल बनाता है।

संचालक - फिल्टर

फ़िल्टर ऑपरेटर फ़िल्टर, जैसा कि नाम से पता चलता है, स्ट्रीम सिग्नल को फ़िल्टर करता है। यदि ऑपरेटर सही लौटाता है, तो आगे खिसक जाता है।

संचालक - ले

ले - उत्सर्जन की संख्या का मान लेता है, जिसके बाद धारा समाप्त हो जाती है।

ऑपरेटर्स - डिबेटटाइम

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

यह तब तक मूल्यों का उत्सर्जन करता है जब तक कि टेकहाइल झूठे नहीं हो जाता है, जिसके बाद यह धारा से सदस्यता समाप्त कर देगा।

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

ऑपरेटर्स - कम्बाइंडलैस्ट

कम्बाइन CombLLestest ऑपरेटर कुछ हद तक वादा के समान है। यह एक में कई धागे जोड़ती है। प्रत्येक थ्रेड कम से कम एक उत्सर्जन करने के बाद, हम एक सरणी के रूप में प्रत्येक से अंतिम मान प्राप्त करते हैं। इसके अलावा, संयुक्त प्रवाह से किसी भी उत्सर्जन के बाद, यह नए मान देगा।

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

ऑपरेटर - शेयर, टैप करें

टैप ऑपरेटर - आपको साइड इफेक्ट करने की अनुमति देता है, अर्थात्, कोई भी कार्य जो अनुक्रम को प्रभावित नहीं करता है।

उपयोगिता शेयर ऑपरेटर इसे एक ठंडी धारा से गर्म बना सकता है।

ऑपरेटरों के साथ समाप्त हो गया। चलो विषय पर चलते हैं।

कान में विचार

और फिर मैं कुछ गुल पीने चला गया। ये उदाहरण मुझे बोर करते हैं: डी

विषय परिवार

विषय परिवार गर्म धाराओं का एक प्रमुख उदाहरण है। ये वर्ग एक प्रकार के संकर हैं जो एक साथ अवलोकन और पर्यवेक्षक के रूप में कार्य करते हैं। चूंकि विषय एक गर्म धारा है, इसलिए आपको इससे सदस्यता समाप्त करने की आवश्यकता है। अगर हम बुनियादी तरीकों के बारे में बात करते हैं, तो यह:

अगला - स्ट्रीम में नए डेटा का स्थानांतरण
त्रुटि - त्रुटि और धारा की समाप्ति
पूर्ण - धारा का पूरा होना
subscribe - स्ट्रीम को सब्सक्राइब करे
unsubscribe - स्ट्रीम से अनसब्सक्राइब करें
asObservable - एक पर्यवेक्षक में बदलना
समझौता करना - एक वादे में तब्दील होना

छिपाना 4 5 प्रकार का विषय।

कान में विचार

उन्होंने धारा 4 पर बात की, लेकिन यह पता चला कि उन्होंने एक और जोड़ दिया। जैसा कि कहा जाता है, जीना और सीखना।

सरल विषय new Subject() सबसे सरल प्रकार का विषय है। यह मापदंडों के बिना बनाया गया है। उन मानों को पास करता है जो सदस्यता के बाद ही आए थे।

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

ReplaySubject new ReplaySubject(bufferSize?: number, windowTime?: number) - इनपुट वैकल्पिक रूप से पहले तर्क को मानों के बफर के आकार के रूप में स्वीकार कर सकता है जिसे वह अपने आप में संग्रहीत करेगा, और दूसरी बार जिसके दौरान उसे बदलावों की आवश्यकता होगी।

AsyncSubject new AsyncSubject() - सबस्क्राइब करते समय कुछ नहीं होता है, और वैल्यू केवल पूर्ण होने पर वापस की जाएगी। केवल अंतिम स्ट्रीम मान लौटाया जाएगा।

WebSocketSubject new WebSocketSubject(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>) - डॉक्यूमेंटेशन इसके बारे में चुप है और मैं इसे पहली बार देख रहा हूं। कौन जानता है कि वह क्या कर रहा है, लिखना, पूरक।

FWF। खैर, यहाँ हमने उस सब पर विचार किया है जो मैं आज बताना चाहता था। मुझे उम्मीद है कि यह जानकारी उपयोगी थी। आप उपयोगी जानकारी टैब में संदर्भों की सूची से खुद को परिचित कर सकते हैं।

अतुल्यकालिक जावास्क्रिप्ट प्रोग्रामिंग (कॉलबैक, वादा, RxJs)

अतुल्यकालिक कोड का विकास।

डेटा स्ट्रीम

अवलोकनीय, ऑब्जर्वर, निर्माता

अंशदान

धाराओं के प्रकार

ऑपरेटर्स

विषय परिवार

उपयोगी जानकारी

More articles: