RxDart: प्रवाह के जादुई रूपांतरण

स्वागत है - यह मेरे स्प्लिट आर्किटेक्चर लेख श्रृंखला का तीसरा भाग है।

• परिचय
• डार्ट स्ट्रीम बेसिक्स
• RxDart: मैजिक स्ट्रीम ट्रांसफॉर्मेशन (यह पोस्ट)
• RxVMS मूल बातें: RxCommand और GetIt
• RxVMS: सेवाएं और प्रबंधक
• RxVMS: स्व-निहित विजेट
• RxVMS के साथ उपयोगकर्ता प्रमाणीकरण

इस बार हम प्रतिक्रियाशील एक्सटेंशन (Rx) के जादुई दायरे में एक छोटा गोता लगाएँगे। मैं सबसे अधिक उपयोग किए जाने वाले आरएक्स फ़ंक्शंस पर ध्यान केंद्रित करूंगा और उनके आवेदन की व्याख्या करूंगा। यदि आपने पिछली पोस्ट नहीं पढ़ी है, तो अब आगे बढ़ने से पहले इसके लिए समय है।

आरएक्सडार्ट डार्ट भाषा के लिए आरएक्स अवधारणा का कार्यान्वयन है, इसके लिए फ्रैंक पेपरमैन्स और ब्रायन एगन को धन्यवाद। यदि आप पहले अन्य भाषाओं में Rx का उपयोग करते हैं, तो आप संभवतः कई कार्यों के नामकरण में अंतर देखेंगे, लेकिन इससे आपको कोई कठिनाई होने की संभावना नहीं है।

परीक्षण के लिए कोड यहाँ है ।

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

वेधशालाएँ बनाना

जैसा कि पहले कहा गया है , ऑब्जर्वबल्स महान विशेषताओं के साथ धाराओं के आरएक्स संस्करण हैं। उन्हें बनाने के कई दिलचस्प तरीके हैं:

धारा से बाहर

किसी भी स्ट्रीम को कंस्ट्रक्टर में बदलकर ऑब्जर्वेबल में बदला जा सकता है:

var controller = new StreamController<String>(); var streamObservable = new Observable(controller.stream); streamObservable.listen(print); 

आवर्ती घटनाएँ

 var timerObservable = Observable.periodic(Duration(seconds: 1), (x) => x.toString() ); timerObservable.listen(print); 

इस तरह, एक अवलोकन योग्य निर्माण किया जाएगा जो एक विशिष्ट अवधि के साथ मूल्यों को प्रदर्शित करता है। तो आप टाइमर को बदल सकते हैं।

एक मूल्य से

कभी-कभी एक एपीआई एक स्ट्रीम / ऑब्जर्वेबल की अपेक्षा करता है जहां आपके पास बस एक मूल्य है। ऐसे मामलों के लिए, ऑब्जर्वेबल का एक कारखाना है।

 var justObservable = Observable<int>.just(42); justObservable.listen(print); //   : 42 

भविष्य से

  Future<String> asyncFunction() async { return Future.delayed(const Duration(seconds: 1), () => "AsyncRsult"); } test('Create Observable from Future', () async { print('start'); var fromFutureObservable = Observable.fromFuture(asyncFunction()); fromFutureObservable.listen(print); 

फ्यूचर से Observable बनाने से फ्यूचर के पूरा होने और उसके रिजल्ट के लिए वैल्यू लौटाने या वैल्यू वापस न आने पर null होने का इंतजार होगा। Future से स्ट्रीम बनाने का दूसरा तरीका है किसी भी Future के लिए toStream() को कॉल toStream() ।

आप सोच रहे होंगे कि फ्यूचर को ऑब्जर्वेबल / स्ट्रीम में बदलने का क्या मतलब है, बजाय इसके इंतजार करने के। निश्चिंत रहें, यह स्पष्ट हो जाएगा जब हम स्ट्रीम में रहते हुए डेटा में हेरफेर के लिए उपलब्ध कार्यों की जांच करेंगे।

विषय

Subjects RxDart में स्ट्रीमकंट्रोलर के लिए एक प्रतिस्थापन है, और यह है कि उन्हें लाइब्रेरी के बाउल में कहीं पर लागू किया गया है।

लेकिन उनका व्यवहार मूल StreamControllers से थोड़ा अलग है:

• आप स्ट्रीम प्रॉपर्टी को एक्सेस किए बिना सीधे एक विषय पर listen() आवेदन कर सकते हैं
• सदस्यता की कोई भी संख्या उपलब्ध है, और सभी श्रोताओं को एक ही समय में एक ही डेटा प्राप्त होता है
• विषय की तीन किस्में हैं, जिन्हें नीचे उदाहरण के साथ समझाया गया है:

PublishSubjects

अनेक श्रोताओं की संभावना को छोड़कर, PublishSubjects ने PublishSubjects तरह व्यवहार किया:

 var subject = new PublishSubject<String>(); subject.listen((item) => print(item)); subject.add("Item1"); //    subject.listen((item) => print(item.toUpperCase())); subject.add("Item2"); subject.add("Item3"); //        await Future.delayed(Duration(seconds: 5)); //    subject.close; 

इस कोड को चलाएं और आपको मिलेगा:

 Item1 ITEM2 Item2 ITEM3 Item3 

यह स्पष्ट है कि दूसरा श्रोता जो पार्टी के लिए देर से था (हम उन्हें देर से सदस्य कहेंगे) पहले बिंदु से चूक गए। इससे बचने के लिए, आप BehaviourSubject उपयोग कर सकते हैं

BehaviourSubject

BehaviourSubject साथ BehaviourSubject प्रत्येक नए ग्राहक को पहले अंतिम स्वीकृत मूल्य प्राप्त होगा:

 var subject = new BehaviorSubject<String>(); subject.listen((item) => print(item)); subject.add("Item1"); subject.add("Item2"); subject.listen((item) => print(item.toUpperCase())); subject.add("Item3"); 

बाहर निकलने पर

 Item1 ITEM2 ITEM3 Item2 Item3 

आप देख सकते हैं कि Item1 दूसरे ग्राहक के लिए खो गया है, लेकिन यह Item2 को प्राप्त करता है। आपको आश्चर्य हो सकता है कि पहला ग्राहक Item2 को प्राप्त करने से पहले दूसरा ग्राहक Item3 को प्राप्त करता है। ऐसा इसलिए है क्योंकि सबस्क्राइबर्स के अनुक्रम की गारंटी नहीं है, हालांकि सभी ग्राहकों को सही क्रम में डेटा प्राप्त होता है। BehaviourSubject केवल देर से ग्राहकों के लिए प्राप्त अंतिम आइटम को कैश करता है। यदि आपको अधिक तत्वों को कैश करने की आवश्यकता है, तो आप ReplaySubject का उपयोग कर सकते हैं। ज्यादातर मामलों में यह आवश्यक नहीं है।

मक्खी पर डेटा हेरफेर

आरएक्स की असली ताकत इस तथ्य में निहित है कि यह आपको स्ट्रीम पर ट्रांसमिशन के दौरान डेटा को संसाधित करने की अनुमति देता है। आरएक्स विधियों में से प्रत्येक परिणामी डेटा (उदाहरण के अनुसार) के साथ एक नई धारा देता है, जिसका अर्थ है कि आप उन्हें एक प्रसंस्करण पाइपलाइन में एक साथ बांध सकते हैं, और यह आरएक्स को एक बहुत शक्तिशाली उपकरण बनाता है।

नक्शा

यदि कोई स्ट्रीम ऑपरेशन है जिसे मैं सबसे अधिक याद नहीं करना चाहता हूं, तो यह map() । map() क्या करता है कि यह प्रत्येक डेटा आइटम को स्थानांतरित करने के लिए लेता है और उस पर एक निश्चित फ़ंक्शन लागू करता है, जिसके बाद यह परिणामी स्ट्रीम में परिणाम डालता है। एक सरल उदाहरण:

 var subject = new PublishSubject<String>(); subject.map((item) => item.toUpperCase()).listen(print); subject.add("Item1"); subject.add("Item2"); subject.add("Item3"); 

परिणाम:

 ITEM1 ITEM2 ITEM3 

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

 var subject = new PublishSubject<int>(); subject.map((intValue) => intValue.toString()) .map((item) => item.toUpperCase()) .listen(print); subject.add(1); subject.add(2); subject.add(3); 

या ऐसा कुछ:

 class DataClass{} class WrapperClass { final DataClass wrapped; WrapperClass(this.wrapped); } var subject = new PublishSubject<WrapperClass>(); subject.map<WrapperClass>((a) => new WrapperClass(a)); 

.map के सबसे उपयोगी उपयोगों में से एक है जब आप किसी REST API या डेटाबेस से एक प्रारूप में डेटा प्राप्त करते हैं और चाहते हैं कि उन्हें अपनी वस्तुओं में परिवर्तित कर दिया जाए:

 class User { final String name; final String adress; final String phoneNumber; final int age; //       - //   factory User.fromJson(String jsonString) { var jsonMap = json.decode(jsonString); return User( jsonMap['name'], jsonMap['adress'], jsonMap['phoneNumber'], jsonMap['age'], ); } User(this.name, this.adress, this.phoneNumber, this.age); @override String toString() { return '$name - $adress - $phoneNumber - $age'; } } void main() { test('Map', () { // -  var jsonStrings = [ '{"name": "Jon Doe", "adress": "New York", "phoneNumber":"424242","age": 42 }', '{"name": "Stephen King", "adress": "Castle Rock", "phoneNumber":"123456","age": 71 }', '{"name": "Jon F. Kennedy", "adress": "Washington", "phoneNumber":"111111","age": 66 }', ]; //   json-,    API/DB. var dataStreamFromAPI = new PublishSubject<String>(); dataStreamFromAPI .map<User>((jsonString) => User.fromJson(jsonString)) // json -> User .listen((user) => print(user.toString())); //    dataStreamFromAPI.add(jsonStrings[0]); dataStreamFromAPI.add(jsonStrings[1]); dataStreamFromAPI.add(jsonStrings[2]); }); 

मैं ध्यान देता हूं कि न केवल स्ट्रीम, बल्कि कोई भी Iterable एक map फ़ंक्शन प्रदान करता है जिसका उपयोग आप सूचियों में परिवर्तनों के लिए कर सकते हैं।

जहाँ

यदि आप केवल स्ट्रीम में होने वाले कुछ निश्चित मानों में रुचि रखते हैं, तो आप अपने श्रोता में if का उपयोग करने के बजाय .where() फ़ंक्शन का उपयोग कर सकते हैं, यह अधिक अभिव्यंजक और पढ़ने में आसान है:

 var subject = new PublishSubject<int>(); subject.where((val) => val.isOdd) .listen( (val) => print('This only prints odd numbers: $val')); subject.where((val) => val.isEven) .listen( (val) => print('This only prints even numbers: $val')); subject.add(1); subject.add(2); subject.add(3); //: This only prints odd numbers: 1 This only prints even numbers: 2 This only prints odd numbers: 3 

debounce

यह Rx के छोटे मोती में से एक है! कल्पना करें कि आपके पास एक खोज क्षेत्र है जो REST API को कॉल करता है यदि इसका पाठ बदला जाता है। हर कीस्ट्रोके के लिए एपीआई कॉल करना महंगा है। इस प्रकार, आप केवल तभी कॉल करना चाहेंगे जब उपयोगकर्ता एक पल के लिए रुक जाए। इसके लिए, debounce() फ़ंक्शन का उपयोग किया जाता है, जो सभी आवक घटनाओं को निगल लेता है अगर वे एक ठहराव के बाद नहीं होते हैं।

 var subject = new PublishSubject<String>(); subject.debounce(new Duration(milliseconds: 500)).listen((s) => print(s)); subject.add('A'); subject.add('AB'); await Future.delayed(Duration(milliseconds: 200)); subject.add("ABC"); //    await Future.delayed(Duration(milliseconds: 700)); //       : 'ABC' 

इसलिए, यदि आप TextField.onChanged हैंडलर को Observable , तो आपको एक सुंदर समाधान मिलेगा।

विस्तृत करें

यदि आपका स्रोत स्ट्रीम ऑब्जेक्टों के सरणियों का उत्सर्जन करता है, और आप प्रत्येक ऑब्जेक्ट को स्वयं संसाधित करना चाहते हैं, तो आप .expand उपयोग कर सकते हैं, जो कि केवल इस प्रकार होगा:

आप इस विधि का आवेदन नीचे फायरस्टोर उदाहरण में देखेंगे।

मर्ज

यदि आपके पास कई अलग-अलग धागे हैं, लेकिन आप उनकी वस्तुओं को एक साथ संसाधित करना चाहते हैं, तो आप .mergeWith उपयोग कर सकते हैं (अन्य Rx कार्यान्वयनों में केवल merge ), जो थ्रेड्स की एक सरणी लेता है और एक मर्ज किए गए थ्रेड देता है।

.mergeWith यह गारंटी नहीं देता है कि धाराओं में कोई भी आदेश मर्ज किया गया है। डेटा इनपुट क्रम में उत्सर्जित होता है।

उदाहरण के लिए, यदि आपके पास दो घटक हैं जो एक स्ट्रीम के माध्यम से त्रुटियों की रिपोर्ट करते हैं, और आप उन्हें एक साथ एक संवाद में प्रदर्शित करना चाहते हैं, तो आप निम्नानुसार कर सकते हैं (छद्म कोड):

 @override initState() { super.initState(); component1.errors.mergeWith([component2.errors]) .listen( (error) async => await showDialog(error.message)); } 

या यदि आप कई सामाजिक नेटवर्क से संदेशों का एक संयुक्त प्रदर्शन चाहते हैं, तो यह इस तरह दिख सकता है (स्यूडोकोड):

 final observableTwitter = getTwitterStream().map((data) => new MyAppPost.fromTwitter(data)); final observableFacebook = getFacebookStream().map((data) => new MyAppPost.fromFaceBook(data)); final postStream = observableTwitter.mergeWith([observableFacebook]); 

ZipWith

zipWith एक स्ट्रीम को दूसरे के साथ मर्ज भी करता है। लेकिन, .mergeWith विपरीत, यह डेटा नहीं भेजता है क्योंकि यह अपने स्रोत धाराओं में से एक से एक तत्व प्राप्त करता है। वह तब तक इंतजार करता है जब तक कि दोनों स्रोत धाराओं के तत्व नहीं आते हैं, और फिर प्रदान किए गए zipper फ़ंक्शन का उपयोग करके उन्हें जोड़ती है:

zipWith हस्ताक्षर डरावना लगता है, लेकिन अब हम इसे देखते हैं:

 // R :   Stream/Observable // S :   Stream/Observable // zipper: - Observable<R> zipWith<S, R>(Stream<S> other, R zipper(T t, S s)) 

एक बहुत ही सरल उदाहरण:

 new Observable.just(1) // .just()  Observable,    .zipWith(new Observable.just(2), (one, two) => one + two) .listen(print); //  3 

एक अधिक व्यावहारिक अनुप्रयोग यह है कि यदि आपको Future वापस आने वाले दो अतुल्यकालिक कार्यों की प्रतीक्षा करने की आवश्यकता है, और दोनों परिणाम वापस आते ही आप डेटा को संसाधित करना चाहते हैं। इस थोड़े से वंचित उदाहरण में, हम दो REST API प्रस्तुत करते हैं: एक User लौटाता है, दूसरा JSON तार के रूप में Product लौटाता है, और हम Invoice ऑब्जेक्ट को वापस करने से पहले दोनों कॉलों की प्रतीक्षा करना चाहते हैं।

 class Invoice { final User user; final Product product; Invoice(this.user, this.product); printInvoice() { print(user.toString()); print(product.toString()); } } //  HTTP ,  Product,  JSON Future<String> getProduct() async { print("Started getting product"); await Future.delayed(Duration(seconds: 2)); print("Finished getting product"); return '{"name": "Flux compensator", "price": 99999.99}'; } //  HTTP ,  User,  JSON Future<String> getUser() async { print("Started getting User"); await Future.delayed(Duration(seconds: 4)); print("Finished getting User"); return '{"name": "Jon Doe", "adress": "New York", "phoneNumber":"424242","age": 42 }'; } void main() { test('zipWith', () async { var userObservable = Observable.fromFuture(getUser()).map<User>((jsonString) => User.fromJson(jsonString)); var productObservable = Observable.fromFuture(getProduct()) .map<Product>((jsonString) => Product.fromJson(jsonString)); Observable<Invoice> invoiceObservable = userObservable.zipWith<Product, Invoice>( productObservable, (user, product) => Invoice(user, product)); print("Start listening for invoices"); invoiceObservable.listen((invoice) => invoice.printInvoice()); //        await Future.delayed(Duration(seconds: 5)); }); } 

आउटपुट को देखते हुए, आप देख सकते हैं कि यह कैसे एसिंक्रोनस रूप से किया जाता है

 Started getting User Started getting product Start listening for invoices Finished getting product Finished getting User Jon Doe - New York - 424242 - 42 Flux compensator - 99999.99 

CombineLatest

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

इससे पहले कि combineLates अपना पहला मूल्य combineLates , सभी स्रोत थ्रेड्स को कम से कम एक प्रविष्टि प्राप्त होनी चाहिए।

पहले इस्तेमाल किए गए तरीकों के विपरीत, combineLatest सबसे स्थिर है। इसके अलावा, चूंकि डार्ट ऑपरेटर को ओवरलोडिंग की अनुमति नहीं देता है, इसलिए स्रोत धाराओं की संख्या के आधार पर combLastest संस्करण हैं: CombLatest2 ... CombLatest9

उदाहरण के लिए, combineLatest अच्छा उपयोग है, यदि आपके पास दो Observable<bool> यह संकेत देता है कि आपके आवेदन के कुछ हिस्से व्यस्त हैं, और आप व्यस्त स्पिनर को प्रदर्शित करना चाहते हैं यदि उनमें से एक व्यस्त है। यह इस तरह दिख सकता है (छद्म कोड):

 class Model { Observable<bool> get isBusy => Observable.combineLatest2(isBusyOne,isBusyTwo, (b1, b2) => b1 || b2); PublishSubject<bool> isBusyOne; PublishSubject<bool> isBusyTwo; } 

अपने UI में, आप Spinner को प्रदर्शित करने के लिए isBusy साथ StreamBuilder का उपयोग कर सकते हैं यदि परिणामी मूल्य सही है।

combineLatest FireStore स्नैपशॉट धाराओं के साथ संयोजन में combineLatest बहुत ही उपयुक्त विशेषता है।

कल्पना करें कि आप एक ऐसा एप्लिकेशन बनाना चाहते हैं जो मौसम के पूर्वानुमान के साथ समाचार फ़ीड प्रदर्शित करे। टिकर संदेश और मौसम डेटा दो अलग-अलग फायरस्टोर संग्रह में संग्रहीत हैं। दोनों स्वतंत्र रूप से अपडेट हैं। आप StreamBuilder का उपयोग करके डेटा अपडेट प्रदर्शित करना चाहते हैं। combineLatest साथ combineLatest यह आसान है:

 class WeatherForecast { final String forecastText; final GeoPoint location; factory WeatherForecast.fromMap(Map<String, dynamic> map) { return WeatherForecast(map['forecastText'], map['location']); } WeatherForecast(this.forecastText, this.location); } class NewsMessage { final String newsText; final GeoPoint location; factory NewsMessage.fromMap(Map<String, dynamic> map) { return NewsMessage(map['newsText'], map['location']); } NewsMessage(this.newsText, this.location); } class CombinedMessage { final WeatherForecast forecast; final NewsMessage newsMessage; CombinedMessage(this.forecast, this.newsMessage); } class Model { CollectionReference weatherCollection; CollectionReference newsCollection; Model() { weatherCollection = Firestore.instance.collection('weather'); newsCollection = Firestore.instance.collection('news'); } Observable<CombinedMessage> getCombinedMessages() { Observable<WeatherForecast> weatherForecasts = weatherCollection .snapshots() .expand((snapShot) => snapShot.documents) .map<WeatherForecast>((document) => WeatherForecast.fromMap(document.data)); Observable<NewsMessage> news = newsCollection .snapshots() .expand((snapShot) => snapShot.documents) .map<NewsMessage>((document) => NewsMessage.fromMap(document.data)); return Observable.combineLatest2( weatherForecasts, news, (weather, news) => CombinedMessage(weather, news)); } } 

आपके UI में, यह कुछ इस तरह दिखेगा: StreamBuilder<CombinedMessage>(stream: model.getCombinedMessages(),...).

अलग

ऊपर वर्णित परिदृश्य में, ऐसा हो सकता है कि BBusyOne और isBusyTwo समान मूल्य देते हैं, जिससे उपयोगकर्ता इंटरफ़ेस का अद्यतन उसी डेटा के साथ होगा। इसे रोकने के लिए, हम .distinct() उपयोग कर सकते हैं। यह सुनिश्चित करता है कि डेटा केवल तभी स्ट्रीम किया जाता है जब नए तत्व का मूल्य पिछले से अलग हो। इस प्रकार, हम कोड को इसमें बदल देंगे:

  Observable<bool> isBusy => isBusyOne.mergeWith([isBusyTwo]).distinct(); 

और यह भी प्रदर्शित करता है कि हम अपने कार्यों को विभिन्न जंजीरों में जोड़ सकते हैं।

AsyncMap

map() अलावा map() एक asyncMap फ़ंक्शन भी है, जो आपको मानचित्र फ़ंक्शन के रूप में एक अतुल्यकालिक फ़ंक्शन का उपयोग करने की अनुमति देता है। आइए हमारे फायरस्टोर उदाहरण के लिए थोड़ा अलग सेटिंग पेश करें। अब आवश्यक WeatherForecast NewsMessage के स्थान पर निर्भर करता है और केवल तभी अपडेट होना चाहिए जब एक नया NewsMessage प्राप्त हो :

 Observable<CombinedMessage> getDependendMessages() { Observable<NewsMessage> news = newsCollection.snapshots().expand((snapShot) { return snapShot.documents; }).map<NewsMessage>((document) { return NewsMessage.fromMap(document.data); }); return news.asyncMap((newsEntry) async { var weatherDocuments = await weatherCollection.where('location', isEqualTo: newsEntry.location).getDocuments(); return new CombinedMessage( WeatherForecast.fromMap(weatherDocuments.documents.first.data), newsEntry); }); } 

GetD dependendMessages द्वारा लौटाए गए ऑब्ज़र्वेबल, हर बार NewsCollection परिवर्तन के दौरान एक नया CombinedMessage उत्पन्न करेगा।

डीबग वेधशालाएँ

सुरुचिपूर्ण Rx कॉल श्रृंखला को देखते हुए, इस तरह एक अभिव्यक्ति को डिबग करना लगभग असंभव लगता है:

 Observable<NewsMessage> news = newsCollection .snapshots() .expand((snapShot) => snapShot.documents) .map<NewsMessage>((document) => NewsMessage.fromMap(document.data)); 

लेकिन ध्यान रखें कि => एक अनाम फ़ंक्शन के लिए केवल एक संक्षिप्त रूप है। ब्लॉक बॉडी में कन्वर्ट का उपयोग करके, आपको मिलेगा:

 Observable<NewsMessage> news = newsCollection .snapshots() .expand((snapShot) { return snapShot.documents; }) .map<NewsMessage>((document) { return NewsMessage.fromMap(document.data); }); 

और अब हम एक ब्रेकपॉइंट सेट कर सकते हैं या अपनी पाइपलाइन के हर चरण पर प्रिंट स्टेटमेंट जोड़ सकते हैं।

साइड इफेक्ट्स से सावधान रहें

यदि आप अपने कोड को अधिक मजबूत बनाने के लिए Rx को भुनाना चाहते हैं, तो हमेशा ध्यान रखें कि Rx "कन्वेयर बेल्ट के साथ" चलते समय डेटा रूपांतरण है। इसलिए, कभी भी फ़ंक्शन को कॉल न करें जो प्रसंस्करण पाइपलाइन के बाहर किसी भी चर / राज्य को तब तक बदलते हैं जब तक आप।
ऐसा करने के बजाय:

 Observable.fromFuture(getProduct()) .map<Product>((jsonString) { var product = Product.fromJson(jsonString); database.save(product); setState((){ _product = product }); return product; }).listen(); 

यह करें:

 Observable.fromFuture(getProduct()) .map<Product>((jsonString) => Product.fromJson(jsonString)) .listen( (product) { database.save(product); setState((){ _product = product }); }); 

map() का कर्तव्य map() स्ट्रीम में डेटा को बदलना है, और कुछ भी नहीं! यदि पारित प्रदर्शन फ़ंक्शन कुछ और करता है, तो इसे संभावित त्रुटियों के रूप में साइड इफेक्ट माना जाएगा, जो कोड को पढ़ते समय पता लगाना मुश्किल है।

संसाधनों को मुक्त करने पर कुछ विचार

मेमोरी लीक से बचने के लिए, सब्स्क्रिप्शन के लिए हमेशा cancel() , स्ट्रीमकंट्रोलर्स के लिए डिस्पोजल close() , सब्जेक्ट्स के लिए close() , जैसे ही आपको जरूरत नहीं होती है।

निष्कर्ष

बधाई हो अगर आप इस क्षण तक मेरे साथ रहे। अब आप न केवल अपने जीवन को आसान बनाने के लिए Rx का उपयोग कर सकते हैं, बल्कि उन अगली पोस्टों के लिए भी तैयारी कर सकते हैं, जिनमें हम RxVMS के विवरणों को प्रस्तुत करेंगे ।