RxSwift文档二（为何使用Rx）_rxnet throttle 不起作用-CSDN博客

本文链接：https://blog.csdn.net/jiuchabaikaishui/article/details/107378339

为何使用Rx

Rx支持以声明方式构建应用程序。

绑定

// 原文这里应该有纰漏，应为firstName.rx.text.orEmpty与lastName.rx.text.orEmpty否则会造成可选字符串未解包
Observable.combineLatest(firstName.rx.text, lastName.rx.text) { $0 + " " + $1 }
    .map { "Greetings, \($0)" }
    .bind(to: greetingLabel.rx.text)

也可以绑定UITableView和UICollectionView。

viewModel
   .rows
   .bind(to: resultsTableView.rx.items(cellIdentifier: "WikipediaSearchCell", cellType: WikipediaSearchCell.self)) { (_, viewModel, cell) in
       cell.title = viewModel.title
       cell.url = viewModel.url
   }
   .disposed(by: disposeBag)

官方建议总是使用.disposed(by: disposeBag)即使这对简单绑定不是必需的。

重试

如果API不会失败会很棒，但遗憾的是它们会失败。假设有一个API方法：

func doSomethingIncredible(forWho: String) throws -> IncredibleThing

如果按原样使用此函数，则在失败时很难进行重试。更不用说建模嵌套调用的复杂性。当然有可能，但代码可能包含许多不关心的瞬态，并且它不可重复使用。

理想情况下，需要捕获重试的本质，并能够将其应用于任何操作。

这是使用Rx进行简单重试的方法

doSomethingIncredible("me")
    .retry(3)

还可以轻松创建自定义重试操作。

代理

代替冗长和难以表示的代码

public func scrollViewDidScroll(scrollView: UIScrollView) { [weak self]
    self?.leftPositionConstraint.constant = scrollView.contentOffset.x
}

Rx实现

self.resultsTableView
    .rx.contentOffset
    .map { $0.x }
    .bind(to: self.leftPositionConstraint.rx.constant)

KVO

代替：

对象销毁了然而键值观察还注册着，观测信息被泄露，甚至可能被错误地附加到其他对象上。

和

-(void)observeValueForKeyPath:(NSString *)keyPath
                     ofObject:(id)object
                       change:(NSDictionary *)change
                      context:(void *)context

使用rx.observe和rx.observeWeakly

这是他们的使用方式：

view.rx.observe(CGRect.self, "frame")
    .subscribe(onNext: { frame in
        print("Got new frame \(frame)")
    })
    .disposed(by: disposeBag)

或者

someSuspiciousViewController
    .rx.observeWeakly(Bool.self, "behavingOk")
    .subscribe(onNext: { behavingOk in
        print("Cats can purr? \(behavingOk)")
    })
    .disposed(by: disposeBag)

通知

代替使用：

@available(iOS 4.0, *)
public func addObserverForName(name: String?, object obj: AnyObject?, queue: NSOperationQueue?, usingBlock block: (NSNotification) -> Void) -> NSObjectProtocol

仅仅编写

NotificationCenter.default
    .rx.notification(NSNotification.Name.UITextViewTextDidBeginEditing, object: myTextView)
    .map {  /*使用数据做一些事情*/ }
    ....

瞬态

编写异步程序时，瞬态存在很多问题。典型示例是自动完成的搜索框。

如果没有Rx要编写自动完成的搜索框代码，那么可能需要解决的第一个问题是当输入abc中的c时，有一个待处理的请求ab，需要取消待处理的请求。好吧，这应该不太难解决，只需创建一个额外的变量来保持对待处理请求的引用。

下一个问题是如果请求失败，则需要执行那种混乱的重试逻辑。但是好吧，增加字段捕获需要处理的重试次数。

如果程序需要在向服务器发出请求之前等待一段时间。毕竟，因为不想有人在长时间输入时太频繁的请求服务器。可能需要添加一个计时字段？

还有一个问题是，在执行搜索时屏幕上需要显示什么，以及即使重试也会失败的情况下需要显示的内容。

写下所有这些并正确地测试它将是乏味的。这是用Rx编写的相同逻辑。

searchTextField.rx.text
    .throttle(.milliseconds(300), scheduler: MainScheduler.instance)
    .distinctUntilChanged()
    .flatMapLatest { query in
        API.getSearchResults(query)
            .retry(3)
            .startWith([]) // 在新的搜索中清除结果
            .catchErrorJustReturn([])
    }
    .subscribe(onNext: { results in
      // 绑定到UI
    })
    .disposed(by: disposeBag)

组合处理

假设希望在表视图中显示模糊图像。首先，应从URL中提取图像，然后解码然后模糊。

单元格退出表视图的可视区域可以取消整个过程是很好的，因为处理模糊的开销非常大。

在单元格进入可见区域后不立即开始获取图像也是很好的，因为如果用户滑动非常快，可能会有很多请求被触发和取消。

如果我们可以限制并发图像操作的数量也很好，同样因为模糊图像是一项开销非常大的操作。

这就是如何使用Rx来做到这一点：

// 这是一个概念性的解决方案
let imageSubscription = imageURLs
    .throttle(.milliseconds(200), scheduler: MainScheduler.instance)
    .flatMapLatest { imageURL in
        API.fetchImage(imageURL)
    }
    .observeOn(operationScheduler)
    .map { imageData in
        return decodeAndBlurImage(imageData)
    }
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { blurredImage in
        imageView.image = blurredImage
    })
    .disposed(by: reuseDisposeBag)

此代码将完成所有这些操作，并且在imageSubscription完成处理时，它将取消所有相关的异步操作，并确保没有恶意图像绑定到UI。

聚合网络请求

如果需要触发两个请求并在两个请求完成时汇总结果，该怎么办？

zip操作符

let userRequest: Observable<User> = API.getUser("me")
let friendsRequest: Observable<[Friend]> = API.getFriends("me")

Observable.zip(userRequest, friendsRequest) { user, friends in
    return (user, friends)
}
.subscribe(onNext: { user, friends in
    // 绑定到界面
})
.disposed(by: disposeBag)

那么，如果这些API在后台线程上返回结果，并且绑定UI必须在主线程上进行呢？可以使用observeOn。

let userRequest: Observable<User> = API.getUser("me")
let friendsRequest: Observable<[Friend]> = API.getFriends("me")

Observable.zip(userRequest, friendsRequest) { user, friends in
    return (user, friends)
}
.observeOn(MainScheduler.instance)
.subscribe(onNext: { user, friends in
    // bind them to the user interface
})
.disposed(by: disposeBag)

还有更多使用Rx发挥作用的实际用例。

状态

允许变化的语言可以轻松访问全局状态并对其进行更改。共享全局状态的不受控制的更改很容易导致组合爆炸。

但另一方面，当以智能方式使用时，命令式语言可以编写更高效更接近硬件的代码。

处理组合爆炸的常用方法是保持状态尽可能简单，并使用单向数据流来模拟派生数据。

这是Rx真正发挥作用的地方。

Rx是函数式和命令式的最佳结合点。它能够使用不可变定义和纯函数以可靠的可组合方式处理可变状态。

那么，有哪些实际例子呢？

易于集成

如果需要创建自己的可观察对象怎么办？这很容易。这段代码来自RxCocoa，这就是需要用URLSession包装HTTP请求的全部内容

extension Reactive where Base: URLSession {
    public func response(request: URLRequest) -> Observable<(Data, HTTPURLResponse)> {
        return Observable.create { observer in
            let task = self.base.dataTask(with: request) { (data, response, error) in
            
                guard let response = response, let data = data else {
                    observer.on(.error(error ?? RxCocoaURLError.unknown))
                    return
                }

                guard let httpResponse = response as? HTTPURLResponse else {
                    observer.on(.error(RxCocoaURLError.nonHTTPResponse(response: response)))
                    return
                }

                observer.on(.next(data, httpResponse))
                observer.on(.completed)
            }

            task.resume()

            return Disposables.create(with: task.cancel)
        }
    }
}