简化创建流程
简化订阅流程
ControlEvent
- ControlEvent: 专门用于描述 UI 控件所产生的事件，它具有以下特征
- 不会产生 error 事件
- 一定在 MainScheduler 订阅（主线程订阅）
- 一定在 MainScheduler 监听（主线程监听）
- 会共享附加作用
let controlEventOB = self.button.rx.controlEvent(.touchUpInside)
controlEventOB.subscribe { (result) in
print("订阅:\(result) \(Thread.current)")
}.disposed(by: self.disposeBag)
controlEventOB.subscribe { (result) in
print("订阅:\(result) \(Thread.current)")
}.disposed(by: self.disposeBag)
订阅:next(()) <NSThread: 0x600001920bc0>{number = 1, name = main}
订阅:next(()) <NSThread: 0x600001920bc0>{number = 1, name = main}
Binder
- 简化订阅流程
- 不会处理错误事件
- 确保绑定都是在给定 Scheduler 上执行（默认 MainScheduler）
- 一旦产生错误事件，在调试环境下将执行 fatalError，在发布环境下将打印错误信息。
// let observer: AnyObserver<Bool> = AnyObserver{ (event) in
// print("observer 当前线程：\(Thread.current)")
// switch event {
// case .next(let value):
// self.label.isHidden = value
// break
// case .error(let error):
// print("observer error:\(error)")
// break
// case .completed:
// print("完成了")
// break
// }
// }
let binder = Binder<Bool>(self.label) { (lab, value) in
print("Binder 当前线程:\(Thread.current)")
lab.isHidden = value
}
let observable = Observable<Bool>.create { (ob) -> Disposable in
ob.onNext(true)
// ob.onError(NSError.init(domain: "com.imefuture.cn", code: 10090, 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)
Driver
- Driver 是一个精心准备的特征序列。它主要是为了简化 UI 层的代码。不过如果你遇到的序列具有以下特征，你也可以使用它：
- 不会产生 error 事件
- 一定在 MainScheduler 监听（主线程监听）
- 会共享附加作用
let result = self.textFiled.rx.text.orEmpty
.asDriver() //普通序列转化为
.throttle(.milliseconds(500))
.flatMap {
self.dealWithData(inputText: $0)
.asDriver(onErrorJustReturn: "检测到了错误")
}
result.map { "长度：\(($0 as! String).count)"}
.drive(self.label.rx.text)
.disposed(by: disposeBag)
result.map { ($0 as! String) }
.drive(self.button.rx.title())
.disposed(by: disposeBag)
func dealWithData(inputText: String) -> Observable<Any> {
print("请求网络了 \(Thread.current)")
return Observable<Any>.create({ (ob) -> Disposable in
if inputText == "1234" {
ob.onError(NSError.init(domain: "com.dyz.cn", code: 2019, userInfo: nil))
}
DispatchQueue.global().async {
print("发送之前看看：\(Thread.current)")
ob.onNext("已经输入：\(inputText)")
ob.onCompleted()
}
return Disposables.create()
})
}
Signal
- Signal 和 Driver 相似，唯一的区别是，Driver 会对新观察者回放（重新发送）上一个元素，而 Signal 不会对新观察者回放上一个元素。
- 这个demo运行 label 是有值的,但是对于我们的新的观察者btn是没有值
- 不会产生 error 事件
- 一定在 MainScheduler 监听（主线程监听）
- 会共享附加作用
let result = self.textFiled.rx.text.orEmpty
.asSignal(onErrorJustReturn: "没有值")
.throttle(.milliseconds(500))
.flatMap {
self.dealWithData(inputText: $0 )
.asSignal(onErrorJustReturn: "检测到了错误")
}
result.map { "长度：\(($0 as! String).count)" }
.emit(to: self.label.rx.text)
.disposed(by: disposeBag)
result.map { ($0 as! String) }
.emit(to: self.button.rx.title())
.disposed(by: disposeBag)
Single
- Single 是 Observable 的另外一个版本。不像 Observable 可以发出多个元素，它要么只能发出一个元素，要么产生一个 error 事件。
- 发出一个元素，或一个 error 事件
- 不会共享附加作用
let singleOB = Single<Any>.create { (single) -> Disposable in
print("singleOB 是否共享")
single(.success("Dyz"))
single(.success("Hello"))
single(.error(NSError.init(domain: "com.ime.cn", code: 098, userInfo: nil)))
return Disposables.create()
}
singleOB.subscribe { (result) in
print("订阅：\(result)")
}.disposed(by: self.disposeBag)
singleOB.subscribe { (result) in
print("订阅：\(result)")
}.disposed(by: self.disposeBag)
singleOB 是否共享
订阅：success("Dyz")
singleOB 是否共享
订阅：success("Dyz")
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.ime.cn", code: 909, userInfo: nil)))
return Disposables.create()
}
completableOB.subscribe { (result) in
print("订阅:\(result)")
}.disposed(by: disposeBag)
completableOB.subscribe { (result) in
print("订阅:\(result)")
}.disposed(by: disposeBag)
completableOB 是否共享
订阅:completed
completableOB 是否共享
订阅:completed
Maybe
- Maybe 是 Observable 的另外一个版本。它介于 Single 和 Completable 之间，它要么只能发出一个元素，要么产生一个 completed 事件，要么产生一个 error 事件。
- 发出一个元素或者一个 completed 事件或者一个 error 事件
- 不会共享附加作用
- 如果你遇到那种可能需要发出一个元素，又可能不需要发出时，就可以使用 Maybe。
let maybeOB = Maybe<Any>.create { (maybe) -> Disposable in
print("maybeOB 是否共享")
maybe(.success("dyz"))
maybe(.completed)
maybe(.error(NSError.init(domain: "com.ime.cn", code: 89, userInfo: nil)))
return Disposables.create()
}
maybeOB.subscribe { (result) in
print("订阅:\(result)")
}.disposed(by: disposeBag)
maybeOB.subscribe { (result) in
print("订阅:\(result)")
}.disposed(by: disposeBag)
maybeOB 是否共享
订阅:success("dyz")
maybeOB 是否共享
订阅:success("dyz")
