绍兴市交通建设有限公司网站,小程序源码怎么上传,网站开发需求分析文档,专门做旅游的视频网站一、变换操作符#xff1a;buffer、map、compactMap等
1.buffer
buffer方法作用是缓冲组合#xff0c;第一个参数是缓冲时间#xff0c;第二个参数是缓冲个数#xff0c;第三个参数是线程。缓存 Observable 中发出的新元素#xff0c;当元素达到某个数量#xff0c;或者…一、变换操作符buffer、map、compactMap等
1.buffer
buffer方法作用是缓冲组合第一个参数是缓冲时间第二个参数是缓冲个数第三个参数是线程。缓存 Observable 中发出的新元素当元素达到某个数量或者经过了特定的时间它就会将这个元素集合发送出来。
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {let disposeBag DisposeBag()override func viewDidLoad() {let subject PublishSubjectString()//每缓存3个元素则组合起来一起发出。//如果1秒钟内不够3个也会发出有几个发几个一个都没有发空数组 []subject.buffer(timeSpan: 1, count: 3, scheduler: MainScheduler.instance).subscribe(onNext: { print($0) }).disposed(by: disposeBag)subject.onNext(a)subject.onNext(b)subject.onNext(c)subject.onNext(1)subject.onNext(2)subject.onNext(3)}
}2.window
● window 操作符和 buffer 十分相似。不过 buffer 是周期性的将缓存的元素集合发送出来而 window 周期性的将元素集合以 Observable 的形态发送出来。 ● 同时 buffer要等到元素搜集完毕后才会发出元素序列。而 window 可以实时发出元素序列。
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {let disposeBag DisposeBag()override func viewDidLoad() {let subject PublishSubjectString()//每3个元素作为一个子Observable发出。subject.window(timeSpan: 1, count: 3, scheduler: MainScheduler.instance).subscribe(onNext: { [weak self] inprint(subscribe: \($0))$0.asObservable().subscribe(onNext: { print($0) }).disposed(by: self!.disposeBag)}).disposed(by: disposeBag)subject.onNext(a)subject.onNext(b)subject.onNext(c)subject.onNext(1)subject.onNext(2)subject.onNext(3)}
}3.map
通过传入一个函数闭包把原来的 Observable 序列转变为一个新的 Observable 序列。
let disposeBag DisposeBag()Observable.of(1, 2, 3).map { $0 * 10}.subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果
//10
//20
//304.flatMap
flatMap 操作符会对源 Observable 的每一个元素应用一个转换方法将他们转换成 Observables。 然后将这些 Observables 的元素合并之后再发送出来。即又将其 “拍扁”降维成一个 Observable 序列。这个操作符是非常有用的。比如当 Observable 的元素本生拥有其他的 Observable 时我们可以将所有子 Observables 的元素发送出来。
let disposeBag DisposeBag()let subject1 BehaviorSubject(value: A)
let subject2 BehaviorSubject(value: 1)let variable Variable(subject1)variable.asObservable().flatMap { $0 }.subscribe(onNext: { print($0) }).disposed(by: disposeBag)subject1.onNext(B)
variable.value subject2
subject2.onNext(2)
subject1.onNext(C)//运行结果
//A
//B
//1
//2
//C注意flatMap并不保证事件的顺序需要保证顺序则需要使用 concatMap
5.concatMap
concatMap 与 flatMap 的唯一区别是当前一个 Observable 元素发送完毕后后一个Observable 才可以开始发出元素。
6.scan
先给一个初始化的数然后不断的拿前一个结果和最新的值进行处理操作。
let disposeBag DisposeBag()Observable.of(1, 2, 3, 4, 5).scan(0) { acum, elem inacum elem}.subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果1 3 6 10 157.groupBy
将源 Observable 分解为多个子 Observable然后将这些子 Observable 发送出来。该操作符会将元素通过某个键进行分组然后将分组后的元素序列以 Observable 的形态发送出来。
let disposeBag DisposeBag()//将奇数偶数分成两组
ObservableInt.of(0, 1, 2, 3, 4, 5).groupBy(keySelector: { (element) - String inreturn element % 2 0 ? 偶数 : 基数}).subscribe { (event) inswitch event {case .next(let group):group.asObservable().subscribe({ (event) inprint(key\(group.key) event\(event))}).disposed(by: disposeBag)default:print()}}
.disposed(by: disposeBag)二、过滤操作符filter、take、skip等
1.filter
用来过滤掉某些不符合要求的事件
let disposeBag DisposeBag()Observable.of(2, 30, 22, 5, 60, 3, 40 ,9).filter {$0 10}.subscribe(onNext: { print($0) }).disposed(by: disposeBag)//运行结果 30 2260402.distinctUntilChanged
过滤掉连续重复的事件
let disposeBag DisposeBag()Observable.of(1, 2, 3, 1, 1, 4).distinctUntilChanged().subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果1 2 3 1 43.single
● 限制只发送一次事件或者满足条件的第一个事件。 ● 如果存在有多个事件或者没有事件都会发出一个 error 事件。 ● 如果只有一个事件则不会发出 error事件
let disposeBag DisposeBag()Observable.of(1, 2, 3, 4).single{ $0 2 }.subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果: 2Observable.of(A, B, C, D).single().subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果
//A
//Unhandled error happenedSequence contains more than one element.4.elementAt
只处理在指定位置的事件.
let disposeBag DisposeBag()Observable.of(1, 2, 3, 4).elementAt(2).subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果: 35.ignoreElements
可以忽略掉所有的元素只发出 error或completed 事件。如果我们并不关心 Observable 的任何元素只想知道 Observable 在什么时候终止那就可以使用 ignoreElements 操作符。
let disposeBag DisposeBag()Observable.of(1, 2, 3, 4).ignoreElements().subscribe{print($0)}.disposed(by: disposeBag)6.take
该方法实现仅发送 Observable 序列中的前 n 个事件在满足数量之后会自动 .completed。
let disposeBag DisposeBag()Observable.of(1, 2, 3, 4).take(2).subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果 1 27.takeLast
仅发送 Observable序列中的后 n 个事件。
let disposeBag DisposeBag()Observable.of(1, 2, 3, 4).takeLast(1).subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果 48.skip
跳过源 Observable 序列发出的前 n 个事件。
let disposeBag DisposeBag()Observable.of(1, 2, 3, 4).skip(2).subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果3 49.sample
● Sample 除了订阅源Observable 外还可以监视另外一个 Observable 即 notifier 。 ● 每当收到 notifier 事件就会从源序列取一个最新的事件并发送。而如果两次 notifier 事件之间没有源序列的事件则不发送值。
let disposeBag DisposeBag()let source PublishSubjectInt()
let notifier PublishSubjectString()source.sample(notifier).subscribe(onNext: { print($0) }).disposed(by: disposeBag)source.onNext(1)//让源序列接收接收消息
notifier.onNext(A)source.onNext(2)//让源序列接收接收消息
notifier.onNext(B)
notifier.onNext(C)source.onNext(3)
source.onNext(4)//让源序列接收接收消息
notifier.onNext(D)source.onNext(5)//让源序列接收接收消息
notifier.onCompleted()//运行结果 1 2 4 510.debounce
● 可以用来过滤掉高频产生的元素它只会发出这种元素该元素产生后一段时间内没有新元素产生。换句话说队列中的元素如果和下一个元素的间隔小于了指定的时间间隔那么这个元素将被过滤掉。 ● debounce 常用在用户输入的时候不需要每个字母敲进去都发送一个事件而是稍等一下取最后一个事件
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {let disposeBag DisposeBag()override func viewDidLoad() {//定义好每个事件里的值以及发送的时间let times [[ value: 1, time: 0.1 ],[ value: 2, time: 1.1 ],[ value: 3, time: 1.2 ],[ value: 4, time: 1.2 ],[ value: 5, time: 1.4 ],[ value: 6, time: 2.1 ]]//生成对应的 Observable 序列并订阅Observable.from(times).flatMap { item inreturn Observable.of(Int(item[value]!)).delaySubscription(Double(item[time]!),scheduler: MainScheduler.instance)}.debounce(0.5, scheduler: MainScheduler.instance) //只发出与下一个间隔超过0.5秒的元素.subscribe(onNext: { print($0) }).disposed(by: disposeBag)}
}//运行结果1 5 6三、条件和布尔操作符amb、takeWhile、skipWhile等
1.amb
当传入多个 Observables 到 amb 操作符时取第一个发出元素或产生事件的 Observable然后只发出它的元素。并忽略掉其他的 Observables。
let disposeBag DisposeBag()let subject1 PublishSubjectInt()
let subject2 PublishSubjectInt()
let subject3 PublishSubjectInt()subject1.amb(subject2)//只取第一个amb的Observable的事件.amb(subject3).subscribe(onNext: { print($0) }).disposed(by: disposeBag)subject2.onNext(1)
subject1.onNext(20)
subject2.onNext(2)
subject1.onNext(40)
subject3.onNext(0)
subject2.onNext(3)
subject1.onNext(60)
subject3.onNext(0)
subject3.onNext(0)//运行结果1 2 32.takeWhile
依次判断 Observable 序列的每一个值是否满足给定的条件。 当第一个不满足条件的值出现时它便自动完成。
let disposeBag DisposeBag()Observable.of(2, 3, 4, 5, 6).takeWhile { $0 4 }.subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果2 3 3.takeUntil
● 除了订阅源 Observable 外通过 takeUntil 方法我们还可以监视另外一个 Observable 即 notifier。 ● 如果 notifier 发出值或 complete 通知那么源 Observable 便自动完成停止发送事件
let disposeBag DisposeBag()let source PublishSubjectString()
let notifier PublishSubjectString()source.takeUntil(notifier).subscribe(onNext: { print($0) }).disposed(by: disposeBag)source.onNext(a)
source.onNext(b)
source.onNext(c)
source.onNext(d)//停止接收消息
notifier.onNext(z)source.onNext(e)
source.onNext(f)
source.onNext(g)//运行结果a b c d4.skipWhile
● 用于跳过前面所有满足条件的事件。 ● 一旦遇到不满足条件的事件之后就不会再跳过了
let disposeBag DisposeBag()Observable.of(2, 3, 4, 5, 6).skipWhile { $0 4 }.subscribe(onNext: { print($0) }).disposed(by: disposeBag)}
}
//运行结果4 5 65.skipUntil
skipUntil 除了订阅源 Observable 外还可以监视另外一个 Observable 即 notifier。与 takeUntil 相反的是源 Observable 序列事件默认会一直跳过直到 notifier 发出值或 complete 通知。
let disposeBag DisposeBag()let source PublishSubjectInt()
let notifier PublishSubjectInt()source.skipUntil(notifier).subscribe(onNext: { print($0) }).disposed(by: disposeBag)source.onNext(1)
source.onNext(2)
source.onNext(3)
source.onNext(4)
source.onNext(5)//开始接收消息
notifier.onNext(0)source.onNext(6)
source.onNext(7)
source.onNext(8)//仍然接收消息
notifier.onNext(0)source.onNext(9)//运行结果6 7 8 9四、结合操作符startWith、merge、zip等
1.startWith
该方法会在 Observable 序列开始之前插入一些事件元素。即发出事件消息之前会先发出这些预先插入的事件消息。
let disposeBag DisposeBag()Observable.of(2, 3).startWith(a).startWith(b).startWith(c).subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果c b a 2 32.merge
该方法可以将多个两个或两个以上的Observable 序列合并成一个 Observable序列。
let disposeBag DisposeBag()let subject1 PublishSubjectInt()
let subject2 PublishSubjectInt()Observable.of(subject1, subject2).merge().subscribe(onNext: { print($0) }).disposed(by: disposeBag)subject1.onNext(20)
subject1.onNext(40)
subject1.onNext(60)
subject2.onNext(1)
subject1.onNext(80)
subject1.onNext(100)
subject2.onNext(1)//运行结果20 40 60 1 80 100 13.zip
该方法可以将多个两个或两个以上的Observable 序列压缩成一个 Observable 序列。而且它会等到每个 Observable 事件一一对应地凑齐之后再合并。
let disposeBag DisposeBag()let subject1 PublishSubjectInt()
let subject2 PublishSubjectString()Observable.zip(subject1, subject2) {\($0)\($1)}.subscribe(onNext: { print($0) }).disposed(by: disposeBag)subject1.onNext(1)
subject2.onNext(A)
subject1.onNext(2)
subject2.onNext(B)
subject2.onNext(C)
subject2.onNext(D)
subject1.onNext(3)
subject1.onNext(4)
subject1.onNext(5)//运行结果 1A 2B 3C 4D4.combineLatest
该方法同样是将多个两个或两个以上的Observable 序列元素进行合并。但与 zip 不同的是每当任意一个 Observable 有新的事件发出时它会将每个 Observable 序列的最新的一个事件元素进行合并。
let disposeBag DisposeBag()let subject1 PublishSubjectInt()
let subject2 PublishSubjectString()Observable.combineLatest(subject1, subject2) {\($0)\($1)}.subscribe(onNext: { print($0) }).disposed(by: disposeBag)subject1.onNext(1)
subject2.onNext(A)
subject1.onNext(2)
subject2.onNext(B)
subject2.onNext(C)
subject2.onNext(D)
subject1.onNext(3)
subject1.onNext(4)
subject1.onNext(5)//运行结果1A 2A 2B 2C 2D 3D 4D 5D5.withLatestFrom
该方法将两个 Observable 序列合并为一个。每当 self 队列发射一个元素时便从第二个序列中取出最新的一个值。
let disposeBag DisposeBag()let subject1 PublishSubjectString()
let subject2 PublishSubjectString()subject1.withLatestFrom(subject2).subscribe(onNext: { print($0) }).disposed(by: disposeBag)subject1.onNext(A)
subject2.onNext(1)
subject1.onNext(B)
subject1.onNext(C)
subject2.onNext(2)
subject1.onNext(D)//运行结果1 1 26.switchLatest
有点像其他语言的switch 方法可以对事件流进行转换。比如本来监听的 subject1我可以通过更改 variable 里面的 value 更换事件源。变成监听 subject2。
let disposeBag DisposeBag()let subject1 BehaviorSubject(value: A)
let subject2 BehaviorSubject(value: 1)let variable Variable(subject1)variable.asObservable().switchLatest().subscribe(onNext: { print($0) }).disposed(by: disposeBag)subject1.onNext(B)
subject1.onNext(C)//改变事件源
variable.value subject2
subject1.onNext(D)
subject2.onNext(2)//改变事件源
variable.value subject1
subject2.onNext(3)
subject1.onNext(E)//运行结果A B C 1 2 D E五、算术聚合操作符toArray、reduce、concat等
1.toArray
该操作符先把一个序列转成一个数组并作为一个单一的事件发送然后结束
let disposeBag DisposeBag()Observable.of(1, 2, 3).toArray().subscribe(onNext: { print($0) }).disposed(by: disposeBag)
//运行结果[1, 2, 3]2.reduce
● reduce 接受一个初始值和一个操作符号。 ● reduce 将给定的初始值与序列里的每个值进行累计运算。得到一个最终结果并将其作为单个值发送出去
let disposeBag DisposeBag()Observable.of(1, 2, 3, 4, 5).reduce(0, accumulator: ).subscribe(onNext: { print($0) }).disposed(by: disposeBag)//运行结果 153.concat
● concat 会把多个 Observable 序列合并串联为一个 Observable 序列。 ● 并且只有当前面一个 Observable 序列发出了 completed 事件才会开始发送下一个 Observable 序列事件。
let disposeBag DisposeBag()let subject1 BehaviorSubject(value: 1)
let subject2 BehaviorSubject(value: 2)let variable Variable(subject1)
variable.asObservable().concat().subscribe(onNext: { print($0) }).disposed(by: disposeBag)subject2.onNext(2)
subject1.onNext(1)
subject1.onNext(1)
subject1.onCompleted()variable.value subject2
subject2.onNext(2)//运行结果1 1 1 2 2 六、连接操作符connect、publish、replay等
可连接的序列Connectable Observable 1可连接的序列和一般序列不同在于有订阅时不会立刻开始发送事件消息只有当调用 connect()之后才会开始发送值。 2可连接的序列可以让所有的订阅者订阅后才开始发出事件消息从而保证我们想要的所有订阅者都能接收到事件消息。
1.publish
publish 方法会将一个正常的序列转换成一个可连接的序列。同时该序列不会立刻发送事件只有在调用 connect 之后才会开始。
///定义延迟执行方法
/// - Parameters:
/// - delay: 延迟时间秒
/// - closure: 延迟执行的闭包
public func delay(_ delay: Double, closure: escaping () - Void) {DispatchQueue.main.asyncAfter(deadline: .now() delay) {closure()}
}//每隔1秒钟发送1个事件
let interval ObservableInt.interval(1, scheduler: MainScheduler.instance).publish()//第一个订阅者立刻开始订阅
_ interval.subscribe(onNext: { print(订阅1: \($0)) })//相当于把事件消息推迟了两秒
delay(2) {_ interval.connect()
}//第二个订阅者延迟5秒开始订阅
delay(5) {_ interval.subscribe(onNext: { print(订阅2: \($0)) })
}//运行结果
//订阅1: 0
//订阅1: 1
//订阅1: 2
//订阅2: 2
//订阅1: 3
//订阅2: 3
//订阅1: 4
//订阅2: 42.replay
● 与publish相同之处在于会将将一个正常的序列转换成一个可连接的序列。同时该序列不会立刻发送事件只有在调用 connect 之后才会开始。 ● 与publish不同在于新的订阅者还能接收到订阅之前的事件消息数量由设置的 bufferSize 决定。
//每隔1秒钟发送1个事件
let interval ObservableInt.interval(1, scheduler: MainScheduler.instance).replay(5)//第一个订阅者立刻开始订阅
_ interval.subscribe(onNext: { print(订阅1: \($0)) })//相当于把事件消息推迟了两秒
delay(2) {_ interval.connect()
}//第二个订阅者延迟5秒开始订阅
delay(5) {_ interval.subscribe(onNext: { print(订阅2: \($0)) })
}//运行结果
//订阅1: 0
//订阅1: 1
//订阅2: 0
//订阅2: 1
//订阅1: 2
//订阅2: 2
//订阅1: 3
//订阅2: 3
//订阅1: 43.multicast
● 将一个正常的序列转换成一个可连接的序列。 ● 同时 multicast 方法还可以传入一个 Subject每当序列发送事件时都会触发这个 Subject 的发送。
//创建一个Subject后面的multicast()方法中传入
let subject PublishSubjectInt()//这个Subject的订阅
_ subject.subscribe(onNext: { print(Subject: \($0)) })//每隔1秒钟发送1个事件
let interval ObservableInt.interval(1, scheduler: MainScheduler.instance).multicast(subject)//第一个订阅者立刻开始订阅
_ interval.subscribe(onNext: { print(订阅1: \($0)) })//相当于把事件消息推迟了两秒
delay(2) {_ interval.connect()
}//第二个订阅者延迟5秒开始订阅
delay(5) {_ interval.subscribe(onNext: { print(订阅2: \($0)) })
}//运行结果
//Subject: 0
//订阅1: 0
//Subject: 1
//订阅1: 1
//Subjec: 2
//订阅1: 2
//订阅2: 2
//Subject: 3
//订阅1: 3
//订阅2: 34.refCount
● 将可被连接的 Observable 转换为普通 Observable ● 即该操作符可以自动连接和断开可连接的 Observable。当第一个观察者对可连接的Observable 订阅时那么底层的 Observable 将被自动连接。当最后一个观察者离开时那么底层的 Observable 将被自动断开连接。
//每隔1秒钟发送1个事件
let interval ObservableInt.interval(1, scheduler: MainScheduler.instance).publish().refCount()//第一个订阅者立刻开始订阅
_ interval.subscribe(onNext: { print(订阅1: \($0)) })//第二个订阅者延迟5秒开始订阅
delay(5) {_ interval.subscribe(onNext: { print(订阅2: \($0)) })
}//运行结果
//订阅1: 0
//订阅1: 1
//订阅1: 2
//订阅1: 3
//订阅1: 4
//订阅1: 5
//订阅2: 5
//订阅1: 6
//订阅2: 6
//订阅1: 7
//订阅27 5.share(relay:)
● 该操作符将使得观察者共享源 Observable并且缓存最新的 n 个元素将这些元素直接发送给新的观察者。 ● 简单来说 shareReplay 就是 replay 和 refCount 的组合。
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {override func viewDidLoad() {//每隔1秒钟发送1个事件let interval ObservableInt.interval(1, scheduler: MainScheduler.instance).share(replay: 5)//第一个订阅者立刻开始订阅_ interval.subscribe(onNext: { print(订阅1: \($0)) })//第二个订阅者延迟5秒开始订阅delay(5) {_ interval.subscribe(onNext: { print(订阅2: \($0)) })}}
}//运行结果
//订阅1: 0
//订阅1: 1
//订阅1: 2
//订阅1: 3
//订阅1: 4
//订阅2: 0
//订阅2: 1
//订阅2: 2
//订阅2: 3
//订阅2: 4
//订阅1: 5
//订阅2: 5
//订阅1: 6
//订阅2: 6七、其他操作符delay、materialize、timeout等
1.delay
将 Observable 的所有元素都先拖延一段设定好的时间然后才将它们发送出来。
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {let disposeBag DisposeBag()override func viewDidLoad() {Observable.of(1, 2, 1).delay(3, scheduler: MainScheduler.instance) //元素延迟3秒才发出.subscribe(onNext: { print($0) }).disposed(by: disposeBag)}
}2.delaySubscription
延时订阅。即经过所设定的时间后才对 Observable 进行订阅操作。
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {let disposeBag DisposeBag()override func viewDidLoad() {Observable.of(1, 2, 1).delaySubscription(3, scheduler: MainScheduler.instance) //延迟3秒才开始订阅.subscribe(onNext: { print($0) }).disposed(by: disposeBag)}
}3.materialize
● 该操作符可以将序列产生的事件转换成元素。 ● 通常一个有限的 Observable 将产生零个或者多个 onNext 事件最后产生一个 onCompleted 或者onError事件。而 materialize 操作符会将 Observable 产生的这些事件全部转换成元素然后发送出来。
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {let disposeBag DisposeBag()override func viewDidLoad() {Observable.of(1, 2, 1).materialize().subscribe(onNext: { print($0) }).disposed(by: disposeBag)}
}//运行结果
//next(1)
//next(2)
//next(1)
//completed4.dematerialize
该操作符的作用和 materialize 正好相反它可以将 materialize 转换后的元素还原。
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {let disposeBag DisposeBag()override func viewDidLoad() {Observable.of(1, 2, 1).materialize().dematerialize().subscribe(onNext: { print($0) }).disposed(by: disposeBag)}
}5.timeout
设置一个超时时间。如果源 Observable 在规定时间内没有发任何出元素就产生一个超时的 error 事件。
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {let disposeBag DisposeBag()override func viewDidLoad() {//定义好每个事件里的值以及发送的时间let times [[ value: 1, time: 0 ],[ value: 2, time: 0.5 ],[ value: 3, time: 1.5 ],[ value: 4, time: 4 ],[ value: 5, time: 5 ]]//生成对应的 Observable 序列并订阅Observable.from(times).flatMap { item inreturn Observable.of(Int(item[value]!)).delaySubscription(Double(item[time]!),scheduler: MainScheduler.instance)}.timeout(2, scheduler: MainScheduler.instance) //超过两秒没发出元素则产生error事件.subscribe(onNext: { element inprint(element)}, onError: { error inprint(error)}).disposed(by: disposeBag)}
}//运行结果
//1
//2
//3
//Sequence timeout6.using
使用 using 操作符创建 Observable 时同时会创建一个可被清除的资源一旦 Observable终止了那么这个资源就会被清除掉了。
import UIKit
import RxSwift
import RxCocoaclass ViewController: UIViewController {override func viewDidLoad() {//一个无限序列每隔0.1秒创建一个序列数 let infiniteInterval$ ObservableInt.interval(0.1, scheduler: MainScheduler.instance).do(onNext: { print(infinite$: \($0)) },onSubscribe: { print(开始订阅 infinite$)},onDispose: { print(销毁 infinite$)})//一个有限序列每隔0.5秒创建一个序列数共创建三个 let limited$ ObservableInt.interval(0.5, scheduler: MainScheduler.instance).take(2).do(onNext: { print(limited$: \($0)) },onSubscribe: { print(开始订阅 limited$)},onDispose: { print(销毁 limited$)})//使用using操作符创建序列let o: ObservableInt Observable.using({ () - AnyDisposable inreturn AnyDisposable(infiniteInterval$.subscribe())}, observableFactory: { _ in return limited$ })o.subscribe()}
}class AnyDisposable: Disposable {let _dispose: () - Voidinit(_ disposable: Disposable) {_dispose disposable.dispose}func dispose() {_dispose()}
}//运行结果
//开始订阅 infinite$
//开始订阅 limited$
//infinited$: 0
//infinited$: 1
//infinited$: 2
//infinited$: 3
//infinited$: 4
//limited$: 0
//infinited$: 5
//infinited$: 6
//infinited$: 7
//infinited$: 8
//infinited$: 9
//limited$: 1
//销毁 limited$
//销毁 infinited$
