RxSwift — co to je, možnosti a reaktivní programování

Co je RxSwift?

RxSwift je Swift port knihovny ReactiveX (Rx) vytvořené společností Microsoft pro .NET v roce 2012. Hlavní myšlenkou Rx je představit jakýkoli asynchronní zdroj dat jako sekvenci Observable, na kterou lze aplikovat funkční operátory. V iOS vývoji se RxSwift používá k propojení UI událostí (stisknutí tlačítka, zadávání textu, gesta) s logikou aplikace bez explicitních delegátů a target-action.

Knihovna se skládá ze tří modulů: RxSwift (jádro — Observable, Operator, Scheduler), RxCocoa (integrace s UIKit — rx rozšíření pro UIButton, UITextField, UITableView) a RxRelay (Subject bez terminálních událostí). Toto rozdělení umožňuje používat jádro v serverovém Swift a testech a připojovat UI pouze pro iOS aplikace.

Podle průzkumu Stack Overflow, 2025 se RxSwift řadí mezi top 5 nejpoužívanějších knihoven třetích stran pro iOS. Hlavním důvodem popularity je jednotné zpracování všech asynchronních vzorů: síťové požadavky přes URLSession, animace přes UIViewPropertyAnimator, oznámení přes NotificationCenter a delegáty přes DelegateProxy — všechno se redukuje na Observable s předvídatelným životním cyklem.

Filosofie reaktivního programování

Reaktivní programování je paradigma, ve kterém program reaguje na změny dat, místo aby je dotazoval. Místo psaní „získej data → zpracuj → aktualizuj UI“ popisuje vývojář řetězec transformací: „až se data změní, aplikuj filtr, potom map, potom aktualizuj UI“. RxSwift implementuje toto paradigma prostřednictvím Observable řetězů s líným prováděním — nic se neděje, dokud se neobjeví odběratel.

Klíčové komponenty RxSwift: Observable, Subject, Disposable

Observable je základní typ RxSwift představující sekvenci událostí v čase. Observable může odesílat tři typy událostí: next (nová hodnota), error (chyba, ukončuje tok) a completed (úspěšné dokončení). Existují finite Observable (končí po odeslání všech hodnot) a infinite Observable (např. UI události — nikdy nekončí).

Životní cyklus Observable

Životní cyklus Observable zahrnuje tři fáze: vytvoření (create, just, from), transformaci (operátory map, filter, flatMap) a přihlášení (subscribe). Bez přihlášení Observable neprovádí žádnou akci — je to líná sekvence. Po přihlášení začne Observable odesílat události odběrateli, dokud neskončí nebo odběratel nezruší přihlášení prostřednictvím Disposable.

import RxSwift

// Vytvoření Observable z pole
let numbers = Observable.from([1, 2, 3, 4, 5])

// Transformace pomocí operátorů
let squared = numbers
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }

// Přihlášení se zpracováním událostí
let disposable = squared
    .subscribe(onNext: { print($0) },
               onError: { print("Error: \($0)") },
               onCompleted: { print("Done") })

Subject je typ, který je současně Observable (lze se na něj přihlásit) i Observer (lze do něj odesílat události). RxSwift poskytuje čtyři typy Subject: PublishSubject (pouze nové události), BehaviorSubject (s počáteční hodnotou), ReplaySubject (ukládání posledních N událostí do vyrovnávací paměti) a AsyncSubject (pouze poslední hodnota před dokončením). Subject je vhodný pro integraci imperativního kódu (closure, delegáty) do reaktivního řetězce.

Disposable je token zrušení přihlášení. Když odběratel již nechce dostávat události, zavolá disposable.dispose(). V praxi se používá DisposeBag: kolekce Disposable, která automaticky ruší všechna přihlášení při deinicializaci vlastníka (např. UIViewController). Toto zabraňuje únikům paměti, které jsou nevyhnutelné při ruční správě přihlášení.

Operátory transformace a filtrace toků

Operátory RxSwift jsou funkce, které přijímají jeden Observable a vracejí jiný Observable, transformující datový tok. Kombinováním operátorů vývojář buduje deklarativní řetězce zpracování bez mezičlenů a race condition. Všechny operátory jsou líné: řetězec se staví při popisu a provádí při přihlášení.

Transformační operátory mění každou událost v toku. map aplikuje funkci na každý prvek, flatMap rozbaluje Observable z každého prvku do jednoho plochého toku, scan akumuluje mezivýsledek (analogické k reduce, ale s emisí každého kroku). buffer seskupuje prvky podle času nebo množství, window rozděluje tok na vnořené Observable podle oken.

// Příklad řetězce operátorů: vyhledávání s 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)

Filtrační operátory propouštějí pouze ty události, které splňují podmínku. filter odděluje podle predikátu, distinctUntilChanged propouští pouze hodnoty lišící se od předchozí, take a takeWhile omezují počet událostí. skip a skipWhile přeskakují prvních N událostí nebo události do splnění podmínky. Pro zpracování chyb se používají catchError (zachycení a nahrazení) a retry (opakování sekvence při chybě).

Kombinační operátory spojují několik Observable do jednoho. combineLatest spojuje poslední hodnoty z více toků do tuple, zip spojuje prvky do párů se stejnými indexy, merge spojuje více toků do jednoho v pořadí příchodu událostí. withLatestFrom spojuje událost z hlavního toku s poslední hodnotou z jiného toku — užitečné pro UI události s aktuálním stavem.

Schedulers a správa vláken provádění

Scheduler v RxSwift je abstrakce nad vláknem provádění (nebo frontou). Scheduler určuje, na kterém vlákně probíhá vytváření událostí, transformace a přihlášení. Na rozdíl od GCD, kde vývojář explicitně uvádí DispatchQueue, RxSwift používá dva parametry: subscribeOn (na kterém vlákně se Observable provádí) a observeOn (na kterém vlákně je volán odběratel).

MainScheduler a BackgroundScheduler

MainScheduler provádí kód na hlavním vlákně — povinné pro aktualizaci UIKit (všechny změny UI musí probíhat na main thread). SerialDispatchQueueScheduler obaluje sekvenční frontu GCD, ConcurrentDispatchQueueScheduler — paralelní. Pro úlohy na pozadí se používá ConcurrentDispatchQueueScheduler s qos: .background nebo .utility.

// Typický vzor: práce na pozadí + UI na main
apiService.fetchData()
    .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background))
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { data in
        self.tableView.reloadData()
        self.loadingIndicator.stopAnimating()
    })
    .disposed(by: disposeBag)

Správné použití Scheduler zabraňuje blokování UI při síťových požadavcích a těžkých výpočtech. subscribeOn ovlivňuje celý upstream (všechny operátory až do observeOn se provádí na uvedeném plánovači). observeOn přepíná downstream — všechny operátory po observeOn se provádí na uvedeném plánovači. V řetězci může být několik observeOn pro přepínání mezi vlákny v různých fázích transformace.

Praktické použití RxSwift v iOS

RxSwift se v iOS projektech nejčastěji používá k propojení UI s daty prostřednictvím reaktivních řetězů. RxCocoa poskytuje rx rozšíření pro všechny standardní UIKit komponenty: rx.tap pro UIButton, rx.text pro UITextField, rx.selectedRow pro UIPickerView. To umožňuje opustit @IBAction a delegáty a nahradit je deklarativními přihlášeními.

RxSwift v kombinaci s MVVM

MVVM (Model-View-ViewModel) je architektonický vzor, ve kterém ViewModel spravuje stav a obchodní logiku a View se přihlašuje k reaktivním vlastnostem ViewModel. RxSwift dokonale zapadá do MVVM: ViewModel publikuje Observable nebo Driver pro data, View se k nim přihlašuje pomocí bind. ViewModel nemá odkaz na View — vrací Observable, které View konzumuje.

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
            }
    }
}

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

Síťové požadavky jsou druhým nejčastějším oborem použití RxSwift. URLSession.rx.response obaluje HTTP požadavek do Observable, který při úspěchu vrací (response, data) a při neúspěchu error. V kombinaci s Codable a operátorem map získáváme kompaktní reaktivní API vrstvu: Observable<MyModel> bez callbacků a zpracování chyb v každé metodě. Při chybě sítě operátor retry(3) automaticky opakuje požadavek třikrát s exponenciálním zpožděním.

RxSwift vs Combine

Combine je nativní Apple framework představený v iOS 13. Řeší stejné úkoly jako RxSwift: práci s asynchronními událostmi prostřednictvím Publisher, Subscriber a operátorů. Combine má však klíčové rozdíly: přísné typování chyb prostřednictvím typu Failure, vestavěnou podporu Swift Concurrency (async/await) a integraci se SwiftUI prostřednictvím @Published a ObservableObject.

RxSwift vítězí ve zpětné kompatibilitě — podporuje iOS 8+, zatímco Combine vyžaduje iOS 13+. RxSwift má bohatší ekosystém rozšíření třetích stran (RxDataSources, RxGesture, RxAnimated) a podrobnou dokumentaci operátorů. Pro projekty podporující starší verze iOS zůstává RxSwift jedinou volbou.

Pro nové projekty s iOS 13+ Apple doporučuje Combine. Je úzce integrován se SwiftUI, má menší binární velikost a oficiální podporu. Migrace existujícího RxSwift kódu na Combine však vyžaduje přepsání všech Observable → Publisher a ekosystém RxCocoa nemá úplný ekvivalent v Combine — UIKit nemá nativní Publisher pro všechny UI komponenty.