RxSwift基本使用(一)
备注:本文参考自田腾飞博文 [RxSwift入坑解读-你所需要知道的各种概念] (http://www.codertian.com/2016/11/27/RxSwift-ru-keng-ji-read-document/),出于个人学习以及笔记需要特记录下RxSwift基本使用
概念
Observable : 可被观察的,事件源
Observer : 观察者,观察者需要订阅Observable,才能受到其发出的事件
DisposeBag : 相当于iOS中的ARC,会在适当的时候销毁观察者,自动去释放资源
如果需要手动销毁观察者直接调用dispose()方法,例:
Observable.empty().subscribe { (str:Event) in
print(“empty:”,str)
}.dispose()
subscribe : 订阅者,用于订阅sequence发出的事件
基本使用
never
never就是创建一个sequence,但不发出任何事件信号
let bag = DisposeBag()
Observable.never().subscribe { (str :Event<String>) in
print("never:",str) //无
}.addDisposableTo(bag)
备注:为了方便简洁,后续例子中创建bag变量的代码将省略
empty
empty创建一个空的sequence,但只能发出一个completed事件
Observable.empty().subscribe { (str :Event<String>) in
print("empty:",str)
}.addDisposableTo(bag)
//empty: completed
just
just创建一个sequence,但只能发出一种特定的事件,能正常结束
Observable.just("just").subscribe { (str :Event<String>) in
print("just:",str)
}.addDisposableTo(bag)
//just:next(just)
//just:completed
of
创建一个sequence能发出很多种事件信号
Observable.of("1","2","3").subscribe { (str) in
print("of:",str)
}.addDisposableTo(bag)
/**
of: next(1)
of: next(2)
of: next(3)
of: completed
*/
//subscribe onNext 直接取值
Observable.of("1","2","3").subscribe(onNext: { (str) in
print("of2:",str)
}).addDisposableTo(bag)
/**
of2: 1
of2: 2
of2: 3
*/
from
from从集合中创建sequence,例如数组,字典或者Set
Observable.from([10,100,1000]).subscribe(onNext: { (num) in
print("from:",num)
}).addDisposableTo(bag)
/**
from: 10
from: 100
from: 1000
**/
create
create 自定义可观察的sequence
//create 自定义可观察的sequence
let myObservable = Observable.create { (observer:AnyObserver<Any>) -> Disposable in
observer.onNext("12")
observer.onNext("21")
observer.onNext("123")
observer.onCompleted()
return Disposables.create()
}
myObservable.subscribe { (e:Event<Any>) in
print("myObservable:",e)
}.addDisposableTo(bag)
/**
myObservable: next(12)
myObservable: next(21)
myObservable: next(123)
myObservable: completed
**/
range
range 创建一个sequence,会发出这个范围中所有事件
Observable.range(start: 1, count: 5).subscribe(onNext: { (num) in
print("range:",num)
}).addDisposableTo(bag)
/**
range: 1
range: 2
range: 3
range: 4
range: 5
**/
repeatElement
创建一个sequence,发出特定的事件n次
Observable.repeatElement("LouKit").take(3).subscribe { print($0)}.addDisposableTo(bag)
//重复发出3次,如果没有take 就无限次
/**
next(LouKit)
next(LouKit)
next(LouKit)
completed
**/
generate
generate是创建一个可观察sequence,当初始化的条件为true的时候,他就会发出所对应的事件
Observable.generate(initialState: 10, condition: {$0 < 15}, iterate: {$0 + 1}).subscribe(onNext: {print("generate",$0)}).addDisposableTo(bag)
/**
generate 10
generate 11
generate 12
generate 13
generate 14
**/
deferred
deferred会为每一为订阅者observer创建一个新的可观察序列
var index = 1
let deferred = Observable<String>.deferred{
print("index:",index)
index += 1
return Observable.create{ observer in
observer.onNext("1")
observer.onNext("2")
observer.onCompleted()
return Disposables.create()
}
}
deferred.subscribe { print("调用1:",$0)}.addDisposableTo(bag)
deferred.subscribe { print("调用2:",$0)}.addDisposableTo(bag)
/**
index: 1
调用1: next(1)
调用1: next(2)
调用1: completed
index: 2
调用2: next(1)
调用2: next(2)
调用2: completed
**/
do
主要用于在subscribe中onNext,onError,onCompleted前调用
Observable.just("00").do(onNext: {print("doOnNext:",$0)},onError: {print("doOnError:",$0)},onCompleted: {print("doOnCompleted:")})
.subscribe(onNext: { (str) in
print("onNext:",str)
}, onError: { (error) in
print("onError")
}, onCompleted: {
print("onCompleted")
}).addDisposableTo(bag)
/**
doOnNext: 00
onNext: 00
doOnCompleted:
onCompleted
**/
Subjects
Subjet是observable和Observer之间的桥梁,一个Subject既可以充当Obserable也可以充当Observer,即它可以发出事件,也可以监听事件
PublishSubject
采用PublishSubject订阅事件的时候,只能接收到订阅他之后
发生的事件
let publicSubject = PublishSubject<String>()
publicSubject.onNext("A")
publicSubject.onNext("B")
publicSubject.subscribe(onNext: {print("publicSubject:",$0)}) .addDisposableTo(bag)
publicSubject.onNext("C")
publicSubject.onNext("D")
/**
publicSubject: C
publicSubject: D
**/
ReplaySubject
可以接收到订阅他之后以及之前
发生的事件,对于要接受几个以前的事件取决于bufferSize设置的大小
let replaySubject = ReplaySubject<String>.create(bufferSize: 2)
replaySubject.onNext("A")
replaySubject.onNext("B")
replaySubject.onNext("C")
replaySubject.onNext("D")
replaySubject.subscribe(onNext: {print("replaySubject:",$0)}) .addDisposableTo(bag)
replaySubject.onNext("E")
replaySubject.onNext("F")
replaySubject.onNext("G")
/**
replaySubject: C
replaySubject: D
replaySubject: E
replaySubject: F
replaySubject: G
**/
//接受全部的事件
let replaySubject2 = ReplaySubject<String>.createUnbounded()
replaySubject2.onNext("A")
replaySubject2.onNext("B")
replaySubject2.subscribe(onNext: {print("replaySubject2:",$0)}) .addDisposableTo(bag)
replaySubject2.onNext("E")
replaySubject2.onNext("F")
/**
replaySubject2: A
replaySubject2: B
replaySubject2: E
replaySubject2: F
**/
BehaviorSubject
采用BehaviorSubject订阅事件,会接收到订阅之前的最后一个事件
以及订阅之后所有事件
。
let behavior = BehaviorSubject(value: "behavior")
behavior.onNext("A")
behavior.onNext("B")
behavior.subscribe(onNext: {print("behavior:",$0)}).addDisposableTo(bag)
behavior.onNext("C")
behavior.onNext("D")
/**
behavior: B
behavior: C
behavior: D
**/
Variable
Variable是对BehaviorSubject一个包装;
Variable当成Obserable, 让订阅者进行订阅时, 需要asObserable转成Obserable;
Variable发出事件, 直接修改对象的value即可;
当事件结束时,Variable会自动发出completed事件
let variable = Variable("variable")
variable.value = "A"
variable.value = "B"
variable.asObservable().subscribe { (event:Event<String>) in
print("variable:",event)
}.addDisposableTo(bag)
variable.value = "C"
variable.value = "D"
/**
variable: next(B)
variable: next(C)
variable: next(D)
variable: completed
**/
联合操作
联合操作就是把多个Observable流合成单个Observable流
startWith
在发出事件消息之前,先发出某个特定的事件消息。
Observable.of(1,2).startWith(3).subscribe(onNext: {print($0)}).addDisposableTo(bag)
/**
3
1
2
**/
merge
将多个Observable流合成单个Observable流,然后任何一个Observable
发出事件都能被接收到
let sub1 = PublishSubject<String>()
let sub2 = PublishSubject<String>()
Observable.of(sub1,sub2).merge().subscribe(onNext: { print($0) }).addDisposableTo(bag)
sub1.onNext("sub1-1")
sub1.onNext("sub1-2")
sub2.onNext("sub2-1")
sub1.onNext("sub1-2")
sub2.onNext("sub2-2")
/**
sub1-1
sub1-2
sub2-1
sub1-2
sub2-2
**/
zip
将多个Observable流合成单个Observable流,只有当多个Observable流同时
发出事件时,并且把多个Observable流的内容
合并成一个元组
,才会触发压缩流的事件。
let zip1 = PublishSubject<String>()
let zip2 = PublishSubject<String>()
Observable.zip(zip1,zip2){ zip1,zip2 in
"\(zip1) \(zip2)"
}.subscribe(onNext: { print($0) })
.addDisposableTo(bag)
zip1.onNext("zip1-1")
zip1.onNext("zip1-2")
zip2.onNext("zip2-1")
zip2.onNext("zip2-2")
/**
zip1-1 zip2-1
zip1-2 zip2-2
**/
注意:merge、zip都能将多个Observable流合成单个Observable流,但合并后前者任何一个Observable发出事件都能被接收到,后者必须是多个流同时发出事件时才被接收到
combineLatest
将多个Observable流合并起来 并拿到其各个流的最新值,即每个合并的signal至少
都有过一次onNext
,才会触发合并的流
let ps1 = PublishSubject<String>()
let ps2 = PublishSubject<String>()
Observable.combineLatest(ps1, ps2) { element1, element2 in
"\(element1) \(element2)"
}
.subscribe(onNext: { print($0) })
.addDisposableTo(bag)
ps1.onNext("ps1-01")
ps1.onNext("ps1-02")
ps2.onNext("ps2-01")
/**
ps1-02 ps2-01
**/
switchLatest
用于对事件流进行转换,即一个Observable中的内容还是Observable。(个人理解)
let bs1 = BehaviorSubject(value: "1")
let bs2 = BehaviorSubject(value: "A")
let variable = Variable(bs1)
variable.asObservable().switchLatest().subscribe(onNext: {print($0)}).addDisposableTo(bag)
bs1.onNext("2")
variable.value = bs2
bs1.onNext("3")
bs2.onNext("B")
/**
1
2
A
B
**/
RxSwift基本使用(一)的更多相关文章
- iOS响应式编程:ReactiveCocoa vs RxSwift 选谁好
转载: iOS响应式编程:ReactiveCocoa vs RxSwift 选谁好 内容来自stack overflow的一个回答:ReactiveCocoa vs RxSwift – pros an ...
- RxSwift 之官方文档
RxSwift 官方文档结构 Introduction: Subjects Transforming Observables Filtering Observables Combining Obser ...
- ReactiveX序列——RxSwift 浅析
ReactiveX序列——RxSwift Swift是苹果公司新推出的一门现代化的编程语言,并且将其开源出来了,Swift具有很多的优点,这也使得这门语言推出的短时间引起了很大反应的原因,在最近的 ...
- ReactiveCocoa / RxSwift 笔记一
原创:转载请注明出处 ReactiveCocoa / RxSwift Native app有很大一部分的时间是在等待事件发生,然后响应事件,比如 1.等待网络请求完成, 2.等待用户的操作, 3.等待 ...
- RxSwift 入坑好多天 - 终于有了一点理解
一.前言 江湖上都在说现在就要赶紧学 swift 了,即将是 swift 的天下了.在 api 变化不大的情况下,swift 作为一门新的语言,集众家之所长,普通编码确实比 oc 要好用的多了 老早就 ...
- RxSwift 系列(六) -- Mathematical and Aggregate Operators
前言 本篇文章将要学习RxSwift中数学和集合操作符,在RxSwift中包括了: toArray reduce concat toArray 将一个Observable序列转化为一个数组,并转换为一 ...
- RxSwift 系列(五) -- Filtering and Conditional Operators
前言 本篇文章将要学习RxSwift中过滤和条件操作符,在RxSwift中包括了: filter distinctUntilChanged elementAt single take takeLast ...
- RxSwift 系列(四) -- Transforming Operators
前言 本篇文章将要学习RxSwift中四种转换操作符: map flatMap flatMapLatest scan map 通过使用一个闭包函数将原来的Observable序列转换为一个新的Obse ...
- RxSwift 系列(三) -- Combination Operators
RxSwift 系列(三) -- Combination Operators 前言 本篇文章将要学习如何将多个Observables组合成一个Observable. Combination Opera ...
- RxSwift 系列(二) -- Subject
前言 Subject是一个代理,它既是Observer,也是Observable.因为它是一个Observer,它可以订阅一个或多个Observable;因为它是一个Observable,它又可以被其 ...
随机推荐
- 20155304 2016-2017-2 《Java程序设计》实验五(网络编程与安全)实验报告
20155304 2016-2017-2 <Java程序设计>实验五(网络编程与安全)实验报告 实验内容及步骤: 一.两人一组结对编程: 参考http://www.cnblogs.com/ ...
- Makefile与Myod
Makefile的引入 课堂测试总结 初识Makefile target ... : prerequisites ... command ... ... target也就是一个目标文件,可以是Obje ...
- loj2538 「PKUWC 2018」Slay the Spire
pkusc 快到了--做点题涨涨 rp. ref我好菜啊QAQ. 可以发现期望只是一个幌子.我们的目的是:对于所有随机的选择方法(一共 \(\binom{2n}{m}\)种),这些选择方法都最优地打出 ...
- win10 Docker Toolbox 默认路径不能写问题
2018-8-30 这几天正学习docker,win10系统家庭版,未升级成专业版,只能安装Docker Toolbox来练习, 安装好后准备做个镜像,默认路径新建目录却提示不允许创建 由于Docke ...
- vue Map 渲染DOM
遍历对象(map),以键值对k:v的形式渲染DOM (1)DOM (2)数据模板
- 各web服务器的特点和优势
1.Tomcat 和 Jetty 面向java语言 天生就是重量级的web服务器.性能一般 2.IIS 只能在windows平台运行,windows作为服务器在稳定性与其他一些性能上不如类unix操作 ...
- 【第二章】MySQL数据库基于Centos7.3-部署
一.MySQL数据库的官方网址: https://www.mysql.com/ https://www.oracle.com/ http://dev.mysql.com/doc/refman/5.7/ ...
- [CF1137]Museums Tour
link \(\text{Description:}\) 一个国家有 \(n\) 个城市,\(m\) 条有向道路组成.在这个国家一个星期有 \(d\) 天,每个城市有一个博物馆. 有个旅行团在城市 \ ...
- ArcFace Demo [Android]
Free SDK demo 工程如何使用? 1.下载代码:git clone https://github.com/asdfqwrasdf/ArcFaceDemo.git 或者直接下载压缩包 2.前往 ...
- Scrum立会报告+燃尽图(十一月二十七日总第三十五次):β阶段最后完善
此作业要求参见:https://edu.cnblogs.com/campus/nenu/2018fall/homework/2415 项目地址:https://git.coding.net/zhang ...