在之前的一系列文章中，与可被观察序列
Observable相关的我们都了解到了很多东西。在之前的文章RxSwift（五）-- RxSwift特征序列Driver中，我们也介绍过，除了Observable，RxSwift还为我们提供了一些场景序列，比如说：Single、Completable、Maybe、Driver、ControlEvent。
那么，这些场景序列和Observable有什么区别呢？如下：
Observable是用于任何环境的一个通用序列。场景序列是一个可以帮助我们更准确的描述序列，还为我们提供了很多更加优雅的方式来编写代码。
在之前的文章中，我们已经知道了Driver序列，今天就来讲一讲其他的场景序列。
Single
介绍
Single不像Observable可以发出多个元素，它只能发出一个元素，或者发出一个error事件。
- 只发出一个元素，或者一个
error事件。- 不会共享状态的变化。
使用场景
Single最常见的使用场景应该就是执行HTTP请求了，然后返回一个响应或者错误，除此之外，我们还可以用Single来描述任何只有一个元素的序列。
SingleEvent
当然，
RxSwift为Single的订阅提供了一个枚举值SingleEvent，以便于我们使用。
.success：里面包含的是该Single的一个元素值.error：包含的是错误
public enum SingleEvent<Element> {
/// One and only sequence element is produced. (underlying observable sequence emits: `.next(Element)`, `.completed`)
case success(Element)
/// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
case error(Swift.Error)
}
举例
举例来自于网络。
（1）下面代码我们定义一个用于生成网络请求 Single的函数：
//获取豆瓣某频道下的歌曲信息
func getPlaylist(_ channel: String) -> Single<[String: Any]> {
return Single<[String: Any]>.create { single in
let url = "https://douban.fm/j/mine/playlist?"
+ "type=n&channel=\(channel)&from=mainsite"
let task = URLSession.shared.dataTask(with: URL(string: url)!) { data, _, 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 {
single(.error(DataError.cantParseJSON))
return
}
single(.success(result))
}
task.resume()
return Disposables.create { task.cancel() }
}
}
//与数据相关的错误类型
enum DataError: Error {
case cantParseJSON
}
（2）接着我们可以使用如下方式使用这个 Single：
//获取第0个频道的歌曲信息
getPlaylist("0")
.subscribe { event in
switch event {
case .success(let json):
print("JSON结果: ", json)
case .error(let error):
print("发生错误: ", error)
}
}
.disposed(by: disposeBag)
（3）也可以使用 subscribe(onSuccess:onError:) 这种方式：
//获取第0个频道的歌曲信息
getPlaylist("0")
.subscribe(onSuccess: { json in
print("JSON结果: ", json)
}, onError: { error in
print("发生错误: ", error)
})
.disposed(by: disposeBag)
asSingle()
我们可以通过调用 Observable 序列的 .asSingle()方法，将它转换为 Single。
Observable.of("1")
.asSingle()
.subscribe({ print($0) })
.disposed(by: disposeBag)
Completable
介绍
Completable是Observable的另外一个版本，它只能发出一个completed事件，或者产生一个error事件。
- 不发出任何元素
- 只会发出一个
Completed事件或者一个error事件- 不会共享状态变化
使用场景
Completable和Observable<Void>很相似，适用于那些只关心任务是否完成，而不需要在意任务返回值的情况。
CompletableEvent
当然，
RxSwift为Completable的订阅提供了一个枚举值CompletableEvent，以便于我们使用。
.completed：用于产生完成事件.error：用于产生一个错误
public enum CompletableEvent {
/// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
case error(Swift.Error)
/// Sequence completed successfully.
case completed
}
举例
举例来自于网络
（1）下面代码我们使用 Completable 来模拟一个数据缓存本地的操作：
//将数据缓存到本地
func cacheLocally() -> Completable {
return Completable.create { completable in
//将数据缓存到本地（这里掠过具体的业务代码，随机成功或失败）
let success = (arc4random() % 2 == 0)
guard success else {
completable(.error(CacheError.failedCaching))
return Disposables.create {}
}
completable(.completed)
return Disposables.create {}
}
}
//与缓存相关的错误类型
enum CacheError: Error {
case failedCaching
}
（2）接着我们可以使用如下方式使用这个 Completable：
cacheLocally()
.subscribe { completable in
switch completable {
case .completed:
print("保存成功!")
case .error(let error):
print("保存失败: \(error.localizedDescription)")
}
}
.disposed(by: disposeBag)
（3）也可以使用 subscribe(onCompleted:onError:) 这种方式：
cacheLocally()
.subscribe(onCompleted: {
print("保存成功!")
}, onError: { error in
print("保存失败: \(error.localizedDescription)")
})
.disposed(by: disposeBag)
Maybe
介绍
Maybe也是Observable的另外一个版本，它是介于Single和Completable之间的，只能发出一个元素，或者一个completed事件，或者产生一个error事件。
- 发出一个元素、或者一个
completed事件、或者产生一个error事件- 不会共享状态变化
使用场景
Maybe适合那种可能需要一个元素，又可能不需要发出的情况。
MaybeEvent
同样的，为方便使用，
RxSwift为Maybe订阅提供了一个枚举MaybeEvent：
.success：里包含该 Maybe 的一个元素值.completed：用于产生完成事件.error：用于产生一个错误
public enum MaybeEvent<Element> {
/// One and only sequence element is produced. (underlying observable sequence emits: `.next(Element)`, `.completed`)
case success(Element)
/// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
case error(Swift.Error)
/// Sequence completed successfully.
case completed
}
举例
举例来自于网络
（1）创建 Maybe 和创建 Observable 同样非常相似：
func generateString() -> Maybe<String> {
return Maybe<String>.create { maybe in
//成功并发出一个元素
maybe(.success("hangge.com"))
//成功但不发出任何元素
maybe(.completed)
//失败
//maybe(.error(StringError.failedGenerate))
return Disposables.create {}
}
}
//与缓存相关的错误类型
enum StringError: Error {
case failedGenerate
}
（2）接着我们可以使用如下方式使用这个 Maybe：
generateString()
.subscribe { maybe in
switch maybe {
case .success(let element):
print("执行完毕，并获得元素：\(element)")
case .completed:
print("执行完毕，且没有任何元素。")
case .error(let error):
print("执行失败: \(error.localizedDescription)")
}
}
.disposed(by: disposeBag)
（3）也可以使用 subscribe(onSuccess:onCompleted:onError:)这种方式：
generateString()
.subscribe(onSuccess: { element in
print("执行完毕，并获得元素：\(element)")
},
onError: { error in
print("执行失败: \(error.localizedDescription)")
},
onCompleted: {
print("执行完毕，且没有任何元素。")
})
.disposed(by: disposeBag)
asMaybe()
（1）我们可以通过调用 Observable 序列的 .asMaybe() 方法，将它转换为 Maybe。
Observable.of("1")
.asMaybe()
.subscribe({ print($0) })
.disposed(by: disposeBag)
ControlEvent
介绍
ControlEvent是专门用于描述UI所产生的事件，拥有该类型的属性都是被观察者Observable，有以下特征：
- 不会产生
error事件- 一定在
MainScheduler订阅（主线程订阅）- 一定在
MainScheduler监听（主线程监听）- 共享状态变化
举例
举例来自于网络
（1）同样地，在 RxCocoa 下许多 UI 控件的事件方法都是被观察者（可观察序列）。比如我们查看源码（UIButton+Rx.swift），可以发现 UIButton 的 rx.tap 方法类型便是 ControlEvent<Void>：
extension Reactive where Base: UIButton {
public var tap: ControlEvent<Void> {
return controlEvent(.touchUpInside)
}
}
（2）那么我们如果想实现当一个 button 被点击时，在控制台输出一段文字。即前者作为被观察者，后者作为观察者。可以这么写：
//订阅按钮点击事件
button.rx.tap
.subscribe(onNext: {
print("欢迎访问hangge.com")
}).disposed(by: disposeBag)
Binder
介绍
Binder专注于特定的场景，主要有以下特征：
- 不会处理错误事件
- 确保绑定都是在给定
Scheduler上执行（默认MainScheduler）- 一旦产生错误事件，在调试环境下将执行
fatalError，在发布环境下将打印错误信息。
举例
举例来自于网络
import UIKit
import RxSwift
import RxCocoa
class ViewController: UIViewController {
@IBOutlet weak var label: UILabel!
let disposeBag = DisposeBag()
override func viewDidLoad() {
//观察者
let observer: Binder<String> = Binder(label) { (view, text) in
//收到发出的索引数后显示到label上
view.text = text
}
//Observable序列（每隔1秒钟发出一个索引数）
let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable
.map { "当前索引数：\($0 )"}
.bind(to: observer)
.disposed(by: disposeBag)
}
}
