RxSwift学习（二）---- Observable 常见的序列创建方法

• RxSwift学习（一）— RxSwift介绍
• RxSwift学习（二）— Observable 常见的序列创建方法
• RxSwift学习（三）— RxSwift 高阶函数
• RxSwift学习（四）— RxSwift 操作符

RxSwift 常见序列

今天我们就来梳理下RxSwift比较常见的序列

create() 序列

此序列我们在前面一章已经讲过了，这里就书写个使用例子：

// 1、创建序列
        _ = Observable<String>.create({ (observable) -> Disposable in
            //3、发送信号
            observable.onNext("RxSwift  你好！")
//            observable.onError()  //发送错误信号
//            observable.onCompleted() //发送完成信号
            
            return Disposables.create() // 销毁
           // 2、订阅序列
        }).subscribe(onNext: { (next) in
            NSLog("订阅到--\(next)")
        }, onError: { (error) in
            NSLog("错误--\(error)")
        }, onCompleted: {
            NSLog("完成回调")
        }, onDisposed: {
            NSLog("订释放回调")
        })

empty() 空序列

• 直接返回完成状态, 没有任何订阅数据
• 开发中不常用

let empty = Observable<Int>.empty()
        _ = empty.subscribe(onNext: { (next) in
            NSLog("订阅到--\(next)")
        } ,onError: { (error) in
            NSLog("错误--\(error)")
        }, onCompleted: {
            NSLog("完成回调")
        }, onDisposed: {
            
        })
        

of() 序列

• 此方法可以创建一个可观察实例,该实例具有可变数量的元素
• 该方法可以接受可变数量的参数（必需要是同类型的）

 		// 多个元素 --针对序列的
        let observable = Observable<String>.of("Json","XML")
        observable
            .subscribe { (event) in
                    Log("---of----\(event)")
            }.disposed(by: self.disposeBag)
        
        // 数组
        Observable<[Int]>.of([23,43])
            .subscribe { (event) in
                Log("---of----\(event)")
            }.disposed(by: self.disposeBag)
        
        // 字典
        Observable<[String: String]>.of(["one": "Json","two": "Xml"])
            .subscribe { (event) in
                Log("---of----\(event)")
            }.disposed(by: self.disposeBag)
            

just() 序列

• 单个信号序列的创建
• 该方法通过传入一个默认值来初始化

let array = ["Json","XML"]
let observable = Observable<[String]>.just(array)

from() 序列

• 将可选序列转换为可观察序列
• 从集合中获取序列:数组,集合,set 获取序列 - 有可选项处理 - 更安全

let observable = Observable<String>.from(["Json","xml"])
observable.subscribe { (event) in
             Log(event)
      }.disposed(by: self.disposeBag)

deferred() 序列

• 返回一个可观察序列，该序列在新观察者订阅时调用指定的工厂函数
• 这里有一个需求:动态序列 - 根据外界的标识 - 动态输出
• 使用deferred()方法延迟Observable序列的初始化，通过传入的block来实现Observable序列的初始化并且返回。

		var isOld = true
        _ = Observable<Int>.deferred({ () -> Observable<Int> in
            // 这里可以设计一个自定义的序列
            isOld = !isOld
            if (isOld) {
                return Observable.of(1)
            }else {
                return Observable.of(3)
            }
            
        }).subscribe({ (event) in
            Log(event)
        }).disposed(by: self.disposeBag)

rang() 序列

• 使用指定的调度程序生成并发送观察者消息，从而在指定范围内生成可观察的整数序列。
• start: 第一个整数
• count: 生成的个数

 _ = Observable.range(start: 2, count: 5)
           	   .subscribe (onNext: { (number) in
                  Log(number)
               }, onError: { (error) in
                Log("error:\(error)")
               }, onCompleted: {
//                Log(self.dataArray)
               }).disposed(by: self.disposeBag)

generate() 序列

• 使用指定的调度程序，通过运行产生该序列元素的状态驱动循环来生成可观察序列
  运行循环发出观察者消息。
• 该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。
• initialState: 初始状态
• condition: 终止生成的条件（返回“ false”时）
• scheduler: 在其上运行生成器循环的调度程序
• iterate : 迭代步长功能
• 类似于数组遍历

		let arr =["TB_1","TB_2","TB_3","TB_4","TB_5","TB_6","TB_7","TB_8","TB_9","TB_10"]]
        Observable.generate(initialState: 0,// 初始值
            condition: { $0 < arr.count}, // 条件1
            iterate: { $0 + 1 })  // 条件2 +2
            .subscribe(onNext: {
                print("遍历arr:",arr[$0])
            })
            .disposed(by: disposeBag)

timer() 序列

• 返回一个可观察序列，该序列使用指定的调度程序运行计时器，在指定的初始相对到期时间过后定期生成一个值
• 可用作定时器
• dueTime: 第一次响应距离现在的时间 延迟多久开始
• period: 时间间隔
• scheduler: 线程

_ = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
            .subscribe({ (event) in
                Log(event)
            }).disposed(by: self.disposeBag)

interval() 序列

• 返回一个可观察序列，该序列在每个周期之后生成一个值，使用指定的调度程序运行计时器并发送观察者消息
• 定时器
• period: 时间间隔
• scheduler: 线程

 _ = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
            .subscribe({ (event) in
                Log(event)
            }).disposed(by: self.disposeBag)

repeatElement() 序列

• 使用指定的调度程序发送观察者消息，生成无限重复给定元素的可观察序列

 _ = Observable<Int>.repeatElement(8)
            .subscribe({ (event) in
                Log(event)
            }).disposed(by: self.disposeBag)

error() 序列

• 返回以错误终止的可观察序列

Observable<String>.error(NSError(domain: "错误", code: 1, userInfo:["error": "1"]))
            .subscribe { (event) in
                Log(event)
            }.disposed(by: self.disposeBag)

never() 序列

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

Observable<String>.never()
            .subscribe { (event) in
                print("走你",event)
            }
            .disposed(by: disposeBag)