這篇文章總結(jié)一下一些場景的序列：

controlEvent

1.在主線程監(jiān)聽
2.會共享附加作用
3.沒有error事件

button.rx.controlEvent(.touchUpInside)
.subscribe { (reslut) in
    print("點(diǎn)擊")
}.disposed(by: disposeBag)

bind

1.綁定在給定 Scheduler 上執(zhí)行（默認(rèn) MainScheduler）
2.若產(chǎn)生錯誤事件，在調(diào)試環(huán)境下將執(zhí)行 fatalError涩搓，在發(fā)布環(huán)境下將打印錯誤信息

textField.rx.text.bind(to: label.rx.text)

Signal

1.在主線程監(jiān)聽
2.會共享附加作用

func search(input: String)-> Observable<String> {
    return Observable<String>.create({ (observer) -> Disposable in
        DispatchQueue.global().async {
            ...//假裝在子線程進(jìn)行了耗時的搜索
            let result = "返回結(jié)果"
            
            observer.onNext(result)
            observer.onCompleted()
        }
        return Disposables.create()
     })
}
func test() {
    let result = inputTf.rx.changed
                 .flatMap { [weak self](text) -> Observable<Any> in
                     //flatMap映射成新序列
                     return self.search(input: text)
                         .observeOn(MainScheduler()))  //主線程
                        .catchErrorJustReturn("發(fā)生錯誤")  //處理error
                 }.share(replay: 1, scope: .whileConnected)  //共享狀態(tài)變化  
    result.bind(to: label.rx.text)  //綁定
}

Driver

1.在主線程監(jiān)聽
2.會共享附加作用
3.相當(dāng)于簡化Signal，Driver會對新觀察者重新發(fā)送上一個元素，而Signal不會對新觀察者重新發(fā)送上一個元素

func search(input: String)-> Observable<String> {
    return Observable<String>.create({ (observer) -> Disposable in
        DispatchQueue.global().async {
            ...//假裝在子線程進(jìn)行了耗時的搜索
            let result = "返回結(jié)果"
            
            observer.onNext(result)
            observer.onCompleted()
        }
        return Disposables.create()
     })
}
func test() {
    func testWithDriver() {
    let result = inputTf.rx.changed
                     .asDriver()
                     .flatMap {
                          return self.search(input: $0)
                              .asDriver(onErrorJustReturn: "發(fā)生錯誤")
                      }
    result.drive(label.rx.text)
}
}

Single

1.只能發(fā)送一次響應(yīng)或error事件

let single = Single<Any>.create { (observer) -> Disposable in
    observer(.success("一次"))
    return Disposables.create()
}

single.subscribe { (reslut) in
    print("訂閱到了")
}.disposed(by: disposeBag)

single.subscribe { (reslut) in
    print("訂閱不到")
}.disposed(by: disposeBag)

Completable

1.只能發(fā)送一次完成或error事件

let completable = Completable.create { (observer) -> Disposable in
    observer(.completed)
    //observer(.error(NSError.init(domain: "error", code: 888, userInfo: nil)))
    return Disposables.create()
}

completable.subscribe {
  print("完成")
} onError: { (error) in
  print("錯誤")   
}

completable.subscribe {
  print("不再打印")
} onError: { (error) in
  print("不再打印")  
}

Maybe

1.只能發(fā)送一次響應(yīng)，或者完成事件闻察，或者error事件

let maybe = Maybe<Any>.create { (observer) -> Disposable in
    observer(.success(""))
    //observer(.completed)
    //observer(.error(NSError.init(domain: "error", code: 888, userInfo: nil)))
    return Disposables.create()
}

maybe.subscribe { (reslut) in
    print("訂閱到了")
}.disposed(by: disposeBag)

maybe.subscribe { (reslut) in
    print("訂閱不到")
}.disposed(by: disposeBag)