RxSwift — qu'est-ce que c'est, fonctionnalités et programmation réactive

Qu'est-ce que RxSwift ?

RxSwift est le port Swift de la bibliothèque ReactiveX (Rx) créée par Microsoft pour .NET en 2012. L'idée centrale de Rx est de représenter toute source de données asynchrone comme une séquence Observable à laquelle des opérateurs fonctionnels peuvent être appliqués. Dans le développement iOS, RxSwift est utilisé pour lier les événements de l'UI (touches de boutons, saisie de texte, gestes) à la logique de l'application sans délégués explicites ni target-action.

La bibliothèque se compose de trois modules : RxSwift (noyau — Observable, Operator, Scheduler), RxCocoa (intégration UIKit — extensions rx pour UIButton, UITextField, UITableView) et RxRelay (Subject sans événements terminaux). Cette séparation permet d'utiliser le noyau dans du Swift côté serveur et dans les tests, en connectant l'encapsulation UI uniquement pour les applications iOS.

Selon l'enquête Stack Overflow, 2025, RxSwift fait partie des 5 bibliothèques tierces les plus utilisées pour iOS. La principale raison de sa popularité est le traitement uniforme de tous les modèles asynchrones : requêtes réseau via URLSession, animations via UIViewPropertyAnimator, notifications via NotificationCenter et délégués via DelegateProxy — tout se résume à un Observable avec un cycle de vie prévisible.

Philosophie de la programmation réactive

La programmation réactive est un paradigme dans lequel le programme réagit aux changements de données plutôt que de les interroger. Au lieu d'écrire « obtenir des données → traiter → mettre à jour l'UI », le développeur décrit une chaîne de transformations : « quand les données changent, appliquer un filtre, puis map, puis mettre à jour l'UI ». RxSwift implémente ce paradigme via des chaînes Observable avec exécution paresseuse — rien ne se produit jusqu'à ce qu'un abonné apparaisse.

Composants clés de RxSwift : Observable, Subject, Disposable

Observable est le type fondamental de RxSwift représentant une séquence d'événements dans le temps. Observable peut envoyer trois types d'événements : next (nouvelle valeur), error (erreur terminant le flux) et completed (achèvement réussi). Il existe des Observable finis (se terminent après l'envoi de toutes les valeurs) et des Observable infinis (par exemple, les événements de l'UI — ne se terminent jamais).

Observable et son cycle de vie

Le cycle de vie d'un Observable comprend trois étapes : création (create, just, from), transformation (opérateurs map, filter, flatMap) et abonnement (subscribe). Sans abonnement, Observable n'effectue aucune action — c'est une séquence paresseuse. Après l'abonnement, Observable commence à envoyer des événements à l'abonné jusqu'à ce qu'il se termine ou que l'abonné annule l'abonnement via Disposable.

import RxSwift

// Créer Observable à partir d'un tableau
let numbers = Observable.from([1, 2, 3, 4, 5])

// Transformation via les opérateurs
let squared = numbers
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }

// Abonnement avec gestion d'événements
let disposable = squared
    .subscribe(onNext: { print($0) },
               onError: { print("Error: \($0)") },
               onCompleted: { print("Done") })

Subject est un type qui est à la fois un Observable (auquel on peut s'abonner) et un Observer (auquel on peut envoyer des événements). RxSwift fournit quatre types de Subject : PublishSubject (uniquement les nouveaux événements), BehaviorSubject (avec une valeur initiale), ReplaySubject (met en mémoire tampon les N derniers événements) et AsyncSubject (seulement la dernière valeur avant l'achèvement). Subject est utile pour intégrer du code impératif (closures, délégués) dans une chaîne réactive.

Disposable est un jeton d'annulation d'abonnement. Lorsque l'abonné ne souhaite plus recevoir d'événements, il appelle disposable.dispose(). En pratique, on utilise DisposeBag : une collection de Disposable qui annule automatiquement tous les abonnements lors de la désinitialisation du propriétaire (par exemple, UIViewController). Cela évite les fuites de mémoire inévitables avec la gestion manuelle des abonnements.

Opérateurs de transformation et de filtrage de flux

Les opérateurs dans RxSwift sont des fonctions qui prennent un Observable et retournent un autre Observable, transformant le flux de données. En combinant des opérateurs, le développeur construit des chaînes de traitement déclaratives sans variables intermédiaires ni conditions de concurrence. Tous les opérateurs sont paresseux : la chaîne est construite lors de la description et exécutée lors de l'abonnement.

Les opérateurs de transformation modifient chaque événement dans le flux. map applique une fonction à chaque élément, flatMap déplie l'Observable de chaque élément en un seul flux plat, scan accumule les résultats intermédiaires (similaire à reduce mais en émettant chaque étape). buffer regroupe les éléments par temps ou quantité, window divise le flux en Observable imbriqués par fenêtres.

// Exemple de chaîne d'opérateurs : recherche avec 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)

Les opérateurs de filtrage ne laissent passer que les événements qui satisfont une condition. filter filtre par prédicat, distinctUntilChanged ne laisse passer que les valeurs différentes de la précédente, take et takeWhile limitent le nombre d'événements. skip et skipWhile sautent les N premiers événements ou les événements jusqu'à ce qu'une condition soit remplie. Pour la gestion des erreurs, on utilise catchError (intercepter et substituer) et retry (réessayer la séquence en cas d'erreur).

Les opérateurs de combinaison combinent plusieurs Observables en un seul. combineLatest fusionne les dernières valeurs de plusieurs flux en un tuple, zip associe les éléments avec les mêmes indices, merge combine plusieurs flux en un dans l'ordre d'arrivée des événements. withLatestFrom combine un événement du flux principal avec la dernière valeur d'un autre flux — utile pour les événements UI avec état courant.

Schedulers et gestion des threads

Scheduler dans RxSwift est une abstraction sur le thread d'exécution (ou la file d'attente). Scheduler détermine sur quel thread la création d'événements, la transformation et l'abonnement sont exécutés. Contrairement à GCD, où le développeur spécifie explicitement DispatchQueue, RxSwift utilise deux paramètres : subscribeOn (sur quel thread l'Observable s'exécute) et observeOn (sur quel thread l'abonné est appelé).

MainScheduler et BackgroundScheduler

MainScheduler exécute le code sur le thread principal — obligatoire pour les mises à jour UIKit (toutes les modifications de l'UI doivent avoir lieu sur le thread principal). SerialDispatchQueueScheduler encapsule une file d'attente GCD série, ConcurrentDispatchQueueScheduler une file d'attente concurrente. Pour les tâches d'arrière-plan, on utilise ConcurrentDispatchQueueScheduler avec qos : .background ou .utility.

// Modèle typique : travail en arrière-plan + UI sur main
apiService.fetchData()
    .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background))
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { data in
        self.tableView.reloadData()
        self.loadingIndicator.stopAnimating()
    })
    .disposed(by: disposeBag)

L'utilisation correcte de Scheduler empêche le blocage de l'UI lors des requêtes réseau et des calculs lourds. subscribeOn affecte tout l'amont (tous les opérateurs avant observeOn s'exécutent sur le planificateur spécifié). observeOn bascule l'aval — tous les opérateurs après observeOn s'exécutent sur le planificateur spécifié. Une chaîne peut avoir plusieurs observeOn pour basculer entre les threads à différentes étapes de transformation.

SerialDispatchQueueScheduler garantit un traitement séquentiel des événements, ce qui est important pour la sécurité des threads des ressources partagées. Pour les opérations à forte charge (traitement d'images, analyse JSON), utilisez ConcurrentDispatchQueueScheduler — RxSwift préservera l'ordre des événements au sein d'un Observable, mais différents Observables peuvent être traités en parallèle.

Application pratique de RxSwift dans iOS

RxSwift dans les projets iOS est le plus souvent utilisé pour lier l'UI aux données via des chaînes réactives. RxCocoa fournit des extensions rx pour tous les composants UIKit standards : rx.tap pour UIButton, rx.text pour UITextField, rx.selectedRow pour UIPickerView. Cela permet d'abandonner @IBAction et les délégués, en les remplaçant par des abonnements déclaratifs.

RxSwift avec MVVM

MVVM (Model-View-ViewModel) est un modèle architectural dans lequel ViewModel gère l'état et la logique métier, et View s'abonne aux propriétés réactives de ViewModel. RxSwift s'intègre parfaitement avec MVVM : ViewModel publie Observable ou Driver pour les données, View s'y abonne via bind. ViewModel n'a pas de référence à View — il retourne des Observable que View consomme.

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

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

Les requêtes réseau sont le deuxième cas d'utilisation le plus courant de RxSwift. URLSession.rx.response encapsule une requête HTTP dans un Observable qui retourne (response, data) en cas de succès ou error en cas d'échec. En combinaison avec Codable et l'opérateur map, on obtient une couche API réactive compacte : Observable<MyModel> sans callbacks ni gestion d'erreurs dans chaque méthode. En cas d'erreur réseau, l'opérateur retry(3) réessaie automatiquement la requête trois fois avec un backoff exponentiel.

RxSwift vs Combine

Combine est le framework natif d'Apple présenté dans iOS 13. Il résout les mêmes tâches que RxSwift : travailler avec des événements asynchrones via Publisher, Subscriber et des opérateurs. Cependant, Combine présente des différences clés : typage strict des erreurs via le type Failure, prise en charge intégrée de Swift Concurrency (async/await) et intégration avec SwiftUI via @Published et ObservableObject.

RxSwift l'emporte en matière de rétrocompatibilité — il supporte iOS 8+, alors que Combine nécessite iOS 13+. RxSwift dispose d'un écosystème plus riche d'extensions tierces (RxDataSources, RxGesture, RxAnimated) et d'une documentation détaillée des opérateurs. Pour les projets prenant en charge les anciennes versions d'iOS, RxSwift reste le seul choix.

Pour les nouveaux projets avec iOS 13+, Apple recommande Combine. Il est étroitement intégré à SwiftUI, a une taille binaire plus petite et un support officiel. Cependant, la migration du code RxSwift existant vers Combine nécessite la réécriture de tous les Observable → Publisher, et l'écosystème RxCocoa n'a pas d'équivalent complet dans Combine — UIKit n'a pas de Publisher natif pour tous les composants de l'UI.