一、emty
创建一个空的序列:本来序列事件是 Int 类型的,调用 emty 函数没有序列,只能 complete:
let emtyOb = Observable < Int > . empty ( )
_ = emtyOb. subscribe ( onNext: { ( number) in
print ( "订阅:" , number)
} , onError: { ( error) in
print ( "error:" , error)
} , onCompleted: {
print ( "完成回调" )
} ) {
print ( "释放回调" )
}
这种方式不常用,但是以点及面展开分析,通过源码解析查看:
override func subscribe< O: ObserverType > ( _ observer: O) - > Disposable where O. E == Element {
observer. on ( . completed)
return Disposables . create ( )
}
很明显在订阅的时候,直接 observer.on(.completed) 发送了完成信号,非常简洁:
二、just
单个信号序列创建,该方法通过传入一个默认值来初始化,构建一个只有一个元素的 Observable 队列,订阅完信息自动 complete。 如下所示,显示地标注出了 Observable 的类型为 Observable<[String]>,即指定了 Observable 所发出的事件携带的数据类型必须是String 类型的:
let array = [ "A" , "B" ]
Observable < [ String ] > . just ( array)
. subscribe { ( event) in
print ( event)
} . disposed ( by: disposeBag)
_ = Observable < [ String ] > . just ( array) . subscribe ( onNext: { ( number) in
print ( "订阅:" , number)
} , onError: { ( error) in
print ( "error:" , error)
} , onCompleted: {
print ( "完成回调" )
} ) {
print ( "释放回调" )
}
just 序列在平时开发里面还是应用挺多的,底层源码如下:
override func subscribe< O: ObserverType > ( _ observer: O) - > Disposable where O. E == Element {
observer. on ( . next ( self . _element) )
observer. on ( . completed)
return Disposables . create ( )
}
observer.on(.next(self._element)) 常规订阅之后就会发送 .next 事件,之后就会自动发送完成事件:
三、of
此方法创建一个新的可观察实例,该实例具有可变数量的元素。 该方法可以接受可变数量的参数(必需要是同类型的):
Observable < String > . of ( "A" , "B" )
. subscribe { ( event) in
print ( event)
} . disposed ( by: disposeBag)
Observable < [ String : Any ] > . of ( [ "name" : "ydw" , "age" : 18 ] )
. subscribe { ( event) in
print ( event)
} . disposed ( by: disposeBag)
Observable < [ String ] > . of ( [ "A" , "B" ] )
. subscribe { ( event) in
print ( event)
} . disposed ( by: disposeBag)
无论字典、数组、多个元素都可以正常使用,初始化保存调度环境和传入的元素 订阅流程也是利用 sink,然后通过 mutableIterator 迭代器处理发送:
四、from
将可选序列转换为可观察序列。从集合中获取序列:数组、集合、set 获取序列,有可选项处理,更安全。 从一个序列 (如Array/Dictionary/Set) 中创建一个 Observable 序列:
Observable < [ String ] > . from ( optional : [ "A" , "B" ] )
. subscribe { ( event) in
print ( event)
} . disposed ( by: disposeBag)
self._optional = optional 底层初始化可选项保存,订阅流程判断是否匹配我可选项; 发送 observer.on(.next(element)) 序列 ,随即自动 observer.on(.completed) 完成序列发送。
五、deferred
返回一个可观察序列,该序列在新观察者订阅时调用指定的工厂函数。 使用 deferred() 方法延迟 Observable 序列的初始化,通过传入的 block 来实现 Observable 序列的初始化并且返回。
var isOdd = true
_ = Observable < Int > . deferred { ( ) - > Observable < Int > in
isOdd = ! isOdd
if isOdd {
return Observable . of ( 1 , 3 , 5 , 7 , 9 )
}
return Observable . of ( 0 , 2 , 4 , 6 , 8 )
}
. subscribe { ( event) in
print ( event)
}
self._observableFactory = observableFactory 初始化保存工厂闭包:
func run ( ) - > Disposable {
do {
let result = try self . _observableFactory ( )
return result. subscribe ( self )
}
catch let e {
self . forwardOn ( . error ( e) )
self . dispose ( )
return Disposables . create ( )
}
}
在订阅流程到 sink 的时候,执行工厂闭包,有种中间层被包装的感觉:
六、rang
使用指定的调度程序生成并发送观察者消息,生成指定范围内的可观察整数序列。 创建一个 Observable 序列,它会发出一系列连续的整数,然后终止。
Observable . range ( start: 2 , count : 5 )
. subscribe { ( event) in
print ( event)
} . disposed ( by: disposeBag)
init ( start: E, count : E, scheduler: ImmediateSchedulerType ) {
self . _start = start
self . _count = count
self . _scheduler = scheduler
}
override func run< O : ObserverType > ( _ observer: O, cancel: Cancelable ) - > ( sink: Disposable , subscription: Disposable ) where O. E == E {
let sink = RangeSink ( parent: self , observer: observer, cancel: cancel)
let subscription = sink. run ( )
return ( sink: sink, subscription: subscription)
}
保存序列中第一个整数的值,要生成的顺序整数的数目以及调度环境。
if i < self . _parent. _count {
self . forwardOn ( . next ( self . _parent. _start + i) )
recurse ( i + 1 )
}
else {
self . forwardOn ( . completed)
self . dispose ( )
}
根据之前保存的信息,数据的状态也不断攀升,然后递归到规定的要求:
七、generate
通过运行产生序列元素的状态驱动循环,使用指定的调度程序运行循环,发送观察者消息,从而生成一个可观察序列。 创建一个 Observable 序列,只要提供的条件值为 true 就可以生成值。 初始值给定,然后判断条件 1 再判断条件2 会一直递归下去,直到条件 1 或者条件 2 不满足,类似数组遍历循环:
参数二 condition:终止生成的条件(返回“false”时);
参数四 调度器:用来运行生成器循环的调度器,默认:CurrentThreadScheduler.instance;
Observable . generate ( initialState: 0 ,
condition: { $0 < 10 } ,
iterate: { $0 + 2 } )
. subscribe { ( event) in
print ( event)
} . disposed ( by: disposeBag)
let arr = [ "A" , "B" ]
Observable . generate ( initialState: 0 ,
condition: { $0 < arr. count } ,
iterate: { $0 + 1 } )
. subscribe ( onNext: {
print ( "遍历arr:" , arr[ $0 ] )
} )
. disposed ( by: disposeBag)
八、timer
获取计时器 Observable 序列,返回一个可观察序列,该序列使用指定的调度程序运行计时器,在指定的初始相对到期时间过后定期生成一个值:
Observable < Int > . timer ( 5 , period: 2 , scheduler: MainScheduler . instance)
. subscribe { ( event) in
print ( event)
}
. disposed ( by: disposeBag)
Observable < Int > . timer ( 1 , scheduler: MainScheduler . instance)
. subscribe { ( event) in
print ( "\( event) " )
}
. disposed ( by: disposeBag)
九、interval
返回一个可观察序列,该序列在每个周期之后生成一个值,使用指定的调度程序运行计时器并发送观察者消息:
Observable < Int > . interval ( 1 , scheduler: MainScheduler . instance)
. subscribe { ( event) in
print ( event)
}
. disposed ( by: disposeBag)
十、repeatElement
使用指定的调度程序发送观察者消息,生成无限重复给定元素的可观察序列:
Observable < Int > . repeatElement ( 5 )
. subscribe { ( event) in
print ( "订阅:" , event)
}
. disposed ( by: disposeBag)
十一、error
创建一个不会发送任何条目并且立即终止错误的 Observable 序列,返回一个以“error”结束的可观察序列。 error 序列平时在开发也比较常见,请求网络失败也会发送失败信号:
Observable < String > . error ( NSError . init ( domain: "dwerror" , code: 10086 , userInfo: [ "reason" : "unknow" ] ) )
. subscribe { ( event) in
print ( "订阅:" , event)
}
. disposed ( by: disposeBag)
十二、never
never 返回一个以“error”结束的可观察序列,这个序列平时在开发也比较常见,请求网络失败也会发送失败信号:
Observable < String > . never ( )
. subscribe { ( event) in
print ( "never:" , event)
}
. disposed ( by: disposeBag)
十三、create()
该方法接受一个 闭包形式的参数,任务是对每一个过来的订阅进行处理。这也是序列创建的一般方式,应用非常之多:
let observable = Observable < String > . create{ observer in
observer. onNext ( "ydw" )
observer. onCompleted ( )
return Disposables . create ( )
}
observable. subscribe {
print ( $0 )
}