RxSwift学习

学习参考文章：
官方github库及使用demo 官方
RxSwift 使用详解系列专题详讲
RxSwift: ReactiveX for Swift
RxSwift 入坑好多天 - 终于有了一点理解
 RxSwift官方例子解析
 Moya+ RxSwift+HandyJSON 优雅处理网络请求
 用 RxSwift 为 Controller 瘦身(1)，优雅的使用网络请求(Moya) + 数据缓存(Cache)。

函数响应式编程是种编程范式。它是通过构建函数操作数据序列，然后对这些序列做出响应的编程方式。

RxSwift使用场景：

target action：比如按钮事件
代理：delegate
闭包回调：闭包
NotificationCenter：通知的使用
KVO
多个任务之间有依赖关系：先处理一个任务获得结果后，再执行另一个任务
等待多个并发任务完成后处理结果

Observable - 产生事件
Observer - 响应事件
Operator - 创建变化组合事件
Disposable - 管理绑定（订阅）的生命周期
Schedulers - 线程队列调配

RxSwift官方使用demo

orEmpty
位于RxCocoa中，将String?的控制属性转为String的控制属性。

/// Transforms control property of type `String?` into control property of type `String`.
    public var orEmpty: RxCocoa.ControlProperty<String> { get }

share(replay:scope:)
会返回一个新的事件序列，处理多个订阅者导致被处理多次情况。
让他们共享这一个源，而不是为他们单独创建新的源。这样可以减少不必要的开支。

Returns an observable sequence that **shares a single subscription to the underlying sequence**, and immediately upon subscription replays  elements in buffer.

map
map 操作符将源 Observable 的每个元素应用你提供的转换方法，然后返回含有转换结果的 Observable。
flatMapLatest
仅仅执行最新的信号，当有新的信号来的时候，取消上一次未执行完的整个序列

Projects each element of an observable sequence into a new sequence of observable sequences and then
         transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.

combineLatest
将多个 Observables 中最新的元素通过一个函数组合起来，然后将这个组合的结果发出来。

多个序列中，任何一个发出元素，就由这多个序列中的最新的几个元素，根据函数组合成一个序列，发出。
例：

        let usernameValid = usernameOutlet.rx.text.orEmpty
            .map { $0.count >= minimalUsernameLength }
            .share(replay: 1) // without this map would be executed once for each binding, rx is stateless by default
        
        let passwordValid = passwordOutlet.rx.text.orEmpty
            .map { $0.count >= minimalPasswordLength }
            .share(replay: 1)
        
        let everythingValid = Observable.combineLatest(usernameValid, passwordValid) { $0 && $1 }
            .share(replay: 1)

disposed(by: disposeBag)
每一个绑定也是有生命周期的。并且这个绑定是可以被清除的。disposed(by: disposeBag)就是将绑定的生命周期交给 disposeBag 来管理。当 disposeBag 被释放的时候，那么里面尚未清除的绑定也就被清除了。这就相当于是在用 ARC来管理绑定的生命周期。
withLatestFrom
将两个可观察序列合并为一个可观察序列，当第二个源有新数据的时候，再发送第一个源，会将第二个源的新数据订阅到。

// 拿到第二个序列的新数据
public func withLatestFrom<SecondO>(_ second: SecondO) -> RxSwift.Observable<SecondO.E> where SecondO : ObservableConvertibleType
// 拿到2个序列的新数据，并进行操作之后返回
public func withLatestFrom<SecondO, ResultType>(_ second: SecondO, resultSelector: @escaping (Self.E, SecondO.E) throws -> ResultType) -> RxSwift.Observable<ResultType> where SecondO : ObservableConvertibleType

官方demo应用：

            signedIn = input.loginTaps.withLatestFrom(usernameAndPassword)
            .flatMapLatest { pair in
                return API.signup(pair.username, password: pair.password)
                    .observeOn(MainScheduler.instance)
                    .catchErrorJustReturn(false)
                    .trackActivity(signingIn)
            }
            .flatMapLatest { loggedIn -> Observable<Bool> in
                let message = loggedIn ? "Mock: Signed in to GitHub." : "Mock: Sign in to GitHub failed"
                return wireframe.promptFor(message, cancelAction: "OK", actions: [])
                    // propagate original value
                    .map { _ in
                        loggedIn
                    }
            }
            .share(replay: 1)

throttle
忽略上一个信号的一段时间的变化,也就是说一段时间没有新的信号输入，才会向下发送
distinctUntilChanged
直到信号改变了再发送