RxSwift Creating

您可以使用create操作符从零开始创建一个可观察对象，传递给这个操作符一个函数，该函数接受 observer 作为其参数，通过适当地调用 observer 的 onNext 、 onError 和 onCompleted 方法，将这个函数编写为一个可观察的函数。 需要注意的是一个结构良好的 Observable 必须调用一次 observer 的 onCompleted 或 onError 方法，并且此后不能尝试调用 observer 的任何其他方法。

let source : Observable = Observable.create { observer in
    for i in 1...5 {
        observer.on(.next(i))
    }
    observer.on(.completed)
    return Disposables.create {
        print("disposed")
    }
}

source.subscribe {
    print($0)
}
/*-----
next(1)
next(2)
next(3)
next(4)
next(5)
completed
disposed
*/ 
复制代码

#2 Empty/Never

Empty

创建一个不发出任何项但正常终止的 Observable (调用onCompleted)

Never创建一个不发出任何项且不终止的可观察对象

Empty/Never这些对于测试目的很有用，有时也可以与其他可观测值结合使用，或者作为期望其他可观测值作为参数的操作符的参数。

let never = Observable<Any>.never()
    
let empty = Observable<Any>.empty()
    
    
never.subscribe { (event) in
    print("never")
    print(event)
}
.disposed(by: bag)
    
empty.subscribe { (event) in
    print("empty")
    print(event)
}
.disposed(by: bag)

/*------
empty
completed
*/ 
复制代码

#3 From

作用将各种其他对象和数据类型转换为可观察的

let anyArray : [Any] = ["string", 1 , 0.3]

let source = Observable.from(anyArray)

source.subscribe {
    print($0)
}

/*----------
next(string)
next(1)
next(0.3)
completed
*/ 
复制代码

#4 Interval

创建一个 Observable ，它发出一个按给定时间间隔间隔的整数序列 Interval操作符返回一个可观察到的值，该值发出一个无限的升序整数序列，在两次发射之间选择一个固定的时间间隔。

Observable<Int>.interval(1.0, scheduler: MainScheduler.instance)
    .subscribe {
        print($0)
    }
    .disposed(by: bag)
//每1秒发送一次从0开始升序的整数
复制代码

#5 Just

创建一个发出特定值的Observable 与From类型，但要注意From会将数组里的元素取出再发送出去，而Just只是简单的将数组或对象作为一个单独值发送出去。

let source = Observable.just(1, 2, 3)

source.subscribe {
    print($0)
}

let source2 = Observable.just([1,2,3])

source2.subscribe {
    print($0)
}
/* ------
next((1, 2, 3))
completed
next([1, 2, 3])
completed
*/ 
复制代码

#6 Range

创建一个 Observable ，该对象发出特定范围的序列整数

Observable.range(start: 1, count: 3)
    .subscribe{
        print($0)
    }
    .disposed(by: bag)
    
/*------
next(1)
next(2)
next(3)
completed
*/ 
复制代码

#7 Repeat

创建一个 Observable ，该对象多次发出特定的项

该操作符重复发送一个项。

#8 Timer

创建一个 Observable ，它在给定的延迟之后发出特定的项

//5秒后发送一个Int值
Observable<Int>.timer(5, scheduler: MainScheduler.instance)
    .subscribe {
        print($0)
    }
    .disposed(by: bag)
/*-------
next(0)
completed
*/
复制代码

#9 Of

此方法创建一个 Observable ，该实例具有可变数量的元素。 功能与From相同，From接受数组为元素，Of接受可变数量的元素

let ofObservable = Observable<Any>.of(1,"test",0.3)

ofObservable.subscribe{
    print($0)
}
.disposed(by: bag)

/*-------------
next(1)
next(test)
next(0.3)
completed
*/
复制代码

文章出处