RxSwift Usage - 今是昨非

RxSwift Usage Memo#

This is a record of commonly used methods in RxSwift.

Implementing Search with RxSwift#

The purpose of distinctUntilChanged is to prevent new events from being generated for consecutive duplicate events. Therefore, using distinctUntilChanged in a search ensures that only different strings are triggered for each search, and it also ensures that only one search is triggered after input stops.

The difference between throttle and debounce:

throttle calls at a fixed interval
debounce calls after a certain number of seconds after the event stops

Therefore, if you need to implement search while typing, use throttle.


    fileprivate func configureSearch() {
      searchBar.rx.text
            .orEmpty
            .throttle(1.0, scheduler: MainScheduler.instance)
            .distinctUntilChanged()
            .subscribe { [unowned self] (query) in
                
            }.disposed(by: disposeBag)
    }

And if you need to implement search after input stops, use debounce.


    fileprivate func configureSearch() {
      searchBar.rx.text
            .orEmpty
            .distinctUntilChanged()
            .debounce(0.5, scheduler: MainScheduler.instance)
            .subscribe { [unowned self] (query) in
                
            }.disposed(by: disposeBag)
    }

Implementing Clicks with RxSwift#


button.rx.tap
    .subscribe(onNext: {
        print("button Tapped")
    })
    .disposed(by: disposeBag)

Implementing Delegates with RxSwift#

scrollView Delegate#


override func viewDidLoad() {
    super.viewDidLoad()

    scrollView.rx.contentOffset
        .subscribe(onNext: { contentOffset in
            print("contentOffset: \(contentOffset)")
        })
        .disposed(by: disposeBag)
}

tableView Delegate#


fileprivate func setupVM() {
    vm.dataList
        .bind(to: tableView.rx.items(cellIdentifier: Cell.CellIdentifier, cellType: Cell.self)) { _, model, cell in
            cell.model = model
        }
        .disposed(by: disposeBag)
    
    Observable
        .zip(tableView.rx.itemSelected, tableView.rx.modelSelected(CellModel.self))
        .subscribe(onNext: { [weak self] indexPath, item in
            self?.handleSelectItem(at: indexPath, model: item)
        })
        .disposed(by: disposeBag)
    
    vm.pageNum
        .subscribe(onNext: { [weak self] pageNum in
            self?.loadData(pageNum)
        })
        .disposed(by: disposeBag)
    
    vm.isLastPage
        .subscribe(onNext: { [weak self] isLastPage in
            self?.tableView.mj_header?.endRefreshing()
            if isLastPage {
                self?.tableView.mj_footer?.endRefreshingWithNoMoreData()
            } else {
                self?.tableView.mj_footer?.endRefreshing()
            }
        })
        .disposed(by: disposeBag)
}

Implementing Notifications with RxSwift#


override func viewDidLoad() {
    super.viewDidLoad()

    NotificationCenter.default.rx
        .notification(.UIApplicationWillEnterForeground)
        .subscribe(onNext: { (notification) in
            print("Application Will Enter Foreground")
        })
        .disposed(by: disposeBag)
}

Integrating Network Requests with RxSwift#

flatMapLatest is used to handle situations where multiple tasks have dependencies, avoiding callback hell.


/// Get user information by username and password
API.token(username: "beeth0ven", password: "987654321")
    .flatMapLatest(API.userInfo)
    .subscribe(onNext: { userInfo in
        print("User information retrieved: \(userInfo)")
    }, onError: { error in
        print("Failed to retrieve user information: \(error)")
    })
    .disposed(by: disposeBag)

zip is used to send multiple requests simultaneously and process them only after all requests are completed.

combineLatest is used to send multiple requests simultaneously, and each request triggers the method for handling events when it is completed.

References: