rxswift学习-Observable之创建

create操作符

public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        return AnonymousObservable(subscribe)
}
//----------------------------------------
let myObservable =  Observable<Int>.create { (observer) -> Disposable in
            observer.onNext(1)
            observer.onNext(2)
            observer.onNext(3)
            observer.onNext(4)
            observer.onNext(5)
            observer.onCompleted()
            return Disposables.create()
        }
        
        myObservable.subscribe { (event) in
            print(event)
        }.disposed(by: bag)
//--------------------------------------------
next(1)
next(2)
next(3)
next(4)
next(5)
completed

Empty, Error, Never操作符

Empty: 只收到一个.completed 
Error: 只收到一个.error 
Never: 永远也不会结束。

just

返回一个只包含一个element的sequnce。

static func just(_ element: E) -> Observable<E>
static func just(_ element: E, 
scheduler: ImmediateSchedulerType) //这个element需要在哪个scheduler上emit。
-> Observable<E>

of

返回一个包含elements的sequence,并在scheduler上emit他们。

static func of(_ elements: E ..., scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E>
//--------
let never = Observable<Int>.of(1,2,3,4,5)

defer

返回一个observable sequence，每当有人subscribe他时，就会调用observableFactory生成一个observable，并subscribe他。

static func deferred(_ observableFactory: @escaping () throws -> Observable<E>)
        -> Observable<E>
//------------------example----------
class SomeType {
    var value:String = ""
    
    func valueObservable()->Observable<String> {
        return Observable.deferred({ [weak self] () -> Observable<String> in
            let value = self == nil ? "" : self!.value
            return Observable<String>.just(value)
        })
    }
}
//-------------------
let someType = SomeType()
someType.value = "helloworld"
someType.valueObservable()
.subscribe { (event) in
    print(event)
}.disposed(by: bag)

someType.value = "happyNewYear"
someType.valueObservable()
.subscribe { (event) in
    print(event)
}.disposed(by: bag)
//-------------结果-------
next(helloworld)
completed
next(happyNewYear)
completed

generate

通过条件循环来生成elements。

static func generate(
  initialState: E, //初始状态
  condition: @escaping (E) throws -> Bool, //循环条件，为false时结束生成
  scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, //emit的scheduler
  iterate: @escaping (E) throws -> E) //迭代函数
-> Observable<E>
//---------------------
let numObservable = Observable<Int>.generate(initialState: 1,
condition: { $0 < 100 }, 
iterate: { $0 + 10 })

numObservable
.subscribe { (event) in
            print(event)
}.disposed(by: bag)
//-----------------
next(1)
next(11)
next(21)
next(31)
next(41)
next(51)
next(61)
next(71)
next(81)
next(91)
completed

repeat

生成一个observable sequence无限重复某个element。

public static func repeatElement(
  _ element: E, //重复的element
  scheduler: ImmediateSchedulerType = //在哪个schduler上emit
  CurrentThreadScheduler.instance) 
-> Observable<E>

using

将resource的生命周期和observable的生命周期绑定。当你调用subscribe时，using会调用这两个factory method。当sequence退出的时候，resource会dispose掉。

public static func using<Resource: Disposable>(
_ resourceFactory: @escaping () throws -> Resource, observableFactory: @escaping (Resource) throws -> Observable<E>) 

-> Observable<E>

range

对整数的扩展,返回一个包含某个范围内的elements的sequence

static func range(
  start: E,//起始值
  count: E,//总共element的个数
  scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance
) -> Observable<E>
//-----------
let range = Observable<Int>.range(start: 10, count: 3)
range.subscribe { (event) in
    print(event)
}.disposed(by: bag)
//------------        
next(10)
next(11)
next(12)
completed

from

将一个数组转换为observable dequence。

public static func from(
  _ array: [E], 
  scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance
) -> Observable<E> 
//------
 let from = Observable<Int>.from([1,2,3,4,5])
from.subscribe { (event) in
    print(event)
}.disposed(by: bag)
//-------
next(1)
next(2)
next(3)
next(4)
next(5)
completed

将一个sequence转换为observable sequence。

public static func from<S: Sequence>(
_ sequence: S, 
scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance
) -> Observable<E> where S.Iterator.Element == E 
//-----
let from = Observable<Int>.from(Set.init(arrayLiteral: 1,2,3,4,5))
from.subscribe { (event) in
    print(event)
}.disposed(by: bag)
//---
next(5)
next(2)
next(3)
next(1)
next(4)
completed

将某个optional值转化为一个observable sequence。如果为nil，那么直接发送.completed否则发送value和.completed。

static func from(_ optional: E?) -> Observable<E>
public static func from(
  _ optional: E?, 
  scheduler: ImmediateSchedulerType
) -> Observable<E>

赏

谢谢你请我吃糖果