हमें फ्लैटपाइप का उपयोग करने की आवश्यकता क्यों है?

Question 1

मैं RxJS का उपयोग करना शुरू कर रहा हूं और मुझे समझ में नहीं आ रहा है कि इस उदाहरण में हमें किसी फ़ंक्शन का उपयोग करने की आवश्यकता है flatMapया concatAll; यहाँ ऐरे की सरणी कहाँ है?

var requestStream = Rx.Observable.just('https://api.github.com/users');

var responseMetastream = requestStream
  .flatMap(function(requestUrl) {
    return Rx.Observable.fromPromise(jQuery.getJSON(requestUrl));
  });

responseMetastream.subscribe(url => {console.log(url)})

यदि कोई नेत्रहीन बता सकता है कि क्या हो रहा है, तो यह बहुत मददगार होगा।

Question 2

जब मेरी नज़र Rxjsउस पर पड़ी तो मैंने भी उस पत्थर पर ठोकर मारी। निम्नलिखित में से मुझे क्या मदद मिली:

reactivex.io से प्रलेखन। उदाहरण के लिए, इसके लिए flatMap: http://reactivex.io/documentation/operators/flatmap.html
rxmarbles से प्रलेखन: http://rxmarbles.com/ । आपको flatMapवहां नहीं मिलेगा , आपको mergeMapइसके बजाय (किसी अन्य नाम) को देखना होगा ।
आरएक्स का परिचय जो आपको याद आ रहा है: https://gist.github.com/staltz/868e7e9bc2a7b8c1f754 । यह एक बहुत ही समान उदाहरण को संबोधित करता है। विशेष रूप से यह इस तथ्य को संबोधित करता है कि एक वादा केवल एक मूल्य का पालन करने योग्य अवलोकन के समान है।
अंत में RxJava से टाइप जानकारी देख रहे हैं। जावास्क्रिप्ट टाइप नहीं होने से यहाँ मदद नहीं मिलती है। मूल रूप से यदि Observable<T>एक अवलोकनीय वस्तु को दर्शाता है जो टाइप टी के मूल्यों को आगे बढ़ाता है, तो इसके तर्क के रूप flatMapमें प्रकार का एक फ़ंक्शन लेता है T' -> Observable<T>, और वापस लौटता है Observable<T>। mapप्रकार T' -> Tऔर रिटर्न देता है Observable<T>।

अपने उदाहरण पर वापस जा रहे हैं, आपके पास एक फ़ंक्शन है जो एक url स्ट्रिंग से वादे पैदा करता है। तो T' : string, और T : promise। और जो हमने पहले कहा promise : Observable<T''>, उससे T : Observable<T''>, साथ T'' : html। यदि आप उस वादे के फलन समारोह में डालते हैं map, तो आपको वह मिलता है Observable<Observable<T''>>जब आप चाहते हैं Observable<T''>: आप चाहते हैं कि htmlमानों का पालन करने योग्य हो । flatMapइस तरह कहा जाता है क्योंकि यह समतल करता है (एक अवलोकनीय परत को हटाता है) से परिणाम map। आपकी पृष्ठभूमि के आधार पर, यह आपके लिए चीनी हो सकता है, लेकिन जानकारी टाइप करने और यहां से आरेखण के साथ सब कुछ मेरे लिए स्पष्ट हो गया है: http://reactivex.io/documentation/operators/flatmap.html ।

Question 3

['a','b','c'].flatMap(function(e) {
    return [e, e+ 'x', e+ 'y',  e+ 'z'  ];
});
//['a', 'ax', 'ay', 'az', 'b', 'bx', 'by', 'bz', 'c', 'cx', 'cy', 'cz']


['a','b','c'].map(function(e) {
    return [e, e+ 'x', e+ 'y',  e+ 'z'  ];
});
//[Array[4], Array[4], Array[4]]

जब आप एक ऑब्जर्वेबल होते हैं तो आप फ्लैटपाइप का उपयोग करते हैं जिसके परिणाम अधिक ऑब्जर्वेबल होते हैं।

यदि आपके पास एक ऑब्जर्वेबल है, जो एक अन्य ऑब्जर्वेबल द्वारा निर्मित है, तो आप इसे फ़िल्टर नहीं कर सकते, कम कर सकते हैं, या सीधे मैप कर सकते हैं क्योंकि आपके पास ऑब्जर्वेबल है डेटा नहीं। यदि आप नक्शे पर एक अवलोकन विकल्प का चयन करते हैं; तब आप ठीक हैं।

दूसरे स्निपेट की तरह, यदि आप एसिंक्स ऑपरेशन कर रहे हैं तो आपको फ्लैटपाइप का उपयोग करने की आवश्यकता है।

var source = Rx.Observable.interval(100).take(10).map(function(num){
    return num+1
});
source.subscribe(function(e){
    console.log(e)
})

<script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/5.4.1/Rx.min.js"></script>

स्निपेट का विस्तार करें

var source = Rx.Observable.interval(100).take(10).flatMap(function(num){
    return Rx.Observable.timer(100).map(() => num)
});
source.subscribe(function(e){
    console.log(e)
})

<script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/5.4.1/Rx.min.js"></script>

स्निपेट का विस्तार करें

Question 4

flatMap एक वेधशाला द्वारा उत्सर्जित वस्तुओं को नए वेधशालाओं में बदलना, फिर उनमें से उत्सर्जन को एक ही वेधशाला में बदलना।

नीचे के परिदृश्य को देखें जहां get("posts")एक अवलोकन योग्य है जो "चपटा" है flatMap।

myObservable.map(e => get("posts")).subscribe(o => console.log(o));
// this would log Observable objects to console.  

myObservable.flatMap(e => get("posts")).subscribe(o => console.log(o));
// this would log posts to console.

Question 5

लोग जो कहते हैं परिभाषा देकर जटिल चीजों पर काबू पाते हैं:

फ़्लैटबॉल वेधशाला द्वारा उत्सर्जित वस्तुओं को वेधशालाओं में परिवर्तित करते हैं, फिर उनमे से उत्सर्जन को एक ही अवलोकन में समतल करते हैं

मैं कसम खाता हूं कि यह परिभाषा अभी भी मुझे भ्रमित करती है लेकिन मैं इसे सबसे सरल तरीके से समझाने जा रहा हूं जो एक उदाहरण का उपयोग करके है

हमारी स्थिति : हमारे पास एक अवलोकन योग्य है जो डेटा (सरल URL) लौटाता है जिसे हम एक HTTP कॉल करने के लिए उपयोग करने जा रहे हैं जो एक अवलोकन योग्य डेटा को लौटाएगा जिसकी हमें आवश्यकता है ताकि आप इस तरह की स्थिति की कल्पना कर सकें:

Observable 1
    |_
       Make Http Call Using Observable 1 Data (returns Observable_2)
            |_
               The Data We Need

इसलिए जैसा कि आप देख सकते हैं कि हम उस डेटा तक नहीं पहुँच सकते हैं जिसकी हमें सीधे ज़रूरत है इसलिए डेटा को पुनः प्राप्त करने का पहला तरीका जो हम सामान्य सदस्यताएँ जैसे उपयोग कर सकते हैं:

Observable_1.subscribe((URL) => {
         Http.get(URL).subscribe((Data_We_Need) => {
                  console.log(Data_We_Need);
          });
});

यह काम करता है लेकिन जैसा कि आप देख सकते हैं कि हमें अपना डेटा प्राप्त करने के लिए घोंसले की सदस्यता लेनी होगी यह वर्तमान में बुरा नहीं लगता है लेकिन कल्पना करें कि हमारे पास 10 नेस्टेड सदस्यता हैं जो कि अप्राप्य हो जाएंगे।

तो इसे संभालने का एक बेहतर तरीका यह है कि आप ऑपरेटर का उपयोग करें flatMapजो कि वही काम करेगा लेकिन हमें उस नेस्टेड सब्सक्रिप्शन से बचना चाहिए:

Observable_1
    .flatMap(URL => Http.get(URL))
    .subscribe(Data_We_Need => console.log(Data_We_Need));

Question 6

सरल:

[1,2,3].map(x => [x, x * 10])
// [[1, 10], [2, 20], [3, 30]]

[1,2,3].flatMap(x => [x, x * 10])
// [1, 10, 2, 20, 3, 30]]

Question 7

यह सरणियों की एक सरणी नहीं है। यह अवलोकनीय है।

निम्नलिखित स्ट्रिंग का एक अवलोकन योग्य स्ट्रीम देता है।

requestStream
  .map(function(requestUrl) {
    return requestUrl;
  });

जबकि यह जस्सन के अवलोकन योग्य धारा का एक अवलोकन योग्य प्रवाह देता है

requestStream
  .map(function(requestUrl) {
    return Rx.Observable.fromPromise(jQuery.getJSON(requestUrl));
  });

flatMap हमारे लिए अवलोकनीय स्वचालित रूप से समतल करता है ताकि हम सीधे जस्सन धारा का निरीक्षण कर सकें

Question 8

यहां सब्सक्राइबर्स का उपयोग कर एक फ्लैटपाइप के बराबर कार्यान्वयन दिखाने के लिए।

बिना फ्लैटपोट के:

this.searchField.valueChanges.debounceTime(400)
.subscribe(
  term => this.searchService.search(term)
  .subscribe( results => {
      console.log(results);  
      this.result = results;
    }
  );
);

फ्लैटपाइप के साथ:

this.searchField.valueChanges.debounceTime(400)
    .flatMap(term => this.searchService.search(term))
    .subscribe(results => {
      console.log(results);
      this.result = results;
    });

http://plnkr.co/edit/BHGmEcdS5eQGX703eRRE?p=preview

आशा है कि यह मदद कर सकता है।

ओलिवर।

Question 9

एक अवलोकन योग्य एक वस्तु है जो घटनाओं की एक धारा का उत्सर्जन करती है: अगला, त्रुटि और पूर्ण।

जब आपका फ़ंक्शन एक ऑब्जर्वेबल लौटाता है, तो यह एक स्ट्रीम नहीं लौट रहा है, लेकिन ऑब्जर्वेबल का एक उदाहरण है। flatMapऑपरेटर बस एक धारा है कि उदाहरण के नक्शे।

इसकी flatMapतुलना में यह व्यवहार है map: दिए गए कार्य को निष्पादित करें और परिणामी वस्तु को एक धारा में समतल करें।

Question 10

फ्लैटपोट के साथ

var requestStream = Rx.Observable.just('https://api.github.com/users');

var responseMetastream = requestStream
  .flatMap(function(requestUrl) {
    return Rx.Observable.fromPromise(jQuery.getJSON(requestUrl));
  });

responseMetastream.subscribe(json => {console.log(json)})

बिना फ्लैटपोट के

var requestStream = Rx.Observable.just('https://api.github.com/users');

var responseMetastream = requestStream
  .map(function(requestUrl) {
    return Rx.Observable.fromPromise(jQuery.getJSON(requestUrl));
  });

responseMetastream.subscribe(jsonStream => {
  jsonStream.subscribe(json => {console.log(json)})
})

Question 11

फ़्लैटबॉल वेधशाला द्वारा उत्सर्जित वस्तुओं को वेधशालाओं में परिवर्तित करते हैं, फिर उनमे से उत्सर्जन को एक ही अवलोकन में समतल करते हैं

मैं बेवकूफ नहीं हूं लेकिन मुझे 10 बार पढ़ना पड़ा और अभी भी नहीं मिला। जब मैंने कोड स्निपेट पढ़ा:

[1,2,3].map(x => [x, x * 10])
// [[1, 10], [2, 20], [3, 30]]

[1,2,3].flatMap(x => [x, x * 10])
// [1, 10, 2, 20, 3, 30]

तब मैं समझ सका कि क्या हो रहा है, यह दो काम करता है:

फ्लैटपाइप :

नक्शा : परिवर्तन *) वेधशालाओं में उत्सर्जित आइटम।

फ्लैट : फिर एक वेधशाला के रूप में उन वेधशालाओं को मर्ज करें।

*) ट्रांसफॉर्म शब्द कहता है कि आइटम को किसी और चीज में बदला जा सकता है।

फिर मर्ज ऑपरेटर के लिए स्पष्ट हो जाता है, यह मैपिंग के बिना सपाट करता है। इसे मर्ज मैप क्यों नहीं कहा जा रहा है ? ऐसा लगता है भी है एक उर्फ mergeMap के लिए है कि नाम के साथ flatMap ।