RxSwift中Observable的各种创建方法

Observable的创建方法有很多，下面我一一举例列举出来：

empty

empty()方法主要是创建了一个空的数据流，即空序列，里面没有任何的元素，所以它不会发出任何的next事件，也不会发出错误事件，它只会发出一个completed事件，然后终结。
没有被订阅的Observable实例并不会发出任何事件，也不会终结，数据也并没有被处理。直到订阅者出现，数据流就会开始向订阅者发送事件了。

        let emtyOb = Observable<Int>.empty()
        _ = emtyOb.subscribe(onNext: { (number) in
            print("订阅:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("完成回调")
        }) {
            print("释放回调")
        }
        /*
          输出：
         完成回调
         释放回调
         */

just

顾名思义，返回只有一个元素的可观察序列。所以订阅传过来的参数也就只有一个：

        // 单个信号序列创建
        let array = ["LG_Cooci","LG_Kody"]
        Observable<[String]>.just(array)
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        print("---------------------")

        _ = Observable<[String]>.just(array).subscribe(onNext: { (number) in
            print("订阅:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("完成回调")
        }) {
            print("释放回调")
        }
        
        /*
         输出：
         next(["LG_Cooci", "LG_Kody"])
         completed
         ---------------------
         订阅: ["LG_Cooci", "LG_Kody"]
         完成回调
         释放回调
         */

以上是两种不同的订阅方法，第一种方法返回的是：包裹着参数的event事件。第二种方法分了3种情况处理，onNext中返回的是参数本身。

of

该方法接收可变的参数，但是参数的类型必须相同 。
如果没显示地说明类型，swift也会自动推断类型。
接收的事件，也是分开的依次接收。

        // 多个元素 - 针对序列处理
        Observable<String>.of("LG_Cooci","LG_Kody")
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        print("---------------------")

        // 字典
        Observable<[String: Any]>.of(["name":"LG_Cooci","age":18])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        print("---------------------")

        
        // 数组
        Observable<[String]>.of(["LG_Cooci","LG_Kody"], ["one","two"])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        /*
         输出：
         next(LG_Cooci)
         next(LG_Kody)
         completed
         ---------------------
         next(["age": 18, "name": "LG_Cooci"])
         completed
         ---------------------
         next(["LG_Cooci", "LG_Kody"])
         next(["one", "two"])
         completed
         */

from

有optional时，是包含一个可选参数的作为元素的序列，只能有一个参数。
没有optional时，是包含一个可列举的序列作为元素的序列。

        Observable<[String]>.from(optional: ["LG_Cooci","LG_Kody"]) // 可选数组
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        print("---------------------")
        Observable.from(optional: ["name":"LG_Cooci","age":18])  // 可选字典
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        print("---------------------")
        Observable.from(optional: "one")  // 可选字符串
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        print("---------------------")
        Observable.from("one")            // 可列举的序列
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        /*
         输出：
         next(["LG_Cooci", "LG_Kody"])
         completed
         ---------------------
         next(["name": "LG_Cooci", "age": 18])
         completed
         ---------------------
         next(one)
         completed
         ---------------------
         next(o)
         next(n)
         next(e)
         completed
         */

defer

一个可观察序列：有由外部控制的，生成序列工厂的方法。并且可以延迟该可观察序列的创建。

        // 这里有一个需求:动态序列 - 根据外界的标识 - 动态输出
        // 使用deferred()方法延迟Observable序列的初始化，通过传入的block来实现Observable序列的初始化并且返回。
        var isOdd = true  // 外界控制变量
        let factory = 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)
            }

        //第一次订阅测试
        _ = factory.subscribe { (event) in
            print("\(isOdd)", event)
        }
        print("---------------------")
        //第二次订阅测试
        _ = factory.subscribe { (event) in
            print("\(isOdd)", event)
        }
        /*
         输出：
         false next(0)
         false next(2)
         false next(4)
         false next(6)
         false next(8)
         false completed
         ---------------------
         true next(1)
         true next(3)
         true next(5)
         true next(7)
         true next(9)
         true completed
         */

rang

指定范围内的连续完整的可观察整数序列

        // 生成指定范围内的可观察整数序列。
        Observable.range(start: 2, count: 5)
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        /*
         输出：
        next(2)
        next(3)
        next(4)
        next(5)
        next(6)
        completed
        */

generate

状态驱动循环产生元素的序列，类似于for循环

        // 该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。
        // 初始值给定 然后判断条件1 再判断条件2 会一直递归下去,直到条件1或者条件2不满足
        // 类似 数组遍历循环
        Observable.generate(initialState: 0,// 初始值
                            condition: { $0 < 10}, // 条件1
                            iterate: { $0 + 2 })  // 条件2 +2
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        print("---------------------")
        // 数组遍历
        let arr = ["LG_Cooci_1","LG_Cooci_2","LG_Cooci_3"]
        Observable.generate(initialState: 0,// 初始值
            condition: { $0 < arr.count}, // 条件1
            iterate: { $0 + 1 })  // 条件2 +2
            .subscribe(onNext: {
                print("遍历arr:",arr[$0])
            })
            .disposed(by: disposeBag)
        /*
         输出：
         next(0)
         next(2)
         next(4)
         next(6)
         next(8)
         completed
         ---------------------
         遍历arr: LG_Cooci_1
         遍历arr: LG_Cooci_2
         遍历arr: LG_Cooci_3
         */

timer

定时器的序列

        // 第一次参数:第一次响应距离现在的时间
        // 第二个参数:时间间隔
        // 第三个参数:线程
        Observable<Int>.timer(5, period: 2, scheduler: MainScheduler.instance)
            .subscribe { (event) in
                print(event)
            }
            .disposed(by: disposeBag)
        print("---------------------")
        // 因为没有指定期限period, 即period为nil, 故认定为一次性
        Observable<Int>.timer(1, scheduler: MainScheduler.instance)
            .subscribe { (event) in
                print("无period： \(event)")
            }
            .disposed(by: disposeBag)
        print("---------------------")

        /*
         输出：
         ---------------------
         ---------------------
         无period： next(0)
         无period： completed
         next(0)
         next(1)
         next(2)
         next(3)
         */

interval

还是一个定时器序列

        // 定时器
        // 第一个参数:时间间隔
        // 第二个参数:线程
        Observable<Int>.interval(1, scheduler: MainScheduler.instance)
            .subscribe { (event) in
                print(event)
            }
            .disposed(by: disposeBag)

repeatElement

可以无限发出给定元素的observable序列，当和别的序列在一个线程的时候，会阻塞线程，导致别的序列不能响应订阅。
比如当和上面的定时器都在主线程的时候，定时器将不会响应

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

error

创建一个不会做任何操作，而是直接发送一个错误的observable序列

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

        enum MyError: Error {
            case A
            case B
        }
        _ = Observable<Int>.error(MyError.A)
            .subscribe { (event) in
                print("订阅:",event)
            }
            .disposed(by: disposeBag)
        /*
         输出：
         订阅: error(Error Domain=lgerror Code=10086 "(null)" UserInfo={reason=unknow})
         ---------------------
         订阅: error(A)
         */

never

创建一个永远不会停止发出Event的observable序列

        print("********never********")
        //MARK:  never
        // 该方法创建一个永远不会发出 Event（也不会终止）的 Observable 序列。
        // 这种类型的响应源 在测试或者在组合操作符中禁用确切的源非常有用
        Observable<String>.never()
            .subscribe { (event) in
                print("走你",event)
            }
            .disposed(by: disposeBag)
        print("********never********")
        
        /*
         ********never********
         ********never********
         */

create

接收一个block形式的参数，对每一个过来的订阅者进行处理的序列

        let observable12 = Observable<String>.create { (observer) -> Disposable in
            //对订阅者发出next事件，且携带一个数据hello world
            observer.onNext("hello world")
            observer.onNext("hello swift")
            //对订阅者发出.complated事件
            observer.onCompleted()
            //一个订阅者会有一个Disposable类型的返回值，所以结尾要return一个Disposable
            return Disposables.create()
        }
        //测试订阅
        _ = observable12.subscribe(onNext: { (string) in
            print("订阅到:\(string)")
        }, onError: { (error) in
            print(error)
        }, onCompleted: {
            print("完成")
        }) {
            print("销毁")
        }
        /*
         订阅到:hello world
         订阅到:hello swift
         完成
         销毁
         */