RxSwfit 学习笔记（二）Observable & Observer
上一篇文章中，咱们已经简单了解了一下RxSwift入门的第一步，在RxCocoa的帮助下，来实现一个登陆输入监听校验的功能。 那么咱们要如何建立一个属于咱们本身的监听序列呢？或者说如何监听咱们本身建立的属性呢，好比说一个String。swift
咱们这里先简单说一下Observable与Observer的区别与联系bash
**Observable：**可监听序列，从名字上来看，咱们就能理解，他是用来被监听的，而不是主动监听的闭包
Observer：观察者，显而易见，它与“可监听序列”相对，它就是用来监听序列的角色。监听事件，而后它须要这个事件作出响应。例如：监听到一个
onNext事件，而后咱们对这个事件做出响应。框架两者相互配合，从而达到响应的效果。异步
Observable 可监听序列
介绍内容摘取自RxSwift的使用详解3（Observable介绍、建立可观察序列） Observable 做为 Rx 的根基，咱们首先对它要有一些基本的了解。 ###1. Observableide
Observable<T>这个类就是Rx框架的基础，咱们能够称它为可观察序列。它的做用就是能够异步地产生一系列的Event（事件），即一个Observable<T>对象会随着时间推移不按期地发出event(element : T)这样一个东西。- 并且这些
Event还能够携带数据，它的泛型<T>就是用来指定这个Event携带的数据的类型。 - 有了可观察序列，咱们还须要有一个
Observer（订阅者）来订阅它，这样这个订阅者才能收到Observable<T>不时发出的Event。
2.Event
查看 RxSwift 源码能够发现，事件 Event 的定义以下：学习
public enum Event<Element> {
/// Next element is produced.
case next(Element)
/// Sequence terminated with an error.
case error(Swift.Error)
/// Sequence completed successfully.
case completed
}
复制代码
能够看到 Event 就是一个枚举，也就是说一个 Observable 是能够发出 3 种不一样类型的 Event 事件：测试
-
next：
next事件就是那个能够携带数据<T>的事件，能够说它就是一个“最正常”的事件。ui -
error：
error事件表示一个错误，它能够携带具体的错误内容，一旦Observable发出了error event，则这个Observable就等于终止了，之后它不再会发出event事件了。this -
completed：
completed事件表示Observable发出的事件正常地结束了，跟error同样，一旦Observable发出了completed event，则这个Observable就等于终止了，之后它不再会发出event事件了。
Observer 观察者
在上文咱们已经有提到过了Observer就是用来“观察”Observable的，那么是如何观察的呢？ 咱们使用 subscribe() 方法来订阅（观察）Observable。 上面有提到Observable发出三种事件next、error、completed，那么Observer也对应的能监听到这三种事件
//订阅序列
observable.subscribe(onNext: { (str) in
print(str)
}, onError: { (error) in
print(error)
}, onCompleted: {
print("completed")
}).disposed(by: disposebag)
复制代码
Observable & Observer 配合使用
1. 最普通的序列建立与订阅
enum MyError: Error {
case errorA
case errorB
}
//建立序列
let testOB = Observable<String>.create { ob in
//发送next事件
ob.onNext("test1")
ob.onNext("test2")
ob.onNext("test3")
//发送error事件
ob.onError(MyError.errorA)
//发送completed事件
ob.onCompleted()
return Disposables.create()
}
//订阅序列
testOB.subscribe(onNext: { (str) in
print(str)
}, onError: { (error) in
print(error)
}, onCompleted: {
print("completed")
}).disposed(by: disposebag)
复制代码
打印结果：
test1
test2
test3
errorA
复制代码
细心的朋友已经发现了，咱们明明有发送completed，可是为何没有打印出来，很明显，问题在ob.onError()上。 咱们在测试一下，挪动一下ob.onError()的位置
//建立序列
let testOB = Observable<String>.create { ob in
ob.onNext("test1")
ob.onNext("test2")
ob.onError(MyError.errorA)
ob.onNext("test3")
ob.onCompleted()
return Disposables.create()
}
复制代码
打印结果：
test1
test2
errorA
复制代码
因此咱们能得出结论，一旦观察者有监听到error事件，那么就会在触发onError:闭包结束后，中止监听。后续应该会好好聊聊这个问题。咱们先暂且了解就好。
2. 跨类使用
咱们新建立一个类FirstViewModel，声明一个Observable<String>类型的变量，而后在初始化方法中直接建立出来。
class FirstViewModel {
var text : Observable<String>!
let disposeBag = DisposeBag()
init() {
text = Observable.create { (observer) -> Disposable in
observer.onNext("test1")
observer.onNext("test2")
observer.onNext("test3")
observer.onCompleted()
return Disposables.create()
}
}
}
复制代码
而后咱们在控制器中，初始化FirstViewModel
class FirstViewController: UIViewController {
var disposeBag = DisposeBag()
override func viewDidLoad() {
super.viewDidLoad()
let vm : FirstViewModel = FirstViewModel.init()
vm.text.subscribe(onNext: { obString in
print(obString)
}, onCompleted: {
print("completed")
}).disposed(by: disposeBag)
}
}
复制代码
command + R 看 输出结果
msg1
msg2
msg3
completed
复制代码
3. 点击按钮发送事件
class FirstViewModel {
class func getText() -> Observable<String> {
//建立一个just事件
return .just("你收到了嘛")
}
}
复制代码
btn.rx.tap.subscribe(onNext: { [weak self] in
self?.btnClick()
}).disposed(by: disposeBag)
//事件
func btnClick() -> Void{
FirstViewModel.getText().subscribe(onNext: { (String) in
print(String)//输出结果： 你收到了嘛
}).disposed(by: disposeBag)
}
复制代码
这里出现了一个.just，这是什么呢。 建立Observable序列的方法有不少种。
建立Observable 序列其余方法
各个方法的区别于做用，能够看这里
print("----------- this is just ----------- ")
let observable_just = Observable<Int>.just(5)
observable_just.subscribe(onNext: { (Int) in
print("\(Int)")
}, onCompleted: {
print("just completed")
}).disposed(by: disposeBag)
print("----------- this is of ----------- ")
let observable_of = Observable.of("A", "B", "C")
observable_of.subscribe(onNext: { (String) in
print("\(String)")
}, onCompleted: {
print("of completed")
}).disposed(by: disposeBag)
print("----------- this is from ----------- ")
let observable_from = Observable.from(["A", "B", "C"])
observable_from.subscribe(onNext: { (String) in
print("\(String)")
}, onCompleted: {
print("from completed")
}).disposed(by: disposeBag)
print("----------- this is empty ----------- ")
let observable_empty = Observable<Int>.empty()
observable_empty.subscribe(onNext: { (Int) in
print("this is empty")
}, onCompleted: {
print("empty completed")
}).disposed(by: disposeBag)
print("----------- this is never ----------- ")
let observable_nerver = Observable<Int>.never()
observable_nerver.subscribe(onNext: { (Int) in
print("this is never")
}, onCompleted: {
print("never completed")
}).disposed(by: disposeBag)
print("----------- this is error ----------- ")
enum MyError: Error {
case A
case B
}
let observable_error = Observable<Int>.error(MyError.A)
observable_error.subscribe(onNext: { (Int) in
}, onError: { (Error) in
print(" \(Error)")
}, onCompleted: {
print("error completed")
}).disposed(by: disposeBag)
print("----------- this is range ----------- ")
let observable_range = Observable.range(start: 1, count: 5)
observable_range.subscribe(onNext: { (Int) in
print("\(Int)")
}, onCompleted: {
print("range completed")
}).disposed(by: disposeBag)
//不能放在主线程，会堵塞
// let observable_repeat = Observable.repeatElement(1)
// observable_repeat.subscribe(onNext: { (Int) in
// print("this is repeat -- \(Int)")
// }, onCompleted: {
// print("repeat completed")
// }).disposed(by: disposeBag)
print("----------- this is generate ----------- ")
//使用generate()方法
let observable_generate = Observable.generate(
initialState: 0,
condition: { $0 <= 10 },
iterate: { $0 + 2 }
)
observable_generate.subscribe(onNext: { (Int) in
print("\(Int)")
}, onCompleted: {
print("generate completed")
}).disposed(by: disposeBag)
print("----------- this is deferred ----------- ")
//用于标记是奇数、仍是偶数
var isOdd = true
//使用deferred()方法延迟Observable序列的初始化，经过传入的block来实现Observable序列的初始化而且返回。
let factory : Observable<Int> = Observable.deferred {
//让每次执行这个block时候都会让奇、偶数进行交替
isOdd = !isOdd
//根据isOdd参数，决定建立并返回的是奇数Observable、仍是偶数Observable
if isOdd {
return Observable.of(1, 3, 5 ,7)
}else {
return Observable.of(2, 4, 6, 8)
}
}
//第1次订阅测试
factory.subscribe { event in
print("\(isOdd)", event)
}.disposed(by: disposeBag)
//第2次订阅测试
factory.subscribe { event in
print("\(isOdd)", event)
}.disposed(by: disposeBag)
//第3次订阅测试
factory.subscribe { event in
print("\(isOdd)", event)
}.disposed(by: disposeBag)
//RxSwift 5.x 弃用 TimeInterval，改用 DispatchTimeInterval
print("----------- this is interval ----------- ")
let observable_interval = Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
observable_interval.subscribe { event in
print(event)
}.disposed(by: disposeBag)
print("----------- this is timer ----------- ")
//5秒种后发出惟一的一个元素0
let observable_timer = Observable<Int>.timer(.seconds(5), scheduler: MainScheduler.instance)
observable_timer.subscribe { event in
print(event)
}.disposed(by: disposeBag)
//延时5秒种后，每隔1秒钟发出一个元素
let observable_timer2 = Observable<Int>.timer(.seconds(5), period: .seconds(5), scheduler: MainScheduler.instance)
observable_timer2.subscribe { event in
print(event)
}.disposed(by: disposeBag)
复制代码
既是Observable 又是 Observer
怎么说呢，像TextField，咱们既能够监听它，又能够把它当作一个观察者。
- 若是是初学者，那么以为上面这句话很奇怪，这个做为观察者是什么意思？ 咱们能够这么理解，咱们既能够监听文本框的输入，又能够给文本框赋值。
那么接下来我就为大家介绍一下这种状况。
class FifthViewController: UIViewController {
var textF:UITextField!
let disposeBag = DisposeBag()
override func viewDidLoad() {
super.viewDidLoad()
textF = UITextField.init(frame: .init(x: 20, y: 120, width: view.frame.width, height: 40))
textF.borderStyle = .roundedRect
view.addSubview(textF)
//把文本框当作观察者
let observer = textF.rx.text
let text:Observable<String> = Observable<String>.create {
$0.onNext("test")
$0.onNext("test1")
$0.onNext("test2")
return Disposables.create()
}
text.bind(to: observer).disposed(by: disposeBag)
//把文本框当作可监听对象
let observable = textF.rx.text
observable.subscribe(onNext: {
print($0 as Any)
}).disposed(by: disposeBag)
}
}
复制代码
另外，框架里面定义了一些辅助类型，它们既是可监听序列也是观察者。若是你能合适的应用这些辅助类型，它们就能够帮助你更准确的描述事物的特征：
- AsyncSubject
- PublishSubject
- ReplaySubject
- BehaviorSubject
- ControlProperty”
摘录来自: RxSwift 中文文档。
以上几种辅助类型我将在 RxSwfit 学习笔记（四）中学习探索
相关文章
- 1. Angular2学习笔记——Observable
- 2. Observer Observable
- 3. RxSwfit 学习笔记（五）操做符，合并Observable序列，merge、combineLatest等
- 4. Observer学习笔记
- 5. Angular学习笔记—RxJS与Observable（转载）
- 6. [译] 经过构建 Observable 来学习 Observable
- 7. Mobx入门之一：observable & observer
- 8. angular4 http RxJS Observable observer演示
- 9. [RxJS] Subject: an Observable and Observer hybrid
- 10. Rxjava2.0学习笔记（二）
- 更多相关文章...
- • 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
- • 我们已经学习了 SQL，下一步学习什么呢？ - SQL 教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • Kotlin学习（二）基本类型
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Angular2学习笔记——Observable
- 2. Observer Observable
- 3. RxSwfit 学习笔记（五）操做符，合并Observable序列，merge、combineLatest等
- 4. Observer学习笔记
- 5. Angular学习笔记—RxJS与Observable（转载）
- 6. [译] 经过构建 Observable 来学习 Observable
- 7. Mobx入门之一：observable & observer
- 8. angular4 http RxJS Observable observer演示
- 9. [RxJS] Subject: an Observable and Observer hybrid
- 10. Rxjava2.0学习笔记（二）