👨🏾‍🎨 🚺 ◻️ RxSwift भाग 1 🎿 ❎ 😮

ReactiveX logo

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

आइए शुरुआत करके देखें कि प्रतिक्रियात्मक प्रोग्रामिंग क्या है।

रिएक्टिव प्रोग्रामिंग एक प्रोग्रामिंग प्रतिमान है जो डेटा प्रवाह और परिवर्तन के प्रसार पर केंद्रित है।

यही महान विकिपीडिया हमें बताता है।

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

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

नमूदार

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

let observable = Observable<String>.just(" observable")

बिंगो ! हमने पहला अवलोकनीय बनाया।

तो क्या?

चूंकि हमने देखी गई वस्तु बनाई है, इसलिए यह तर्कसंगत है कि हमें एक ऐसी वस्तु बनाने की आवश्यकता है जो अवलोकन करेगी।

 let observable = Observable<String>.just(" observable") _ = observable.subscribe { (event) in print(event) }

हमें लॉग में निम्नलिखित मिलते हैं:

 next( observable) completed

पूरा?

अवलोकन योग्य हमें इसकी घटनाओं के बारे में जानकारी भेजता है, केवल 3 प्रकार हैं:

अगला
त्रुटि
पूरा

साथ में अगले तत्व के साथ वह तत्व आता है जिसे हमने भेजा था और हमारे द्वारा भेजे गए सभी ईवेंट, त्रुटि के रूप में नाम भेजा जाता है, और जब हमारे अवलोकनीय ने सभी डेटा भेजा है और समाप्त हो गया है तो मामले में पूरा हो जाएगा।

हम और अधिक विस्तृत बना सकते हैं ~~प्रेक्षक~~ सब इवेंट को संभालने के लिए एक अधिक सुविधाजनक दृश्य प्राप्त करें।

 _ = observable.subscribe(onNext: { (event) in print(event) }, onError: { (error) in print(error) }, onCompleted: { print("finish") }) { print("disposed") // ,          }

   finish disposed

अवलोकन में, आप न केवल एक पंक्ति से एक अनुक्रम बना सकते हैं, और वास्तव में न केवल लाइनों से, हम वहां कोई भी डेटा प्रकार डाल सकते हैं।

 let sequence = Observable<Int>.of(1, 2, 4, 5, 6) _ = sequence.subscribe { (event) in print(event) }

 next(1) next(2) ... completed

अवलोकनीय मूल्यों की एक सरणी से बनाया जा सकता है।

 let array = [1, 2, 3] let observable = Observable<Int>.from(array) _ = observable.subscribe { (event) in print(event) }

 next(1) next(2) next(3) completed

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

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

निपटान

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

यह याद रखना महत्वपूर्ण है कि ऑब्जर्वेबल एक "ठंडा" प्रकार है, अर्थात, हमारा अवलोकन किसी भी घटना को तब तक "उत्सर्जित" नहीं करता है जब तक कि वह सब्सक्राइब न हो। जब तक यह एक त्रुटि संदेश या एक त्रुटि संदेश ( पूर्ण ) भेजता है तब तक अवलोकन योग्य है। यदि हम सदस्यता को स्पष्ट रूप से रद्द करना चाहते हैं, तो हम निम्नलिखित कर सकते हैं।

 // №1 //   let array = [1, 2, 3] // observable    let observable = Observable<Int>.from(array) //   observable let subscription = observable.subscribe { (event) in print(event) } //dispos'    subscription.dispose()

और भी हैं ~~सुंदर~~ सही विकल्प।

 //  "" let bag = DisposeBag() //   let array = [1, 2, 3] // observable    let observable = Observable<Int>.from(array) //   observable _ = observable.subscribe { (event) in print(event) }.disposed(by: bag)

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

ऑपरेटर्स

फ़ंक्शनल-रिएक्टिव प्रोग्रामिंग (नीचे FRP) में कई अंतर्निहित ऑपरेटर हैं जो अवलोकन योग्य तत्वों को बदलने के लिए हैं। एक साइट rxmarbles है , इस पर आप सभी ऑपरेटरों के काम और प्रभाव को देख सकते हैं, अच्छी तरह से, लेकिन हम अभी भी उनमें से कुछ को देखते हैं।

नक्शा

मैप ऑपरेटर का उपयोग बहुत बार किया जाता है और मुझे लगता है कि यह बहुतों से परिचित है, इसकी मदद से हम प्राप्त सभी तत्वों को बदल देते हैं।
एक उदाहरण:

 let bag = DisposeBag() let array = [1, 2, 3] let observable = Observable<Int>.from(array).map { $0 * 2 } _ = observable.subscribe { (e) in print(e) }.disponsed(by: bag)

कंसोल में हमें क्या मिलता है:

 next(2) next(4) next(6) completed

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

 let bag = DisposeBag() let observable = Observable<Int>.from(array) //  observable let transformObservable = observable.map { $0 * 2 } _ = transformObservable.subscribe { (e) in print(e) }.disposed(by: bag)

$ 0 क्या है?

$ 0 डिफ़ॉल्ट रूप से तत्व का नाम है, हम तरीकों में संक्षिप्त और पूर्ण रिकॉर्ड का उपयोग कर सकते हैं, अक्सर हम संक्षिप्त रूप का उपयोग करते हैं।

 //  let transformObservable = observable.map { $0 * 2 } //  let transformObservable = observable.map { (element) -> Int in return element * 2 }

सहमत हूँ कि संक्षिप्त रूप बहुत सरल है, है ना?

फ़िल्टर

फ़िल्टर ऑपरेटर हमें हमारे अवलोकनीय द्वारा उत्सर्जित डेटा को फ़िल्टर करने की अनुमति देता है, अर्थात, सदस्यता लेते समय, हम हमारे लिए अनावश्यक मान प्राप्त नहीं करेंगे।
एक उदाहरण:

 let bag = DisposeBag() let array = [1, 2, 3, 4, 5 , 6, 7] // observable   let observable = Observable<Int>.from(array) //  filter,     observable let filteredObservable = observable.filter { $0 > 2 } // _ = filteredObservable.subscribe { (e) in print(e) }.disposed(by: bag)

कंसोल में हमें क्या मिलता है?

 next(3) next(4) next(5) ... completed

जैसा कि हम देखते हैं, कंसोल में हमारे पास केवल वही मूल्य हैं जो हमारी स्थितियों को संतुष्ट करते हैं।

वैसे, ऑपरेटरों को जोड़ा जा सकता है, यह इस तरह से होगा यदि हम फ़िल्टरिंग ऑपरेटर और मानचित्र ऑपरेटर दोनों को तुरंत लागू करना चाहते थे।

 let bag = DisposeBag() let array = [1, 2, 3, 4, 5 , 6, 7] let observable = Observable<Int>.from(array) let filteredAndMappedObservable = observable .filter { $0 > 2 } .map { $0 * 2 } _ = filteredAndMappedObservable.subscribe { (e) in print(e) }.disposed(by: bag)

कंसोल:

 next(6) next(8) next(10) next(12) next(14) completed

अलग

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

 let bag = DisposeBag() let array = [1, 1, 1, 2, 3, 3, 5, 5, 6] let observable = Observable<Int>.from(array) let filteredObservable = observable.distinctUntilChanged() _ = filteredObservable.subscribe { (e) in print(e) }.disposed(by: bag)

कंसोल में, हमें निम्न मिलते हैं:

 next(1) next(2) next(3) next(5) next(6) completed

यही है, यदि अनुक्रम का वर्तमान तत्व पिछले एक के समान है, तो यह छोड़ दिया जाता है और जब तक कि पिछले एक से एक अलग तत्व प्रकट नहीं होता है, यह तब बहुत सुविधाजनक होता है जब हम डेटा प्राप्त करते हैं, कहते हैं, यूआई, अर्थात् तालिका, हमारे पास अब जैसा है वैसा ही है, तो टेबल को फिर से लोड नहीं करना चाहिए।

TakeLast

एक बहुत ही सरल लीलास्ट ऑपरेटर, हम अंत से तत्वों की संख्या को लेते हैं।

 let bag = DisposeBag() let array = [1, 1, 1, 2, 3, 3, 5, 5, 6] let observable = Observable<Int>.from(array) let takeLastObservable = observable.takeLast(1) _ = takeLastObservable.subscribe { (e) in print(e) }.disposed(by: bag)

कंसोल में हमें निम्नलिखित मिलते हैं:

 next(6) completed

थ्रॉटल और इंटरवल

फिर मैंने एक बार में 2 ऑपरेटरों को लेने का फैसला किया, सिर्फ इसलिए कि दूसरे की मदद से, पहले के काम को दिखाना आसान है।

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

 let bag = DisposeBag() //observable     0.5    1   0 let observable = Observable<Int>.interval(0.5, scheduler: MainScheduler.instance) let throttleObservable = observable.throttle(1.0, scheduler: MainScheduler.instance) _ = takeLastObservable.subscribe { (event) in print("throttle \(event)") }.disposed(by: bag)

कंसोल में होगा:

 throttle next(0) throttle next(2) throttle next(4) throttle next(6) ...

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

debounce

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

 let bag = DisposeBag() let observable = Observable<Int>.interval(1.5, scheduler: MainScheduler.instance) let debounceObservable = observable.debounce(1.0, scheduler: MainScheduler.instance) _ = debounceObservable.subscribe({ (e) in print("debounce \(e)") }).disposed(by: bag)

इस स्तर पर, मैं ऑपरेटरों के साथ समाप्त करने का प्रस्ताव करता हूं, RxSwift ढांचे में उनमें से बहुत सारे हैं, यह नहीं कहा जा सकता है कि उनमें से सभी रोजमर्रा की जिंदगी में बहुत आवश्यक हैं, लेकिन आपको अभी भी उनके अस्तित्व के बारे में जानने की आवश्यकता है, इसलिए rxmarbles की वेबसाइट पर ऑपरेटरों की पूरी सूची से खुद को परिचित करना उचित है।

समयबद्धक

एक बहुत ही महत्वपूर्ण विषय जिसे मैं इस लेख में छूना चाहूंगा वह है अनुसूचक। शेड्यूलर, हमें अपने थ्रेडेबल को कुछ थ्रेड्स पर चलाने की अनुमति देते हैं और उनकी अपनी सूक्ष्मताएं हैं। शुरू करने के लिए, अवलोकन योग्य अनुसूचक को स्थापित करने के 2 प्रकार हैं - [अवलोकन करें] () और [सदस्यता लें] ()।

SubscribeOn

SubscribeOn उस थ्रेड के लिए ज़िम्मेदार होता है जिसमें संपूर्ण अवलोकन प्रक्रिया तब तक चलेगी जब तक कि उसकी घटनाएँ हैंडलर (ग्राहक) तक नहीं पहुँच जातीं।

ObserveOn

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

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

आइए देखें कि यह एक उदाहरण के साथ कैसे काम करता है:

 let observable = Observable<Int>.create { (observer) -> Disposable in print("thread observable -> \(Thread.current)") observer.onNext(1) observer.onNext(2) return Disposables.create() }.subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background)) _ = observable .observeOn(MainScheduler.instance) .subscribe({ (e) in print("thread -> \(Thread.current)") print(e) })

कंसोल में हमें मिलता है:

 thread observable -> <NSThread: 0x604000465040>{number = 3, name = (null)} thread -> <NSThread: 0x60000006f6c0>{number = 1, name = main} next(1) thread -> <NSThread: 0x60000006f6c0>{number = 1, name = main} next(2)

हम देखते हैं कि पृष्ठभूमि थ्रेड में ऑब्जर्वेबल बनाया गया था, और हमने डेटा को मुख्य थ्रेड में संसाधित किया। उदाहरण के लिए, नेटवर्क के साथ काम करते समय यह उपयोगी है:

 let rxRequest = URLSession.shared.rx.data(request: URLRequest(url: URL(string: "http://jsonplaceholder.typicode.com/posts/1")!)).subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background)) _ = rxRequest .observeOn(MainScheduler.instance) .subscribe { (event) in print(" \(event)") print("thread \(Thread.current)") }

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

 curl -X GET "http://jsonplaceholder.typicode.com/posts/1" -i -v Success (305ms): Status 200 ** next(292 bytes)** thread -> <NSThread: 0x600000072580>{number = 1, name = main}  completed thread -> <NSThread: 0x600000072580>{number = 1, name = main}

फाइनल में, आइए देखें कि हमारे पास किस प्रकार का डेटा आया था, इसके लिए हमें एक चेक प्रदर्शन करना होगा ताकि दुर्घटना से पूर्ण संदेश को पार्स करना शुरू न करें।

 _ = rxRequest .observeOn(MainScheduler.instance) .subscribe { (event) in if (!event.isCompleted && event.error == nil) { let json = try? JSONSerialization.jsonObject(with: event.element!, options: []) print(json!) } print("data -> \(event)") print("thread -> \(Thread.current)") }

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

 curl -X GET "http://jsonplaceholder.typicode.com/posts/1" -i -v Success (182ms): Status 200 { body = "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"; id = 1; title = "sunt aut facere repellat provident occaecati excepturi optio reprehenderit"; userId = 1; } data -> next(292 bytes) thread -> <NSThread: 0x60400006c6c0>{number = 1, name = main} data -> completed thread -> <NSThread: 0x60400006c6c0>{number = 1, name = main}

डेटा प्राप्त :-)

विषय

हम गर्म की ओर मुड़ते हैं, अर्थात् "ठंडा" या "निष्क्रिय" जो "गर्म" या "सक्रिय" अवलोकन योग्य है, जिसे विषय'आमी कहते हैं। यदि इससे पहले हमारे पर्यवेक्षक ने उनकी सदस्यता लेने के बाद ही अपना काम शुरू कर दिया था और आपके दिमाग में एक सवाल था, "आपको इसकी आवश्यकता क्यों है?", तो विषय हमेशा काम करते हैं और हमेशा प्राप्त डेटा भेजते हैं।

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

चलो एक विषय और 2 ग्राहक बनाएं, विषय के बाद पहला अधिकार बनाएं, विषय को मूल्य भेजें, और फिर दूसरा बनाएं और कुछ और मान भेजें।

 let subject = PublishSubject<Int>() subject.subscribe { (event) in print("  \(event)") } subject.onNext(1) _ = subject.subscribe { (event) in print("  \(event)") } subject.onNext(2) subject.onNext(3) subject.onNext(4)

हम कंसोल में क्या देखेंगे? सही, पहला पहला इवेंट पाने में कामयाब रहा, लेकिन दूसरा नहीं।

   next(1)   next(2)   next(2)   next(3)   next(3)   next(4)   next(4)

पहले से ही प्रतिक्रियाशील प्रोग्रामिंग के आपके विचार के लिए अधिक अनुकूल है?
विषय कई रूपों में आते हैं, वे सभी भिन्न होते हैं कि वे मूल्यों को कैसे भेजते हैं।

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

ReplaySubject - लेकिन यह सबसे महत्वपूर्ण है, बनाते समय, हम इसे बफर का आकार (कितने मान याद रहेंगे) बताते हैं, परिणामस्वरूप, यह स्मृति में अंतिम n मानों को संग्रहीत करता है और उन्हें तुरंत नए ग्राहक को भेजता है।

 let subject = ReplaySubject<Int>.create(bufferSize: 3) subject.subscribe { (event) in print("  \(event)") } subject.onNext(1) subject.subscribe { (event) in print("  \(event)") } subject.onNext(2) subject.onNext(3) subject.subscribe { (event) in print("  \(event)") } subject.onNext(4)

हम कंसोल को देखते हैं

   next(1)   next(1)   next(2)   next(2)   next(3)   next(3)   next(1)   next(2)   next(3)   next(4)   next(4)   next(4)

BehaviorSubject पिछले एक के रूप में ऐसी बकवास नहीं है, इसका एक शुरुआती मूल्य है और यह अंतिम मूल्य को याद रखता है और ग्राहक की सदस्यता के तुरंत बाद इसे भेजता है।

 let subject = BehaviorSubject<Int>(value: 0) subject.subscribe { (event) in print("  \(event)") } subject.onNext(1) subject.subscribe { (event) in print("  \(event)") } subject.onNext(2) subject.onNext(3) subject.subscribe { (event) in print("  \(event)") } subject.onNext(4)

कंसोल

   next(0)   next(1)   next(1)   next(2)   next(2)   next(3)   next(3)   next(3)   next(4)   next(4)   next(4)

निष्कर्ष

यह एक परिचयात्मक लेख लिखा गया था ताकि आप मूल बातें जान सकें और बाद में उन पर निर्माण कर सकें। निम्नलिखित लेखों में, हम यूआई यूआई घटकों के साथ RxSwift के साथ काम करने के लिए देखेंगे, UI घटकों के लिए एक्सटेंशन बना रहे हैं।

RxSwift'om एकजुट नहीं है

प्रतिक्रियाशील प्रोग्रामिंग न केवल RxSwift लाइब्रेरी में कार्यान्वित की जाती है, कई कार्यान्वयन हैं, यहाँ उनमें से सबसे लोकप्रिय हैं ReacktiveKit / Bond , ReactiveSwift / ReactiveCocoa । हुड के तहत कार्यान्वयन में सभी में छोटे अंतर हैं, लेकिन मेरी राय में यह बेहतर है कि आप RxSwift के साथ प्रतिक्रियावाद का ज्ञान शुरू करें, क्योंकि यह उनके बीच सबसे लोकप्रिय है और महान Google में अधिक उत्तर होंगे, लेकिन आपके बाद इस अवधारणा के सार को समझें, आप अपने स्वाद और रंग के लिए पुस्तकालयों का चयन कर सकते हैं।
लेख के लेखक: पावेल ग्रीचिकिन

RxSwift भाग 1