emty

创建一个空的序列,但是只能订阅到complete

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

just

构建一个只有一个元素的observable序列,订阅信息自动completed

        let array = ["LG_Cooci","LG_Kody"]
        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序列

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

from

从一个序列(如Array/Dictionary/Set)中创建一个observable序列

       Observable<[String]>.from(optional: ["LG_Cooci","LG_Kody"])
           .subscribe { (event) in
               print(event)
           }.disposed(by: disposeBag)

deferred

为每一个订阅者创建一个新的observable序列

       // 这里有一个需求:动态序列 - 根据外界的标识 - 动态输出
       // 使用deferred()方法延迟Observable序列的初始化，通过传入的block来实现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)

generate

创建一个observable序列，只要提供的条件为true,就可以生成值

       //MARK:  generate
       // 该方法创建一个只有当提供的所有的判断条件都为 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)

    // 数组遍历
       let arr = ["m1","m2","m3","m4","m5","m6",]
       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序列

        //MARK:  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

底层就是封装timer

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

repeatElement

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

error

       //MARK:  error
       // 对消费者发出一个错误信号
       Observable<String>.error(NSError.init(domain: "lgerror", code: 10086, userInfo: ["reason":"unknow"]))
           .subscribe { (event) in
               print("订阅:",event)
           }
           .disposed(by: disposeBag)

never

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