RxSwift基礎-オペレーターその1

# はじめに
RxSwiftで使えるオペレーターを備忘録的に書き綴っていきたいと思います。
また、公式Exanpleを参考にしています。


https://github.com/ReactiveX/RxSwift

動画でRxSwiftを**非常に解りやすく**紹介していた

https://www.youtube.com/watch?v=sJbvQByQYlc

も参考にしています。是非見て頂きたいです。

作業環境については、

https://qiita.com/masasumi0327/items/2ae144160987e571bce4

を参考に構築して頂ければと思います。
### never
```swift
func never() {
    let disposeBag = DisposeBag()
    Observable.never()
        .subscribe { event in
            print(event)
        }
        .disposed(by: disposeBag)   
}
never() // [出力なし]
```

neverという名前が付くくらいなので、**イベントを一切発生させない**オペレーターです。
ビルドしても何も出力されません。
### empty
```swift
func empty() {
    let disposeBag = DisposeBag()

    Observable<Int>.empty()
        .subscribe { event in
            print(event)
        }
        .disposed(by: disposeBag)
}
empty() // completed
```
completedイベントのみ流すオペレーターです。
### just
```swift
func just() {
    let disposeBag = DisposeBag()

    Observable.just("🔴")
        .subscribe { event in
            print(event)
        }
        .disposed(by: disposeBag)
}
just() // next(🔴) completed
```
イベントを一つとcompletedを流すオペレーターです。
### of
```swift
func of() {
    let disposeBag = DisposeBag()

    Observable.of("🐶", "🐱", "🐭", "🐹")
        .subscribe(onNext: { element in
            print(element)
        })
        .disposed(by: disposeBag)
}

of() // 🐶🐱🐭🐹
```
指定した個数分のオペレーターを発生させるオペレーターです。
ここでは、subscribe後に、
```
onNext
```
が使われています。これは、nextイベントのみ流すメソッドになります。
### from
```swift
func from() {
    let disposeBag = DisposeBag()

    Observable.from(["🐶", "🐱", "🐭", "🐹"])
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}

from() // 🐶🐱🐭🐹
```
ArrayやDictionary,Setの型のObservableを作成出来るオペレーターです。
### create
```swift
func create() {
    let disposeBag = DisposeBag()

    let myJust = { (element: String) -> Observable<String> in
        return Observable.create { observer in
            observer.on(.next(element))
            observer.on(.completed)
            return Disposables.create()
        }
    }
    // nextとcompletedを流すObservableを作成している。(justオペレーターと同じ挙動)

    myJust("🔴")
        .subscribe { print($0) }
        .disposed(by: disposeBag)
}
create() // next(🔴) completed
```
Observable自体をを作成出来るオペレーターです。
### range
```swift
func range() {
    let disposeBag = DisposeBag()

    Observable.range(start: 4, count: 10)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}
range() // 4 5 6 7 8 9 10 11 12 13
```
startで指定した整数から、countで指定した整数まで、繰り返し処理してくれるオペレーターです。
### repeatElement
```swift
func repeatElement() {
    let disposeBag = DisposeBag()

    Observable.repeatElement("🔴")
        .take(3)// 記述がないと無限に出力されます!!
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}

repeatElement() // 🔴 🔴 🔴
```
take()で指定した整数までObservableを作成します。
take()を指定しないと無限にObservableが作成されてしまいます。
### generate
```swift
func generate() {
    let disposeBag = DisposeBag()

    Observable.generate(
            initialState: 0,
            condition: { $0 < 3 },
            iterate: { $0 + 1 })
    
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}

generate() // 0 1 2
```
initialState, condition, iterateで指定した値が**true**である限り、Observableが作成されます。
### deferred
```swift
func deferred() {
    let disposeBag = DisposeBag()
    var count = 1

    let deferredSequence = Observable<String>.deferred {
        print("Creating \(count)")
        count += 1

        return Observable.create { observer in
            print("Emitting...")
            observer.onNext("🐶")
            observer.onNext("🐱")
            observer.onNext("🐵")
            return Disposables.create()
        }
    }

    deferredSequence
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)

    deferredSequence
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}

deferred() // Creating 1 Emitting...🐶🐱🐵 Creating 2 Emitting...🐶🐱🐵
```
このメソッドでは、createで作成したオブザーバーを購読する際に、サブスクライブする瞬間にオブザーバーを作成しています。
(サブスクライブされるまで、オブザーバーが作成されない)
なので、常に最新の値が保証されます。・・・みたいです。😓
### error
```swift
public enum TestError: Swift.Error {
    case test
}

func error() {
    let disposeBag = DisposeBag()

    Observable<Int>.error(TestError.test)
        .subscribe { print($0) }
        .disposed(by: disposeBag)
}

error() // error(test)
```
名前の冠する通り、エラーイベントを発行するオペレーターです。
### doOn
```swift
func doOn() {
    let disposeBag = DisposeBag()

    Observable.of("🍎", "🍐", "🍊", "🍋")
        .do(onNext: { print("Intercepted:", $0) }, afterNext: { print("Intercepted after:", $0) }, onError: { print("Intercepted error:", $0) }, afterError: { print("Intercepted after error:", $0) }, onCompleted: { print("Completed")  }, afterCompleted: { print("After completed")  })
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}
doOn() /* 
Intercepted: 🍎
🍎
Intercepted after: 🍎
Intercepted: 🍐
🍐
Intercepted after: 🍐
Intercepted: 🍊
🍊
Intercepted after: 🍊
Intercepted: 🍋
🍋
Intercepted after: 🍋
Completed After completed
/*
```
出力を見る限り、Observable.of()で作成したオブザーバーをサブスクライブする際にその前後で新たなイベントを行えるオペレーターです。よく解りませんでした。😭

以上になります!!!
今後も記事としてアウトプットして、理解を深めていきたいと思います。