RxSwift — यह क्या है, विशेषताएं और रिएक्टिव प्रोग्रामिंग

RxSwift क्या है?

RxSwift 2012 में Microsoft द्वारा .NET के लिए बनाई गई ReactiveX (Rx) लाइब्रेरी का Swift पोर्ट है। Rx का मुख्य विचार किसी भी एसिंक्रोनस डेटा स्रोत को Observable अनुक्रम के रूप में प्रस्तुत करना है जिस पर कार्यात्मक ऑपरेटर लागू किए जा सकते हैं। iOS डेवलपमेंट में, RxSwift का उपयोग UI इवेंट (बटन टैप, टेक्स्ट इनपुट, जेस्चर) को स्पष्ट डेलिगेट्स और target-action के बिना एप्लिकेशन लॉजिक से जोड़ने के लिए किया जाता है।

लाइब्रेरी तीन मॉड्यूल से बनी है: RxSwift (कोर — Observable, Operator, Scheduler), RxCocoa (UIKit एकीकरण — UIButton, UITextField, UITableView के लिए rx एक्सटेंशन) और RxRelay (टर्मिनल इवेंट के बिना Subject)। यह अलगाव कोर को सर्वर-साइड Swift और परीक्षणों में उपयोग करने की अनुमति देता है, UI रैपर को केवल iOS एप्लिकेशन के लिए जोड़ता है।

Stack Overflow, 2025 सर्वेक्षण के अनुसार, RxSwift iOS के लिए शीर्ष 5 सबसे अधिक उपयोग की जाने वाली तृतीय-पक्ष लाइब्रेरी में से एक है। इसकी लोकप्रियता का मुख्य कारण सभी एसिंक्रोनस पैटर्न का एकसमान प्रबंधन है: URLSession के माध्यम से नेटवर्क अनुरोध, UIViewPropertyAnimator के माध्यम से एनिमेशन, NotificationCenter के माध्यम से सूचनाएं और DelegateProxy के माध्यम से डेलिगेट — यह सब एक पूर्वानुमानित जीवनचक्र के साथ Observable में समाहित हो जाता है।

रिएक्टिव प्रोग्रामिंग का दर्शन

रिएक्टिव प्रोग्रामिंग एक प्रतिमान है जिसमें प्रोग्राम डेटा परिवर्तनों पर प्रतिक्रिया करता है न कि उन्हें पोल करता है। “डेटा प्राप्त करें → प्रक्रिया करें → UI अपडेट करें” लिखने के बजाय, डेवलपर एक रूपांतरण श्रृंखला का वर्णन करता है: “जब डेटा बदलता है, फ़िल्टर लागू करें, फिर map, फिर UI अपडेट करें”। RxSwift इस प्रतिमान को आलसी निष्पादन वाली Observable श्रृंखलाओं के माध्यम से लागू करता है — जब तक कोई सब्सक्राइबर नहीं आता, कुछ भी नहीं होता।

RxSwift के मुख्य घटक: Observable, Subject, Disposable

Observable RxSwift का मूलभूत प्रकार है जो समय के साथ इवेंट के अनुक्रम का प्रतिनिधित्व करता है। Observable तीन प्रकार के इवेंट भेज सकता है: next (नया मान), error (स्ट्रीम को समाप्त करने वाली त्रुटि) और completed (सफल समाप्ति)। सीमित Observable (सभी मान भेजने के बाद पूरा होते हैं) और असीमित Observable (जैसे UI इवेंट — कभी पूरा नहीं होते) होते हैं।

Observable और इसका जीवनचक्र

Observable के जीवनचक्र में तीन चरण शामिल हैं: निर्माण (create, just, from), रूपांतरण (ऑपरेटर map, filter, flatMap) और सब्सक्रिप्शन (subscribe)। सब्सक्रिप्शन के बिना, Observable कोई कार्य नहीं करता — यह एक आलसी अनुक्रम है। सब्सक्रिप्शन के बाद, Observable तब तक सब्सक्राइबर को इवेंट भेजना शुरू करता है जब तक वह पूरा नहीं हो जाता या सब्सक्राइबर Disposable के माध्यम से सब्सक्रिप्शन रद्द नहीं कर देता।

import RxSwift

// ऐरे से Observable बनाना
let numbers = Observable.from([1, 2, 3, 4, 5])

// ऑपरेटरों के माध्यम से रूपांतरण
let squared = numbers
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }

// इवेंट हैंडलिंग के साथ सब्सक्रिप्शन
let disposable = squared
    .subscribe(onNext: { print($0) },
               onError: { print("Error: \($0)") },
               onCompleted: { print("Done") })

Subject एक प्रकार है जो एक साथ Observable (इसकी सदस्यता ली जा सकती है) और Observer (इसमें इवेंट भेजे जा सकते हैं) है। RxSwift चार प्रकार के Subject प्रदान करता है: PublishSubject (केवल नए इवेंट), BehaviorSubject (प्रारंभिक मान के साथ), ReplaySubject (अंतिम N इवेंट को बफर करता है) और AsyncSubject (पूरा होने से पहले केवल अंतिम मान)। Subject रिएक्टिव चेन में इम्पेरेटिव कोड (क्लोजर, डेलिगेट) को एकीकृत करने के लिए उपयोगी है।

Disposable एक सब्सक्रिप्शन रद्दीकरण टोकन है। जब सब्सक्राइबर अब इवेंट प्राप्त नहीं करना चाहता, तो वह disposable.dispose() को कॉल करता है। व्यवहार में, DisposeBag का उपयोग किया जाता है: Disposable का एक संग्रह जो मालिक (जैसे UIViewController) के डीइनिशियलाइज़ेशन पर स्वचालित रूप से सभी सब्सक्रिप्शन रद्द कर देता है। यह मेमोरी लीक को रोकता है जो मैन्युअल सब्सक्रिप्शन प्रबंधन में अपरिहार्य हैं।

स्ट्रीम रूपांतरण और फ़िल्टरिंग ऑपरेटर

RxSwift में ऑपरेटर ऐसे फ़ंक्शन हैं जो एक Observable लेते हैं और दूसरा Observable लौटाते हैं, डेटा स्ट्रीम को रूपांतरित करते हैं। ऑपरेटरों को संयोजित करके, डेवलपर बिना मध्यवर्ती चर और रेस कंडीशन के घोषणात्मक प्रसंस्करण श्रृंखलाएं बनाता है। सभी ऑपरेटर आलसी हैं: श्रृंखला विवरण के समय बनती है और सब्सक्रिप्शन पर निष्पादित होती है।

रूपांतरण ऑपरेटर स्ट्रीम में प्रत्येक इवेंट को बदलते हैं। map प्रत्येक तत्व पर एक फ़ंक्शन लागू करता है, flatMap प्रत्येक तत्व से Observable को एक समतल स्ट्रीम में खोलता है, scan मध्यवर्ती परिणाम जमा करता है (reduce के समान लेकिन प्रत्येक चरण को उत्सर्जित करता है)। buffer तत्वों को समय या गणना के अनुसार समूहित करता है, window स्ट्रीम को विंडो द्वारा नेस्टेड Observable में विभाजित करता है।

// ऑपरेटर चेन का उदाहरण: debounce के साथ खोज
searchTextField.rx.text
    .orEmpty
    .debounce(.milliseconds(300), scheduler: MainScheduler.instance)
    .distinctUntilChanged()
    .flatMapLatest { query -> Observable<[String]> in
        return apiService.search(query)
    }
    .bind(to: tableView.rx.items(cellIdentifier: "Cell")) { _, item, cell in
        cell.textLabel?.text = item
    }
    .disposed(by: disposeBag)

फ़िल्टरिंग ऑपरेटर केवल उन इवेंट को पास करते हैं जो एक शर्त को पूरा करते हैं। filter विधेय द्वारा फ़िल्टर करता है, distinctUntilChanged केवल पिछले से भिन्न मान पास करता है, take और takeWhile इवेंट की संख्या को सीमित करते हैं। skip और skipWhile पहले N इवेंट या शर्त पूरी होने तक इवेंट को छोड़ते हैं। त्रुटि प्रबंधन के लिए catchError (अवरोधन और प्रतिस्थापन) और retry (त्रुटि पर अनुक्रम पुनः प्रयास) का उपयोग किया जाता है।

संयोजन ऑपरेटर कई Observables को एक में जोड़ते हैं। combineLatest कई स्ट्रीम से नवीनतम मानों को एक टुपल में मर्ज करता है, zip समान अनुक्रमांक वाले तत्वों को जोड़ता है, merge इवेंट आगमन के क्रम में कई स्ट्रीम को एक में जोड़ता है। withLatestFrom मुख्य स्ट्रीम से एक इवेंट को दूसरी स्ट्रीम के नवीनतम मान के साथ जोड़ता है — वर्तमान स्थिति के साथ UI इवेंट के लिए उपयोगी।

Schedulers और थ्रेड प्रबंधन

RxSwift में Scheduler निष्पादन थ्रेड (या कतार) पर एक अमूर्तता है। Scheduler निर्धारित करता है कि इवेंट निर्माण, रूपांतरण और सब्सक्रिप्शन किस थ्रेड पर निष्पादित होते हैं। GCD के विपरीत, जहां डेवलपर स्पष्ट रूप से DispatchQueue निर्दिष्ट करता है, RxSwift दो पैरामीटर का उपयोग करता है: subscribeOn (किस थ्रेड पर Observable निष्पादित होता है) और observeOn (किस थ्रेड पर सब्सक्राइबर को कॉल किया जाता है)।

MainScheduler और BackgroundScheduler

MainScheduler मुख्य थ्रेड पर कोड निष्पादित करता है — UIKit अपडेट के लिए अनिवार्य (सभी UI परिवर्तन मुख्य थ्रेड पर होने चाहिए)। SerialDispatchQueueScheduler एक सीरियल GCD कतार को लपेटता है, ConcurrentDispatchQueueScheduler एक समवर्ती कतार को। पृष्ठभूमि कार्यों के लिए qos: .background या .utility के साथ ConcurrentDispatchQueueScheduler का उपयोग किया जाता है।

// विशिष्ट पैटर्न: पृष्ठभूमि कार्य + main पर UI
apiService.fetchData()
    .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background))
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { data in
        self.tableView.reloadData()
        self.loadingIndicator.stopAnimating()
    })
    .disposed(by: disposeBag)

Scheduler का सही उपयोग नेटवर्क अनुरोधों और भारी गणनाओं के दौरान UI अवरोधन को रोकता है। subscribeOn पूरे अपस्ट्रीम को प्रभावित करता है (observeOn से पहले सभी ऑपरेटर निर्दिष्ट शेड्यूलर पर निष्पादित होते हैं)। observeOn डाउनस्ट्रीम को स्विच करता है — observeOn के बाद सभी ऑपरेटर निर्दिष्ट शेड्यूलर पर निष्पादित होते हैं। एक श्रृंखला में विभिन्न रूपांतरण चरणों में थ्रेड के बीच स्विच करने के लिए कई observeOn हो सकते हैं।

SerialDispatchQueueScheduler इवेंट के अनुक्रमिक प्रसंस्करण की गारंटी देता है, जो साझा संसाधनों की थ्रेड सुरक्षा के लिए महत्वपूर्ण है। उच्च-लोड संचालन (इमेज प्रोसेसिंग, JSON पार्सिंग) के लिए ConcurrentDispatchQueueScheduler का उपयोग करें — RxSwift एक Observable के भीतर इवेंट क्रम को संरक्षित करेगा, लेकिन विभिन्न Observables समानांतर में संसाधित हो सकते हैं।

iOS में RxSwift का व्यावहारिक अनुप्रयोग

RxSwift का उपयोग iOS प्रोजेक्ट्स में अक्सर रिएक्टिव चेन के माध्यम से UI को डेटा से जोड़ने के लिए किया जाता है। RxCocoa सभी मानक UIKit घटकों के लिए rx एक्सटेंशन प्रदान करता है: UIButton के लिए rx.tap, UITextField के लिए rx.text, UIPickerView के लिए rx.selectedRow। यह @IBAction और डेलिगेट्स को छोड़ने, उन्हें घोषणात्मक सब्सक्रिप्शन से बदलने की अनुमति देता है।

MVVM के साथ RxSwift

MVVM (Model-View-ViewModel) एक आर्किटेक्चरल पैटर्न है जिसमें ViewModel स्थिति और व्यावसायिक तर्क का प्रबंधन करता है, और View ViewModel के रिएक्टिव गुणों की सदस्यता लेता है। RxSwift MVVM के साथ पूरी तरह से फिट बैठता है: ViewModel डेटा के लिए Observable या Driver प्रकाशित करता है, View bind के माध्यम से उनकी सदस्यता लेता है। ViewModel के पास View का कोई संदर्भ नहीं है — यह Observable लौटाता है जिसे View उपभोग करता है।

class LoginViewModel {
    let email = BehaviorRelay<String>(value: "")
    let password = BehaviorRelay<String>(value: "")

    var isFormValid: Observable<Bool> {
        return Observable
            .combineLatest(email, password) {
                !$0.isEmpty && $0.contains("@") && $1.count >= 6
            }
    }
}

// ViewController में:
viewModel.isFormValid
    .bind(to: loginButton.rx.isEnabled)
    .disposed(by: disposeBag)

नेटवर्क अनुरोध RxSwift का दूसरा सबसे आम उपयोग मामला है। URLSession.rx.response HTTP अनुरोध को Observable में लपेटता है जो सफलता पर (response, data) या विफलता पर error लौटाता है। Codable और map ऑपरेटर के संयोजन में, एक कॉम्पैक्ट रिएक्टिव API परत प्राप्त होती है: Observable<MyModel> बिना callbacks और प्रत्येक विधि में त्रुटि प्रबंधन के। नेटवर्क त्रुटि पर, retry(3) ऑपरेटर एक्सपोनेंशियल बैकऑफ़ के साथ स्वचालित रूप से तीन बार अनुरोध दोहराता है।

RxSwift बनाम Combine

Combine iOS 13 में पेश किया गया Apple का नेटिव फ्रेमवर्क है। यह RxSwift के समान कार्यों को हल करता है: Publisher, Subscriber और ऑपरेटरों के माध्यम से एसिंक्रोनस इवेंट के साथ काम करना। हालांकि, Combine में प्रमुख अंतर हैं: Failure प्रकार के माध्यम से सख्त त्रुटि टाइपिंग, Swift Concurrency (async/await) के लिए अंतर्निहित समर्थन और @Published और ObservableObject के माध्यम से SwiftUI के साथ एकीकरण।

RxSwift पिछड़े संगतता में जीतता है — यह iOS 8+ का समर्थन करता है, जबकि Combine को iOS 13+ की आवश्यकता है। RxSwift के पास तृतीय-पक्ष एक्सटेंशन (RxDataSources, RxGesture, RxAnimated) का समृद्ध पारिस्थितिकी तंत्र और विस्तृत ऑपरेटर दस्तावेज़ीकरण है। पुराने iOS संस्करणों का समर्थन करने वाली परियोजनाओं के लिए, RxSwift एकमात्र विकल्प बना हुआ है।

iOS 13+ वाली नई परियोजनाओं के लिए, Apple Combine की सिफारिश करता है। यह SwiftUI के साथ कसकर एकीकृत है, इसका बाइनरी आकार छोटा है और आधिकारिक समर्थन है। हालांकि, मौजूदा RxSwift कोड को Combine में माइग्रेट करने के लिए सभी Observable → Publisher को फिर से लिखने की आवश्यकता होती है, और RxCocoa पारिस्थितिकी तंत्र का कोई पूर्ण Combine समकक्ष नहीं है — UIKit में सभी UI घटकों के लिए मूल Publisher नहीं है।