RxSwift：Rx标准库API的Swift实现，不包括任何iOS相关的内容
RxCocoa：基于RxSwift，给iOS UI控件扩展了很多Rx特性
使用需要import RxSwiftimport RxCocoa
Observable：负责发送事件（Event）
Observe：负责订阅Observable，监听Observable发送的事件（Event）
1、RxSwift简单使用
just() 方法
（1）该方法通过传入一个默认值来初始化。
（2）下面样例我们显式地标注出了 observable 的类型为 Observable<Int>，即指定了这个 Observable 所发出的事件携带的数据类型必须是 Int 类型的。
// element [1,2,3]
let observable = Observable.just([1,2,3])
of() 方法
（1）该方法可以接受可变数量的参数（必需要是同类型的）
（2）下面样例中我没有显式地声明出 Observable 的泛型类型，Swift 也会自动推断类型。
// element 1,2,3
let observable = Observable.of(1, 2, 3)
from() 方法
（1）该方法需要一个数组参数。
（2）下面样例中数据里的元素就会被当做这个 Observable 所发出 event 携带的数据内容，最终效果同上面和 of() 样例是一样的。
// element 1,2,3
let observable = Observable.from([1,2,3])
range() 方法
（1）该方法通过指定起始和结束数值，创建一个以这个范围内所有值作为初始值的 Observable 序列。
（2）下面样例中，两种方法创建的 Observable 序列都是一样的。
//使用range()
let observable = Observable.range(start: 1, count: 5)
//使用of()
let observable = Observable.of(1, 2, 3 ,4 ,5)
repeatElement() 方法
该方法创建一个可以无限发出给定元素的 Event 的 Observable 序列（永不终止）。
let observable = Observable.repeatElement(1)
generate() 方法
（1）该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。
（2）下面样例中，两种方法创建的 Observable 序列都是一样的。
//使用generate()方法
let observable = Observable.generate(
initialState: 0,
condition: { $0 <= 10 },
iterate: { $0 + 2 }
)
//使用of()方法
let observable = Observable.of(0 , 2 ,4 ,6 ,8 ,10)
create() 方法
enum LFError: Error {
case rxError
}
static func testRxSwift() {
// 1、创建observable
let observable = Observable<Int>.create { (observe) -> Disposable in
// 3、observe发送数据
observe.onNext(1)
observe.onNext(2)
observe.onError(LFError.rxError)
observe.onCompleted()
return Disposables.create()
}
// 2、订阅observable（onNext:闭包表达式，订阅observable发出的数据）
observable.subscribe(onNext: { (element) in
print("element = \(element)")
}, onError: { (error) in
print("error = \(error)")
}, onCompleted: {
print("completed")
}).dispose() // 马上调用dispose()：一次性订阅，只订阅一次
/// disposable调用dispose()，observable发送任何数据，observe都不会再接收到
let disposable = observable.subscribe { (event) in
switch event {
case .next(let element):
print("element = \(element)")
case.error(let error):
print("error = \(error)")
case .completed:
print("completed")
}
}
disposable.dispose()
}
interval() 方法
（1）这个方法创建的 Observable 序列每隔一段设定的时间，会发出一个索引数的元素。而且它会一直发送下去。
（2）下面方法让其每 1 秒发送一次，并且是在主线程（MainScheduler）发送
let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable.subscribe { event in
print(event)
2、timer() 方法，定时器
（1）这个方法有两种用法，一种是创建的 Observable 序列在经过设定的一段时间后，产生唯一的一个元素。
//5秒种后发出唯一的一个元素0
let observable = Observable<Int>.timer(5, scheduler: MainScheduler.instance)
observable.subscribe { event in
print(event)
}
（2）另一种是创建的 Observable 序列在经过设定的一段时间后，每隔一段时间产生一个元素。
func testRxSwiftTimer() {
/// dueTime:延时时间 period:间隔时间 scheduler:线程
let observable = Observable<Int>.timer(.seconds(3), period: .seconds(1), scheduler: MainScheduler.instance)
print("创建observable")
observable.subscribe(onNext: { (element) in
print("element = \(element)")
}, onError: { (error) in
print("error = \(error)")
}, onCompleted: {
print("completed")
})
/// observable发出的数据，绑定到label上
/// label.rx.text 是一个observe，订阅observable发出的数据
observable.map {"数值是：\($0)"}.bind(to: self.label.rx.text)
}
2、disposable调用dispose()，observable发送任何数据，observe都不会再接收到
func testRxSwiftDisposable() {
let observable = Observable.just([1,2,3])
/// 立即取消订阅，一次性订阅
observable.subscribe { (event) in
print(event)
}.dispose()
/// 当bag销毁(deinit)时，会自动调用Disposable实例的dispose，observe订阅也跟着销毁
observable.subscribe { (event) in
print(event)
}.disposed(by: bag)
/// RxSwift 给NSObject扩展的 deallocated
let _ = observable.takeUntil(self.rx.deallocated).subscribe { (event) in
print(event)
}
}
3、将observable的值，绑定到控件上
func testRxSwiftObserve() {
/// 创建observe
let observe = AnyObserver<Int>.init { (event) in
switch event {
case .next(let element):
print("element = \(element)")
case .completed:
print("completed")
case .error(let error):
print("error = \(error)")
}
}
Observable.just(1).subscribe(observe).dispose()
/// 创建observe（Binder也是observe）
let binderObserve = Binder<String>.init(self.label) { (label, value) in
label.text = value
}
Observable.just(1).map { "数值：\($0)" }.subscribe(binderObserve).dispose()
Observable.just(1).map { "数值：\($0)" }.bind(to: binderObserve).dispose()
/// 将observable的值，绑定到button上
/// self.button.rx.isHidden self.button.rx.enable是一个observe，订阅（subscribe/bind）observable发出的数据
let observable = Observable<Int>.timer(.seconds(3), period: .seconds(1), scheduler: MainScheduler.instance)
let binderObserve = Binder<Bool>.init(self.button) { (button, value) in
// 业务逻辑
button.isHidden = value
}
observable.map { $0 % 2 == 0 }.bind(to: binderObserve).disposed(by: bag)
observable.map { $0 % 2 == 0 }.bind(to: self.button.rx.isHidden).disposed(by: bag)
observable.map { $0 % 2 == 0 }.bind(to: self.button.rx.enable).disposed(by: bag)
}
/// 给rx前缀扩展isHidden、enable计算属性
extension Reactive where Base: UIButton {
var isHidden: Binder<Bool> {
return Binder<Bool>(base) { (button, value) in
button.isHidden = value
}
}
var enable: Binder<Bool> {
return Binder<Bool>(base) { (button, value) in
button.isEnabled = value
}
}
}
4、observable create操作符。
传入一个观察者observer，然后调用observer的onNext，onCompleted和onError方法。返回一个可观察的obserable序列
func testObservableCreate() {
// subscribe(_ on:) 订阅信号
let observable1 = Observable<Any>.create { ( anyObserver: AnyObserver) -> Disposable in
anyObserver.onNext("1")
anyObserver.onNext("12")
anyObserver.onNext("123")
anyObserver.onCompleted()
return Disposables.create()
}
observable1.subscribe { (any) in
debugPrint("any = \(any)")
}.disposed(by: self.disposeBag)
/**
* "any = next(1)"
* "any = next(12)"
* "any = next(123)"
* "any = completed"
*/
// subscribe(onNext:) 订阅值
let observable2 = Observable<String>.create { ( anyObserver:AnyObserver<String>) -> Disposable in
anyObserver.onNext("1")
anyObserver.onNext("12")
anyObserver.onNext("123")
anyObserver.onCompleted()
return Disposables.create()
}.subscribe(onNext: { (string) in
print("string = \(string)")
}).disposed(by: self.disposeBag)
/**
* string = 1
* string = 12
* string = 123
*/
/**
* ReplaySubject：可以接收到订阅他之后的事件，但也可以接受订阅他之前发出的事件，接受几个事件取决与bufferSize的大小
* createUnbounded()表示接受所有事件
* create(bufferSize: 1) 表示可接受到的订阅他之前的事件的个数
*/
let replaySubject = ReplaySubject<String>.createUnbounded()
let replaySubject = ReplaySubject<String>.create(bufferSize: 1)
replaySubject.onNext("1")
replaySubject.onNext("12")
replaySubject.subscribe(onNext: { (string) in
debugPrint("string = \(string)")
}).disposed(by: self.disposeBag)
replaySubject.onNext("123")
replaySubject.onCompleted()
/**
* create(bufferSize: 1)
* "string = 12"
* "string = 123"
*/
/**
* 当你订阅了BehaviorSubject，你会接受到订阅之前的最后一个事件,订阅之后的事件一定会触发
*/
let behaviorSubject = BehaviorSubject<String>.init(value: "1")
behaviorSubject.onNext("12")
behaviorSubject.subscribe(onNext: { (string) in
debugPrint("string = \(string)")
}).disposed(by: self.disposeBag)
behaviorSubject.onNext("123")
behaviorSubject.onCompleted()
/**
* "string = 12"
* "string = 123"
*/
}
RxSwift中文文档
为什么要使用 RxSwift ？:https://beeth0ven.github.io/RxSwift-Chinese-Documentation
网友评论