Single

Single 是 Observable 的另外一个版本。不像 Observable 可以发出多个元素，它要么只能发出一个元素，要么产生一个 error 事件。

发出一个元素，或一个 error 事件

不会共享状态变化

一个比较常见的例子就是执行 HTTP 请求，然后返回一个应答或错误。不过你也可以用 Single 来描述任何只有一个元素的序列。

源文档中 ,订阅提供一个 SingleEvent 的枚举：

public enum SingleEvent<Element> {
    case success(Element)
    case error(Swift.Error)
}

所以使用Rx的时候注意方法

Single_Method("hello world").subscribe(onSuccess: ((Any) -> Void)?,
                                       onError: ((Error) -> Void)? )

Demo

//特征序列 : Single  : 做网络请求
func Single_Method(_ repo : String) -> Single<Any> {
    return Single<Any>.create(subscribe: { (single) -> Disposable in
        let url = URL(string: "www.baidu.com\(repo)")!
        let task = URLSession.shared.dataTask(with: url, completionHandler: { (data, response, error) in
        if let error = error {
            single(.error(error))
            return
        }
        guard
            let data = data ,
            let json = try? JSONSerialization.jsonObject(with: data, options: .mutableLeaves) ,
            let result = json as? [String : Any] else {
            return
            }
            single(.success(result))
        })
        task.resume()
        return Disposables.create()
    })
}
    
func Single_Use()  {
    Single_Method("hello world").subscribe(onSuccess: { (result) in
        print(result)
    }) { (error) in
        print(error)
    }
}


重要 : 这里唯一不好的地方是 single(.success(result)) 与 single(.error(error)),没有语法糖提示.

Completable

Completable 是 Observable 的另外一个版本。不像 Observable 可以发出多个元素，它要么只能产生一个 completed 事件，要么产生一个 error 事件。

发出零个元素

发出一个 completed 事件或者一个 error 事件

不会共享状态变化

Completable 适用于那种你只关心任务是否完成，而不需要在意任务返回值的情况。它和 Observable<Void> 有点相似。

源文档中 ,订阅提供一个 CompletableEvent 的枚举：

public enum CompletableEvent {
    case error(Swift.Error)
    case completed
}

//特征序列 : Completeable  : 处理事件的结果.
func completeable_Method() -> Completable {
    return Completable.create(subscribe: { (complete) -> Disposable in
        //做一些处理,返回BOOL类型的值 , 假设有个属性completeFlag为true
        let success = self.completeFlag
        if success == false {
            complete(.error(self.error!))
        } else {
            complete(.completed)
        }
        
        return Disposables.create()
    })
}
    
func complete_Use()  {
    completeable_Method().subscribe(onCompleted: {
        print("complete")
    }) { (error) in
        print(error)
    }
}

看了前面两个,下面三个大概也知道具体的操作了.模板基本一致.注意的是:

Event 的枚举
Event 的调用(没有语法糖提示)
每个方法最后return Disposables.create() (这个接下来了解)
通过rx的方式调用用法的时候注意选择subscribe的方法,对应Event 的枚举

Maybe

Maybe 是 Observable 的另外一个版本。它介于 Single 和 Completable 之间，它要么只能发出一个元素，要么产生一个 completed 事件，要么产生一个 error 事件。

发出一个元素或者一个 completed 事件或者一个 error 事件

不会共享状态变化

如果你遇到那种可能需要发出一个元素，又可能不需要发出时，就可以使用 Maybe。