let lgError = NSError.init(domain: "com.error.cn", code: 10090, userInfo: nil)
var disposeBag = DisposeBag()
1、组合操作符
1、startWith -- 在开始从可观察源发出元素之前，发出指定的元素序列
let ss = "12"
Observable.of("1", "2", "3", "4") // 这里面的元素类型决定后面需要添加什么样的类型
.startWith("A")
.startWith("a")
.startWith("a", "c", "s")
.startWith(ss)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果：12
a
c
s
a
A
1
2
3
4
2、merge -- 将源可观察序列中的元素组合成一个新的可观察序列，并将像每个源可观察序列发出元素一样发出每个元素
let subject1 = PublishSubject<String>()
let subject2 = PublishSubject<String>()
let subject3 = PublishSubject<String>()
Observable.of(subject1, subject2, subject3) // 可添加任意数量，但必须是同一类型的
.merge()
.subscribe(onNext: { print(($0)) })
.disposed(by: disposeBag)
subject1.onNext("a")
subject2.onNext("b")
subject1.onNext("aaa")
subject2.onNext("bbb")
subject2.onNext("ccc")
subject3.onNext("ccc")
结果：a
b
aaa
bbb
ccc
ccc
3、zip -- 将多达8个源可观测序列组合成一个新的可观测序列，并将从组合的可观测序列中发射出对应索引处每个源可观测序列的元素
let stringSubject1 = PublishSubject<String>()
let intSubject2 = PublishSubject<Int>()
Observable.zip(stringSubject1, intSubject2) { stringElement, intElement in // 也可以多个序列
"\(stringElement) \(intElement)"
}
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
stringSubject1.onNext("aa")
intSubject2.onNext(23)
intSubject2.onNext(13)
intSubject2.onNext(26)
intSubject2.onNext(34)
stringSubject1.onNext("bb")
stringSubject1.onNext("cc") // 两份序列必须成对有值才有响应
结果：aa 23
bb 13
cc 26
4、combineLatest -- 将8源可观测序列组合成一个新的观测序列,并将开始发出联合观测序列的每个源的最新元素可观测序列一旦所有排放源序列至少有一个元素,并且当源可观测序列发出的任何一个新元素
let stringSub1 = PublishSubject<String>()
let intSub2 = PublishSubject<Int>()
Observable.combineLatest(stringSub1, intSub2){stringElement, intElement in // 也可以多个序列
"\(stringElement) \(intElement)"
}
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
stringSub1.onNext("X")
intSub2.onNext(12)
stringSub1.onNext("Q")
intSub2.onNext(23)
intSub2.onNext(34) // 类似zip，必须成对有值才有响应，但是后面出现的会覆盖前面出现的值
结果 X 12
Q 12
Q 23
Q 34
应用：比如账户和密码同时满足->才能登陆. 不关心账户密码怎么变化的只要查看最后有值就可以
5、switchLatest -- 将可观察序列发出的元素转换为可观察序列，并从最近的内部可观察序列发出元素
let switchLatestSub1 = BehaviorSubject(value: "A")
let switchLatestSub2 = BehaviorSubject(value: "1")
let switchLatestSub = BehaviorSubject(value: switchLatestSub1) // 监听switchLatestSub1
switchLatestSub.asObservable()
.switchLatest()
.subscribe(onNext: { print(($0)) })
.disposed(by: disposeBag)
switchLatestSub1.onNext("B")
switchLatestSub1.onNext("C")
switchLatestSub2.onNext("2")
switchLatestSub2.onNext("3") // switchLatestSub不会监听“2”、“3”，但是会保存，默认后面的会覆盖前面的
switchLatestSub.onNext(switchLatestSub2) // 切换监听switchLatestSub2
switchLatestSub1.onNext("DDD")
switchLatestSub2.onNext("222")
switchLatestSub.onNext(switchLatestSub1)
结果 A
B
C
3
222
DDD
2、映射操作符
1、map -- 转换闭包应用于可观察序列发出的元素，并返回转换后的元素的新可观察序列。
Observable.of(1, 2, 3, 4)
.map { (number) -> Int in
return number + 2
}
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果
3
4
5
6
2、flatMap -- 将可观测序列发射的元素转换为可观测序列，并将两个可观测序列的发射合并为一个可观测序列。
let boy = Player(score: 100)
let girl = Player(score: 90)
let player = BehaviorSubject(value: boy)
player.asObservable()
.flatMap { $0.score.asObservable() }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
boy.score.onNext(60)
player.onNext(girl) // 对于任何一个可观察序列的新发射都可做出反应
boy.score.onNext(50)
girl.score.onNext(20)
结果
100
60
90
50
20
3、scan -- 从初始就带有一个默认值开始，然后对可观察序列发出的每个元素应用累加器闭包，并以单个元素可观察序列的形式返回每个中间结果
Observable.of(10, 100, 1000)
.scan(1) { aggregateValue, newValue in
aggregateValue + newValue // 1 + (10) , 1 + (100 + 10) , 1 + (1000 + 100 + 10)
}
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果
11
111
1111
3、过滤条件操作符
1、filter -- 仅从满足指定条件的可观察序列中发出那些元素
Observable.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
.filter{ $0 % 2 == 0 }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果
2
4
6
8
10
2、distinctUntilChanged -- 抑制可观察序列发出的顺序重复元素
Observable.of("1", "1", "2", "2", "2", "3", "4", "2", "2") // 也可为 Int型
.distinctUntilChanged()
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag) // 连续的重复的才会去重
结果
1
2
3
4
2
3、elementAt -- 仅在可观察序列发出的所有元素的指定索引处发出元素
Observable.of("t", "e", "s", "t")
.elementAt(2)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果
s
4、single -- 只发出可观察序列发出的第一个元素(或满足条件的第一个元素)。如果可观察序列发出多个元素，将抛出一个错误。
Observable.of("bbb")
.single() // 发出第一个，因为只有一个，所以不会抛出错误
.subscribe(onNext: {print($0)} )
.disposed(by: disposeBag)
Observable.of("bbb", "aaa", "aaa", "ccc")
.single() // 发出第一个，因为有多个，所以会抛出错误
.subscribe(onNext: {print($0)} )
.disposed(by: disposeBag)
Observable.of("aaa", "bbb", "aaa", "ccc")
.single { $0 == "ccc" } // 满足条件只有一个，所以发出这个，不会抛出错误
.subscribe(onNext: {print($0)} )
.disposed(by: disposeBag)
Observable.of("aaa", "bbb", "aaa", "ccc")
.single { $0 == "aaa" } // 满足条件有多个，所以发出这个，并且抛出错误
.subscribe(onNext: {print($0)} )
.disposed(by: disposeBag)
结果
bbb
bbb
Unhandled error happened: Sequence contains more than one element.
subscription called from:
ccc
aaa
Unhandled error happened: Sequence contains more than one element.
subscription called from:
5、take -- 只从一个可观察序列的开始发出指定数量的元素。 上面signal只有一个序列 在实际开发会受到局限 这里引出 take 想几个就几个
Observable.of("aaa", "bbb", "ccc", "ddd")
.take(3)
.subscribe(onNext: { print($0) } )
.disposed(by: disposeBag)
结果
aaa
bbb
ccc
6、takeLast -- 仅从可观察序列的末尾发出指定数量的元素
Observable.of("aaa", "bbb", "ccc", "ddd")
.takeLast(3)
.subscribe(onNext: { print($0) } )
.disposed(by: disposeBag)
结果
bbb
ccc
ddd
7、takeWhile -- 只要指定条件的值为true，就从可观察序列的开始发出元素
Observable.of(1, 2, 3, 4, 5, 6, 7, 8)
.takeWhile{ $0 < 4 }
.subscribe(onNext: { print($0) } )
.disposed(by: disposeBag)
结果
1
2
3
8、takeUntil -- 从源可观察序列发出元素，直到参考可观察序列发出元素(cell重用运用)
let sourceSequence = PublishSubject<String>()
let referenceSequence = PublishSubject<String>()
sourceSequence
.takeUntil(referenceSequence)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
sourceSequence.onNext("aaa")
sourceSequence.onNext("bbb")
sourceSequence.onNext("ccc")
referenceSequence.onNext("AAA") // 往下sourceSequence就不发出元素了
sourceSequence.onNext("ddd")
结果
aaa
bbb
ccc
9、skip -- 从源可观察序列发出元素，直到参考可观察序列发出元素
Observable.of(1, 2, 3, 4, 5, 6, 7, 8, 4)
.skip(4)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果
5
6
7
8
4
10、skipWhile --
Observable.of(1, 2, 3, 4, 5, 6, 7, 8, 4)
.skipWhile{ $0 < 3 }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果
3
4
5
6
7
8
4
11、skipUntil -- 抑制从源可观察序列发出元素，直到参考可观察序列发出元素
let sourceSeq = PublishSubject<String>()
let referenceSeq = PublishSubject<String>()
sourceSeq
.skipUntil(referenceSeq)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
sourceSeq.onNext("aaa")
sourceSeq.onNext("bbb")
sourceSeq.onNext("ccc")
referenceSeq.onNext("AAA") // 往下sourceSeq才开始发出元素了
sourceSeq.onNext("ddd")
结果
ddd
4、集合控制操作符
1、toArray -- 将一个可观察序列转换为一个数组，将该数组作为一个新的单元素可观察序列发出，然后终止
Observable.range(start: 1, count: 10)
.toArray()
.subscribe{ print($0) }
.disposed(by: disposeBag)
结果
success([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
2、reduce -- 从一个设置的初始化值开始，然后对一个可观察序列发出的所有元素应用累加器闭包，并以单个元素可观察序列的形式返回聚合结果
Observable.of(10, 100, 1000)
.reduce(1, accumulator: +) // 1 + 10 + 100 + 1000 = 1111
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Observable.of(10, 100, 1000)
.reduce(1, accumulator: -) // 1 - (10 + 100 + 1000) = -1109
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果
1111
-1109
3、concat -- 以顺序方式连接来自一个可观察序列的内部可观察序列的元素，在从下一个序列发出元素之前，等待每个序列成功终止
let subject1 = BehaviorSubject(value: "aaa")
let subject2 = BehaviorSubject(value: "AAA")
let subjectsSubject = BehaviorSubject(value: subject1)
subjectsSubject.asObservable()
.concat()
.subscribe(onNext: {print($0)} )
.disposed(by: disposeBag)
subject1.onNext("bbb")
subject1.onNext("ccc")
subjectsSubject.onNext(subject2)
subject1.onNext("ddd")
subject2.onNext("BBB")
subject2.onNext("CCC")
subject1.onCompleted() // subject1停止发 subject2开始发，subject2会发出保存的最后一个元素
subject2.onNext("DDD")
subject1.onNext("eee")
结果
aaa
bbb
ccc
ddd
CCC
DDD
5、从错误通知中恢复的操作符
1、catchErrorJustReturn -- 从错误事件中恢复，方法是返回一个可观察到的序列，该序列发出单个元素，然后终止
let sequenceThatFails = PublishSubject<String>()
sequenceThatFails
.catchErrorJustReturn("Test")
.subscribe { print($0) }
.disposed(by: disposeBag)
sequenceThatFails.onNext("AAA")
sequenceThatFails.onNext("BBB") // 正常序列发送成功的
sequenceThatFails.onError(self.lgError) // 发送失败的序列,一旦订阅到位 返回我们之前设定的错误的预案
结果
next(AAA)
next(BBB)
next(Test)
completed
2、catchError -- 通过切换到提供的恢复可观察序列，从错误事件中恢复
let recoverySequence = PublishSubject<String>()
sequenceThatFails
.catchError {
print("Error:", $0)
return recoverySequence
}
.subscribe { print($0) }
.disposed(by: disposeBag)
sequenceThatFails.onNext("AAA")
sequenceThatFails.onNext("BBB") // 正常序列发送成功的
sequenceThatFails.onError(lgError) // 发送失败的序列，此时往后可以正常发送成功
recoverySequence.onNext("CCC")
结果
Error: Error Domain=com.error.cn Code=10090 "(null)"
next(CCC)
3、retry -- 通过无限地重新订阅可观察序列来恢复重复的错误事件
var count = 1 // 外界变量控制流程
let sequenceRetryErrors = Observable<String>.create { observer in
observer.onNext("AAA")
observer.onNext("BBB")
observer.onNext("CCC")
if count == 1 { // 流程进来之后就会过度-这里的条件可以作为出口,失败的次数
observer.onError(self.lgError) // 接收到了错误序列,重试序列发生
print("错误序列来了")
count += 1
}
observer.onNext("aaa")
observer.onNext("bbb")
observer.onNext("ccc")
observer.onCompleted()
return Disposables.create()
}
sequenceRetryErrors
.retry()
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果
AAA
BBB
CCC
错误序列来了
AAA
BBB
CCC
aaa
bbb
ccc
4、retry(_:) -- 通过重新订阅可观察到的序列，重复地从错误事件中恢复，直到重试次数达到max未遂计数
let sequenceThatErrors = Observable<String>.create { observer in
observer.onNext("AAA")
observer.onNext("BBB")
observer.onNext("CCC")
if count < 10 {
observer.onError(self.lgError)
print("错误序列来了")
count += 1
}
observer.onNext("aaa")
observer.onNext("bbb")
observer.onNext("ccc")
observer.onCompleted()
return Disposables.create()
}
sequenceThatErrors
.retry(3) // 最大重复数
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
结果
AAA
BBB
CCC
错误序列来了
AAA
BBB
CCC
错误序列来了
AAA
BBB
CCC
错误序列来了
Unhandled error happened: Error Domain=com.error.cn Code=10090 "(null)"
subscription called from:
扫一扫
3556
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
