RxSwift Observable(观察量) subscribe(订阅)

RxSwift Observable(观察量) subscribe(订阅)

1.观察量Observable

(监听 元素一系列变化 并且 内部相应作出处理) 生成的一个方法

这个元素可以是多样化，比如array，string，button的事件，文本框的字符串变化。

特点

Observable< E >，E代表观察的元素类型

转化为一个序列，本身并不会触发执行。

只有 被订阅的时候，才会触发执行。

如果是无限序列，比如按钮点击事件，在不需要的时候需要disposable

​

Example

Never

产生一个观察量，但永不执行

func rx_Observable_never(){
// 处置管理器，相当于arc管理
let disposBag = DisposeBag()
Observable<String>.never().subscribe { _ in
print("never永远不会执行")
}.addDisposableTo(disposBag) //将这个rx资源加入管理器disposBag
}

//上面是函数组合调用，这里分解开来写
func rx_Observable_never(){
let disposeBag = DisposeBag()//处置器
let neverSequence = Observable<String>.never()//观察量序列

//订阅
let neverSequenceSubscription = neverSequence
.subscribe { _ in
print("This will never be printed")
}

//回收
neverSequenceSubscription.addDisposableTo(disposeBag)
}

​

empty

空的观察量序列，就是除了完成信号，再也没有其他的了

func rx_Observable_empty(){
let disposeBag = DisposeBag()

Observable<Int>.empty()
.subscribe { event in
print(event)
}
.addDisposableTo(disposeBag)
}

​

just

观察量只有一个元素

func rx_Observable_just(){
let disposeBag = DisposeBag()

Observable.just("��")
.subscribe { event in
print(event)
}
.addDisposableTo(disposeBag)
}

​

of

固定数量的元素 转化为观察量序列

func rx_Observable_of(){
let disposeBag = DisposeBag()

Observable.of("��","��", "��", "��", "��")
.subscribe(onNext: { element in
print(element)
})
.addDisposableTo(disposeBag)
}

​

from

将数组或者字典或其他集合 转化为观察量序列

func rx_Observable_from(){
let disposeBag = DisposeBag()

Observable.from(["��", "��", "��", "��"])
.subscribe(onNext: { print($0) })
.addDisposableTo(disposeBag)
}

​

create

创建自定义的观察量序列

// 传入一个数组，返回一个 观察量序列
func rx_Observable_create(){
let test = { (arr:[String])->Observable<String> in
return Observable.create{ observer in

for element in arr{
// 订阅事件流
observer.onNext(element)
}

// 完成
observer.onCompleted()

// 一个订阅事件 包含一个返回的disposable 取消方法
return Disposables.create {
print("妹纸，来嘿嘿嘿吧")
}
}
}

}

test(arr: ["短裙","美腿","丝袜","高跟"]).subscribe(onNext: { x in
print("哎哟这\(x)不错哦")
}).addDisposableTo(disposeBag)

}

​

range

创建一个 观察量序列 为连续的整数

func rx_Observable_range(){
let disposeBag = DisposeBag()

Observable.range(start: 1, count: 10)
.subscribe { print($0) }
.addDisposableTo(disposeBag)
}

repeatElement

将一个固定元素重复无限发送的 观察量序列

func rx_Observable_repeatElement() {
let disposeBag = DisposeBag()

Observable.repeatElement("��")
.take(3)//发送三次，这个去掉无限发送
.subscribe(onNext: { print($0) })
.addDisposableTo(disposeBag)
}

​

generate

generate生成一个条件环境, 把再这个环境中的符合条件的信号发送出去

func rx_Observable_generate() {
let disposeBag = DisposeBag()

Observable.generate(
initialState: 0,
condition: { $0 < 3 },
iterate: { $0 + 1 }
)
.subscribe(onNext: { print($0) })
.addDisposableTo(disposeBag)
}

​

deferred

产生一个观察量序列，条件:只有被订阅的时候才实际的创建出来

func rx_Observable_deferred() {
let disposeBag = DisposeBag()
var count = 1

let deferredSequence = Observable<String>.deferred {
print("Creating \(count)")
count += 1

return Observable.create { observer in
print("Emitting...")
observer.onNext("��")
observer.onNext("��")
observer.onNext("��")
return Disposables.create()
}
}

deferredSequence
.subscribe(onNext: { print($0) })
.addDisposableTo(disposeBag)

deferredSequence
.subscribe(onNext: { print($0) })
.addDisposableTo(disposeBag)
}

​

error

发送一个错误的观察量序列

func rx_Observable_error() {
let disposeBag = DisposeBag()

Observable<Int>.error(TestError.test)
.subscribe { print($0) }
.addDisposableTo(disposeBag)
}

doOn

对每个发出的事件调用副作用操作，并返回（传递）原始事件。

func rx_Observable_doOn() {
let disposeBag = DisposeBag()

Observable.of("��", "��", "��", "��")
.do(onNext: { print("Intercepted:", $0) }, onError: { print("Intercepted error:", $0) }, onCompleted: { print("Completed")  })
.subscribe(onNext: { print($0) })
.addDisposableTo(disposeBag)
}

​

​

// 传入一个数组，返回一个 观察量序列,观察的类型是泛型E
func test<E>(arr:[E])->Observable<E>{
// 返回观察量序列
// 创建观察量，传入一个 订阅事件，返回一个观察量序列
return Observable.create{ observer in                        for element in arr{
// 订阅事件流
observer.onNext(element)
}
// 完成
observer.onCompleted()
// 一个订阅事件 包含一个返回的disposable 取消方法
return Disposables.create()
}
}

​

2. 订阅 subscribe

触发观察量序列的执行

无限序列使用完订阅 记得 disposable

多个订阅者 订阅一个观察量序列，序列事件触发时，会通知每一个订阅者。

test(arr: ["美腿","丝袜","短裙","高跟"]).subscribe(

// 接收的序列，传过来的什么，就是什么
onNext: { x in
print(x)
}, onError: { Error in
print(Error)
}, onCompleted: {
print("完成")
}) {
print("取消")
}.dispose()// 这里是有限的序列，可以不调用，无限序列使用完毕需要调用