RxSwift（10）— 场景序列总结

就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！

• RxSwift（1）— 初探
• RxSwift（2）— 核心逻辑源码分析
• RxSwift（3）— Observable序列的建立方式
• RxSwift（4）— 高阶函数（上）
• RxSwift（5）— 高阶函数（下）
• RxSwift（6）— 调度者-scheduler源码解析（上）
• RxSwift（7）— 调度者-scheduler源码解析（下）
• RxSwift（8）— KVO底层探索（上）
• RxSwift（9）— KVO底层探索（下）
• RxSwift（10）— 场景序列总结
• RxSwift（11）— dispose源码解析
• RxSwift（12）— Subject即攻也守
• RxSwift（13）— 爬过的坑
• RxSwift（14）— MVVM双向绑定

---

RxSwift 目录直通车 --- 和谐学习，不急不躁！

---

这个篇章介绍平时开发常常运用的序列，这些序列都是由普通序列封装而来，可是对平时开发是由大大的帮助，简易流程，而且很是切合相关场景

ControlEvent

ControlEvent: 专门用于描述 UI 控件所产生的事件，它具备如下特征

• 不会产生 error 事件
• 必定在 MainScheduler 订阅（主线程订阅）
• 必定在 MainScheduler 监听（主线程监听）
• 会共享附加做用

let controlEventOB = self.btn.rx.controlEvent(.touchUpInside)

controlEventOB.subscribe { (reslut) in
        print("订阅:\(reslut) \n \(Thread.current)")
    }.disposed(by: disposeBag)

controlEventOB.subscribe { (reslut) in
        print("订阅:\(reslut) \n \(Thread.current)")
    }.disposed(by: self.disposeBag)
复制代码

• events.subscribeOn(ConcurrentMainScheduler.instance)保证主队列调度
• UI响应事件，不会存在失败响应

binder

• 不会处理错误事件
• 确保绑定都是在给定 Scheduler 上执行（默认 MainScheduler）
• 一旦产生错误事件，在调试环境下将执行 fatalError，在发布环境下将打印错误信息。

let observer : AnyObserver<Bool> = AnyObserver { (event) in
    print("observer当前线程:\(Thread.current)")
    switch event{
    case .next(let isHidden) :
        print("来了,请看label的状态")
        self.label.isHidden = isHidden
    case .error(let error) :
        print("\(error)")
    case .completed :
        print("完成了")
    }
}

let binder = Binder<Bool>(self.label) { (lab, isHidden) in
    print("Binder当前线程:\(Thread.current)")
    lab.isHidden = isHidden
}

let observable = Observable<Bool>.create { (ob) -> Disposable in
    ob.onNext(true)
    ob.onError(NSError.init(domain: "com.lgcoooci.cn", code: 10086, userInfo: nil))
    ob.onCompleted()
    return Disposables.create()
    }.observeOn(ConcurrentDispatchQueueScheduler(queue: DispatchQueue.global()))

// observable.bind(to: observer).disposed(by: self.disposeBag)
observable.bind(to: binder).disposed(by: self.disposeBag)
复制代码

• RxSwift里面也封装了不少的binder,咱们直接开发使用很直接
• 尤为针对UI控件，很是爽，你能够下面的封装

extension Reactive where Base: UIButton {
    
    /// Reactive wrapper for `setTitle(_:for:)`
    public func title(for controlState: UIControl.State = []) -> Binder<String?> {
        return Binder(self.base) { button, title -> Void in
            button.setTitle(title, for: controlState)
        }
    }

    /// Reactive wrapper for `setImage(_:for:)`
    public func image(for controlState: UIControl.State = []) -> Binder<UIImage?> {
        return Binder(self.base) { button, image -> Void in
            button.setImage(image, for: controlState)
        }
    }

    /// Reactive wrapper for `setBackgroundImage(_:for:)`
    public func backgroundImage(for controlState: UIControl.State = []) -> Binder<UIImage?> {
        return Binder(self.base) { button, image -> Void in
            button.setBackgroundImage(image, for: controlState)
        }
    }
}
复制代码

Driver

Driver 是一个精心准备的特征序列。它主要是为了简化 UI 层的代码。不过若是你遇到的序列具备如下特征，你也可使用它：

• 不会产生 error 事件
• 必定在 MainScheduler 监听（主线程监听）
• 会共享附加做用

let result = self.textFiled.rx.text.orEmpty
    .asDriver() // 普通序列转化为
    .throttle(.milliseconds(500))
    .flatMap {
        self.dealwithData(inputText: $0)
            .asDriver(onErrorJustReturn: "检测到了错误")
}

// 绑定到label上面
result.map { "长度:\(($0 as! String).count)" }
    .drive(self.label.rx.text)
    .disposed(by: disposeBag)
// 绑定到button上面
result.map { ($0 as! String) }
    .drive(self.btn.rx.title())
    .disposed(by: disposeBag)
复制代码

• 底层源码封装source.share(replay: 1, scope: .whileConnected) 序列状态共享
• catchErrorJustReturn(onErrorJustReturn) 保证了无错误信号
• observeOn(DriverSharingStrategy.scheduler)保证了调度环境在主线程

Signal

Signal 和 Driver 类似，惟一的区别是，Driver 会对新观察者回放（从新发送）上一个元素，而 Signal 不会对新观察者回放上一个元素。

• 这个demo运行 label 是有值的,可是对于咱们的新的观察者btn是没有值
• 不会产生 error 事件
• 必定在 MainScheduler 监听（主线程监听）
• 会共享附加做用

let result = self.textFiled.rx.text.orEmpty
    .asSignal(onErrorJustReturn: "没有值") // 普通序列转化为signle
    .throttle(.milliseconds(500))
    .flatMap {
        self.dealwithData(inputText: $0)
            .asSignal(onErrorJustReturn: "检测到了错误")
}

// 绑定到label上面
result.map { "长度:\(($0 as! String).count)" }
    .emit(to: self.label.rx.text)
    .disposed(by: disposeBag)
// 绑定到button上面
result.map { ($0 as! String) }
    .emit(to: self.btn.rx.title())
    .disposed(by: disposeBag)
复制代码

• catchErrorJustReturn(onErrorJustReturn) 保证了无错误信号
• observeOn(DriverSharingStrategy.scheduler)保证了调度环境在主线程
• source.share(scope: .whileConnected) 序列状态共享

Single

Single 是 Observable 的另一个版本。不像 Observable 能够发出多个元素，它要么只能发出一个元素，要么产生一个 error 事件。

• 发出一个元素，或一个 error 事件
• 不会共享附加做用

let singleOB = Single<Any>.create { (single) -> Disposable in
    print("singleOB 是否共享")
    single(.success("Cooci"))
    single(.error(NSError.init(domain: "com.lgcoooci.cn", 
    code: 10086, userInfo: nil)))
    return Disposables.create()
}

singleOB.subscribe { (reslut) in
    print("订阅:\(reslut)")
    }.disposed(by: disposeBag)

singleOB.subscribe { (reslut) in
    print("订阅:\(reslut)")
    }.disposed(by: disposeBag)
复制代码

Completable

Completable 是 Observable 的另一个版本。不像 Observable 能够发出多个元素，它要么只能产生一个 completed 事件，要么产生一个 error 事件

• 发出零个元素
• 发出一个 completed 元素，或一个 error 事件
• 不会共享附加做用
• Completable 适用于那种你只关心任务是否完成，而不须要在乎任务返回值的状况。它和 Observable<Void> 有点类似。

let completableOB = Completable.create { (completable) -> Disposable in
    print("completableOB 是否共享")
    completable(.completed)
    completable(.error(NSError.init(domain: "com.lgcoooci.cn", 
    code: 10086, userInfo: nil)))
    return Disposables.create()
}

completableOB.subscribe { (reslut) in
    print("订阅:\(reslut)")
    }.disposed(by: disposeBag)

completableOB.subscribe { (reslut) in
    print("订阅:\(reslut)")
    }.disposed(by: disposeBag)
复制代码

Maybe

Maybe 是 Observable 的另一个版本。它介于 Single 和 Completable 之间，它要么只能发出一个元素，要么产生一个completed 事件，要么产生一个 error 事件。

• 发出一个元素或者一个 completed 事件或者一个 error 事件
• 不会共享附加做用
• 若是你遇到那种可能须要发出一个元素，又可能不须要发出时，就可使用 Maybe。

let maybeOB = Maybe<Any>.create { (maybe) -> Disposable in
    print("maybe 是否共享")
    maybe(.success("Cooci"))
    maybe(.completed)
    maybe(.error(NSError.init(domain: "com.lgcoooci.cn", 
    code: 10086, userInfo: nil)))
    return Disposables.create()
}

maybeOB.subscribe { (reslut) in
    print("订阅:\(reslut)")
    }.disposed(by: disposeBag)

maybeOB.subscribe { (reslut) in
    print("订阅:\(reslut)")
    }.disposed(by: disposeBag)
    
复制代码

这个篇章没有太多的底层封装，由于都是差很少的，由于篇幅关系，就没有累赘，但愿读者认真感觉，在不那么了解的状况下，不妨本身Demo感觉一下特色

就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！