阅读 603

RxSwift(六)基本使用之Observavle的创建

前言

前几篇文章探索了RXSwift的核心逻辑,这篇文章先来点简单的,总结一下RXSwfit中Observavle的创建方法,了解该如何使用这些方法创建序列。

empty序列创建

执行代码后可以发现,控制台只打印了"完成回调"和"释放回调",由于这里的序列为空,调用empty函数只能订阅到onCompleted事件

  let emtyOb = Observable<Int>.empty()
        _ = emtyOb.subscribe(onNext: { (number) in
            print("订阅:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("完成回调")
        }) {
            print("释放回调")
        }
复制代码

just 单个序列的创建

我这里是用just创建了一个array进行发送和订阅,[String]这里指String数组,这里传的是泛型Element,如果改成String,那么发送String即可, just(String)

 //MARK:  just
        // 单个信号序列创建
        let array = ["one","two"]
        Observable<[String]>.just(array)
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        _ = Observable<[String]>.just(array).subscribe(onNext: { (number) in
            print("订阅到:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("完成回调")
        }) {
            print("释放回调")
        }
复制代码

of 多元素的序列创建

 Observable<String>.of("one","two")
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        // 字典
        Observable<[String: Any]>.of(["name":"David","age":18])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        // 数组
        Observable<[String]>.of(["hoho","heihei"])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
复制代码

from 从(数组,集合,set)中获取序列

使用from获取序列有可选项处理,更安全

Observable<[String]>.from(optional: ["one","two"])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
复制代码

deferred 延迟序列初始化

直到订阅发生,才创建 Observable,并且为每位订阅者创建全新的 Observable。

deferred 操作符将等待观察者订阅它,才创建一个 Observable,它会通过一个构建函数为每一位订阅者创建新的 Observable。看上去每位订阅者都是对同一个 Observable 产生订阅, 实际上它们都获得了独立的序列。

那么这个有什么用呢?比如在完成一个界面上的登录注册功能时,其实要传递的参数都差不多,那么通过一个标记值,然后通过这个判断,来返回不同的序列(登录和注册序列)。表面上他们订阅的是同一个序列,其实里面的序列又是独立分开的,可以执行不同的功能。可以从下面的代码进行理解.

var isOdd = true
        _ = Observable<Int>.deferred { () -> Observable<Int> in
            // 这里设计我们的序列
            isOdd = !isOdd
            if isOdd {
                return Observable.of(1,3,5,7,9)
            }
            return Observable.of(0,2,4,6,8)
            }
            .subscribe { (event) in
                print(event)
            }
复制代码

range 生成指定范围内的可观察整数序列

创建一个Observable序列,它会发出一系列连续的整数,然后停止

    Observable.range(start: 2, count: 5)
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
复制代码

genearte 创建条件序列

该方法创建一个只有当提供的所有的判断条件都为 true 的时候,才会给出动作的 Observable 序列。 如下所示,序列只要满足条件1和条件2,就会一直递归下去,直到其中一个条件不满足就停止

    Observable.generate(initialState: 0,// 初始值
                            condition: { $0 < 10}, // 条件1
                            iterate: { $0 + 2 })  // 条件2 +2
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
复制代码

常见用途是在数组的遍历时进行条件筛选

 let arr = ["arr_1","arr_2","arr_3"]
        Observable.generate(initialState: 0,// 初始值
            condition: { $0 < arr.count}, // 条件1
            iterate: { $0 + 1 })  // 条件2 +2
            .subscribe(onNext: {
                print("遍历arr:",arr[$0])
            })
            .disposed(by: disposeBag)
复制代码

timer 创建定时器序列

 // 第一次参数:第一次响应距离现在的时间
        // 第二个参数:时间间隔
        // 第三个参数:线程
        Observable<Int>.timer(5, period: 2, scheduler: MainScheduler.instance)
            .subscribe { (event) in
                print(event)
            }
        .disposed(by: disposeBag)

        // 因为没有指定期限period,故认定为一次性
        Observable<Int>.timer(1, scheduler: MainScheduler.instance)
            .subscribe { (event) in
                print("111111111 \(event)")
            }
            //.disposed(by: disposeBag)
复制代码

interval 创建定时器

  // 定时器
        Observable<Int>.interval(1, scheduler: MainScheduler.instance)
            .subscribe { (event) in
                print(event)
            }
            //.disposed(by: disposeBag)
复制代码

repeatElement 创建永不停止的序列

 // 该方法创建一个可以无限发出给定元素的 Event的 Observable 序列(永不终止)
        Observable<Int>.repeatElement(5)
            .subscribe { (event) in
                // print("订阅:",event)
            }
            .disposed(by: disposeBag)
复制代码

error 手动发送错误信号

  Observable<String>.error(NSError.init(domain: "lgerror", code: 10086, userInfo: ["reason":"unknow"]))
            .subscribe { (event) in
                print("订阅:",event)
            }
            .disposed(by: disposeBag)
复制代码

never

该方法创建一个永远不会发出 Event(也不会终止)的 Observable 序列。 这种类型的响应源 在测试或者在组合操作符中禁用确切的源非常有用。

    Observable<String>.never()
            .subscribe { (event) in
                print("订阅:",event)
            }
            .disposed(by: disposeBag)
复制代码

总结

以上就是RxSwift的创建Observable的方法总结,在需要用到的时候可以查询并且能够在相关的情况能灵活使用。

文章分类
iOS
文章标签