RxSwift - Observable 생성 시 사용하는 연산자 정리

just

 

하나의 element 만 방출하는 단순한 형태의 연산자

Observable<Int>.just(1)
Observable.just([1,2,3,4,5])
// 1
// [1,2,3,4,5]

 

of

 

여러 element 를 나열하여 순차적으로 방출하는 연산자. 방출하고 싶은 event 를 , 로 나열해서 대입하면, 순차적으로 이벤트를 생성한다.

Observable<Int>.of(1,2,3,4,5)
// 1
// 2
// 3
// 4
// 5

 

방출하는 element 의 type 을 지정해주지 않아도, Observable 은 타입 추론을 통해 Observable Sequence 를 생성한다.

Observable.of([1,2,3,4,5])
// [1,2,3,4,5]

 

위와 같은 경우는 Array 를 element 로 대입하였는데, 하나의 Array 만을 방출하는 것과 같으므로, just 연산자를 쓴 것과 동일하다. 

 

from

 

Array 형태의 element 만 받으며, Array 안의 element 를 하나씩 순차적으로 방출한다.

Observable.from([1,2,3,4,5])
// 1
// 2
// 3
// 4
// 5

 

empty

 

아무런 event 를 방출하지 않는, 단지 complete 만 방출하는 연산자.

Observable.empty()
    .subscribe {
        print($0)
    }

 

empty 의 경우 가지고 있는 요소가 없기 때문에 타입 추론을 할 수 없다. 즉, 타입을 명시적으로 표현해줘야 하며, 이와 같은 경우 void 는 매우 적절한 표현 방식이다.

Observable<Void>.empty()
    .subscribe {
        print($0)
    }

 

그렇다면 왜 empty 를 사용할까? 크게 두 가지 상황일 때 사용할 수 있다.

① 즉시 종료할 수 있는 Observable 을 return 하고 싶을 때

② 의도적으로 0개의 값을 가지는 Observable 을 return 하고 싶을 때

 

never

 

아무런 event 도 방출하지 않기 때문에, debug 를 통해서만 제대로 구독되고 있는지 확인할 수 있다.

print("-------never-------")
Observable<Void>.never()
    .debug("never")
    .subscribe(
        onNext: {
            print($0)
        },
        onCompleted: {
            print("completed")
        }
    )
    
-------never-------
2022-10-24 18:19:47.133: never -> subscribed

 

타입을 지정해도 에러가 뜬다. 작동은 하지만 아무런 것도 방출하지 않는 것.

이는 debug 연산자를 활용해 확인할 수 있는데, debug 가 subscribe 는 된 것을 알 수 있다.

 

range

 

start, count 값을 통해 순차적으로 하나씩 element 를 방출하는 연산자.

print("-------Range------")
Observable.range(start: 1, count: 3)
    .subscribe(onNext: {
        print("2*\($0) = \(2*$0)")
    })

-------Range------
2*1 = 2
2*2 = 4
2*3 = 6

 

create

 

event 를 각각 방출하는 Observer 를 이용해서 Observable Sequence 를 만드는 방식

print("-------create------")
Observable.create { observer -> Disposable in
    observer.onNext(1)
//    == observer.on(.next(1))
    observer.onCompleted()
//    == observer.on(.completed)
    observer.onNext(2)
    return Disposables.create()
}
.subscribe {
    print($0)
}
.disposed(by: disposeBag)

-------create------
next(1)
completed

 

escaping 에는 AnyObserver 라는 escaping 이 있다. 

AnyObserver 를 취한 후, Disposable 를 return 하는 클로저이다. AnyObserver 은 제너릭 타입으로, Observer Sequence 에 값을 쉽게 추가할 수 있도록 한다. 이렇게 추가한 값은 subscribe 를 했을 때 방출된다.

 

위 코드는 onComplete 이벤트를 통해 Observable 이 종료되었기 때문에, next 이벤트를 날려도 방출되지 않는다.

 

deffered

 

Subscriber 를 기다리는 Observable 을 만드는 대신에, 각 subscriber 에게 새롭게 Observable 항목을 제공하는 Observable Factory 를 만드는 방식이다. 여기서 observable factory 란 Observable 을 감싸는 Observable 이다.

print("-------deffered------")
Observable.deferred {
    Observable.of(1,2,3)
}
.subscribe {
    print($0)
}
.disposed(by: disposeBag)

-------deffered------
next(1)
next(2)
next(3)
completed

 

마치 deferred 가 없고, observable.of 만 있듯이 동작한다. 그럼 deffered 연산자는 언제 사용할까?

print("-------deffered2------")
var thumbsUp: Bool = true

let factory: Observable<String> = Observable.deferred {
    thumbsUp = !thumbsUp
    
    if thumbsUp {
        return Observable.of("👍")
    } else {
        return Observable.of("👎")
    }
}
// deferred 로 만든 factory 라는 observable 이 구독될때마다 엄지를 뒤집어준다

for _ in 0...3 {
    factory.subscribe(onNext: {
        print($0)
    })
    .disposed(by: disposeBag)
}

-------deffered2------
👎
👍
👎
👍