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

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

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

अनेकता एक संग्रह है जिसके तत्वों को "आखिरी बार, पहले बाहर" LIFO के आधार पर पुनर्प्राप्त किया जाता है

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

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

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

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

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

आइए निम्नलिखित उदाहरण पर एक नज़र डालें और इसे चरण दर चरण देखें। आइए यह भी देखें कि सिस्टम में क्या होता है.

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

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

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

3) और यह पूरा हो गया है

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

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

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

7) setTimeout(function cb1() {... }) कमांड ने अपना काम पूरा कर लिया है और कॉल स्टैक से हटा दिया गया है।

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

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

10) कमांड console.log('Bye') को कॉल स्टैक से हटा दिया गया है।

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

12) इवेंट लूप कॉलबैक कतार से फ़ंक्शन सीबी1 लेता है और इसे कॉल स्टैक पर धकेलता है।

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

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

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

16) फ़ंक्शन सीबी1 को कॉल स्टैक से हटा दिया गया है।

आइए गतिशीलता में एक उदाहरण देखें:

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

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

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

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

संचालक-का

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

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

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

संचालक- लीजिए

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

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

डिबाउंसटाइम - आउटपुट डेटा के बीच निर्दिष्ट समय अंतराल के भीतर आने वाले उत्सर्जित मूल्यों को त्याग देता है - समय अंतराल बीत जाने के बाद, अंतिम मान उत्सर्जित करता है।

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

ऑपरेटर्स-टेकव्हाइल

जब तक टेकव्हाइल गलत नहीं लौटता, तब तक मान उत्सर्जित करता है, फिर थ्रेड से सदस्यता समाप्त कर देता है।

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

ऑपरेटर्स-कंबाइनलेटेस्ट

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

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

ऑपरेटर्स - फोर्कजॉइन

फोर्कजॉइन भी थ्रेड्स से जुड़ता है, लेकिन यह केवल तभी एक मान उत्सर्जित करता है जब सभी थ्रेड्स पूर्ण हो जाते हैं।

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 - एक पर्यवेक्षक में परिवर्तित करें
• toPromise - एक वादे में बदल जाता है

4 5 प्रकार के विषय आवंटित करें।

बहुत अधिक सोचना

मैंने स्ट्रीम पर 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>) - दस्तावेज़ीकरण इसके बारे में चुप है और मैं स्वयं इसे पहली बार देखता हूँ। कौन जाने क्या करता है, लिखो, हम जोड़ देंगे।

उफ़्फ़. ख़ैर, आज मैं जो कुछ भी बताना चाहता था, हमने उस पर विचार कर लिया है। आशा है यह जानकारी उपयोगी रही होगी. आप उपयोगी सूचना टैब में साहित्य की सूची स्वयं पढ़ सकते हैं।

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

• स्ट्रीम से लिंक करें
• जेएस कैसे काम करता है: इंजन, रनटाइम तंत्र, कॉल स्टैक का अवलोकन
• जेएस कैसे काम करता है: इवेंट लूप, एसिंक, और एसिंक/वेट के साथ अपने कोड को बेहतर बनाने के पांच तरीके
• JavaSript में इवेंट लूप कैसे काम करता है
• अतुल्यकालिक जावास्क्रिप्ट का विकास
• RxJS क्या है और इसके बारे में जानना क्यों उपयोगी है
  
• RxJS का व्यावहारिक अनुप्रयोग
• आरएक्सजेएस ऑब्जर्वेबल्स ट्यूटोरियल - ऑब्जर्वेबल्स बनाना और सदस्यता लेना
• आरएक्सजेएस: गर्म और ठंडे वेधशालाएँ
• ऑब्जर्वेबल बनाने के लिए कक्षाएं, फ़ंक्शन। संचालक।
• उदाहरण के तौर पर RxJS ऑपरेटर्स
• एपीआई सूची
• RxJS में विषय और अनुसूची की विविधताएँ

स्रोत: www.habr.com