RxSwift--常见Observable序列的创建

  本文主要讲解一下常见Observable序列的创建，这样会对RxSwift应用方面有一个宏观的了解。

1.empty

Returns an empty observable sequence, using the specified scheduler to send out the single Completed message.
对于一个空序列，调用empty函数，因为序列为空，所以直接返回completed消息。

let emtyOb = Observable<Int>.empty()
        let _ = emtyOb.subscribe(onNext: { (number) in
            print("---subscribe:",number)
        }, onError: { (error) in
            print("---error:",error)
        }, onCompleted: {
            print("---completed")
        }) {
            print("---release")
        }

输出：

---completed
---release

2.just

Returns an observable sequence that contains a single element.
单个信号序列创建，输出每一个序列。

let array = ["Apple","Banana"]
        Observable<[String]>.just(array)
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        let _ = Observable<[String]>.just(array).subscribe(onNext: { (number) in
            print("---subscribe:",number)
        }, onError: { (error) in
            print("---error:",error)
        }, onCompleted: {
            print("---completed")
        }) {
            print("---release")
        }

输出：

next(["Apple", "Banana"])
completed
---subscribe: ["Apple", "Banana"]
---completed
---release

3.of

This method creates a new Observable instance with a variable number of elements.
多序列元素、字典、数组输出，针对序列处理。

 // 1.多个元素
        Observable<String>.of("Apple","Banana")
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        // 2.字典
        Observable<[String: Any]>.of(["name":"Apple","age":18])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
        // 3.数组
        Observable<[String]>.of(["Apple","Banana"])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)

输出：

next(Apple)
next(Banana)
completed
next(["age": 18, "name": "Apple"])
completed
next(["Apple", "Banana"])
completed

4.from

Converts a optional to an observable sequence.
从集合中获取序列，包括数组、集合、set，具有可选项处理，更加安全。

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

输出：

next(["Apple", "Banana"])
completed

5.defer

Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.
延迟Observable序列的初始化，通过传入的block实现Observable序列的初始化。

	var isOdd = true
    let _ = 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)
    }

输出：

next(1)
next(3)
next(5)
next(7)
next(9)
completed

6.range

Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to generate and send out observer messages.
生成指定范围内的可观察证书序列。

Observable.range(start: 3, count: 5)
	.subscribe { (event) in
		print(event)
	}.disposed(by: disposeBag)

输出：

next(3)
next(4)
next(5)
next(6)
completed

7.generate

Generates an observable sequence by running a state-driven loop producing the sequence’s elements, using the specified scheduler to run the loop send out observer messages.
创建一个只有当提供的所有的判断条件都为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)

输出：

next(0)
next(2)
next(4)
next(6)
next(8)
completed

8.timer

Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers.
定时器序列，使用指定的scheduler调度器，在指定的初始值之后，按照指定时间间隔生成定时器序列。

        // 参数1:第一次响应距离现在的时间
		// 参数2:时间间隔
		// 参数3:线程
        Observable<Int>.timer(1, 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")
            }
            .disposed(by: disposeBag)

9.interval

Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages.
定时器序列，使用指定的scheduler调度器，在指定时间间隔内生成定时器Event。

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

10.repeatElement

Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages.
创建一个可以无限发出给定元素的序列，永不停止。

Observable<Int>.repeatElement(5)
	.subscribe { (event) in
		print("---subscribe:",event)
	}
	.disposed(by: disposeBag)

11.error

Returns an observable sequence that terminates with an error.
发出错误信号。

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

12.never

Returns a non-terminating observable sequence, which can be used to denote an infinite duration.
永远不会发出Event的Observable序列。这种类型的响应源在测试或者在组合操作符中禁用确切的源非常有用。

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