RxSwift — ano ito, mga kakayahan at reaktibong programming

Ano ang RxSwift?

RxSwift ay ang Swift port ng ReactiveX (Rx) library na ginawa ng Microsoft para sa .NET noong 2012. Ang pangunahing ideya ng Rx ay ipakita ang anumang asynchronous na pinagmumulan ng data bilang isang Observable sequence kung saan maaaring ilapat ang mga functional operator. Sa pag-develop ng iOS, ginagamit ang RxSwift para ikonekta ang mga kaganapan ng UI (pagpindot ng buton, pag-input ng teksto, mga kilos) sa lohika ng aplikasyon nang walang tahasang delegate at target-action.

Ang library ay binubuo ng tatlong module: RxSwift (core — Observable, Operator, Scheduler), RxCocoa (integrasyon sa UIKit — mga rx extension para sa UIButton, UITextField, UITableView) at RxRelay (Subject na walang terminal na kaganapan). Ang paghahati na ito ay nagpapahintulot sa paggamit ng core sa server Swift at mga test, at pagkonekta ng UI layer para lamang sa mga iOS application.

Ayon sa survey ng Stack Overflow, 2025, ang RxSwift ay nasa top 5 pinaka-ginagamit na third-party library para sa iOS. Ang pangunahing dahilan ng kasikatan ay ang pare-parehong pagproseso ng lahat ng asynchronous pattern: mga network request sa pamamagitan ng URLSession, mga animation sa pamamagitan ng UIViewPropertyAnimator, mga notification sa pamamagitan ng NotificationCenter at mga delegate sa pamamagitan ng DelegateProxy — lahat ay nababawasan sa Observable na may predictable na lifecycle.

Pilosopiya ng Reaktibong Programming

Reaktibong Programming ay isang paradigma kung saan ang programa ay tumutugon sa mga pagbabago ng data, hindi ito poll. Sa halip na isulat ang “kumuha ng data → iproseso → i-update ang UI”, inilalarawan ng developer ang isang chain ng pagbabago: “kapag nagbago ang data, ilapat ang filter, pagkatapos map, pagkatapos i-update ang UI”. Ipinapatupad ng RxSwift ang paradigma na ito sa pamamagitan ng Observable chain na may tamad na pagpapatupad — walang nangyayari hanggang lumitaw ang isang subscriber.

Mga Pangunahing Bahagi ng RxSwift: Observable, Subject, Disposable

Observable ay ang pundamental na uri ng RxSwift na kumakatawan sa isang sequence ng mga kaganapan sa oras. Ang Observable ay maaaring magpadala ng tatlong uri ng kaganapan: next (bagong halaga), error (error, nagtatapos ng daloy) at completed (matagumpay na pagkumpleto). Mayroong finite Observable (natatapos pagkatapos ipadala ang lahat ng halaga) at infinite Observable (hal. mga kaganapan ng UI — hindi natatapos).

Lifecycle ng Observable

Lifecycle ng Observable ay may tatlong yugto: paglikha (create, just, from), pagbabago (mga operator map, filter, flatMap) at subscription (subscribe). Kung walang subscription, hindi nagsasagawa ng anumang aksyon ang Observable — ito ay isang tamad na sequence. Pagkatapos ng subscription, magsisimulang magpadala ang Observable ng mga kaganapan sa subscriber hanggang sa matapos ito o kanselahin ng subscriber ang subscription sa pamamagitan ng Disposable.

import RxSwift

// Paglikha ng Observable mula sa array
let numbers = Observable.from([1, 2, 3, 4, 5])

// Pagbabago sa pamamagitan ng operator
let squared = numbers
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }

// Subscription na may paghawak ng kaganapan
let disposable = squared
    .subscribe(onNext: { print($0) },
               onError: { print("Error: \($0)") },
               onCompleted: { print("Done") })

Subject ay isang uri na parehong Observable (maaaring mag-subscribe) at Observer (maaaring magpadala ng mga kaganapan). Nagbibigay ang RxSwift ng apat na uri ng Subject: PublishSubject (bagong kaganapan lamang), BehaviorSubject (may paunang halaga), ReplaySubject (buffering ng huling N kaganapan) at AsyncSubject (huling halaga lamang bago matapos). Ang Subject ay maginhawa para sa integrasyon ng imperatibong code (closure, delegate) sa reaktibong chain.

Disposable ay isang token ng pagkansela ng subscription. Kapag ayaw na ng subscriber na makatanggap ng mga kaganapan, tinatawag niya ang disposable.dispose(). Sa praktika, ginagamit ang DisposeBag: isang koleksyon ng Disposable na awtomatikong nagkakansela ng lahat ng subscription sa deinitialization ng may-ari (hal. UIViewController). Pinipigilan nito ang pagtagas ng memory na hindi maiiwasan sa manual na pamamahala ng mga subscription.

Mga Operator ng Pagbabago at Pagsala ng Daloy

Mga Operator ng RxSwift ay mga function na kumukuha ng isang Observable at nagbabalik ng isa pang Observable, binabago ang daloy ng data. Sa pamamagitan ng pagsasama ng mga operator, bumubuo ang developer ng mga deklaratibong chain ng pagproseso nang walang intermediate variable at race condition. Lahat ng operator ay tamad: ang chain ay binuo sa paglalarawan at isinasagawa sa subscription.

Mga Operator ng Pagbabago ay nagbabago ng bawat kaganapan sa daloy. naglalapat ng function sa bawat elemento, binubuksan ng flatMap ang Observable mula sa bawat elemento sa isang patag na daloy, iniipon ng scan ang intermediate na resulta (katulad ng reduce, ngunit may emisyon ng bawat hakbang). buffer naggrupo ng mga elemento ayon sa oras o dami, window naghahati ng daloy sa nested Observable ayon sa mga window.

// Halimbawa ng chain ng operator: paghahanap na may 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)

Mga Operator ng Pagsala ay nagpapadaan lamang ng mga kaganapan na nakakatugon sa kondisyon. filter naghihiwalay ayon sa predicate, distinctUntilChanged nagpapadaan lamang ng mga halaga na iba sa nauna, take at takeWhile naglilimita ng bilang ng mga kaganapan. skip at skipWhile lumalaktaw sa unang N kaganapan o mga kaganapan hanggang sa matugunan ang kondisyon. Para sa paghawak ng error, ginagamit ang catchError (pagsalo at pagpapalit) at retry (pag-uulit ng sequence sa error).

Mga Operator ng Pagsasama ay nagsasama ng maraming Observable sa isa. pinagsasama ng combineLatest ang huling halaga mula sa maraming daloy sa isang tuple, pinagsasama ng zip ang mga elemento nang pares na may parehong index, pinagsasama ng merge ang maraming daloy sa isa ayon sa pagkakasunod-sunod ng pagdating ng mga kaganapan. withLatestFrom pinagsasama ang isang kaganapan mula sa pangunahing daloy sa huling halaga mula sa ibang daloy — maginhawa para sa mga kaganapan ng UI na may kasalukuyang estado.

Schedulers at Pamamahala ng Thread ng Pagpapatupad

Scheduler sa RxSwift ay isang abstraction sa ibabaw ng thread ng pagpapatupad (o queue). Tinutukoy ng Scheduler kung saang thread isinasagawa ang paglikha ng kaganapan, pagbabago at subscription. Hindi tulad ng GCD kung saan tahasang itinuturo ng developer ang DispatchQueue, gumagamit ang RxSwift ng dalawang parameter: subscribeOn (kung saang thread isinasagawa ang Observable) at observeOn (kung saang thread tinatawag ang subscriber).

MainScheduler at BackgroundScheduler

MainScheduler ay nagpapatupad ng code sa pangunahing thread — sapilitan para sa pag-update ng UIKit (lahat ng pagbabago sa UI ay dapat mangyari sa main thread). Binalot ng SerialDispatchQueueScheduler ang sequential GCD queue, ConcurrentDispatchQueueScheduler — parallel queue. Para sa mga gawain sa background, ginagamit ang ConcurrentDispatchQueueScheduler na may qos: .background o .utility.

// Karaniwang pattern: background work + UI sa main
apiService.fetchData()
    .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background))
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { data in
        self.tableView.reloadData()
        self.loadingIndicator.stopAnimating()
    })
    .disposed(by: disposeBag)

Ang tamang paggamit ng Scheduler ay pumipigil sa pag-block ng UI sa mga network request at mabibigat na kalkulasyon. Ang subscribeOn ay nakakaapekto sa buong upstream (lahat ng operator hanggang observeOn ay isinasagawa sa tinukoy na scheduler). Ang observeOn ay lumilipat ng downstream — lahat ng operator pagkatapos ng observeOn ay isinasagawa sa tinukoy na scheduler. Sa chain ay maaaring maraming observeOn para sa paglipat sa pagitan ng mga thread sa iba't ibang yugto ng pagbabago.

Praktikal na Aplikasyon ng RxSwift sa iOS

RxSwift sa mga proyekto ng iOS ay pinakamadalas ginagamit para sa pagkonekta ng UI sa data sa pamamagitan ng reaktibong chain. Nagbibigay ang RxCocoa ng mga rx extension para sa lahat ng standard na UIKit component: rx.tap para sa UIButton, rx.text para sa UITextField, rx.selectedRow para sa UIPickerView. Pinapayagan nito ang pagpapalit ng @IBAction at mga delegate ng mga deklaratibong subscription.

RxSwift sa Kombinasyon sa MVVM

MVVM (Model-View-ViewModel) ay isang pattern ng arkitektura kung saan ang ViewModel ay namamahala ng estado at lohika ng negosyo, at ang View ay nag-subscribe sa mga reaktibong property ng ViewModel. Perpektong akma ang RxSwift sa MVVM: Ang ViewModel ay nag-publish ng Observable o Driver para sa data, ang View ay nag-subscribe sa kanila sa pamamagitan ng bind. Ang ViewModel ay walang referensya sa View — nagbabalik ito ng Observable na kinokonsumo ng 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
            }
    }
}

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

Mga network request — pangalawang pinakamadalas na lugar ng aplikasyon ng RxSwift. Binalot ng URLSession.rx.response ang HTTP request sa Observable na nagbabalik ng (response, data) sa tagumpay o error sa pagkabigo. Sa kombinasyon sa Codable at operator na map, nakakakuha tayo ng isang compact na reaktibong API layer: Observable<MyModel> na walang callback at paghawak ng error sa bawat method. Sa error ng network, ang operator na retry(3) ay awtomatikong umuulit ng request nang tatlong beses na may exponential delay.

RxSwift vs Combine

Combine ay isang native na framework ng Apple, ipinakilala sa iOS 13. Nilulutas nito ang parehong mga gawain tulad ng RxSwift: pagtatrabaho sa mga asynchronous na kaganapan sa pamamagitan ng Publisher, Subscriber at operator. Ngunit ang Combine ay may mga pangunahing pagkakaiba: mahigpit na pag-type ng error sa pamamagitan ng Failure type, built-in na suporta para sa Swift Concurrency (async/await) at integrasyon sa SwiftUI sa pamamagitan ng @Published at ObservableObject.

RxSwift ay nananalo sa backward compatibility — sumusuporta sa iOS 8+, samantalang ang Combine ay nangangailangan ng iOS 13+. Ang RxSwift ay may mas mayamang ecosystem ng third-party extension (RxDataSources, RxGesture, RxAnimated) at detalyadong dokumentasyon ng mga operator. Para sa mga proyektong sumusuporta sa lumang bersyon ng iOS, ang RxSwift ay nananatiling tanging pagpipilian.

Para sa mga bagong proyekto na may iOS 13+, inirerekomenda ng Apple ang Combine. Ito ay malapit na isinama sa SwiftUI, may mas maliit na binary size at opisyal na suporta. Gayunpaman, ang pag-migrate ng umiiral na RxSwift code sa Combine ay nangangailangan ng pag-rewrite ng lahat ng Observable → Publisher, at ang ecosystem ng RxCocoa ay walang kumpletong katumbas sa Combine — ang UIKit ay walang native na Publisher para sa lahat ng UI component.