iOS第三方库

RxSwift(八)-- 场景序列介绍

2019-08-13  本文已影响0人  Daniel_Harvey

在之前的一系列文章中,与可被观察序列Observable相关的我们都了解到了很多东西。在之前的文章RxSwift(五)-- RxSwift特征序列Driver中,我们也介绍过,除了ObservableRxSwift还为我们提供了一些场景序列,比如说:SingleCompletableMaybeDriverControlEvent
那么,这些场景序列和Observable有什么区别呢?如下:

  • Observable是用于任何环境的一个通用序列。
  • 场景序列是一个可以帮助我们更准确的描述序列,还为我们提供了很多更加优雅的方式来编写代码。

在之前的文章中,我们已经知道了Driver序列,今天就来讲一讲其他的场景序列。

Single

介绍

Single不像Observable可以发出多个元素,它只能发出一个元素,或者发出一个error事件。

  • 只发出一个元素,或者一个error事件。
  • 不会共享状态的变化。

使用场景

Single最常见的使用场景应该就是执行HTTP请求了,然后返回一个响应或者错误,除此之外,我们还可以用Single来描述任何只有一个元素的序列。

SingleEvent

当然,RxSwiftSingle的订阅提供了一个枚举值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

介绍

CompletableObservable的另外一个版本,它只能发出一个completed事件,或者产生一个error事件。

  • 不发出任何元素
  • 只会发出一个Completed事件或者一个error事件
  • 不会共享状态变化

使用场景

CompletableObservable<Void>很相似,适用于那些只关心任务是否完成,而不需要在意任务返回值的情况。

CompletableEvent

当然,RxSwiftCompletable的订阅提供了一个枚举值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的另外一个版本,它是介于SingleCompletable之间的,只能发出一个元素,或者一个completed事件,或者产生一个error事件。

  • 发出一个元素、或者一个completed事件、或者产生一个error事件
  • 不会共享状态变化

使用场景

Maybe适合那种可能需要一个元素,又可能不需要发出的情况。

MaybeEvent

同样的,为方便使用,RxSwiftMaybe 订阅提供了一个枚举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),可以发现 UIButtonrx.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)
    }
}
上一篇 下一篇

猜你喜欢

热点阅读